Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "s390_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "unsigned", "int", "i", ",", "nelt", ";", "if", "(", "!", "s390_vector_mode_supported_p", "(", "vmode", ")", "||", "GET_MODE_SIZE", "(", "vmode", ")", "!=", "16", ")", "return", "false", ";", "d", ".", "target", "=", "target", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "vmode", "=", "vmode", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "d", ".", "vmode", ")", ")", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "d", ".", "testing_p", "=", "target", "==", "NULL_RTX", ";", "gcc_assert", "(", "target", "==", "NULL_RTX", "||", "REG_P", "(", "target", ")", ")", ";", "gcc_assert", "(", "sel", ".", "length", "(", ")", "==", "nelt", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "unsigned", "char", "e", "=", "sel", "[", "i", "]", ";", "gcc_assert", "(", "e", "<", "2", "*", "nelt", ")", ";", "d", ".", "perm", "[", "i", "]", "=", "e", ";", "}", "return", "vectorize_vec_perm_const_1", "(", "d", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "can", "emit", "instructions", "for", "the", "constant", "permutation", "vector", "in", "SEL", ".", "If", "OUTPUT", ",", "IN0", ",", "IN1", "are", "non-null", "the", "hook", "is", "supposed", "to", "emit", "the", "required", "INSNs", "." ]

[ "s390", "16", "0", "2" ]

[]

[ "<s>", "static", "enum", "rs6000_reg_type", "register_to_reg_type", "(", "rtx", "reg", ",", "bool", "*", "is_altivec", ")", "{", "HOST_WIDE_INT", "regno", ";", "enum", "reg_class", "rclass", ";", "if", "(", "SUBREG_P", "(", "reg", ")", ")", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "NO_REG_TYPE", ";", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "{", "if", "(", "!", "lra_in_progress", "&&", "!", "reload_completed", ")", "return", "PSEUDO_REG_TYPE", ";", "regno", "=", "true_regnum", "(", "reg", ")", ";", "if", "(", "regno", "<", "0", "||", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "return", "PSEUDO_REG_TYPE", ";", "}", "gcc_assert", "(", "regno", ">=", "0", ")", ";", "if", "(", "is_altivec", "&&", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "*", "is_altivec", "=", "true", ";", "rclass", "=", "rs6000_regno_regclass", "[", "regno", "]", ";", "return", "reg_class_to_reg_type", "[", "(", "int", ")", "rclass", "]", ";", "}", "</s>" ]

[ "Classify", "a", "register", "type", ".", "Because", "the", "FMRGOW/FMRGEW", "instructions", "only", "work", "on", "traditional", "floating", "point", "registers", ",", "and", "the", "VMRGOW/VMRGEW", "instructions", "only", "work", "on", "the", "traditional", "altivec", "registers", ",", "note", "if", "an", "altivec", "register", "was", "chosen", "." ]

[ "rs6000", "0", "0" ]

[]

[ "<s>", "bool", "s390_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "cfun", "->", "machine", "->", "base_reg", ")", "if", "(", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "old_reg", "||", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "new_reg", ")", "return", "false", ";", "if", "(", "GENERAL_REGNO_P", "(", "new_reg", ")", "&&", "!", "call_really_used_regs", "[", "new_reg", "]", "&&", "cfun_gpr_save_slot", "(", "new_reg", ")", "==", "0", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "." ]

[ "s390", "0" ]

[]

[ "<s>", "bool", "mips_const_vector_same_val_p", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "int", "i", ",", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "rtx", "first", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_VECTOR", "||", "GET_MODE", "(", "op", ")", "!=", "mode", ")", "return", "false", ";", "first", "=", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nunits", ";", "i", "++", ")", "if", "(", "!", "rtx_equal_p", "(", "first", ",", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "constant", "vector", "with", "the", "number", "of", "units", "in", "MODE", ",", "and", "each", "unit", "has", "the", "same", "value", "." ]

[ "mips", "0", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "Subtarget", ".", "hasVector", "(", ")", "?", "CSR_SystemZ_AllRegs_Vector_SaveList", ":", "CSR_SystemZ_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_SystemZ_SwiftError_SaveList", ";", "return", "CSR_SystemZ_SaveList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "tilepro_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "fnaddr", ",", "chaddr", ";", "rtx", "mem", ";", "rtx", "begin_addr", ",", "end_addr", ";", "int", "ptr_mode_size", "=", "GET_MODE_SIZE", "(", "ptr_mode", ")", ";", "fnaddr", "=", "copy_to_reg", "(", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ")", ";", "chaddr", "=", "copy_to_reg", "(", "static_chain", ")", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "TRAMPOLINE_SIZE", "-", "2", "*", "ptr_mode_size", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "TRAMPOLINE_SIZE", "-", "ptr_mode_size", ")", ";", "emit_move_insn", "(", "mem", ",", "chaddr", ")", ";", "begin_addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "end_addr", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "TRAMPOLINE_SIZE", ")", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__clear_cache\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "2", ",", "begin_addr", ",", "Pmode", ",", "end_addr", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_TRAMPOLINE_INIT", "." ]

[ "tilepro", "0", "2", "0", "0", "\"__clear_cache\"", "2" ]

[]

[ "<s>", "static", "tree", "ix86_mangle_function_version_assembler_name", "(", "tree", "decl", ",", "tree", "id", ")", "{", "tree", "version_attr", ";", "const", "char", "*", "orig_name", ",", "*", "version_string", ";", "char", "*", "attr_str", ",", "*", "assembler_name", ";", "if", "(", "DECL_DECLARED_INLINE_P", "(", "decl", ")", "&&", "lookup_attribute", "(", "\"gnu_inline\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"Function versions cannot be marked as gnu_inline,\"", "\" bodies have to be generated\"", ")", ";", "if", "(", "DECL_VIRTUAL_P", "(", "decl", ")", "||", "DECL_VINDEX", "(", "decl", ")", ")", "sorry", "(", "\"Virtual function multiversioning not supported\"", ")", ";", "version_attr", "=", "lookup_attribute", "(", "\"target\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "gcc_assert", "(", "version_attr", "!=", "NULL_TREE", ")", ";", "orig_name", "=", "IDENTIFIER_POINTER", "(", "id", ")", ";", "version_string", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "version_attr", ")", ")", ")", ";", "if", "(", "strcmp", "(", "version_string", ",", "\"default\"", ")", "==", "0", ")", "return", "id", ";", "attr_str", "=", "sorted_attr_string", "(", "TREE_VALUE", "(", "version_attr", ")", ")", ";", "assembler_name", "=", "XNEWVEC", "(", "char", ",", "strlen", "(", "orig_name", ")", "+", "strlen", "(", "attr_str", ")", "+", "2", ")", ";", "sprintf", "(", "assembler_name", ",", "\"%s.%s\"", ",", "orig_name", ",", "attr_str", ")", ";", "if", "(", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", ")", "SET_DECL_RTL", "(", "decl", ",", "NULL", ")", ";", "tree", "ret", "=", "get_identifier", "(", "assembler_name", ")", ";", "XDELETEVEC", "(", "attr_str", ")", ";", "XDELETEVEC", "(", "assembler_name", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "This", "function", "changes", "the", "assembler", "name", "for", "functions", "that", "are", "versions", ".", "If", "DECL", "is", "a", "function", "version", "and", "has", "a", "``", "target", "''", "attribute", ",", "it", "appends", "the", "attribute", "string", "to", "its", "assembler", "name", "." ]

[ "i386", "\"gnu_inline\"", "\"Function versions cannot be marked as gnu_inline,\"", "\" bodies have to be generated\"", "\"Virtual function multiversioning not supported\"", "\"target\"", "\"default\"", "0", "2", "\"%s.%s\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "hasHighOperandLatency", "(", "const", "TargetSchedModel", "&", "SchedModel", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "return", "isHighLatencyDef", "(", "DefMI", ".", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

[ "Compute", "operand", "latency", "between", "a", "def", "of", "'Reg", "'", "and", "a", "use", "in", "the", "current", "loop", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "RISCVExpandSSR", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "RISCVInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "this", "->", "MF", "=", "&", "MF", ";", "this", "->", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "Enabled", "=", "false", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "RISCVExpandSSR", "::", "RegisterMergingPreferences", "RMP", "=", "gatherRegisterMergingPreferences", "(", ")", ";", "if", "(", "RMP", ".", "Enable", "&&", "RVFI", "->", "getUsedSSR", "(", ")", ")", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "mergePushPop", "(", "MBB", ")", ";", "if", "(", "Modified", ")", "{", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "unsigned", "ssr_no", "=", "0", ";", "ssr_no", "<", "NUM_SSR", ";", "++", "ssr_no", ")", "MBB", ".", "addLiveIn", "(", "getSSRFtReg", "(", "ssr_no", ")", ")", ";", "MBB", ".", "sortUniqueLiveIns", "(", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "RI5CY", "RISCV", "RISCV", "RISCV", "RISCV", "0" ]

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MBlaze", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "MBlazeISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "MBlaze", "::", "R15", ",", "MVT", "::", "i32", ")", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "MBlazeISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "MBlaze", "::", "R15", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "MBlaze", "MBlaze", "ISD::OutputArg", "16", "MBlaze", "0", "0", "\"Can only return in registers!\"", "1", "MBlazeISD::Ret", "MVT::Other", "MBlaze::R15", "MVT::i32", "MBlazeISD::Ret", "MVT::Other", "MBlaze::R15", "MVT::i32" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "LLVMContext", "&", "Ctx", "=", "M", ".", "getContext", "(", ")", ";", "Mod", "=", "&", "M", ";", "FloatType", "=", "Type", "::", "getFloatTy", "(", "Ctx", ")", ";", "Int32Type", "=", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ";", "V4f32Type", "=", "VectorType", "::", "get", "(", "FloatType", ",", "4", ")", ";", "V4i32Type", "=", "VectorType", "::", "get", "(", "Int32Type", ",", "4", ")", ";", "Type", "*", "ArgsType", "[", "]", "=", "{", "V4f32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "}", ";", "TexSign", "=", "FunctionType", "::", "get", "(", "V4f32Type", ",", "ArgsType", ",", "false", ")", ";", "Type", "*", "ArgsQType", "[", "]", "=", "{", "V4i32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "Int32Type", ",", "}", ";", "TexQSign", "=", "FunctionType", "::", "get", "(", "V4f32Type", ",", "ArgsQType", ",", "false", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "R600", "4", "4" ]

[]

[ "<s>", "static", "bool", "iq2000_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_COMPLEX_FLOAT", ")", "==", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_COMPLEX_FLOAT", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "iq2000" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "is64Bit", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "this", ",", "TM", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "InstSelector", ".", "reset", "(", "createX86InstructionSelector", "(", "TM", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "tree", "rs6000_d_handle_target_float_abi", "(", "void", ")", "{", "const", "char", "*", "abi", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "abi", "=", "\"hard\"", ";", "else", "if", "(", "TARGET_SOFT_FLOAT", ")", "abi", "=", "\"soft\"", ";", "else", "abi", "=", "\"\"", ";", "return", "build_string_literal", "(", "strlen", "(", "abi", ")", "+", "1", ",", "abi", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "floatAbi", "''", ")", "'", "." ]

[ "rs6000", "\"hard\"", "\"soft\"", "\"\"", "1" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Register", ":", "OS", "<<", "\"Reg<\"", "<<", "Reg", ".", "Num", "<<", "\">\"", ";", "break", ";", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", "<<", "(", "(", "const", "MCConstantExpr", "*", ")", "Imm", ".", "Val", ")", "->", "getValue", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "LC2200", "\"Reg<\"", "\">\"", "\"Imm<\"", "\">\"" ]

[]

[ "<s>", "bool", "PatmosFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "PatmosMachineFunctionInfo", "&", "PMFI", "=", "*", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "spilledSize", "=", "0", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "if", "(", "Reg", "==", "Patmos", "::", "S0", "&&", "PMFI", ".", "getS0SpillReg", "(", ")", ")", "{", "TII", ".", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "PMFI", ".", "getS0SpillReg", "(", ")", ",", "Reg", ",", "true", ")", ";", "prior", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "continue", ";", "}", "if", "(", "Patmos", "::", "SRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "TII", ".", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "Patmos", "::", "R9", ",", "Reg", ",", "true", ")", ";", "prior", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Reg", "=", "Patmos", "::", "R9", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "prior", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "spilledSize", "+=", "4", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "Patmos", "Patmos", "Patmos", "Patmos", "0", "0", "1", "Patmos::PRegsRegClass", "Patmos::S0", "Patmos::SRegsRegClass", "Patmos::R9", "Patmos::R9", "1", "4" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "DEXT", ":", "case", "Mips", "::", "DINS", ":", "LowerDextDins", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::DEXT", "Mips::DINS", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "\"Desc.getSize() returns 0\"" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "12", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "RISCV", "RISCV", "12" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "report_fatal_error", "(", "\"ISRs cannot be called directly\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "MSP430", "MSP430", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot be called directly\"" ]

[]

[ "<s>", "void", "mprocFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "mproc", "mproc" ]

[]

[ "<s>", "static", "void", "mips_pop_asm_switch_1", "(", "struct", "mips_asm_switch", "*", "asm_switch", ",", "const", "char", "*", "prefix", ",", "const", "char", "*", "suffix", ")", "{", "gcc_assert", "(", "asm_switch", "->", "nesting_level", ")", ";", "asm_switch", "->", "nesting_level", "--", ";", "if", "(", "asm_switch", "->", "nesting_level", "==", "0", ")", "fprintf", "(", "asm_out_file", ",", "\"%s.set\\t%s%s\"", ",", "prefix", ",", "asm_switch", "->", "name", ",", "suffix", ")", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "end", "a", "block", "." ]

[ "mips", "0", "\"%s.set\\t%s%s\"" ]

[]

[ "<s>", "void", "BlackfinRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "assert", "(", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "\"FP elimination on a non-leaf function is not supported\"", ")", ";", "adjustRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "FrameSize", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "UNLINK", ")", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Blackfin", "4", "0", "\"Misaligned frame size\"", "\"FP elimination on a non-leaf function is not supported\"", "BF::SP", "BF::P1", "BF::UNLINK" ]

[]

[ "<s>", "static", "unsigned", "rs6000_adjust_vect_cost_per_stmt", "(", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ")", "{", "if", "(", "kind", "==", "scalar_stmt", "&&", "stmt_info", "&&", "stmt_info", "->", "stmt", "&&", "gimple_code", "(", "stmt_info", "->", "stmt", ")", "==", "GIMPLE_ASSIGN", ")", "{", "tree_code", "subcode", "=", "gimple_assign_rhs_code", "(", "stmt_info", "->", "stmt", ")", ";", "if", "(", "subcode", "==", "COND_EXPR", ")", "return", "2", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Adjust", "vectorization", "cost", "after", "calling", "rs6000_builtin_vectorization_cost", ".", "For", "some", "statement", ",", "we", "would", "like", "to", "further", "fine-grain", "tweak", "the", "cost", "on", "top", "of", "rs6000_builtin_vectorization_cost", "handling", "which", "does", "n't", "have", "any", "information", "on", "statement", "operation", "codes", "etc", ".", "One", "typical", "case", "here", "is", "COND_EXPR", ",", "it", "takes", "the", "same", "cost", "to", "simple", "FXU", "instruction", "when", "evaluating", "for", "scalar", "cost", ",", "but", "it", "should", "be", "priced", "more", "whatever", "transformed", "to", "either", "compare", "+", "branch", "or", "compare", "+", "isel", "instructions", "." ]

[ "rs6000", "2", "0" ]

[]

[ "<s>", "const", "Z80oldSubtarget", "&", "getSubtarget", "(", ")", "const", "{", "return", "*", "Subtarget", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "Z80old", "Z80old" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isAsmClobberable", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "PhysReg", ")", "const", "{", "return", "!", "isReservedReg", "(", "MF", ",", "PhysReg", ")", ";", "}", "</s>" ]

[ "Returns", "false", "if", "we", "ca", "n't", "guarantee", "that", "Physreg", ",", "specified", "as", "an", "IR", "asm", "clobber", "constraint", ",", "will", "be", "preserved", "across", "the", "statement", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "AArch64ConditionalCompares", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Compares **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SchedModel", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getSchedModel", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "MinSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ";", "bool", "Changed", "=", "false", ";", "CmpConv", ".", "runOnMachineFunction", "(", "MF", ",", "MBPI", ")", ";", "for", "(", "auto", "*", "I", ":", "depth_first", "(", "DomTree", ")", ")", "if", "(", "tryConvert", "(", "I", "->", "getBlock", "(", ")", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Compares **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "static", "rtx", "get_branch_target", "(", "rtx", "branch", ")", "{", "if", "(", "CALL_P", "(", "branch", ")", ")", "{", "rtx", "call", ";", "call", "=", "XVECEXP", "(", "PATTERN", "(", "branch", ")", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "SET", ")", "call", "=", "SET_SRC", "(", "call", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "!=", "CALL", ")", "abort", "(", ")", ";", "return", "XEXP", "(", "XEXP", "(", "call", ",", "0", ")", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Returns", "0", "if", "we", "do", "n't", "want", "a", "hint", "for", "this", "branch", ".", "Otherwise", "return", "the", "rtx", "for", "the", "branch", "target", "." ]

[ "microblaze", "0", "0", "0", "0" ]

[]

[ "<s>", "int", "vfp3_const_double_rtx", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_VFP3", ")", "return", "0", ";", "return", "vfp3_const_double_index", "(", "x", ")", "!=", "-", "1", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "rtx", "X", "is", "a", "valid", "immediate", "VFPv3", "constant", "." ]

[ "arm", "0", "1" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "MSP430" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectRead", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ",", "unsigned", "AddrChan", ")", "const", "{", "unsigned", "AddrReg", ";", "switch", "(", "AddrChan", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid Channel\"", ")", ";", "case", "0", ":", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "1", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_YRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "2", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_ZRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "3", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_WRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "}", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "*", "MOVA", ",", "AMDGPU", "::", "OpName", "::", "write", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "ValueReg", ",", "AddrReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "*", "Mov", ",", "AMDGPU", "::", "OpName", "::", "src0_rel", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "read", "." ]

[ "AMDGPU", "R600", "\"Invalid Channel\"", "0", "AMDGPU::R600_AddrRegClass", "1", "AMDGPU::R600_Addr_YRegClass", "2", "AMDGPU::R600_Addr_ZRegClass", "3", "AMDGPU::R600_Addr_WRegClass", "AMDGPU::MOVA_INT_eg", "AMDGPU::AR_X", "AMDGPU::OpName", "0", "AMDGPU::MOV", "AMDGPU::AR_X", "AMDGPU::OpName", "1" ]

[]

[ "<s>", "static", "int", "ix86_mode_entry", "(", "int", "entity", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "ix86_dirflag_mode_entry", "(", ")", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_entry", "(", ")", ";", "case", "I387_ROUNDEVEN", ":", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "I387_CW_ANY", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "mode", "that", "ENTITY", "is", "assumed", "to", "be", "switched", "to", "at", "function", "entry", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "avr_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "if", "(", "cum", "->", "nregs", "&&", "bytes", "<=", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "cum", "->", "regno", "-", "bytes", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Controls", "whether", "a", "function", "argument", "is", "passed", "in", "a", "register", ",", "and", "which", "register", "." ]

[ "avr" ]

[]

[ "<s>", "const", "SIRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "outliner", "::", "TargetCostInfo", "X86InstrInfo", "::", "getOutliningCandidateInfo", "(", "std", "::", "vector", "<", "outliner", "::", "Candidate", ">", "&", "RepeatedSequenceLocs", ")", "const", "{", "unsigned", "SequenceSize", "=", "std", "::", "accumulate", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "front", "(", ")", ",", "std", "::", "next", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", ")", ",", "0", ",", "[", "]", "(", "unsigned", "Sum", ",", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isKill", "(", ")", ")", "return", "Sum", ";", "return", "Sum", "+", "1", ";", "}", ")", ";", "if", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", "->", "isTerminator", "(", ")", ")", "return", "outliner", "::", "TargetCostInfo", "(", "SequenceSize", ",", "1", ",", "0", ",", "MachineOutlinerTailCall", ",", "MachineOutlinerTailCall", ")", ";", "return", "outliner", "::", "TargetCostInfo", "(", "SequenceSize", ",", "1", ",", "1", ",", "MachineOutlinerDefault", ",", "MachineOutlinerDefault", ")", ";", "}", "</s>" ]

[ "Returns", "a", "outliner", ":", ":OutlinedFunction", "struct", "containing", "target-specific", "information", "for", "a", "set", "of", "outlining", "candidates", "." ]

[ "X86", "X86", "0", "0", "0", "1", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "static", "int", "nvptx_sese_number", "(", "int", "n", ",", "int", "p", ",", "int", "dir", ",", "basic_block", "b", ",", "auto_vec", "<", "basic_block", ">", "*", "list", ")", "{", "if", "(", "BB_GET_SESE", "(", "b", ")", ")", "return", "n", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Block %d(%d), parent (%d), orientation %+d\\n\"", ",", "b", "->", "index", ",", "n", ",", "p", ",", "dir", ")", ";", "BB_SET_SESE", "(", "b", ",", "new", "bb_sese", "(", "n", ",", "p", ",", "dir", ")", ")", ";", "p", "=", "n", ";", "n", "+=", "3", ";", "list", "->", "quick_push", "(", "b", ")", ";", "for", "(", "unsigned", "ix", "=", "2", ";", "ix", ";", "ix", "--", ")", "{", "vec", "<", "edge", ",", "va_gc", ">", "*", "edges", "=", "dir", ">", "0", "?", "b", "->", "succs", ":", "b", "->", "preds", ";", "size_t", "offset", "=", "(", "dir", ">", "0", "?", "offsetof", "(", "edge_def", ",", "dest", ")", ":", "offsetof", "(", "edge_def", ",", "src", ")", ")", ";", "edge", "e", ";", "edge_iterator", "(", "ei", ")", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "edges", ")", "{", "basic_block", "target", "=", "*", "(", "basic_block", "*", ")", "(", "(", "char", "*", ")", "e", "+", "offset", ")", ";", "if", "(", "target", "->", "flags", "&", "BB_VISITED", ")", "n", "=", "nvptx_sese_number", "(", "n", ",", "p", ",", "dir", ",", "target", ",", "list", ")", ";", "}", "dir", "=", "-", "dir", ";", "}", "return", "n", ";", "}", "</s>" ]

[ "DFS", "walk", "creating", "SESE", "data", "structures", ".", "Only", "cover", "nodes", "with", "BB_VISITED", "set", ".", "Append", "discovered", "blocks", "to", "LIST", ".", "We", "number", "in", "increments", "of", "3", "so", "that", "the", "above", "and", "below", "pseudo", "nodes", "can", "be", "implicitly", "numbered", "too", "." ]

[ "nvptx", "\"Block %d(%d), parent (%d), orientation %+d\\n\"", "3", "2", "0", "0" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createRISCVBranchSelectionPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "SPIRV" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "parsePrimaryExpr", "(", "const", "MCExpr", "*", "&", "Res", ",", "SMLoc", "&", "EndLoc", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "if", "(", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Percent", ")", "||", "(", "isParsingIntelSyntax", "(", ")", "&&", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Identifier", ")", "&&", "MatchRegisterName", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", ")", ")", ")", "{", "SMLoc", "StartLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "unsigned", "RegNo", ";", "if", "(", "ParseRegister", "(", "RegNo", ",", "StartLoc", ",", "EndLoc", ")", ")", "return", "true", ";", "Res", "=", "X86MCExpr", "::", "create", "(", "RegNo", ",", "Parser", ".", "getContext", "(", ")", ")", ";", "return", "false", ";", "}", "return", "Parser", ".", "parsePrimaryExpr", "(", "Res", ",", "EndLoc", ",", "nullptr", ")", ";", "}", "</s>" ]

[ "Parse", "a", "primary", "expression", "." ]

[ "X86", "X86", "X86MCExpr::create" ]

[]

[ "<s>", "void", "MipsELFStreamer", "::", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "MCContext", "&", "Context", "=", "getContext", "(", ")", ";", "const", "MCRegisterInfo", "*", "MCRegInfo", "=", "Context", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "unsigned", "OpIndex", "=", "0", ";", "OpIndex", "<", "Inst", ".", "getNumOperands", "(", ")", ";", "++", "OpIndex", ")", "{", "const", "MCOperand", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpIndex", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "RegInfoRecord", "->", "SetPhysRegUsed", "(", "Reg", ",", "MCRegInfo", ")", ";", "}", "createPendingLabelRelocs", "(", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "Mips", "Mips", "0" ]

[]

[ "<s>", "bool", "ix86_using_red_zone", "(", "void", ")", "{", "return", "(", "TARGET_RED_ZONE", "&&", "!", "TARGET_64BIT_MS_ABI", "&&", "(", "!", "cfun", "->", "machine", "->", "has_local_indirect_jump", "||", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_keep", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "red-zone", "is", "in", "use", "." ]

[ "i386" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "VZEXT_MOVL", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SHUFPS", ":", "case", "X86ISD", "::", "SHUFPD", ":", "case", "X86ISD", "::", "PALIGN", ":", "case", "X86ISD", "::", "PUNPCKHBW", ":", "case", "X86ISD", "::", "PUNPCKHWD", ":", "case", "X86ISD", "::", "PUNPCKHDQ", ":", "case", "X86ISD", "::", "PUNPCKHQDQ", ":", "case", "X86ISD", "::", "UNPCKHPS", ":", "case", "X86ISD", "::", "UNPCKHPD", ":", "case", "X86ISD", "::", "PUNPCKLBW", ":", "case", "X86ISD", "::", "PUNPCKLWD", ":", "case", "X86ISD", "::", "PUNPCKLDQ", ":", "case", "X86ISD", "::", "PUNPCKLQDQ", ":", "case", "X86ISD", "::", "UNPCKLPS", ":", "case", "X86ISD", "::", "UNPCKLPD", ":", "case", "X86ISD", "::", "MOVHLPS", ":", "case", "X86ISD", "::", "MOVLHPS", ":", "case", "X86ISD", "::", "PSHUFD", ":", "case", "X86ISD", "::", "PSHUFHW", ":", "case", "X86ISD", "::", "PSHUFLW", ":", "case", "X86ISD", "::", "MOVSS", ":", "case", "X86ISD", "::", "MOVSD", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "X86", "X86", "ISD::EXTRACT_VECTOR_ELT", "ISD::SELECT", "X86ISD::CMOV", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::OR", "ISD::STORE", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT", "X86ISD::VZEXT_MOVL", "ISD::ZERO_EXTEND", "X86ISD::SHUFPS", "X86ISD::SHUFPD", "X86ISD::PALIGN", "X86ISD::PUNPCKHBW", "X86ISD::PUNPCKHWD", "X86ISD::PUNPCKHDQ", "X86ISD::PUNPCKHQDQ", "X86ISD::UNPCKHPS", "X86ISD::UNPCKHPD", "X86ISD::PUNPCKLBW", "X86ISD::PUNPCKLWD", "X86ISD::PUNPCKLDQ", "X86ISD::PUNPCKLQDQ", "X86ISD::UNPCKLPS", "X86ISD::UNPCKLPD", "X86ISD::MOVHLPS", "X86ISD::MOVLHPS", "X86ISD::PSHUFD", "X86ISD::PSHUFHW", "X86ISD::PSHUFLW", "X86ISD::MOVSS", "X86ISD::MOVSD", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "bool", "PPCLinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getDataLayout", "(", ")", ";", "bool", "isPPC64", "=", "TD", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "PPCTargetStreamer", "&", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "&", ">", "(", "*", "OutStreamer", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "!", "TOC", ".", "empty", "(", ")", ")", "{", "const", "MCSectionELF", "*", "Section", ";", "if", "(", "isPPC64", ")", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".toc\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "else", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".got2\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "Section", ")", ";", "for", "(", "MapVector", "<", "MCSymbol", "*", ",", "MCSymbol", "*", ">", "::", "iterator", "I", "=", "TOC", ".", "begin", "(", ")", ",", "E", "=", "TOC", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "I", "->", "second", ")", ";", "MCSymbol", "*", "S", "=", "I", "->", "first", ";", "if", "(", "isPPC64", ")", "TS", ".", "emitTCEntry", "(", "*", "S", ")", ";", "else", "OutStreamer", ".", "EmitSymbolValue", "(", "S", ",", "4", ")", ";", "}", "}", "MachineModuleInfoELF", "&", "MMIELF", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MachineModuleInfoELF", "::", "SymbolListTy", "Stubs", "=", "MMIELF", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "PowerPC", "PPC", "PPC", "64", "PPC", "PPC", "PPC", "\".toc\"", "\".got2\"", "PPC", "4", "0", "PPC", "8", "4" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_reg_using_mov", "(", "machine_mode", "mode", ",", "unsigned", "int", "regno", ",", "HOST_WIDE_INT", "cfa_offset", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rtx", "mem", ",", "addr", ",", "base", ",", "insn", ";", "unsigned", "int", "align", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "addr", "=", "choose_baseaddr", "(", "cfa_offset", ",", "&", "align", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "addr", ")", ";", "align", "=", "MIN", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", ",", "align", ")", ";", "gcc_assert", "(", "!", "(", "cfa_offset", "&", "(", "align", "/", "BITS_PER_UNIT", "-", "1", ")", ")", ")", ";", "set_mem_align", "(", "mem", ",", "align", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "base", "=", "addr", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "gcc_checking_assert", "(", "REG_P", "(", "base", ")", ")", ";", "if", "(", "m", "->", "fs", ".", "realigned", ")", "{", "gcc_checking_assert", "(", "stack_realign_drap", ")", ";", "if", "(", "regno", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", "{", "gcc_checking_assert", "(", "cfun", "->", "machine", "->", "fs", ".", "fp_valid", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "cfun", "->", "machine", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "mem", ")", ";", "}", "else", "{", "gcc_checking_assert", "(", "cfun", "->", "machine", "->", "fs", ".", "fp_valid", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "cfun", "->", "machine", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_EXPRESSION", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "}", "else", "if", "(", "base", "==", "stack_pointer_rtx", "&&", "m", "->", "fs", ".", "sp_realigned", "&&", "cfa_offset", ">=", "m", "->", "fs", ".", "sp_realigned_offset", ")", "{", "gcc_checking_assert", "(", "stack_realign_fp", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_EXPRESSION", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "else", "if", "(", "base", "!=", "m", "->", "fs", ".", "cfa_reg", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "m", "->", "fs", ".", "cfa_reg", ",", "m", "->", "fs", ".", "cfa_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "single", "register", "save", "at", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386", "1", "1", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "usesConstantBus", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpIdx", ")", "{", "const", "MCOperand", "&", "MO", "=", "Inst", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "!", "isInlineConstant", "(", "Inst", ",", "OpIdx", ")", ";", "}", "else", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "auto", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "const", "MCRegisterInfo", "*", "TRI", "=", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "isSGPR", "(", "mc2PseudoReg", "(", "Reg", ")", ",", "TRI", ")", "&&", "Reg", "!=", "SGPR_NULL", ";", "}", "else", "{", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "microblaze_declare_object", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "const", "char", "*", "section", ",", "const", "char", "*", "fmt", ",", "int", "size", ")", "{", "fputs", "(", "section", ",", "stream", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "fmt", ",", "size", ")", ";", "}", "</s>" ]

[ "Emit", "either", "a", "label", ",", ".comm", ",", "or", ".lcomm", "directive", ",", "and", "mark", "that", "the", "symbol", "is", "used", ",", "so", "that", "we", "do", "n't", "emit", "an", ".extern", "for", "it", "in", "microblaze_asm_file_end", "." ]

[ "microblaze" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SI annotate control flow\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "R600", "\"SI annotate control flow\"" ]

[]

[ "<s>", "static", "bool", "mayAlias", "(", "MachineInstr", "&", "MIa", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "MemInsns", ",", "const", "AArch64InstrInfo", "*", "TII", ")", "{", "for", "(", "MachineInstr", "*", "MIb", ":", "MemInsns", ")", "if", "(", "mayAlias", "(", "MIa", ",", "*", "MIb", ",", "TII", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "instruction", "'s", "memory", "access", "aliases", "the", "memory", "access", "of", "Other", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "index_term_p", "(", "rtx", "prod", ",", "machine_mode", "mode", ",", "bool", "strict", ")", "{", "rtx", "xfoo0", ",", "xfoo1", ";", "bool", "log_p", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", ")", "return", "BASE_REGISTER_P", "(", "prod", ",", "strict", ")", ";", "if", "(", "(", "GET_CODE", "(", "prod", ")", "!=", "MULT", "&&", "GET_CODE", "(", "prod", ")", "!=", "ASHIFT", ")", "||", "GET_MODE_SIZE", "(", "mode", ")", ">", "8", ")", "return", "false", ";", "log_p", "=", "GET_CODE", "(", "prod", ")", "==", "ASHIFT", ";", "xfoo0", "=", "XEXP", "(", "prod", ",", "0", ")", ";", "xfoo1", "=", "XEXP", "(", "prod", ",", "1", ")", ";", "if", "(", "CONST_INT_P", "(", "xfoo0", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "(", "log_p", "?", "1", "<<", "INTVAL", "(", "xfoo0", ")", ":", "INTVAL", "(", "xfoo0", ")", ")", "&&", "INDEX_REGISTER_P", "(", "xfoo1", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "CONST_INT_P", "(", "xfoo1", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "(", "log_p", "?", "1", "<<", "INTVAL", "(", "xfoo1", ")", ":", "INTVAL", "(", "xfoo1", ")", ")", "&&", "INDEX_REGISTER_P", "(", "xfoo0", ",", "strict", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "1", "if", "PROD", "is", "either", "a", "reg", "times", "size", "of", "mode", "MODE", "and", "MODE", "is", "less", "than", "or", "equal", "8", "bytes", ",", "or", "just", "a", "reg", "if", "MODE", "is", "one", "byte", "." ]

[ "vax", "1", "8", "0", "1", "1", "1" ]

[]

[ "<s>", "const", "ArrayRef", "<", "MCPhysReg", ">", "Cpu0ABIInfo", "::", "GetByValArgRegs", "(", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsS32", "(", ")", ")", "return", "makeArrayRef", "(", "S32IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "byval", "arguments", "." ]

[ "Cpu0", "Cpu0", "\"Unhandled ABI\"" ]

[]

[ "<s>", "bool", "MipsConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "MCP", "=", "mf", ".", "getConstantPool", "(", ")", ";", "STI", "=", "&", "mf", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island machine function \"", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "STI", "->", "inMips16Mode", "(", ")", "||", "!", "MipsSubtarget", "::", "useConstantIslands", "(", ")", ")", "{", "return", "false", ";", "}", "TII", "=", "(", "const", "Mips16InstrInfo", "*", ")", "MF", "->", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MFI", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island processing \"", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "PrescannedForConstants", ")", "prescanForConstants", "(", ")", ";", "HasFarJump", "=", "false", ";", "MF", "->", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialPlacement", "(", "CPEMIs", ")", ";", "initPICLabelUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "initializeFunctionInfo", "(", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "MadeChange", "|=", "removeUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "0", ",", "NoBRIters", "=", "0", ";", "(", "void", ")", "NoBRIters", ";", "while", "(", "true", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning CP iteration #\"", "<<", "NoCPIters", "<<", "'\\n'", ")", ";", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "i", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "30", ")", "report_fatal_error", "(", "\"Constant Island pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning BR iteration #\"", "<<", "NoBRIters", "<<", "'\\n'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "30", ")", "report_fatal_error", "(", "\"Branch Fix Up pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BBInfo", ".", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Mips", "Mips", "Mips", "\"constant island machine function \"", "\"\\n\"", "Mips", "Mips", "Mips", "Mips", "\"constant island processing \"", "\"\\n\"", "0", "0", "\"Beginning CP iteration #\"", "0", "30", "\"Constant Island pass failed to converge!\"", "\"Beginning BR iteration #\"", "0", "30", "\"Branch Fix Up pass failed to converge!\"" ]

[]

[ "<s>", "static", "bool", "rs6000_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "RELOCATABLE_NEEDS_FIXUP", "&&", "size", "==", "4", "&&", "aligned_p", ")", "{", "static", "int", "recurse", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "TARGET_RELOCATABLE", "||", "flag_pic", ">", "1", ")", "&&", "in_section", "!=", "toc_section", "&&", "!", "recurse", "&&", "!", "CONST_SCALAR_INT_P", "(", "x", ")", "&&", "CONSTANT_P", "(", "x", ")", ")", "{", "char", "buf", "[", "256", "]", ";", "recurse", "=", "1", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCP\"", ",", "fixuplabelno", ")", ";", "fixuplabelno", "++", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "buf", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t(\"", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fprintf", "(", "asm_out_file", ",", "\")@fixup\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"", ")", ";", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "2", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t\"", ")", ";", "assemble_name", "(", "asm_out_file", ",", "buf", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\n\\t.previous\\n\"", ")", ";", "recurse", "=", "0", ";", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "XSTR", "(", "x", ",", "0", ")", "[", "0", "]", "==", "'.'", "&&", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "x", ",", "0", ")", ";", "while", "(", "*", "name", "==", "'.'", ")", "name", "++", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t%s\\n\"", ",", "name", ")", ";", "return", "true", ";", "}", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "powerpc", "version", "has", "to", "handle", "fixup", "entries", "for", "relocatable", "code", "if", "RELOCATABLE_NEEDS_FIXUP", "is", "defined", ".", "It", "also", "needs", "to", "handle", "DI-mode", "objects", "on", "64-bit", "targets", "." ]

[ "rs6000", "4", "0", "1", "256", "1", "\"LCP\"", "\"\\t.long\\t(\"", "\")@fixup\\n\"", "\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"", "2", "\"\\t.long\\t\"", "\"\\n\\t.previous\\n\"", "0", "0", "0", "0", "\"\\t.long\\t%s\\n\"" ]

[]

[ "<s>", "bool", "MBlazeTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "!", "Kind", ".", "isBSS", "(", ")", "&&", "!", "Kind", ".", "isDataRel", "(", ")", ")", "return", "false", ";", "if", "(", "Kind", ".", "isMergeable1ByteCString", "(", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "rtx", "aarch64_simd_dup_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "x", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "vals", ",", "&", "x", ")", ")", "return", "NULL_RTX", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "x", ")", ";", "return", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "If", "VALS", "is", "a", "vector", "constant", "that", "can", "be", "loaded", "into", "a", "register", "using", "DUP", ",", "generate", "instructions", "to", "do", "so", "and", "return", "an", "RTX", "to", "assign", "to", "the", "register", ".", "Otherwise", "return", "NULL_RTX", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "TOY", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_TOY_CALL\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_TOY_BR\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "TOY", "TOY::NumTargetFixupKinds", "\"fixup_TOY_CALL\"", "0", "16", "\"fixup_TOY_BR\"", "0", "16", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "(", "MFI", "->", "hasCalls", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MFI", "->", "hasStackMap", "(", ")", "||", "MFI", "->", "hasPatchPoint", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "virtual", "gimple", "*", "fold", "(", "gimple_folder", "&", ")", "const", "{", "return", "NULL", ";", "}", "</s>" ]

[ "Try", "to", "fold", "the", "call", ".", "Return", "the", "new", "statement", "on", "success", "and", "null", "on", "failure", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "Hexagon" ]

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "X86InstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "uint16_t", "domain", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "unsigned", "opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "uint16_t", "validDomains", "=", "0", ";", "if", "(", "domain", ")", "{", "if", "(", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ",", "ReplaceableInstrs", ")", ")", "{", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "lookup", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX2", ")", ")", "{", "validDomains", "=", "Subtarget", ".", "hasAVX2", "(", ")", "?", "0xe", ":", "0x6", ";", "}", "else", "if", "(", "lookup", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX2InsertExtract", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "hasAVX2", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0", ",", "0", ")", ";", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "lookupAVX512", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX512", ")", ")", "{", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "Subtarget", ".", "hasDQI", "(", ")", "&&", "lookupAVX512", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX512DQ", ")", ")", "{", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "Subtarget", ".", "hasDQI", "(", ")", ")", "{", "if", "(", "const", "uint16_t", "*", "table", "=", "lookupAVX512", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX512DQMasked", ")", ")", "{", "if", "(", "domain", "==", "1", "||", "(", "domain", "==", "3", "&&", "table", "[", "3", "]", "==", "opcode", ")", ")", "validDomains", "=", "0xa", ";", "else", "validDomains", "=", "0xc", ";", "}", "}", "}", "return", "std", "::", "make_pair", "(", "domain", ",", "validDomains", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "X86", "X86", "X86II::SSEDomainShift", "3", "0", "0xe", "0xe", "0x6", "0", "0", "0xe", "0xe", "0xe", "1", "3", "3", "0xa", "0xc" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "bool", "NeedsAlign", "=", "(", "MFI", ".", "getMaxAlign", "(", ")", ">", "getStackAlign", "(", ")", ")", ";", "if", "(", "!", "HasAlloca", "||", "!", "NeedsAlign", ")", "return", ";", "SmallSet", "<", "int", ",", "4", ">", "DealignSlots", ";", "unsigned", "LFS", "=", "MFI", ".", "getLocalFrameSize", "(", ")", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MFI", ".", "isSpillSlotObjectIndex", "(", "i", ")", "||", "MFI", ".", "isDeadObjectIndex", "(", "i", ")", ")", "continue", ";", "unsigned", "S", "=", "MFI", ".", "getObjectSize", "(", "i", ")", ";", "Align", "A", "=", "std", "::", "max", "(", "MFI", ".", "getObjectAlign", "(", "i", ")", ",", "Align", "(", "8", ")", ")", ";", "MFI", ".", "setObjectAlignment", "(", "i", ",", "Align", "(", "8", ")", ")", ";", "LFS", "=", "alignTo", "(", "LFS", "+", "S", ",", "A", ")", ";", "MFI", ".", "mapLocalFrameObject", "(", "i", ",", "-", "static_cast", "<", "int64_t", ">", "(", "LFS", ")", ")", ";", "DealignSlots", ".", "insert", "(", "i", ")", ";", "}", "MFI", ".", "setLocalFrameSize", "(", "LFS", ")", ";", "Align", "A", "=", "MFI", ".", "getLocalFrameMaxAlign", "(", ")", ";", "assert", "(", "A", "<=", "8", "&&", "\"Unexpected local frame alignment\"", ")", ";", "if", "(", "A", "==", "1", ")", "MFI", ".", "setLocalFrameMaxAlign", "(", "Align", "(", "8", ")", ")", ";", "MFI", ".", "setUseLocalStackAllocationBlock", "(", "true", ")", ";", "if", "(", "!", "DealignSlots", ".", "empty", "(", ")", ")", "{", "for", "(", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "BB", ")", "{", "bool", "KeepOld", "=", "true", ";", "ArrayRef", "<", "MachineMemOperand", "*", ">", "memops", "=", "MI", ".", "memoperands", "(", ")", ";", "SmallVector", "<", "MachineMemOperand", "*", ",", "1", ">", "new_memops", ";", "for", "(", "MachineMemOperand", "*", "MMO", ":", "memops", ")", "{", "auto", "*", "PV", "=", "MMO", "->", "getPseudoValue", "(", ")", ";", "if", "(", "auto", "*", "FS", "=", "dyn_cast_or_null", "<", "FixedStackPseudoSourceValue", ">", "(", "PV", ")", ")", "{", "int", "FI", "=", "FS", "->", "getFrameIndex", "(", ")", ";", "if", "(", "DealignSlots", ".", "count", "(", "FI", ")", ")", "{", "auto", "*", "NewMMO", "=", "MF", ".", "getMachineMemOperand", "(", "MMO", "->", "getPointerInfo", "(", ")", ",", "MMO", "->", "getFlags", "(", ")", ",", "MMO", "->", "getSize", "(", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ",", "MMO", "->", "getAAInfo", "(", ")", ",", "MMO", "->", "getRanges", "(", ")", ",", "MMO", "->", "getSyncScopeID", "(", ")", ",", "MMO", "->", "getOrdering", "(", ")", ",", "MMO", "->", "getFailureOrdering", "(", ")", ")", ";", "new_memops", ".", "push_back", "(", "NewMMO", ")", ";", "KeepOld", "=", "false", ";", "continue", ";", "}", "}", "new_memops", ".", "push_back", "(", "MMO", ")", ";", "}", "if", "(", "!", "KeepOld", ")", "MI", ".", "setMemRefs", "(", "MF", ",", "new_memops", ")", ";", "}", "}", "}", "unsigned", "AP", "=", "0", ";", "if", "(", "const", "MachineInstr", "*", "AI", "=", "getAlignaInstr", "(", "MF", ")", ")", "AP", "=", "AI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "HMFI", ".", "setStackAlignBasePhysReg", "(", "AP", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "Hexagon", "Hexagon", "4", "0", "8", "8", "8", "\"Unexpected local frame alignment\"", "1", "8", "1", "0", "0", "Hexagon" ]

[]

[ "<s>", "bool", "DCPU16FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Dcpu16", "DCPU16" ]

[]

[ "<s>", "bool", "mprocPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createmprocISelDag", "(", "getmprocTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "mproc", "mproc", "mproc", "mproc" ]

[]

[ "<s>", "MCSymbol", "*", "X86AsmPrinter", "::", "GetCPISymbol", "(", "unsigned", "CPID", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetKnownWindowsMSVC", "(", ")", ")", "{", "const", "MachineConstantPoolEntry", "&", "CPE", "=", "MF", "->", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", "[", "CPID", "]", ";", "if", "(", "!", "CPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "{", "SectionKind", "Kind", "=", "CPE", ".", "getSectionKind", "(", "TM", ".", "getDataLayout", "(", ")", ")", ";", "const", "Constant", "*", "C", "=", "CPE", ".", "Val", ".", "ConstVal", ";", "const", "MCSectionCOFF", "*", "S", "=", "cast", "<", "MCSectionCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForConstant", "(", "Kind", ",", "C", ")", ")", ";", "if", "(", "MCSymbol", "*", "Sym", "=", "S", "->", "getCOMDATSymbol", "(", ")", ")", "{", "if", "(", "Sym", "->", "isUndefined", "(", ")", ")", "OutStreamer", ".", "EmitSymbolAttribute", "(", "Sym", ",", "MCSA_Global", ")", ";", "return", "Sym", ";", "}", "}", "}", "return", "AsmPrinter", "::", "GetCPISymbol", "(", "CPID", ")", ";", "}", "</s>" ]

[ "Return", "the", "symbol", "for", "the", "specified", "constant", "pool", "entry", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "PPCDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "if", "(", "TM", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", ";", "PeepholePPC64", "(", ")", ";", "PeepholeCROps", "(", ")", ";", "PeepholePPC64ZExt", "(", ")", ";", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "unsigned", "Cpu0MachineFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "return", "GlobalBaseReg", "=", "Cpu0", "::", "GP", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Cpu0", "Cpu0", "Cpu0::GP" ]

[]

[ "<s>", "void", "M68kIncomingValueHandler", "::", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "{", "MIRBuilder", ".", "getMRI", "(", ")", "->", "addLiveIn", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "PhysReg", ")", ";", "IncomingValueHandler", "::", "assignValueToReg", "(", "ValVReg", ",", "PhysReg", ",", "VA", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "void", "MINA32MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Binary", ",", "support", "::", "little", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "MINA32", "MINA32", "support::endian", "support::little" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", ")", "return", ";", "for", "(", "ConstMIOperands", "MO", "(", "*", "MI", ")", ";", "MO", ".", "isValid", "(", ")", ";", "++", "MO", ")", "if", "(", "MO", "->", "isReg", "(", ")", "&&", "MO", "->", "isDef", "(", ")", "&&", "!", "MO", "->", "isImplicit", "(", ")", ")", "RegDefs", ".", "insert", "(", "MO", "->", "getReg", "(", ")", ")", ";", "if", "(", "TII", "->", "isZeroCost", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", ";", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", ")", "{", "assert", "(", "TII", "->", "mayBeNewStore", "(", "*", "MI", ")", "&&", "\"Expecting .new store\"", ")", ";", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "TII", "->", "getDotNewOp", "(", "*", "MI", ")", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "assert", "(", "Resources", "->", "canReserveResources", "(", "*", "NewMI", ")", ")", ";", "Resources", "->", "reserveResources", "(", "*", "NewMI", ")", ";", "MF", "->", "DeleteMachineInstr", "(", "NewMI", ")", ";", "}", "else", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Add instruction \"", "<<", "*", "MI", ")", ";", "if", "(", "TII", "->", "mayBeCurLoad", "(", "*", "MI", ")", ")", "for", "(", "auto", "&", "S", ":", "SU", "->", "Succs", ")", "if", "(", "S", ".", "isAssignedRegDep", "(", ")", "&&", "S", ".", "getLatency", "(", ")", "==", "0", "&&", "SU", "->", "getHeight", "(", ")", "==", "S", ".", "getSUnit", "(", ")", "->", "getHeight", "(", ")", ")", "{", "UsesDotCur", "=", "S", ".", "getSUnit", "(", ")", ";", "DotCurPNum", "=", "PacketNum", ";", "break", ";", "}", "if", "(", "SU", "==", "UsesDotCur", ")", "{", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "}", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Hexagon", "Hexagon", "\"Expecting .new store\"", "\" Add instruction \"", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"R600 Vector Registers Merge Pass\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "R600", "\"R600 Vector Registers Merge Pass\"" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "ARMAsmBackendELF", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "unsigned", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "\"BFD_RELOC_NONE\"", ",", "ELF", "::", "R_ARM_NONE", ")", ".", "Case", "(", "\"BFD_RELOC_8\"", ",", "ELF", "::", "R_ARM_ABS8", ")", ".", "Case", "(", "\"BFD_RELOC_16\"", ",", "ELF", "::", "R_ARM_ABS16", ")", ".", "Case", "(", "\"BFD_RELOC_32\"", ",", "ELF", "::", "R_ARM_ABS32", ")", ".", "Default", "(", "-", "1u", ")", ";", "if", "(", "Type", "==", "-", "1u", ")", "return", "None", ";", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "ARM", "ARM", "\"BFD_RELOC_NONE\"", "ARM", "\"BFD_RELOC_8\"", "ARM", "\"BFD_RELOC_16\"", "ARM", "\"BFD_RELOC_32\"", "ARM", "1u", "1u" ]

[]

[ "<s>", "static", "void", "convert_to_callp", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "lab", ";", "extract_insn", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "{", "rtx", "dest", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "lab", "=", "recog_data", ".", "operand", "[", "1", "]", ";", "PATTERN", "(", "insn", ")", "=", "gen_callp_value", "(", "dest", ",", "lab", ")", ";", "INSN_CODE", "(", "insn", ")", "=", "CODE_FOR_callp_value", ";", "}", "else", "{", "lab", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "PATTERN", "(", "insn", ")", "=", "gen_callp", "(", "lab", ")", ";", "INSN_CODE", "(", "insn", ")", "=", "CODE_FOR_callp", ";", "}", "}", "</s>" ]

[ "Convert", "the", "pattern", "of", "INSN", ",", "which", "must", "be", "a", "CALL_INSN", ",", "into", "a", "callp", "." ]

[ "c6x", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "avr_addr_space_diagnose_usage", "(", "addr_space_t", "as", ",", "location_t", "loc", ")", "{", "(", "void", ")", "avr_addr_space_supported_p", "(", "as", ",", "loc", ")", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_DIAGNOSE_USAGE", "'", "." ]

[ "avr" ]

[]

[ "<s>", "rtx", "function_expander", "::", "generate_insn", "(", "insn_code", "icode", ")", "{", "expand_insn", "(", "icode", ",", "m_ops", ".", "length", "(", ")", ",", "m_ops", ".", "address", "(", ")", ")", ";", "return", "function_returns_void_p", "(", ")", "?", "const0_rtx", ":", "m_ops", "[", "0", "]", ".", "value", ";", "}", "</s>" ]

[ "Generate", "instruction", "ICODE", ",", "given", "that", "its", "operands", "have", "already", "been", "added", "to", "M_OPS", ".", "Return", "the", "value", "of", "the", "first", "operand", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "bool", "arm_is_segment_info_known", "(", "rtx", "orig", ",", "bool", "*", "is_readonly", ")", "{", "*", "is_readonly", "=", "false", ";", "if", "(", "LABEL_REF_P", "(", "orig", ")", ")", "{", "*", "is_readonly", "=", "true", ";", "return", "true", ";", "}", "if", "(", "SYMBOL_REF_P", "(", "orig", ")", ")", "{", "if", "(", "CONSTANT_POOL_ADDRESS_P", "(", "orig", ")", ")", "{", "*", "is_readonly", "=", "true", ";", "return", "true", ";", "}", "if", "(", "SYMBOL_REF_LOCAL_P", "(", "orig", ")", "&&", "!", "SYMBOL_REF_EXTERNAL_P", "(", "orig", ")", "&&", "SYMBOL_REF_DECL", "(", "orig", ")", "&&", "(", "!", "DECL_P", "(", "SYMBOL_REF_DECL", "(", "orig", ")", ")", "||", "!", "DECL_COMMON", "(", "SYMBOL_REF_DECL", "(", "orig", ")", ")", ")", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "orig", ")", ";", "tree", "init", "=", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "?", "DECL_INITIAL", "(", "decl", ")", ":", "(", "TREE_CODE", "(", "decl", ")", "==", "CONSTRUCTOR", ")", "?", "decl", ":", "0", ";", "int", "reloc", "=", "0", ";", "bool", "named_section", ",", "readonly", ";", "if", "(", "init", "&&", "init", "!=", "error_mark_node", ")", "reloc", "=", "compute_reloc_for_constant", "(", "init", ")", ";", "named_section", "=", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "lookup_attribute", "(", "\"section\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "readonly", "=", "decl_readonly_section", "(", "decl", ",", "reloc", ")", ";", "if", "(", "named_section", ")", "return", "false", ";", "*", "is_readonly", "=", "readonly", ";", "return", "true", ";", "}", "return", "false", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Try", "to", "determine", "whether", "an", "object", ",", "referenced", "via", "ORIG", ",", "will", "be", "placed", "in", "the", "text", "or", "data", "segment", ".", "This", "is", "used", "in", "FDPIC", "mode", ",", "to", "decide", "which", "relocations", "to", "use", "when", "accessing", "ORIG", ".", "*", "IS_READONLY", "is", "set", "to", "true", "if", "ORIG", "is", "a", "read-only", "location", ",", "false", "otherwise", ".", "Return", "true", "if", "we", "could", "determine", "the", "location", "of", "ORIG", ",", "false", "otherwise", ".", "*", "IS_READONLY", "is", "valid", "only", "when", "we", "return", "true", "." ]

[ "arm", "0", "0", "\"section\"" ]

[]

[ "<s>", "bool", "s390_match_ccmode", "(", "rtx", "insn", ",", "enum", "machine_mode", "req_mode", ")", "{", "int", "i", ";", "if", "(", "req_mode", "==", "VOIDmode", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "return", "s390_match_ccmode_set", "(", "PATTERN", "(", "insn", ")", ",", "req_mode", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "set", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", "if", "(", "!", "s390_match_ccmode_set", "(", "set", ",", "req_mode", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "every", "SET", "in", "INSN", "that", "sets", "the", "CC", "register", "has", "source", "and", "destination", "with", "matching", "CC", "modes", "and", "that", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

[ "s390", "0", "0", "0" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getArgRegsSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NumRegs", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MIB", ".", "copyImplicitOps", "(", "&", "*", "MI", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NumRegs", "=", "true", ";", "}", "if", "(", "NumRegs", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "else", "MF", ".", "DeleteMachineInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SAVErr", ",", "SAVEri", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "regFP", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I6", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "regFP", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "nullptr", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "unsigned", "regInRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I7", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "O7", ",", "true", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "nullptr", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "\"Shrink-wrapping not yet supported\"", "Sparc", "Sparc", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "Sparc", "SP", "SP::I6", "SP::I7", "SP::O7" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "MSP430" ]

[]

[ "<s>", "bool", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "VE" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createMipsISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "static", "int", "ix86_avx_u128_mode_after", "(", "int", "mode", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "vzeroupper_operation", "(", "pat", ",", "VOIDmode", ")", "||", "vzeroall_operation", "(", "pat", ",", "VOIDmode", ")", ")", "return", "AVX_U128_CLEAN", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "bool", "avx_reg256_found", "=", "false", ";", "note_stores", "(", "pat", ",", "ix86_check_avx256_stores", ",", "&", "avx_reg256_found", ")", ";", "return", "avx_reg256_found", "?", "AVX_U128_DIRTY", ":", "AVX_U128_CLEAN", ";", "}", "return", "mode", ";", "}", "</s>" ]

[ "Calculate", "mode", "of", "upper", "128bit", "AVX", "registers", "after", "the", "insn", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "rl78_alloc_physical_registers_op1", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "rtx_equal_p", "(", "OP", "(", "0", ")", ",", "OP", "(", "1", ")", ")", ")", "{", "OP", "(", "0", ")", "=", "OP", "(", "1", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "1", ")", ",", "DE", ",", "insn", ")", ";", "}", "else", "{", "if", "(", "MEM_P", "(", "OP", "(", "0", ")", ")", "&&", "already_contains", "(", "HL", ",", "XEXP", "(", "OP", "(", "0", ")", ",", "0", ")", ")", ")", "{", "OP", "(", "0", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "0", ")", ",", "HL", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "1", ")", ",", "BC", ",", "insn", ")", ";", "}", "else", "{", "OP", "(", "0", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "0", ")", ",", "BC", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "1", ")", ",", "HL", ",", "insn", ")", ";", "}", "}", "MAYBE_OK", "(", "insn", ")", ";", "OP", "(", "0", ")", "=", "move_from_acc", "(", "0", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "OP", "(", "1", ")", "=", "move_to_acc", "(", "1", ",", "insn", ")", ";", "MUST_BE_OK", "(", "insn", ")", ";", "}", "</s>" ]

[ "Devirtualize", "an", "insn", "of", "the", "form", "(", "SET", "(", "op", ")", "(", "unop", "(", "op", ")", ")", ")", "." ]

[ "rl78", "0", "1", "0", "1", "1", "0", "0", "0", "0", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MipsRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "ABI", ".", "GetStackPtr", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "ZERO", "=", "ABI", ".", "GetNullPtr", "(", ")", ";", "unsigned", "MOVE", "=", "ABI", ".", "GetGPRMoveOp", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "MOVE", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "for", "(", "int", "J", "=", "0", ";", "J", "<", "4", ";", "++", "J", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "ABI", ".", "GetEhDataReg", "(", "J", ")", ",", "MipsFI", "->", "getEhDataRegFI", "(", "J", ")", ",", "RC", ",", "&", "RegInfo", ")", ";", "}", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "0", "0", "4", "Mips" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "if", "(", "EnableSIInsertWaitcntsPass", ")", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "else", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "createSIMemoryLegalizerPass", "(", ")", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "bool", "aarch64_mask_and_shift_for_ubfiz_p", "(", "machine_mode", "mode", ",", "rtx", "mask", ",", "rtx", "shft_amnt", ")", "{", "return", "CONST_INT_P", "(", "mask", ")", "&&", "CONST_INT_P", "(", "shft_amnt", ")", "&&", "INTVAL", "(", "shft_amnt", ")", "<", "GET_MODE_BITSIZE", "(", "mode", ")", "&&", "exact_log2", "(", "(", "INTVAL", "(", "mask", ")", ">>", "INTVAL", "(", "shft_amnt", ")", ")", "+", "1", ")", ">=", "0", "&&", "(", "INTVAL", "(", "mask", ")", "&", "(", "(", "1", "<<", "INTVAL", "(", "shft_amnt", ")", ")", "-", "1", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "mask", "and", "a", "shift", "amount", "from", "an", "RTX", "of", "the", "form", "(", "x", "<", "<", "SHFT_AMNT", ")", "&", "MASK", "are", "valid", "to", "combine", "into", "a", "UBFIZ", "instruction", "of", "mode", "MODE", ".", "See", "the", "*", "andim_ashift", "<", "mode", ">", "_bfiz", "pattern", "." ]

[ "aarch64", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createARMFixCortexA57AES1742098Pass", "(", ")", ")", ";", "addPass", "(", "createARMBranchTargetsPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "addPass", "(", "createARMLowOverheadLoopsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "{", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createEHContGuardCatchretPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "frv_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_CAN_ELIMINATE", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "MCS51AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "Loc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "return", "emit", "(", "Inst", ",", "Loc", ",", "Out", ")", ";", "case", "Match_MissingFeature", ":", "return", "missingFeature", "(", "Loc", ",", "ErrorInfo", ")", ";", "case", "Match_InvalidOperand", ":", "return", "invalidOperand", "(", "Loc", ",", "Operands", ",", "ErrorInfo", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "Loc", ",", "\"invalid instruction\"", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "MCS51", "MCS51", "\"invalid instruction\"" ]

[]

[ "<s>", "bool", "SITypeRewriter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "v16i8", "=", "VectorType", "::", "get", "(", "Type", "::", "getInt8Ty", "(", "M", ".", "getContext", "(", ")", ")", ",", "16", ")", ";", "v4i32", "=", "VectorType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "M", ".", "getContext", "(", ")", ")", ",", "4", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "SI", "16", "4" ]

[]

[ "<s>", "bool", "mask_low_and_shift_p", "(", "machine_mode", "mode", ",", "rtx", "mask", ",", "rtx", "shift", ",", "int", "maxlen", ")", "{", "return", "IN_RANGE", "(", "mask_low_and_shift_len", "(", "mode", ",", "mask", ",", "shift", ")", ",", "1", ",", "maxlen", ")", ";", "}", "</s>" ]

[ "Check", "if", "MASK", "and", "SHIFT", "are", "valid", "in", "mask-low-and-shift-left", "operation", "if", "MAXLEN", "is", "the", "maxium", "length", "of", "consecutive", "bits", "that", "can", "make", "up", "MASK", ".", "MODE", "is", "the", "mode", "of", "the", "operation", ".", "See", "mask_low_and_shift_len", "for", "the", "actual", "definition", "." ]

[ "mips", "1" ]

[]

[ "<s>", "bool", "isCheapToSpeculateCtlz", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "SystemZ" ]

[]

[ "<s>", "void", "VideoCore4RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "frameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "frameIndex", ")", ";", "unsigned", "reg", "=", "getFrameRegister", "(", "MF", ")", ";", "int64_t", "offset", "=", "spOffset", "+", "(", "int64_t", ")", "stackSize", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "reg", ",", "false", ",", "false", ",", "true", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "offset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "VideoCore4", "VideoCore4", "0", "\"Unexpected\"", "1" ]

[]

[ "<s>", "tree", "gimple_folder", "::", "load_store_cookie", "(", "tree", "type", ")", "{", "return", "build_int_cst", "(", "build_pointer_type", "(", "type", ")", ",", "TYPE_ALIGN", "(", "type", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "alignment", "and", "TBAA", "argument", "to", "an", "internal", "load", "or", "store", "function", "like", "IFN_MASK_LOAD", "or", "IFN_MASK_STORE", ",", "given", "that", "it", "accesses", "memory", "elements", "of", "type", "TYPE", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "breakPartialRegDependency", "(", "MachineInstr", "&", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "OpNum", "<", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"OpNum is not a def\"", ")", ";", "assert", "(", "TRI", "&&", "\"Need TRI instance\"", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNum", ")", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Reg", ")", "&&", "\"Can't break virtual register dependencies.\"", ")", ";", "unsigned", "DReg", "=", "Reg", ";", "if", "(", "ARM", "::", "SPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "DReg", "=", "ARM", "::", "D0", "+", "(", "Reg", "-", "ARM", "::", "S0", ")", "/", "2", ";", "assert", "(", "TRI", "->", "isSuperRegister", "(", "Reg", ",", "DReg", ")", "&&", "\"Register enums broken\"", ")", ";", "}", "assert", "(", "ARM", "::", "DPRRegClass", ".", "contains", "(", "DReg", ")", "&&", "\"Can only break D-reg deps\"", ")", ";", "assert", "(", "MI", ".", "definesRegister", "(", "DReg", ",", "TRI", ")", "&&", "\"MI doesn't clobber full D-reg\"", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "FCONSTD", ")", ",", "DReg", ")", ".", "addImm", "(", "96", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "MI", ".", "addRegisterKilled", "(", "DReg", ",", "TRI", ",", "true", ")", ";", "}", "</s>" ]

[ "Insert", "a", "dependency-breaking", "instruction", "before", "MI", "to", "eliminate", "an", "unwanted", "dependency", "on", "OpNum", "." ]

[ "ARM", "ARM", "\"OpNum is not a def\"", "\"Need TRI instance\"", "\"Can't break virtual register dependencies.\"", "ARM::SPRRegClass", "ARM::D0", "ARM::S0", "2", "\"Register enums broken\"", "ARM::DPRRegClass", "\"Can only break D-reg deps\"", "\"MI doesn't clobber full D-reg\"", "ARM::FCONSTD", "96", "ARMCC::AL" ]

[]

[ "<s>", "bool", "ARMLowOverheadLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM Loops on \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" ------------- \\n\"", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "MF", ")", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")", ";", "BBUtils", "->", "adjustBBOffsetsAfter", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "ML", ":", "MLI", ")", "{", "if", "(", "!", "ML", "->", "getParentLoop", "(", ")", ")", "Changed", "|=", "ProcessLoop", "(", "ML", ")", ";", "}", "Changed", "|=", "RevertNonLoops", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "ARM", "ARM", "ARM", "\"ARM Loops on \"", "\" ------------- \\n\"", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "int", "arc_check_release31a", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "pred", "||", "!", "INSN_P", "(", "pred", ")", "||", "!", "succ", "||", "!", "INSN_P", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "!", "JUMP_P", "(", "pred", ")", "&&", "!", "single_set", "(", "pred", ")", ")", "return", "0", ";", "if", "(", "!", "JUMP_P", "(", "succ", ")", "&&", "!", "single_set", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "TARGET_HS", "&&", "(", "arc_tune", "==", "ARC_TUNE_ARCHS4X_REL31A", ")", ")", "switch", "(", "get_attr_type", "(", "pred", ")", ")", "{", "case", "TYPE_STORE", ":", "switch", "(", "get_attr_type", "(", "succ", ")", ")", "{", "case", "TYPE_BRCC", ":", "case", "TYPE_BRCC_NO_DELAY_SLOT", ":", "case", "TYPE_LOOP_END", ":", "return", "1", ";", "default", ":", "break", ";", "}", "break", ";", "case", "TYPE_BRCC", ":", "case", "TYPE_BRCC_NO_DELAY_SLOT", ":", "case", "TYPE_LOOP_END", ":", "if", "(", "get_attr_type", "(", "succ", ")", "==", "TYPE_STORE", ")", "return", "1", ";", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "When", "compiling", "for", "release", "310a", ",", "insert", "a", "nop", "before", "any", "conditional", "jump", "." ]

[ "arc", "0", "0", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "LW", ":", "RISCV", "::", "LD", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLD", ";", "else", "if", "(", "RISCV", "::", "VGRRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "RISCV", "::", "VPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "RISCV", "::", "VQRRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "RISCV", "::", "VORRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "VLE_V_um", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "if", "(", "Opcode", "==", "RISCV", "::", "VLE_V_um", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "else", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass", "32", "RISCV::LW", "RISCV::LD", "RISCV::FPR32RegClass", "RISCV::FLW", "RISCV::FPR64RegClass", "RISCV::FLD", "RISCV::VGRRegClass", "RISCV::VPRRegClass", "RISCV::VQRRegClass", "RISCV::VORRegClass", "RISCV::VLE_V_um", "\"Can't load this register from stack slot\"", "RISCV::VLE_V_um", "0" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "addPass", "(", "createARMLowOverheadLoopsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "mayLoad", "(", ")", "const", "{", "return", "Load", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "could", "possibly", "read", "memory", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "TPCAAWrapperPass", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "TPC", "TPC" ]

[]