Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "m32r_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "using", "NEW_REG", "in", "place", "of", "OLD_REG", "is", "ok", "." ]

[ "m32r", "\"interrupt\"", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "int", ",", "MVT", ">", "SITargetLowering", "::", "getTypeLegalizationCost", "(", "const", "DataLayout", "&", "DL", ",", "Type", "*", "Ty", ")", "const", "{", "auto", "Cost", "=", "TargetLoweringBase", "::", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "auto", "Size", "=", "DL", ".", "getTypeSizeInBits", "(", "Ty", ")", ";", "if", "(", "Size", "<=", "256", ")", "return", "Cost", ";", "Cost", ".", "first", "=", "(", "Size", "+", "255", ")", "/", "256", ";", "return", "Cost", ";", "}", "</s>" ]

[ "Estimate", "the", "cost", "of", "type-legalization", "and", "the", "legalized", "type", "." ]

[ "AMDGPU", "SI", "256", "255", "256" ]

[]

[ "<s>", "static", "void", "frv_frame_access", "(", "frv_frame_accessor_t", "*", "accessor", ",", "rtx", "reg", ",", "int", "stack_offset", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "mem", "=", "frv_frame_mem", "(", "mode", ",", "accessor", "->", "base", ",", "stack_offset", "-", "accessor", "->", "base_offset", ")", ";", "if", "(", "accessor", "->", "op", "==", "FRV_LOAD", ")", "{", "if", "(", "SPR_P", "(", "REGNO", "(", "reg", ")", ")", ")", "{", "rtx", "temp", "=", "gen_rtx_REG", "(", "mode", ",", "TEMP_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "mem", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "temp", ")", ")", ";", "}", "else", "{", "if", "(", "mode", "==", "DImode", "&&", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "1", ")", ")", "==", "REG", ")", "{", "rtx", "temp", "=", "gen_rtx_REG", "(", "SImode", ",", "TEMP_REGNO", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_PLUS", "(", "SImode", ",", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "0", ")", ",", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "1", ")", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "temp", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ")", ";", "}", "emit_use", "(", "reg", ")", ";", "}", "else", "{", "if", "(", "SPR_P", "(", "REGNO", "(", "reg", ")", ")", ")", "{", "rtx", "temp", "=", "gen_rtx_REG", "(", "mode", ",", "TEMP_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "reg", ")", ")", ";", "frv_frame_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "mem", ",", "temp", ")", ",", "frv_dwarf_store", "(", "reg", ",", "stack_offset", ")", ")", ";", "}", "else", "if", "(", "mode", "==", "DImode", ")", "{", "rtx", "reg1", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", ")", ";", "rtx", "reg2", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", "+", "1", ")", ";", "rtx", "set1", "=", "frv_dwarf_store", "(", "reg1", ",", "stack_offset", ")", ";", "rtx", "set2", "=", "frv_dwarf_store", "(", "reg2", ",", "stack_offset", "+", "4", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "1", ")", ")", "==", "REG", ")", "{", "rtx", "temp", "=", "gen_rtx_REG", "(", "SImode", ",", "TEMP_REGNO", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_PLUS", "(", "SImode", ",", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "0", ")", ",", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "1", ")", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "temp", ")", ";", "}", "frv_frame_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "mem", ",", "reg", ")", ",", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set1", ",", "set2", ")", ")", ")", ";", "}", "else", "frv_frame_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "mem", ",", "reg", ")", ",", "frv_dwarf_store", "(", "reg", ",", "stack_offset", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "instructions", "that", "transfer", "REG", "to", "or", "from", "the", "memory", "location", "(", "sp", "+", "STACK_OFFSET", ")", ".", "The", "register", "is", "stored", "in", "memory", "if", "ACCESSOR-", ">", "OP", "is", "FRV_STORE", "and", "loaded", "if", "it", "is", "FRV_LOAD", ".", "Only", "the", "prologue", "uses", "this", "function", "to", "store", "registers", "and", "only", "the", "epilogue", "uses", "it", "to", "load", "them", ".", "The", "caller", "sets", "up", "ACCESSOR", "so", "that", "BASE", "is", "equal", "to", "(", "sp", "+", "BASE_OFFSET", ")", ".", "The", "generated", "instruction", "will", "use", "BASE", "as", "its", "base", "register", ".", "BASE", "may", "simply", "be", "the", "stack", "pointer", ",", "but", "if", "several", "accesses", "are", "being", "made", "to", "a", "region", "far", "away", "from", "the", "stack", "pointer", ",", "it", "may", "be", "more", "efficient", "to", "set", "up", "a", "temporary", "instead", ".", "Store", "instructions", "will", "be", "frame-related", "and", "will", "be", "annotated", "with", "the", "overall", "effect", "of", "the", "store", ".", "Load", "instructions", "will", "be", "followed", "by", "a", "(", "use", ")", "to", "prevent", "later", "optimizations", "from", "zapping", "them", ".", "The", "function", "takes", "care", "of", "the", "moves", "to", "and", "from", "SPRs", ",", "using", "TEMP_REGNO", "as", "a", "temporary", "in", "such", "cases", "." ]

[ "frv", "0", "0", "0", "0", "1", "0", "0", "0", "1", "1", "4", "0", "0", "0", "0", "1", "0", "0", "0", "1", "2" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "MI", "&&", "\"Unable to get the legal offset for nil instruction.\"", ")", ";", "StackOffset", "SaveOffset", "(", "Offset", ",", "MVT", "::", "i8", ")", ";", "return", "isAArch64FrameOffsetLegal", "(", "*", "MI", ",", "SaveOffset", ")", "&", "AArch64FrameOffsetIsLegal", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "AArch64", "AArch64", "\"Unable to get the legal offset for nil instruction.\"", "MVT::i8", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "short", "imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "Lo", ")", "return", "false", ";", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "else", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", ")", "return", "false", ";", "APInt", "LHSKnownZero", ",", "LHSKnownOne", ";", "APInt", "RHSKnownZero", ",", "RHSKnownOne", ";", "DAG", ".", "ComputeMaskedBits", "(", "N", ".", "getOperand", "(", "0", ")", ",", "APInt", "::", "getAllOnesValue", "(", "N", ".", "getOperand", "(", "0", ")", ".", "getValueSizeInBits", "(", ")", ")", ",", "LHSKnownZero", ",", "LHSKnownOne", ")", ";", "if", "(", "LHSKnownZero", ".", "getBoolValue", "(", ")", ")", "{", "DAG", ".", "ComputeMaskedBits", "(", "N", ".", "getOperand", "(", "1", ")", ",", "APInt", "::", "getAllOnesValue", "(", "N", ".", "getOperand", "(", "1", ")", ".", "getValueSizeInBits", "(", ")", ")", ",", "RHSKnownZero", ",", "RHSKnownOne", ")", ";", "if", "(", "~", "(", "LHSKnownZero", "|", "RHSKnownZero", ")", "==", "0", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressRegReg", "-", "Given", "the", "specified", "addressed", ",", "check", "to", "see", "if", "it", "can", "be", "more", "efficiently", "represented", "as", "[", "r+imm", "]", "." ]

[ "PowerPC", "PPC", "0", "ISD::ADD", "1", "1", "PPCISD::Lo", "0", "1", "ISD::OR", "1", "0", "0", "1", "1", "0", "0", "1" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "O", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", ";", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"unknown pcrel immediate operand\"", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "EvaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "\"0x\"", ";", "O", ".", "write_hex", "(", "Address", ")", ";", "}", "else", "{", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "X86", "X86", "\"unknown pcrel immediate operand\"", "\"0x\"" ]

[]

[ "<s>", "void", "aarch64_simd_lane_bounds", "(", "rtx", "operand", ",", "HOST_WIDE_INT", "low", ",", "HOST_WIDE_INT", "high", ",", "const_tree", "exp", ")", "{", "HOST_WIDE_INT", "lane", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operand", ")", ")", ";", "lane", "=", "INTVAL", "(", "operand", ")", ";", "if", "(", "lane", "<", "low", "||", "lane", ">=", "high", ")", "{", "if", "(", "exp", ")", "error", "(", "\"%Klane %ld out of range %ld - %ld\"", ",", "exp", ",", "lane", ",", "low", ",", "high", "-", "1", ")", ";", "else", "error", "(", "\"lane %ld out of range %ld - %ld\"", ",", "lane", ",", "low", ",", "high", "-", "1", ")", ";", "}", "}", "</s>" ]

[ "Bounds-check", "lanes", ".", "Ensure", "OPERAND", "lies", "between", "LOW", "(", "inclusive", ")", "and", "HIGH", "(", "exclusive", ")", "." ]

[ "aarch64", "\"%Klane %ld out of range %ld - %ld\"", "1", "\"lane %ld out of range %ld - %ld\"", "1" ]

[]

[ "<s>", "unsigned", "getFirstDomain", "(", ")", "const", "{", "return", "CountTrailingZeros_32", "(", "AvailableDomains", ")", ";", "}", "</s>" ]

[ "First", "domain", "available", "." ]

[ "X86" ]

[]

[ "<s>", "static", "rtx", "or1k_restore_reg", "(", "int", "regno", ",", "HOST_WIDE_INT", "offset", ",", "rtx", "cfa_restores", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "return", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "cfa_restores", ")", ";", "}", "</s>" ]

[ "Emit", "rtl", "to", "restore", "register", "REGNO", "contents", "from", "stack", "memory", "at", "the", "given", "OFFSET", "from", "the", "current", "stack", "pointer", "." ]

[ "or1k" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ",", "STI", ",", "*", "this", ")", ";", "return", "MCInstLowering", ".", "lowerOperand", "(", "MO", ",", "MCOp", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

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

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Mips", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Mips_NONE\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_Mips_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_REL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_26\"", ",", "0", ",", "26", ",", "0", "}", ",", "{", "\"fixup_Mips_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LITERAL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_PC16\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Mips_CALL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT5\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT6\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_64\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_Mips_TLSGD\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOTTPREL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_Branch_PCRel\"", ",", "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", "." ]

[ "Mips", "Mips::NumTargetFixupKinds", "\"fixup_Mips_NONE\"", "0", "0", "0", "\"fixup_Mips_16\"", "0", "16", "0", "\"fixup_Mips_32\"", "0", "32", "0", "\"fixup_Mips_REL32\"", "0", "32", "0", "\"fixup_Mips_26\"", "0", "26", "0", "\"fixup_Mips_HI16\"", "0", "16", "0", "\"fixup_Mips_LO16\"", "0", "16", "0", "\"fixup_Mips_GPREL16\"", "0", "16", "0", "\"fixup_Mips_LITERAL\"", "0", "16", "0", "\"fixup_Mips_GOT16\"", "0", "16", "0", "\"fixup_Mips_PC16\"", "0", "16", "\"fixup_Mips_CALL16\"", "0", "16", "0", "\"fixup_Mips_GPREL32\"", "0", "32", "0", "\"fixup_Mips_SHIFT5\"", "6", "5", "0", "\"fixup_Mips_SHIFT6\"", "6", "5", "0", "\"fixup_Mips_64\"", "0", "64", "0", "\"fixup_Mips_TLSGD\"", "0", "16", "0", "\"fixup_Mips_GOTTPREL\"", "0", "16", "0", "\"fixup_Mips_TPREL_HI\"", "0", "16", "0", "\"fixup_Mips_TPREL_LO\"", "0", "16", "0", "\"fixup_Mips_Branch_PCRel\"", "0", "16", "\"Invalid kind!\"" ]

[]

[ "<s>", "int", "rs6000_emit_vector_cond_expr", "(", "rtx", "dest", ",", "rtx", "op_true", ",", "rtx", "op_false", ",", "rtx", "cond", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "mask_mode", "=", "GET_MODE", "(", "cc_op0", ")", ";", "enum", "rtx_code", "rcode", "=", "GET_CODE", "(", "cond", ")", ";", "machine_mode", "cc_mode", "=", "CCmode", ";", "rtx", "mask", ";", "rtx", "cond2", ";", "rtx", "tmp", ";", "bool", "invert_move", "=", "false", ";", "if", "(", "VECTOR_UNIT_NONE_P", "(", "dest_mode", ")", ")", "return", "0", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "dest_mode", ")", "==", "GET_MODE_SIZE", "(", "mask_mode", ")", "&&", "GET_MODE_NUNITS", "(", "dest_mode", ")", "==", "GET_MODE_NUNITS", "(", "mask_mode", ")", ")", ";", "switch", "(", "rcode", ")", "{", "case", "NE", ":", "case", "UNLE", ":", "case", "UNLT", ":", "case", "UNGE", ":", "case", "UNGT", ":", "invert_move", "=", "true", ";", "rcode", "=", "reverse_condition_maybe_unordered", "(", "rcode", ")", ";", "if", "(", "rcode", "==", "UNKNOWN", ")", "return", "0", ";", "break", ";", "case", "GTU", ":", "case", "GEU", ":", "case", "LTU", ":", "case", "LEU", ":", "cc_mode", "=", "CCUNSmode", ";", "break", ";", "default", ":", "break", ";", "}", "mask", "=", "rs6000_emit_vector_compare", "(", "rcode", ",", "cc_op0", ",", "cc_op1", ",", "mask_mode", ")", ";", "if", "(", "!", "mask", ")", "return", "0", ";", "if", "(", "invert_move", ")", "{", "tmp", "=", "op_true", ";", "op_true", "=", "op_false", ";", "op_false", "=", "tmp", ";", "}", "cond2", "=", "gen_rtx_fmt_ee", "(", "NE", ",", "cc_mode", ",", "gen_lowpart", "(", "dest_mode", ",", "mask", ")", ",", "CONST0_RTX", "(", "dest_mode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "dest_mode", ",", "cond2", ",", "op_true", ",", "op_false", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Emit", "vector", "conditional", "expression", ".", "DEST", "is", "destination", ".", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ".", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", "." ]

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

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "SNESTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCFunction", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "SNES", "SNES", "ISD::OutputArg", "16" ]

[]

[ "<s>", "void", "MMIXAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "LowerMMIXMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "MMIX" ]

[]

[ "<s>", "Sched", "::", "Preference", "ARMTargetLowering", "::", "getSchedulingPreference", "(", "SDNode", "*", "N", ")", "const", "{", "unsigned", "NumVals", "=", "N", "->", "getNumValues", "(", ")", ";", "if", "(", "!", "NumVals", ")", "return", "Sched", "::", "RegPressure", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumVals", ";", "++", "i", ")", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "i", ")", ";", "if", "(", "VT", "==", "MVT", "::", "Flag", "||", "VT", "==", "MVT", "::", "Other", ")", "continue", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "||", "VT", ".", "isVector", "(", ")", ")", "return", "Sched", "::", "Latency", ";", "}", "if", "(", "!", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "Sched", "::", "RegPressure", ";", "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetInstrDesc", "&", "TID", "=", "TII", "->", "get", "(", "N", "->", "getMachineOpcode", "(", ")", ")", ";", "if", "(", "TID", ".", "getNumDefs", "(", ")", "==", "0", ")", "return", "Sched", "::", "RegPressure", ";", "if", "(", "!", "Itins", "->", "isEmpty", "(", ")", "&&", "Itins", "->", "getOperandCycle", "(", "TID", ".", "getSchedClass", "(", ")", ",", "0", ")", ">", "2", ")", "return", "Sched", "::", "Latency", ";", "return", "Sched", "::", "RegPressure", ";", "}", "</s>" ]

[ "Some", "scheduler", ",", "e.g", "." ]

[ "ARM", "ARM", "0", "MVT::Flag", "MVT::Other", "0", "0", "2" ]

[]

[ "<s>", "static", "void", "arm_option_check_internal", "(", "struct", "gcc_options", "*", "opts", ")", "{", "int", "flags", "=", "opts", "->", "x_target_flags", ";", "if", "(", "TARGET_IWMMXT", "&&", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_neon", ")", ")", "error", "(", "\"iWMMXt and NEON are incompatible\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_notm", ")", ")", "error", "(", "\"target CPU does not support ARM mode\"", ")", ";", "if", "(", "(", "TARGET_TPCS_FRAME", "||", "TARGET_TPCS_LEAF_FRAME", ")", "&&", "TARGET_ARM_P", "(", "flags", ")", ")", "warning", "(", "0", ",", "\"enabling backtrace support is only meaningful when compiling for the Thumb\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "warning", "(", "0", ",", "\"enabling callee interworking support is only meaningful when compiling for the Thumb\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "write_symbols", "!=", "NO_DEBUG", "&&", "!", "TARGET_APCS_FRAME", "&&", "(", "TARGET_DEFAULT", "&", "MASK_APCS_FRAME", ")", ")", "warning", "(", "0", ",", "\"-g with -mno-apcs-frame may not give sensible debugging\"", ")", ";", "if", "(", "TARGET_THUMB_P", "(", "flags", ")", "&&", "TARGET_IWMMXT", ")", "error", "(", "\"iWMMXt unsupported under Thumb mode\"", ")", ";", "if", "(", "TARGET_HARD_TP", "&&", "TARGET_THUMB1_P", "(", "flags", ")", ")", "error", "(", "\"can not use -mtp=cp15 with 16-bit Thumb\"", ")", ";", "if", "(", "TARGET_THUMB_P", "(", "flags", ")", "&&", "TARGET_VXWORKS_RTP", "&&", "flag_pic", ")", "{", "error", "(", "\"RTP PIC is incompatible with Thumb\"", ")", ";", "flag_pic", "=", "0", ";", "}", "if", "(", "(", "target_pure_code", "||", "target_slow_flash_data", ")", "&&", "(", "!", "TARGET_HAVE_MOVT", "||", "arm_arch_notm", "||", "flag_pic", "||", "TARGET_NEON", ")", ")", "{", "const", "char", "*", "flag", "=", "(", "target_pure_code", "?", "\"-mpure-code\"", ":", "\"-mslow-flash-data\"", ")", ";", "error", "(", "\"%s only supports non-pic code on M-profile targets with the \"", "\"MOVT instruction\"", ",", "flag", ")", ";", "}", "}", "</s>" ]

[ "Check", "any", "incompatible", "options", "that", "the", "user", "has", "specified", "." ]

[ "arm", "\"iWMMXt and NEON are incompatible\"", "\"target CPU does not support ARM mode\"", "0", "\"enabling backtrace support is only meaningful when compiling for the Thumb\"", "0", "\"enabling callee interworking support is only meaningful when compiling for the Thumb\"", "0", "\"-g with -mno-apcs-frame may not give sensible debugging\"", "\"iWMMXt unsupported under Thumb mode\"", "\"can not use -mtp=cp15 with 16-bit Thumb\"", "\"RTP PIC is incompatible with Thumb\"", "0", "\"-mpure-code\"", "\"-mslow-flash-data\"", "\"%s only supports non-pic code on M-profile targets with the \"", "\"MOVT instruction\"" ]

[]

[ "<s>", "static", "void", "cris_file_end", "(", "void", ")", "{", "if", "(", "TARGET_LINUX", "&&", "trampolines_created", ")", "file_end_indicate_exec_stack", "(", ")", ";", "}", "</s>" ]

[ "Output", "that", "goes", "at", "the", "end", "of", "the", "file", ",", "similarly", "." ]

[ "cris" ]

[]

[ "<s>", "SUnit", "*", "R600SchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "SUnit", "*", "SU", "=", "0", ";", "NextInstKind", "=", "IDOther", ";", "IsTopNode", "=", "false", ";", "bool", "AllowSwitchToAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "||", "(", "Available", "[", "CurInstKind", "]", ".", "empty", "(", ")", ")", ";", "bool", "AllowSwitchFromAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "&&", "(", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", "||", "!", "Available", "[", "IDOther", "]", ".", "empty", "(", ")", ")", ";", "if", "(", "CurInstKind", "==", "IDAlu", "&&", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", ")", "{", "float", "ALUFetchRationEstimate", "=", "(", "AluInstCount", "+", "AvailablesAluCount", "(", ")", "+", "Pending", "[", "IDAlu", "]", ".", "size", "(", ")", ")", "/", "(", "FetchInstCount", "+", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ")", ";", "unsigned", "NeededWF", "=", "62.5f", "/", "ALUFetchRationEstimate", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "NeededWF", "<<", "\" approx. Wavefronts Required\\n\"", ")", ";", "unsigned", "NearRegisterRequirement", "=", "2", "*", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ";", "if", "(", "NeededWF", ">", "getWFCountLimitedByGPR", "(", "NearRegisterRequirement", ")", ")", "AllowSwitchFromAlu", "=", "true", ";", "}", "if", "(", "!", "SU", "&&", "!", "UnscheduledARDefs", ".", "empty", "(", ")", ")", "{", "SU", "=", "UnscheduledARDefs", "[", "0", "]", ";", "UnscheduledARDefs", ".", "erase", "(", "UnscheduledARDefs", ".", "begin", "(", ")", ")", ";", "NextInstKind", "=", "IDAlu", ";", "}", "if", "(", "!", "SU", "&&", "(", "(", "AllowSwitchToAlu", "&&", "CurInstKind", "!=", "IDAlu", ")", "||", "(", "!", "AllowSwitchFromAlu", "&&", "CurInstKind", "==", "IDAlu", ")", ")", ")", "{", "SU", "=", "pickAlu", "(", ")", ";", "if", "(", "!", "SU", "&&", "!", "PhysicalRegCopy", ".", "empty", "(", ")", ")", "{", "SU", "=", "PhysicalRegCopy", ".", "front", "(", ")", ";", "PhysicalRegCopy", ".", "erase", "(", "PhysicalRegCopy", ".", "begin", "(", ")", ")", ";", "}", "if", "(", "SU", ")", "{", "if", "(", "CurEmitted", ">=", "InstKindLimit", "[", "IDAlu", "]", ")", "CurEmitted", "=", "0", ";", "NextInstKind", "=", "IDAlu", ";", "}", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDFetch", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDFetch", ";", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDOther", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDOther", ";", "}", "if", "(", "!", "SU", "&&", "!", "UnscheduledARUses", ".", "empty", "(", ")", ")", "{", "SU", "=", "UnscheduledARUses", "[", "0", "]", ";", "UnscheduledARUses", ".", "erase", "(", "UnscheduledARUses", ".", "begin", "(", ")", ")", ";", "NextInstKind", "=", "IDAlu", ";", "}", "DEBUG", "(", "if", "(", "SU", ")", "{", "dbgs", "(", ")", "<<", "\" ** Pick node **\\n\"", ";", "SU", "->", "dump", "(", "DAG", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"NO NODE \\n\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "DAG", "->", "SUnits", ".", "size", "(", ")", ";", "i", "++", ")", "{", "const", "SUnit", "&", "S", "=", "DAG", "->", "SUnits", "[", "i", "]", ";", "if", "(", "!", "S", ".", "isScheduled", ")", "S", ".", "dump", "(", "DAG", ")", ";", "}", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "R600", "0", "62.5f", "\" approx. Wavefronts Required\\n\"", "2", "0", "0", "0", "\" ** Pick node **\\n\"", "\"NO NODE \\n\"", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "isO32", "(", ")", ",", "Subtarget", "->", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", "->", "mipsSEUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "isN64", "(", ")", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "Mips", "Mips", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0_64", "Mips::V0", "1", "0", "MipsISD::Ret", "MVT::Other" ]

[]

[ "<s>", "rtx", "aarch64_gen_compare_reg", "(", "RTX_CODE", "code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "machine_mode", "cmp_mode", "=", "GET_MODE", "(", "x", ")", ";", "machine_mode", "cc_mode", ";", "rtx", "cc_reg", ";", "if", "(", "cmp_mode", "==", "TImode", ")", "{", "gcc_assert", "(", "code", "==", "NE", ")", ";", "cc_mode", "=", "CCmode", ";", "cc_reg", "=", "gen_rtx_REG", "(", "cc_mode", ",", "CC_REGNUM", ")", ";", "rtx", "x_lo", "=", "operand_subword", "(", "x", ",", "0", ",", "0", ",", "TImode", ")", ";", "rtx", "y_lo", "=", "operand_subword", "(", "y", ",", "0", ",", "0", ",", "TImode", ")", ";", "emit_set_insn", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "cc_mode", ",", "x_lo", ",", "y_lo", ")", ")", ";", "rtx", "x_hi", "=", "operand_subword", "(", "x", ",", "1", ",", "0", ",", "TImode", ")", ";", "rtx", "y_hi", "=", "operand_subword", "(", "y", ",", "1", ",", "0", ",", "TImode", ")", ";", "emit_insn", "(", "gen_ccmpccdi", "(", "cc_reg", ",", "cc_reg", ",", "x_hi", ",", "y_hi", ",", "gen_rtx_EQ", "(", "cc_mode", ",", "cc_reg", ",", "const0_rtx", ")", ",", "GEN_INT", "(", "AARCH64_EQ", ")", ")", ")", ";", "}", "else", "{", "cc_mode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "cc_reg", "=", "gen_rtx_REG", "(", "cc_mode", ",", "CC_REGNUM", ")", ";", "emit_set_insn", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "cc_mode", ",", "x", ",", "y", ")", ")", ";", "}", "return", "cc_reg", ";", "}", "</s>" ]

[ "X", "and", "Y", "are", "two", "things", "to", "compare", "using", "CODE", ".", "Emit", "the", "compare", "insn", "and", "return", "the", "rtx", "for", "register", "0", "in", "the", "proper", "mode", "." ]

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

[]

[ "<s>", "bool", "convertSetCCLogicToBitwiseLogic", "(", "EVT", "VT", ")", "const", "override", "{", "return", "VT", ".", "isScalarInteger", "(", ")", ";", "}", "</s>" ]

[ "Use", "bitwise", "logic", "to", "make", "pairs", "of", "compares", "more", "efficient", "." ]

[ "SystemZ" ]

[]

[ "<s>", "static", "int", "mn10300_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", ")", "{", "HOST_WIDE_INT", "i", ";", "rtx", "base", ",", "index", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "speed", "?", "1", ":", "4", ";", "case", "REG", ":", "case", "SUBREG", ":", "case", "POST_INC", ":", "return", "0", ";", "case", "POST_MODIFY", ":", "i", "=", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "?", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ":", "0x12345678", ")", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "128", ",", "127", ")", ")", "return", "speed", "?", "0", ":", "1", ";", "if", "(", "speed", ")", "return", "1", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "0x800000", ",", "0x7fffff", ")", ")", "return", "3", ";", "return", "4", ";", "case", "PLUS", ":", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "index", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "register_operand", "(", "index", ",", "SImode", ")", ")", "{", "if", "(", "register_operand", "(", "base", ",", "SImode", ")", ")", "return", "1", ";", "base", "=", "XEXP", "(", "x", ",", "1", ")", ";", "index", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "i", "=", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "?", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ":", "0x12345678", ")", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "128", ",", "127", ")", ")", "return", "speed", "?", "0", ":", "1", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "32768", ",", "32767", ")", ")", "return", "speed", "?", "0", ":", "2", ";", "return", "speed", "?", "2", ":", "6", ";", "default", ":", "return", "rtx_cost", "(", "x", ",", "Pmode", ",", "MEM", ",", "0", ",", "speed", ")", ";", "}", "}", "</s>" ]

[ "For", "addresses", ",", "costs", "are", "relative", "to", "``", "MOV", "(", "Rm", ")", ",", "Rn", "''", ".", "For", "AM33", "this", "is", "the", "3-byte", "fully", "general", "instruction", ";", "for", "MN103", "this", "is", "the", "2-byte", "form", "with", "an", "address", "register", "." ]

[ "mn10300", "1", "4", "0", "1", "1", "0x12345678", "128", "127", "0", "1", "1", "0x800000", "0x7fffff", "3", "4", "0", "1", "1", "1", "0", "1", "1", "0x12345678", "128", "127", "0", "1", "32768", "32767", "0", "2", "2", "6", "0" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", ".", "isZero", "(", ")", ")", "continue", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "uint64_t", "StackOffset", "=", "Handler", ".", "StackUsed", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "return", "false", ";", "}", "StackOffset", "=", "alignTo", "(", "Handler", ".", "StackUsed", ",", "Subtarget", ".", "isTargetILP32", "(", ")", "?", "4", ":", "8", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MFI", ".", "CreateFixedObject", "(", "4", ",", "StackOffset", ",", "true", ")", ")", ";", "}", "if", "(", "doesCalleeRestoreStack", "(", "F", ".", "getCallingConv", "(", ")", ",", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", ")", "{", "StackOffset", "=", "alignTo", "(", "StackOffset", ",", "16", ")", ";", "FuncInfo", "->", "setArgumentStackToRestore", "(", "StackOffset", ")", ";", "}", "FuncInfo", "->", "setBytesInStackArgArea", "(", "StackOffset", ")", ";", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "hasCustomCallingConv", "(", ")", ")", "Subtarget", ".", "getRegisterInfo", "(", ")", "->", "UpdateCustomCalleeSavedRegs", "(", "MF", ")", ";", "handleMustTailForwardedRegisters", "(", "MIRBuilder", ",", "AssignFn", ")", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "AArch64", "AArch64", "8", "0", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "4", "8", "4", "16", "AArch64" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Outs", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "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", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "MSP430MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "Register", "Reg", "=", "FuncInfo", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in entry block\"", ")", ";", "MVT", "PtrVT", "=", "getFrameIndexTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "PtrVT", ")", ";", "unsigned", "R12", "=", "MSP430", "::", "R12", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R12", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "R12", ",", "PtrVT", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430", "\"sret virtual register not created in entry block\"", "MSP430::R12", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "bool", "riscv_gpr_save_operation_p", "(", "rtx", "op", ")", "{", "unsigned", "len", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "if", "(", "len", ">", "ARRAY_SIZE", "(", "gpr_save_reg_order", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "rtx", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "if", "(", "i", "==", "0", ")", "{", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "UNSPEC_VOLATILE", "||", "GET_CODE", "(", "XVECEXP", "(", "elt", ",", "0", ",", "0", ")", ")", "!=", "CONST_INT", "||", "XINT", "(", "elt", ",", "1", ")", "!=", "UNSPECV_GPR_SAVE", ")", "return", "false", ";", "}", "else", "{", "unsigned", "expect_code", "=", "i", "<", "3", "?", "CLOBBER", ":", "USE", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "expect_code", "||", "!", "REG_P", "(", "XEXP", "(", "elt", ",", "1", ")", ")", "||", "(", "REGNO", "(", "XEXP", "(", "elt", ",", "1", ")", ")", "!=", "gpr_save_reg_order", "[", "i", "]", ")", ")", "return", "false", ";", "}", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "valid", "gpr_save", "pattern", "." ]

[ "riscv", "0", "0", "0", "0", "0", "0", "1", "3", "1", "1" ]

[]

[ "<s>", "FastISel", "*", "MipsTargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "const", "{", "if", "(", "!", "funcInfo", ".", "MF", "->", "getTarget", "(", ")", ".", "Options", ".", "EnableFastISel", ")", "return", "TargetLowering", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "return", "Mips", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "Mips", "Mips", "Mips::createFastISel" ]

[]

[ "<s>", "bool", "fusion_gpr_load_p", "(", "rtx", "addis_reg", ",", "rtx", "addis_value", ",", "rtx", "target", ",", "rtx", "mem", ")", "{", "rtx", "addr", ";", "rtx", "base_reg", ";", "if", "(", "!", "base_reg_operand", "(", "addis_reg", ",", "GET_MODE", "(", "addis_reg", ")", ")", ")", "return", "false", ";", "if", "(", "!", "base_reg_operand", "(", "target", ",", "GET_MODE", "(", "target", ")", ")", ")", "return", "false", ";", "if", "(", "!", "fusion_gpr_addis", "(", "addis_value", ",", "GET_MODE", "(", "addis_value", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "ZERO_EXTEND", "||", "(", "GET_CODE", "(", "mem", ")", "==", "SIGN_EXTEND", "&&", "TARGET_P8_FUSION_SIGN", ")", ")", "mem", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "!", "fusion_gpr_mem_load", "(", "mem", ",", "GET_MODE", "(", "mem", ")", ")", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", "&&", "GET_CODE", "(", "addr", ")", "!=", "LO_SUM", ")", "return", "false", ";", "if", "(", "REGNO", "(", "addis_reg", ")", "!=", "REGNO", "(", "target", ")", ")", "{", "if", "(", "reg_mentioned_p", "(", "target", ",", "mem", ")", ")", "return", "false", ";", "if", "(", "!", "peep2_reg_dead_p", "(", "2", ",", "addis_reg", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "target", ")", "&&", "REGNO", "(", "target", ")", "==", "STACK_POINTER_REGNUM", ")", "return", "false", ";", "}", "base_reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "return", "REGNO", "(", "addis_reg", ")", "==", "REGNO", "(", "base_reg", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "peephole2", "can", "combine", "a", "load", "involving", "a", "combination", "of", "an", "addis", "instruction", "and", "a", "load", "with", "an", "offset", "that", "can", "be", "fused", "together", "on", "a", "power8", "." ]

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

[]

[ "<s>", "static", "void", "single_move_for_movmem", "(", "rtx", "dst", ",", "rtx", "src", ",", "machine_mode", "mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "scratch", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "srcmem", ",", "dstmem", ";", "srcmem", "=", "adjust_address_nv", "(", "src", ",", "mode", ",", "offset", ")", ";", "dstmem", "=", "adjust_address_nv", "(", "dst", ",", "mode", ",", "offset", ")", ";", "emit_move_insn", "(", "scratch", ",", "srcmem", ")", ";", "emit_move_insn", "(", "dstmem", ",", "scratch", ")", ";", "}", "</s>" ]

[ "Adjust", "DST", "and", "SRC", "by", "OFFSET", "bytes", ",", "and", "generate", "one", "move", "in", "mode", "MODE", "." ]

[ "bfin" ]

[]

[ "<s>", "void", "NVPTXRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "NVPTX", "::", "VRFrame", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "\"Unexpected\"", "1", "NVPTX::VRFrame", "1" ]

[]

[ "<s>", "static", "std", "::", "pair", "<", "rtx_insn", "*", ",", "rtx_insn", "*", ">", "sh_try_split_insn_simple", "(", "rtx_insn", "*", "i", ",", "rtx_insn", "*", "curr_insn", ",", "int", "n", "=", "0", ")", "{", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"sh_try_split_insn_simple n = %d i = \\n\"", ",", "n", ")", ";", "print_rtl_single", "(", "dump_file", ",", "i", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "rtx_insn", "*", "seq", "=", "split_insns", "(", "PATTERN", "(", "i", ")", ",", "curr_insn", ")", ";", "if", "(", "seq", "==", "NULL", ")", "return", "std", "::", "make_pair", "(", "i", ",", "i", ")", ";", "for", "(", "rtx_insn", "*", "s", "=", "seq", ";", "s", "!=", "NULL", ";", "s", "=", "NEXT_INSN", "(", "s", ")", ")", "if", "(", "INSN_P", "(", "s", ")", "&&", "rtx_equal_p", "(", "PATTERN", "(", "s", ")", ",", "PATTERN", "(", "i", ")", ")", ")", "return", "std", "::", "make_pair", "(", "i", ",", "i", ")", ";", "unshare_all_rtl_in_chain", "(", "seq", ")", ";", "rtx_insn", "*", "seqlast", "=", "seq", ";", "while", "(", "NEXT_INSN", "(", "seqlast", ")", "!=", "NULL", ")", "seqlast", "=", "NEXT_INSN", "(", "seqlast", ")", ";", "if", "(", "rtx_insn", "*", "iprev", "=", "PREV_INSN", "(", "i", ")", ")", "SET_NEXT_INSN", "(", "iprev", ")", "=", "seq", ";", "if", "(", "rtx_insn", "*", "inext", "=", "NEXT_INSN", "(", "i", ")", ")", "SET_PREV_INSN", "(", "inext", ")", "=", "seqlast", ";", "SET_PREV_INSN", "(", "seq", ")", "=", "PREV_INSN", "(", "i", ")", ";", "SET_NEXT_INSN", "(", "seqlast", ")", "=", "NEXT_INSN", "(", "i", ")", ";", "SET_PREV_INSN", "(", "i", ")", "=", "NULL", ";", "SET_NEXT_INSN", "(", "i", ")", "=", "NULL", ";", "for", "(", "i", "=", "seq", ";", ";", "i", "=", "NEXT_INSN", "(", "i", ")", ")", "{", "std", "::", "pair", "<", "rtx_insn", "*", ",", "rtx_insn", "*", ">", "ii", "=", "sh_try_split_insn_simple", "(", "i", ",", "curr_insn", ",", "n", "+", "1", ")", ";", "if", "(", "i", "==", "seq", ")", "seq", "=", "ii", ".", "first", ";", "if", "(", "i", "==", "seqlast", ")", "{", "seqlast", "=", "ii", ".", "second", ";", "break", ";", "}", "i", "=", "ii", ".", "first", ";", "}", "return", "std", "::", "make_pair", "(", "seq", ",", "seqlast", ")", ";", "}", "</s>" ]

[ "Given", "an", "rtx", "x", ",", "which", "is", "assumed", "to", "be", "some", "expression", "that", "has", "been", "matched", "by", "the", "'treg_set_expr", "'", "predicate", "before", ",", "split", "and", "emit", "the", "insns", "that", "are", "necessary", "to", "calculate", "the", "expression", "and", "store", "the", "result", "in", "the", "T", "bit", ".", "The", "splitting", "is", "done", "recursively", "similar", "to", "'try_split", "'", "in", "emit-rt.c", ".", "Unfortunately", "we", "ca", "n't", "use", "'try_split", "'", "here", "directly", ",", "as", "it", "tries", "to", "invoke", "'delete_insn", "'", "which", "then", "causes", "the", "DF", "parts", "to", "bail", "out", ",", "because", "we", "currently", "are", "inside", "another", "gen_split", "*", "function", "and", "would", "invoke", "'try_split", "'", "in", "a", "reentrant", "way", "." ]

[ "sh", "0", "\"sh_try_split_insn_simple n = %d i = \\n\"", "\"\\n\"", "1" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "AM", ".", "BaseOffs", "!=", "0", "&&", "!", "Subtarget", ".", "hasP9Vector", "(", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseOffs", "<=", "-", "(", "1LL", "<<", "16", ")", "||", "AM", ".", "BaseOffs", ">=", "(", "1LL", "<<", "16", ")", "-", "1", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "case", "2", ":", "if", "(", "AM", ".", "HasBaseReg", "||", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "PowerPC", "PPC", "0", "1LL", "16", "1LL", "16", "1", "0", "1", "2" ]

[]

[ "<s>", "const", "TPCAAResult", "&", "getResult", "(", ")", "const", "{", "return", "*", "Result", ";", "}", "</s>" ]

[ "Get", "the", "result", "of", "an", "analysis", "pass", "for", "a", "given", "IR", "unit", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "CPU", ",", "Options", ")", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ",", "isLittle", "(", "isLittle", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "Subtarget", ".", "isTargetHardFloat", "(", ")", "?", "FloatABI", "::", "Hard", ":", "FloatABI", "::", "Soft", ";", "if", "(", "Options", ".", "EABIVersion", "==", "EABI", "::", "Default", "||", "Options", ".", "EABIVersion", "==", "EABI", "::", "Unknown", ")", "{", "if", "(", "Subtarget", ".", "isTargetGNUAEABI", "(", ")", "||", "Subtarget", ".", "isTargetMuslAEABI", "(", ")", ")", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "GNU", ";", "else", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "EABI5", ";", "}", "initAsmInfo", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isThumb", "(", ")", "&&", "!", "Subtarget", ".", "hasARMOps", "(", ")", ")", "report_fatal_error", "(", "\"CPU: '\"", "+", "Subtarget", ".", "getCPUString", "(", ")", "+", "\"' does not \"", "\"support ARM mode execution!\"", ")", ";", "}", "</s>" ]

[ "Create", "an", "ARM", "architecture", "model", "." ]

[ "ARM", "ARM", "ARM", "ARM", "\"CPU: '\"", "\"' does not \"", "\"support ARM mode execution!\"" ]

[]

[ "<s>", "void", "RISCVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoTAIL", ")", "{", "expandFunctionCall", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "2", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoAddTPRel", ")", "{", "expandAddTPRel", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "1", ";", "return", ";", "}", "switch", "(", "Size", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled encodeInstruction length!\"", ")", ";", "case", "2", ":", "{", "uint16_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "case", "4", ":", "{", "uint32_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "2", "RISCV::PseudoAddTPRel", "1", "\"Unhandled encodeInstruction length!\"", "2", "support::endian", "support::little", "4", "support::endian", "support::little" ]

[]

[ "<s>", "int", "frv_acc_group", "(", "rtx", "insn", ")", "{", "if", "(", "frv_cpu_type", "==", "FRV_CPU_FR550", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "REG_P", "(", "*", "iter", ")", ")", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "*", "iter", ")", ";", "if", "(", "ACC_P", "(", "regno", ")", ")", "return", "(", "regno", "-", "ACC_FIRST", ")", "&", "4", "?", "ACC_GROUP_ODD", ":", "ACC_GROUP_EVEN", ";", "if", "(", "ACCG_P", "(", "regno", ")", ")", "return", "(", "regno", "-", "ACCG_FIRST", ")", "&", "4", "?", "ACC_GROUP_ODD", ":", "ACC_GROUP_EVEN", ";", "}", "}", "return", "ACC_GROUP_NONE", ";", "}", "</s>" ]

[ "Return", "the", "value", "of", "INSN", "'s", "acc_group", "attribute", "." ]

[ "frv", "4", "4" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "MBB", ".", "isEHFuncletEntry", "(", ")", "&&", "STI", ".", "is32Bit", "(", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "bool", "CanKill", "=", "!", "isLiveIn", ";", "if", "(", "CanKill", ")", "{", "for", "(", "MCRegAliasIterator", "AReg", "(", "Reg", ",", "TRI", ",", "false", ")", ";", "AReg", ".", "isValid", "(", ")", ";", "++", "AReg", ")", "{", "if", "(", "MRI", ".", "isLiveIn", "(", "*", "AReg", ")", ")", "{", "CanKill", "=", "false", ";", "break", ";", "}", "}", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "CanKill", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MVT", "VT", "=", "MVT", "::", "Other", ";", "if", "(", "X86", "::", "VK16RegClass", ".", "contains", "(", "Reg", ")", ")", "VT", "=", "STI", ".", "hasBWI", "(", ")", "?", "MVT", "::", "v64i1", ":", "MVT", "::", "v16i1", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ",", "VT", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "--", "MI", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "MI", ";", "}", "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", "(", ")", "." ]

[ "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::Other", "X86::VK16RegClass", "MVT::v64i1", "MVT::v16i1", "1" ]

[]

[ "<s>", "static", "rtx", "frv_expand_load_builtin", "(", "enum", "insn_code", "icode", ",", "enum", "machine_mode", "target_mode", ",", "tree", "arglist", ",", "rtx", "target", ")", "{", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "cookie", "=", "frv_io_address_cookie", "(", "op0", ")", ";", "if", "(", "target", "==", "0", "||", "!", "REG_P", "(", "target", ")", ")", "target", "=", "gen_reg_rtx", "(", "target_mode", ")", ";", "op0", "=", "frv_volatile_memref", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ",", "op0", ")", ";", "convert_move", "(", "target", ",", "op0", ",", "1", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "copy_rtx", "(", "op0", ")", ",", "cookie", ",", "GEN_INT", "(", "FRV_IO_READ", ")", ")", ")", ";", "cfun", "->", "machine", "->", "has_membar_p", "=", "1", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "__builtin_read", "*", "function", ".", "ICODE", "is", "the", "instruction", "code", "for", "the", "membar", "and", "TARGET_MODE", "is", "the", "mode", "that", "the", "loaded", "value", "should", "have", "." ]

[ "frv", "0", "0", "1", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "else", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "TGSIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "fi", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "TGSI", "::", "IRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "LDpis", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "fi", ")", ";", "else", "if", "(", "RC", "==", "&", "TGSI", "::", "IVRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "LDpiv", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "fi", ")", ";", "else", "if", "(", "RC", "==", "&", "TGSI", "::", "FRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "LDpfs", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "fi", ")", ";", "else", "if", "(", "RC", "==", "&", "TGSI", "::", "FVRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "LDpfv", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "fi", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI::IRegsRegClass", "TGSI::LDpis", "TGSI::IVRegsRegClass", "TGSI::LDpiv", "TGSI::FRegsRegClass", "TGSI::LDpfs", "TGSI::FVRegsRegClass", "TGSI::LDpfv", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "bool", "MOSAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "const", "MOSRegisterInfo", "&", "TRI", "=", "*", "MO", ".", "getParent", "(", ")", "->", "getMF", "(", ")", "->", "getSubtarget", "<", "MOSSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "errs", "(", ")", "<<", "\"Unsupported inline asm operand: \"", "<<", "MO", "<<", "\"\\n\"", ";", "return", "true", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "OS", "<<", "MO", ".", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "MOS", "::", "Imag16RegClass", ".", "contains", "(", "Reg", ")", "||", "MOS", "::", "Imag8RegClass", ".", "contains", "(", "Reg", ")", ")", "OS", "<<", "\"mos8(\"", "<<", "TRI", ".", "getImag8SymbolName", "(", "Reg", ")", "<<", "\")\"", ";", "else", "OS", "<<", "TRI", ".", "getRegAsmName", "(", "Reg", ")", ";", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "MOS", "MOS", "MOS", "MOS", "\"Unsupported inline asm operand: \"", "\"\\n\"", "MOS::Imag16RegClass", "MOS::Imag8RegClass", "\"mos8(\"", "\")\"" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "const", "SIMachineFunctionInfo", "&", "MFI", "=", "*", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MFI", ".", "isEntryFunction", "(", ")", ")", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDHSA", "||", "isHsaAbiVersion2", "(", "getGlobalSTI", "(", ")", ")", ")", "return", ";", "auto", "&", "Streamer", "=", "getTargetStreamer", "(", ")", "->", "getStreamer", "(", ")", ";", "auto", "&", "Context", "=", "Streamer", ".", "getContext", "(", ")", ";", "auto", "&", "ObjectFileInfo", "=", "*", "Context", ".", "getObjectFileInfo", "(", ")", ";", "auto", "&", "ReadOnlySection", "=", "*", "ObjectFileInfo", ".", "getReadOnlySection", "(", ")", ";", "Streamer", ".", "PushSection", "(", ")", ";", "Streamer", ".", "SwitchSection", "(", "&", "ReadOnlySection", ")", ";", "Streamer", ".", "emitValueToAlignment", "(", "64", ",", "0", ",", "1", ",", "0", ")", ";", "if", "(", "ReadOnlySection", ".", "getAlignment", "(", ")", "<", "64", ")", "ReadOnlySection", ".", "setAlignment", "(", "Align", "(", "64", ")", ")", ";", "const", "GCNSubtarget", "&", "STM", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "SmallString", "<", "128", ">", "KernelName", ";", "getNameWithPrefix", "(", "KernelName", ",", "&", "MF", "->", "getFunction", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitAmdhsaKernelDescriptor", "(", "STM", ",", "KernelName", ",", "getAmdhsaKernelDescriptor", "(", "*", "MF", ",", "CurrentProgramInfo", ")", ",", "CurrentProgramInfo", ".", "NumVGPRsForWavesPerEU", ",", "CurrentProgramInfo", ".", "NumSGPRsForWavesPerEU", "-", "IsaInfo", "::", "getNumExtraSGPRs", "(", "&", "STM", ",", "CurrentProgramInfo", ".", "VCCUsed", ",", "CurrentProgramInfo", ".", "FlatUsed", ")", ",", "CurrentProgramInfo", ".", "VCCUsed", ",", "CurrentProgramInfo", ".", "FlatUsed", ")", ";", "Streamer", ".", "PopSection", "(", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "64", "0", "1", "0", "64", "64", "128" ]

[]

[ "<s>", "static", "bool", "aarch64_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "if", "(", "args", ")", "{", "if", "(", "!", "aarch64_process_target_attr", "(", "args", ")", ")", "return", "false", ";", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "}", "else", "{", "pop_target", "=", "pop_target", "?", "pop_target", ":", "target_option_default_node", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "pop_target", ")", ")", ";", "}", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "aarch64_reset_previous_fndecl", "(", ")", ";", "cpp_options", "*", "cpp_opts", "=", "cpp_get_options", "(", "parse_in", ")", ";", "unsigned", "char", "saved_warn_unused_macros", "=", "cpp_opts", "->", "warn_unused_macros", ";", "cpp_opts", "->", "warn_unused_macros", "=", "0", ";", "cpp_force_token_locations", "(", "parse_in", ",", "BUILTINS_LOCATION", ")", ";", "aarch64_update_cpp_builtins", "(", "parse_in", ")", ";", "cpp_stop_forcing_token_locations", "(", "parse_in", ")", ";", "cpp_opts", "->", "warn_unused_macros", "=", "saved_warn_unused_macros", ";", "if", "(", "pop_target", ")", "aarch64_save_restore_target_globals", "(", "pop_target", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "state", ",", "and", "update", "the", "macros", "based", "on", "what", "was", "changed", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "Optional", "<", "unsigned", ">", "AArch64InstrInfo", "::", "getUnscaledLdSt", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "{", "}", ";", "case", "AArch64", "::", "PRFMui", ":", "return", "AArch64", "::", "PRFUMi", ";", "case", "AArch64", "::", "LDRXui", ":", "return", "AArch64", "::", "LDURXi", ";", "case", "AArch64", "::", "LDRWui", ":", "return", "AArch64", "::", "LDURWi", ";", "case", "AArch64", "::", "LDRBui", ":", "return", "AArch64", "::", "LDURBi", ";", "case", "AArch64", "::", "LDRHui", ":", "return", "AArch64", "::", "LDURHi", ";", "case", "AArch64", "::", "LDRSui", ":", "return", "AArch64", "::", "LDURSi", ";", "case", "AArch64", "::", "LDRDui", ":", "return", "AArch64", "::", "LDURDi", ";", "case", "AArch64", "::", "LDRQui", ":", "return", "AArch64", "::", "LDURQi", ";", "case", "AArch64", "::", "LDRBBui", ":", "return", "AArch64", "::", "LDURBBi", ";", "case", "AArch64", "::", "LDRHHui", ":", "return", "AArch64", "::", "LDURHHi", ";", "case", "AArch64", "::", "LDRSBXui", ":", "return", "AArch64", "::", "LDURSBXi", ";", "case", "AArch64", "::", "LDRSBWui", ":", "return", "AArch64", "::", "LDURSBWi", ";", "case", "AArch64", "::", "LDRSHXui", ":", "return", "AArch64", "::", "LDURSHXi", ";", "case", "AArch64", "::", "LDRSHWui", ":", "return", "AArch64", "::", "LDURSHWi", ";", "case", "AArch64", "::", "LDRSWui", ":", "return", "AArch64", "::", "LDURSWi", ";", "case", "AArch64", "::", "STRXui", ":", "return", "AArch64", "::", "STURXi", ";", "case", "AArch64", "::", "STRWui", ":", "return", "AArch64", "::", "STURWi", ";", "case", "AArch64", "::", "STRBui", ":", "return", "AArch64", "::", "STURBi", ";", "case", "AArch64", "::", "STRHui", ":", "return", "AArch64", "::", "STURHi", ";", "case", "AArch64", "::", "STRSui", ":", "return", "AArch64", "::", "STURSi", ";", "case", "AArch64", "::", "STRDui", ":", "return", "AArch64", "::", "STURDi", ";", "case", "AArch64", "::", "STRQui", ":", "return", "AArch64", "::", "STURQi", ";", "case", "AArch64", "::", "STRBBui", ":", "return", "AArch64", "::", "STURBBi", ";", "case", "AArch64", "::", "STRHHui", ":", "return", "AArch64", "::", "STURHHi", ";", "}", "}", "</s>" ]

[ "Returns", "the", "unscaled", "load/store", "for", "the", "scaled", "load/store", "opcode", ",", "if", "there", "is", "a", "corresponding", "unscaled", "variant", "available", "." ]

[ "AArch64", "AArch64", "AArch64::PRFMui", "AArch64::PRFUMi", "AArch64::LDRXui", "AArch64::LDURXi", "AArch64::LDRWui", "AArch64::LDURWi", "AArch64::LDRBui", "AArch64::LDURBi", "AArch64::LDRHui", "AArch64::LDURHi", "AArch64::LDRSui", "AArch64::LDURSi", "AArch64::LDRDui", "AArch64::LDURDi", "AArch64::LDRQui", "AArch64::LDURQi", "AArch64::LDRBBui", "AArch64::LDURBBi", "AArch64::LDRHHui", "AArch64::LDURHHi", "AArch64::LDRSBXui", "AArch64::LDURSBXi", "AArch64::LDRSBWui", "AArch64::LDURSBWi", "AArch64::LDRSHXui", "AArch64::LDURSHXi", "AArch64::LDRSHWui", "AArch64::LDURSHWi", "AArch64::LDRSWui", "AArch64::LDURSWi", "AArch64::STRXui", "AArch64::STURXi", "AArch64::STRWui", "AArch64::STURWi", "AArch64::STRBui", "AArch64::STURBi", "AArch64::STRHui", "AArch64::STURHi", "AArch64::STRSui", "AArch64::STURSi", "AArch64::STRDui", "AArch64::STURDi", "AArch64::STRQui", "AArch64::STURQi", "AArch64::STRBBui", "AArch64::STURBBi", "AArch64::STRHHui", "AArch64::STURHHi" ]

[]

[ "<s>", "static", "tree", "add_attribute", "(", "const", "char", "*", "name", ",", "tree", "attrs", ")", "{", "return", "tree_cons", "(", "get_identifier", "(", "name", ")", ",", "NULL_TREE", ",", "attrs", ")", ";", "}", "</s>" ]

[ "Add", "attribute", "NAME", "to", "ATTRS", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "if", "(", "AVR", "::", "GPR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "MOVRdRr", ";", "}", "else", "if", "(", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "MOVWRdRr", ";", "}", "else", "if", "(", "SrcReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPREAD", ";", "}", "else", "if", "(", "DestReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPWRITE", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "AVR", "AVR", "AVR::GPR8RegClass", "AVR::MOVRdRr", "AVR::DREGSRegClass", "AVR::MOVWRdRr", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPREAD", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPWRITE", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Copy structure (byval *) arguments to stack\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"Copy structure (byval *) arguments to stack\"" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_value", "(", "const_tree", "type", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", ")", "{", "int", "unsignedp", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "machine_mode", "orig_mode", "=", "TYPE_MODE", "(", "type", ")", ";", "machine_mode", "mode", "=", "promote_function_mode", "(", "type", ",", "orig_mode", ",", "&", "unsignedp", ",", "NULL_TREE", ",", "1", ")", ";", "if", "(", "outgoing", ")", "return", "gen_rtx_REG", "(", "mode", ",", "NVPTX_RETURN_REGNUM", ")", ";", "if", "(", "cfun", "->", "machine", "->", "start_call", "==", "NULL_RTX", ")", "return", "gen_rtx_REG", "(", "mode", ",", "NVPTX_RETURN_REGNUM", ")", ";", "return", "gen_reg_rtx", "(", "mode", ")", ";", "}", "</s>" ]

[ "TARGET_FUNCTION_VALUE", "implementation", ".", "Returns", "an", "RTX", "representing", "the", "place", "where", "function", "FUNC", "returns", "or", "receives", "a", "value", "of", "data", "type", "TYPE", "." ]

[ "nvptx", "1" ]

[]

[ "<s>", "static", "bool", "pdp11_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "0", "||", "INTVAL", "(", "x", ")", "==", "-", "1", "||", "INTVAL", "(", "x", ")", "==", "1", ")", "{", "*", "total", "=", "0", ";", "return", "true", ";", "}", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "2", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "*", "total", "=", "4", ";", "return", "true", ";", "case", "MULT", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "11", ")", ";", "return", "false", ";", "case", "DIV", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "25", ")", ";", "return", "false", ";", "case", "MOD", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "26", ")", ";", "return", "false", ";", "case", "ABS", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "false", ";", "case", "ZERO_EXTEND", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "case", "SIGN_EXTEND", ":", "if", "(", "mode", "==", "HImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "if", "(", "mode", "==", "SImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "6", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "return", "false", ";", "case", "ASHIFT", ":", "case", "LSHIFTRT", ":", "case", "ASHIFTRT", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "if", "(", "mode", "==", "QImode", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "8", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "}", "else", "if", "(", "mode", "==", "HImode", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "if", "(", "abs", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "==", "1", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2.5", "+", "0.5", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "}", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "10", ")", ";", "}", "else", "if", "(", "mode", "==", "SImode", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2.5", "+", "0.5", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "18", ")", ";", "}", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "This", "tries", "to", "approximate", "what", "pdp11_insn_cost", "would", "do", ",", "but", "without", "visibility", "into", "the", "actual", "instruction", "being", "generated", "it", "'s", "inevitably", "a", "rough", "approximation", "." ]

[ "pdp11", "0", "1", "1", "0", "2", "4", "2", "11", "2", "25", "2", "26", "3", "1", "1", "6", "2", "1", "1", "8", "1", "1", "1", "1", "1", "2.5", "0.5", "1", "10", "1", "2.5", "0.5", "1", "18" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", ",", "int", "caller", ")", "{", "struct", "cgraph_local_info", "*", "i", "=", "NULL", ";", "struct", "cgraph_node", "*", "target", "=", "NULL", ";", "memset", "(", "cum", ",", "0", ",", "sizeof", "(", "*", "cum", ")", ")", ";", "if", "(", "fndecl", ")", "{", "target", "=", "cgraph_node", "::", "get", "(", "fndecl", ")", ";", "if", "(", "target", ")", "{", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "i", "=", "cgraph_node", "::", "local_info", "(", "target", "->", "decl", ")", ";", "cum", "->", "call_abi", "=", "ix86_function_abi", "(", "target", "->", "decl", ")", ";", "}", "else", "cum", "->", "call_abi", "=", "ix86_function_abi", "(", "fndecl", ")", ";", "}", "else", "cum", "->", "call_abi", "=", "ix86_function_type_abi", "(", "fntype", ")", ";", "cum", "->", "caller", "=", "caller", ";", "cum", "->", "nregs", "=", "ix86_regparm", ";", "if", "(", "TARGET_64BIT", ")", "{", "cum", "->", "nregs", "=", "(", "cum", "->", "call_abi", "==", "SYSV_ABI", "?", "X86_64_REGPARM_MAX", ":", "X86_64_MS_REGPARM_MAX", ")", ";", "}", "if", "(", "TARGET_SSE", ")", "{", "cum", "->", "sse_nregs", "=", "SSE_REGPARM_MAX", ";", "if", "(", "TARGET_64BIT", ")", "{", "cum", "->", "sse_nregs", "=", "(", "cum", "->", "call_abi", "==", "SYSV_ABI", "?", "X86_64_SSE_REGPARM_MAX", ":", "X86_64_MS_SSE_REGPARM_MAX", ")", ";", "}", "}", "if", "(", "TARGET_MMX", ")", "cum", "->", "mmx_nregs", "=", "MMX_REGPARM_MAX", ";", "cum", "->", "warn_avx512f", "=", "true", ";", "cum", "->", "warn_avx", "=", "true", ";", "cum", "->", "warn_sse", "=", "true", ";", "cum", "->", "warn_mmx", "=", "true", ";", "if", "(", "i", "&&", "i", "->", "local", "&&", "i", "->", "can_change_signature", ")", "fntype", "=", "TREE_TYPE", "(", "target", "->", "decl", ")", ";", "cum", "->", "stdarg", "=", "stdarg_p", "(", "fntype", ")", ";", "cum", "->", "maybe_vaarg", "=", "(", "fntype", "?", "(", "!", "prototype_p", "(", "fntype", ")", "||", "stdarg_p", "(", "fntype", ")", ")", ":", "!", "libname", ")", ";", "cum", "->", "bnd_regno", "=", "FIRST_BND_REG", ";", "cum", "->", "bnds_in_bt", "=", "0", ";", "cum", "->", "force_bnd_pass", "=", "0", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "stdarg_p", "(", "fntype", ")", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "sse_nregs", "=", "0", ";", "cum", "->", "mmx_nregs", "=", "0", ";", "cum", "->", "warn_avx512f", "=", "false", ";", "cum", "->", "warn_avx", "=", "false", ";", "cum", "->", "warn_sse", "=", "false", ";", "cum", "->", "warn_mmx", "=", "false", ";", "return", ";", "}", "if", "(", "fntype", ")", "{", "unsigned", "int", "ccvt", "=", "ix86_get_callcvt", "(", "fntype", ")", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "{", "cum", "->", "nregs", "=", "1", ";", "cum", "->", "fastcall", "=", "1", ";", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "{", "cum", "->", "nregs", "=", "2", ";", "cum", "->", "fastcall", "=", "1", ";", "}", "else", "cum", "->", "nregs", "=", "ix86_function_regparm", "(", "fntype", ",", "fndecl", ")", ";", "}", "cum", "->", "float_in_sse", "=", "ix86_function_sseregparm", "(", "fntype", ",", "fndecl", ",", "true", ")", ";", "}", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

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

[]

[ "<s>", "static", "int", "find_gr_spill", "(", "enum", "ia64_frame_regs", "r", ",", "int", "try_locals", ")", "{", "int", "regno", ";", "if", "(", "emitted_frame_related_regs", "[", "r", "]", "!=", "0", ")", "{", "regno", "=", "emitted_frame_related_regs", "[", "r", "]", ";", "if", "(", "regno", ">=", "LOC_REG", "(", "0", ")", "&&", "regno", "<", "LOC_REG", "(", "80", "-", "frame_pointer_needed", ")", "&&", "current_frame_info", ".", "n_local_regs", "<", "regno", "-", "LOC_REG", "(", "0", ")", "+", "1", ")", "current_frame_info", ".", "n_local_regs", "=", "regno", "-", "LOC_REG", "(", "0", ")", "+", "1", ";", "else", "if", "(", "crtl", "->", "is_leaf", "&&", "regno", ">=", "GR_REG", "(", "1", ")", "&&", "regno", "<=", "GR_REG", "(", "31", ")", ")", "current_frame_info", ".", "gr_used_mask", "|=", "1", "<<", "regno", ";", "return", "regno", ";", "}", "if", "(", "crtl", "->", "is_leaf", ")", "{", "for", "(", "regno", "=", "GR_REG", "(", "1", ")", ";", "regno", "<=", "GR_REG", "(", "31", ")", ";", "regno", "++", ")", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "!", "global_regs", "[", "regno", "]", "&&", "(", "(", "current_frame_info", ".", "gr_used_mask", ">>", "regno", ")", "&", "1", ")", "==", "0", "&&", "!", "is_emitted", "(", "regno", ")", ")", "{", "current_frame_info", ".", "gr_used_mask", "|=", "1", "<<", "regno", ";", "return", "regno", ";", "}", "}", "if", "(", "try_locals", ")", "{", "regno", "=", "current_frame_info", ".", "n_local_regs", ";", "while", "(", "regno", "<", "(", "80", "-", "frame_pointer_needed", ")", ")", "if", "(", "!", "is_emitted", "(", "LOC_REG", "(", "regno", "++", ")", ")", ")", "{", "current_frame_info", ".", "n_local_regs", "=", "regno", ";", "return", "LOC_REG", "(", "regno", "-", "1", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Helper", "function", "for", "ia64_compute_frame_size", ":", "find", "an", "appropriate", "general", "register", "to", "spill", "some", "special", "register", "to", ".", "SPECIAL_SPILL_MASK", "contains", "bits", "in", "GR0", "to", "GR31", "that", "have", "already", "been", "allocated", "by", "this", "routine", ".", "TRY_LOCALS", "is", "true", "if", "we", "should", "attempt", "to", "locate", "a", "local", "regnum", "." ]

[ "ia64", "0", "0", "80", "0", "1", "0", "1", "1", "31", "1", "1", "31", "1", "0", "1", "80", "1", "0" ]

[]

[ "<s>", "int", "mips_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "if", "(", "length", "==", "MAX_PIC_BRANCH_LENGTH", "&&", "JUMP_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", ">=", "0", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_BRANCH", ")", "{", "length", "=", "simplejump_p", "(", "insn", ")", "?", "0", ":", "8", ";", "length", "+=", "BASE_INSN_LENGTH", "*", "mips_load_label_num_insns", "(", ")", ";", "length", "+=", "TARGET_COMPRESSION", "?", "2", ":", "4", ";", "}", "if", "(", "CALL_P", "(", "insn", ")", "||", "(", "TARGET_MIPS16", "?", "simplejump_p", "(", "insn", ")", ":", "JUMP_P", "(", "insn", ")", ")", ")", "length", "+=", "TARGET_MIPS16", "?", "2", ":", "4", ";", "if", "(", "!", "cfun", "->", "machine", "->", "ignore_hazard_length_p", "&&", "INSN_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", ">=", "0", ")", "switch", "(", "get_attr_hazard", "(", "insn", ")", ")", "{", "case", "HAZARD_NONE", ":", "break", ";", "case", "HAZARD_DELAY", ":", "case", "HAZARD_FORBIDDEN_SLOT", ":", "length", "+=", "NOP_INSN_LENGTH", ";", "break", ";", "case", "HAZARD_HILO", ":", "length", "+=", "NOP_INSN_LENGTH", "*", "2", ";", "break", ";", "}", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "INSN", ".", "LENGTH", "is", "the", "initial", "length", "computed", "by", "attributes", "in", "the", "machine-description", "file", "." ]

[ "mips", "0", "0", "8", "2", "4", "2", "4", "0", "2" ]

[]

[ "<s>", "void", "M680x0RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "M680x0FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineOperand", "&", "Disp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "-", "1", ")", ";", "MachineOperand", "&", "Base", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "Imm", "=", "(", "int", ")", "(", "Disp", ".", "getImm", "(", ")", ")", ";", "int", "FIndex", "=", "(", "int", ")", "(", "Base", ".", "getIndex", "(", ")", ")", ";", "bool", "AfterFPPop", "=", "false", ";", "unsigned", "BasePtr", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "Base", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "unsigned", "IgnoredFrameReg", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", ".", "getObjectOffset", "(", "FIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "{", "FIOffset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FIndex", ",", "IgnoredFrameReg", ")", ";", "}", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "long", "long", "Offset", "=", "FIOffset", "+", "Imm", ";", "Disp", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "OpKind", "::", "Reg", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "Num", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "TPC", "\"Invalid access!\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "&&", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"AnyReg unimplemented on 32-bit AIX.\"", ")", ";", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", "&&", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"SplitCSR unimplemented on AIX.\"", ")", ";", "return", "CSR_SRV464_TLS_PE_SaveList", ";", "}", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", "&&", "!", "Subtarget", ".", "isUsingPCRelativeCalls", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Cold", ")", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"Cold calling unimplemented on AIX.\"", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_Altivec_SaveList", ":", "CSR_SVR64_ColdCC_Altivec_SaveList", ";", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_SaveList", ":", "CSR_SVR64_ColdCC_SaveList", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR32_ColdCC_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR32_ColdCC_SPE_SaveList", ";", "return", "CSR_SVR32_ColdCC_SaveList", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "SaveR2", "?", "CSR_PPC64_R2_Altivec_SaveList", ":", "CSR_PPC64_Altivec_SaveList", ";", "return", "SaveR2", "?", "CSR_PPC64_R2_SaveList", ":", "CSR_PPC64_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "return", "CSR_AIX32_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR432_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR432_SPE_SaveList", ";", "return", "CSR_SVR432_SaveList", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "\"AnyReg unimplemented on 32-bit AIX.\"", "PPC", "PPC", "\"SplitCSR unimplemented on AIX.\"", "PPC::X2", "\"Cold calling unimplemented on AIX.\"", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "int", "AArch64FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "return", "resolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ",", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SanitizeHWAddress", ")", ",", "false", ")", ".", "getBytes", "(", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "const", "bool", "restrict_addressing_modes_for_nacl", "=", "Subtarget", "->", "isTargetNaCl", "(", ")", "&&", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "LOAD", "||", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "STORE", ")", ";", "if", "(", "restrict_addressing_modes_for_nacl", ")", "{", "return", "false", ";", "}", "EVT", "VT", ";", "SDValue", "Ptr", ";", "bool", "isSEXTLoad", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "isInc", ";", "bool", "isLegal", "=", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "isLegal", "=", "getT2IndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "isLegal", "=", "getARMIndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "if", "(", "!", "isLegal", ")", "return", "false", ";", "if", "(", "Ptr", "!=", "Base", ")", "{", "if", "(", "Ptr", "==", "Offset", "&&", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "!", "Subtarget", "->", "isThumb2", "(", ")", ")", "std", "::", "swap", "(", "Base", ",", "Offset", ")", ";", "if", "(", "Ptr", "!=", "Base", ")", "return", "false", ";", "}", "AM", "=", "isInc", "?", "ISD", "::", "POST_INC", ":", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::LOAD", "ISD::STORE", "ISD::SEXTLOAD", "ARM", "ISD::ADD", "ISD::POST_INC", "ISD::POST_DEC" ]

[]

[ "<s>", "bool", "AMDGPUTTIImpl", "::", "getTgtMemIntrinsic", "(", "IntrinsicInst", "*", "Inst", ",", "MemIntrinsicInfo", "&", "Info", ")", "const", "{", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "{", "auto", "*", "Ordering", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "2", ")", ")", ";", "auto", "*", "Volatile", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "4", ")", ")", ";", "if", "(", "!", "Ordering", "||", "!", "Volatile", ")", "return", "false", ";", "unsigned", "OrderingVal", "=", "Ordering", "->", "getZExtValue", "(", ")", ";", "if", "(", "OrderingVal", ">", "static_cast", "<", "unsigned", ">", "(", "AtomicOrdering", "::", "SequentiallyConsistent", ")", ")", "return", "false", ";", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "0", ")", ";", "Info", ".", "Ordering", "=", "static_cast", "<", "AtomicOrdering", ">", "(", "OrderingVal", ")", ";", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "true", ";", "Info", ".", "IsVolatile", "=", "!", "Volatile", "->", "isNullValue", "(", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AMDGPU", "AMDGPU", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "2", "4", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "ARM_BRANCH_TARGETS_NAME", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "mips_force_address", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "mips_legitimate_address_p", "(", "mode", ",", "x", ",", "false", ")", ")", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "If", "X", "is", "not", "a", "valid", "address", "for", "mode", "MODE", ",", "force", "it", "into", "a", "register", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "X86InstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "const", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCopy", "(", "I", ",", "TII", ",", "MRI", ",", "TRI", ",", "RBI", ")", ";", "return", "true", ";", "}", "assert", "(", "I", ".", "getNumOperands", "(", ")", "==", "I", ".", "getNumExplicitOperands", "(", ")", "&&", "\"Generic instruction has unexpected implicit operands\\n\"", ")", ";", "if", "(", "selectBinaryOp", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectLoadStoreOp", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectFrameIndex", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "return", "selectImpl", "(", "I", ")", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "X86", "X86", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "\"Generic instruction has unexpected implicit operands\\n\"" ]

[]

[ "<s>", "uint64_t", "PPCFrameLowering", "::", "getBasePointerSaveOffset", "(", ")", "const", "{", "return", "BasePointerSaveOffset", ";", "}", "</s>" ]

[ "getBasePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "base", "pointer", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "rtx", "inner", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "inner", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "inner", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "inner", ",", "1", ")", ")", "==", "CONST_INT", ")", "inner", "=", "XEXP", "(", "inner", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "inner", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "inner", ",", "1", ")", ")", "{", "case", "UNSPEC_GOTOFF", ":", "return", "TARGET_64BIT", ";", "case", "UNSPEC_TPOFF", ":", "x", "=", "XVECEXP", "(", "inner", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", ";", "default", ":", "return", "false", ";", "}", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "legitimate_pic_address_disp_p", "(", "x", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnablePromoteConstant", ")", "addPass", "(", "createAArch64PromoteConstantPass", "(", ")", ")", ";", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "{", "bool", "OnlyOptimizeForSize", "=", "(", "TM", "->", "getOptLevel", "(", ")", "<", "CodeGenOpt", "::", "Aggressive", ")", "&&", "(", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", ";", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "4095", ",", "OnlyOptimizeForSize", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64AddressTypePromotionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "AArch64", "AArch64", "AArch64", "4095", "AArch64" ]

[]

[ "<s>", "static", "rtx", "loongarch_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "base", ",", "addr", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "loongarch_tls_symbol_p", "(", "x", ")", ")", "return", "loongarch_legitimize_tls_address", "(", "x", ")", ";", "loongarch_split_plus", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "0", ")", "{", "if", "(", "!", "loongarch_valid_base_register_p", "(", "base", ",", "mode", ",", "false", ")", ")", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "base", ")", ";", "addr", "=", "loongarch_add_offset", "(", "NULL", ",", "base", ",", "offset", ")", ";", "return", "loongarch_force_address", "(", "addr", ",", "mode", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "implement", "LEGITIMIZE_ADDRESS", ".", "If", "X", "can", "be", "legitimized", "in", "a", "way", "that", "the", "generic", "machinery", "might", "not", "expect", ",", "return", "a", "new", "address", ",", "otherwise", "return", "NULL", ".", "MODE", "is", "the", "mode", "of", "the", "memory", "being", "accessed", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "static", "void", "fatal", "(", "const", "char", "*", "msg", ")", "{", "fprintf", "(", "stderr", ",", "\"FATAL: %s\\n\"", ",", "msg", ")", ";", "abort", "(", ")", ";", "}", "</s>" ]

[ "Produce", "a", "fatal", "error", "message", "." ]

[ "rs6000", "\"FATAL: %s\\n\"" ]

[]

[ "<s>", "void", "XtensaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Couldn't reach here\"", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"Couldn't reach here\"" ]

[]

[ "<s>", "static", "void", "ix86_seh_fixup_eh_fallthru", "(", "void", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ";", "for", "(", "insn", "=", "BB_END", "(", "e", "->", "src", ")", ";", "insn", "!=", "NULL", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "if", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_EPILOGUE_BEG", ")", "break", ";", "if", "(", "insn", "==", "NULL", ")", "continue", ";", "insn", "=", "prev_active_insn", "(", "insn", ")", ";", "if", "(", "insn", "==", "NULL", "||", "!", "can_throw_internal", "(", "insn", ")", ")", "continue", ";", "for", "(", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "next", "!=", "NULL", ";", "next", "=", "NEXT_INSN", "(", "next", ")", ")", "if", "(", "NOTE_P", "(", "next", ")", "&&", "(", "NOTE_KIND", "(", "next", ")", "==", "NOTE_INSN_VAR_LOCATION", "||", "NOTE_KIND", "(", "next", ")", "==", "NOTE_INSN_CALL_ARG_LOCATION", ")", ")", "insn", "=", "next", ";", "else", "break", ";", "emit_insn_after", "(", "gen_nops", "(", "const1_rtx", ")", ",", "insn", ")", ";", "}", "}", "</s>" ]

[ "Fix", "up", "a", "Windows", "system", "unwinder", "issue", ".", "If", "an", "EH", "region", "falls", "through", "into", "the", "epilogue", ",", "the", "Windows", "system", "unwinder", "will", "apply", "epilogue", "logic", "and", "produce", "incorrect", "offsets", ".", "This", "can", "be", "avoided", "by", "adding", "a", "nop", "between", "the", "last", "insn", "that", "can", "throw", "and", "the", "first", "insn", "of", "the", "epilogue", "." ]

[ "i386" ]

[]

[ "<s>", "void", "s390_indirect_branch_via_inline_thunk", "(", "rtx", "execute_target", ")", "{", "if", "(", "TARGET_INDIRECT_BRANCH_TABLE", ")", "{", "char", "label", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label", ",", "indirect_branch_table_label", "[", "s390_opt_indirect_branch_jump", "]", ",", "indirect_branch_table_label_no", "[", "s390_opt_indirect_branch_jump", "]", "++", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "label", ")", ";", "}", "if", "(", "!", "TARGET_ZARCH", ")", "fputs", "(", "\"\\t.machinemode zarch\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "REG_P", "(", "execute_target", ")", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tex\\t%%r0,0(%%r%d)\\n\"", ",", "REGNO", "(", "execute_target", ")", ")", ";", "else", "output_asm_insn", "(", "\"\\texrl\\t%%r0,%0\"", ",", "&", "execute_target", ")", ";", "if", "(", "!", "TARGET_ZARCH", ")", "fputs", "(", "\"\\t.machinemode esa\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"0:\\tj\\t0b\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "an", "inline", "thunk", "for", "indirect", "jumps", ".", "EXECUTE_TARGET", "can", "either", "be", "an", "address", "register", "or", "a", "label", "pointing", "to", "the", "location", "of", "the", "jump", "instruction", "." ]

[ "s390", "32", "\"\\t.machinemode zarch\\n\"", "\"\\tex\\t%%r0,0(%%r%d)\\n\"", "\"\\texrl\\t%%r0,%0\"", "\"\\t.machinemode esa\\n\"", "\"0:\\tj\\t0b\\n\"" ]

[]

[ "<s>", "RegisterRef", "RegisterAggr", "::", "normalize", "(", "RegisterRef", "RR", ")", "const", "{", "const", "TargetRegisterClass", "*", "RC", "=", "PRI", ".", "RegInfos", "[", "RR", ".", "Reg", "]", ".", "RegClass", ";", "LaneBitmask", "RCMask", "=", "RC", "!=", "nullptr", "?", "RC", "->", "LaneMask", ":", "LaneBitmask", "(", "0x00000001", ")", ";", "LaneBitmask", "Common", "=", "RR", ".", "Mask", "&", "RCMask", ";", "RegisterId", "SuperReg", "=", "PRI", ".", "RegInfos", "[", "RR", ".", "Reg", "]", ".", "MaxSuper", ";", "uint32_t", "Sub", "=", "PRI", ".", "getTRI", "(", ")", ".", "getSubRegIndex", "(", "SuperReg", ",", "RR", ".", "Reg", ")", ";", "LaneBitmask", "SuperMask", "=", "PRI", ".", "getTRI", "(", ")", ".", "composeSubRegIndexLaneMask", "(", "Sub", ",", "Common", ")", ";", "return", "RegisterRef", "(", "SuperReg", ",", "SuperMask", ")", ";", "}", "</s>" ]

[ "Weight", "normalization", "function", "." ]

[ "Hexagon", "0x00000001" ]

[]

[ "<s>", "bool", "WebAssemblyArgumentMove", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Argument Move **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "InsertPt", "=", "EntryMBB", ".", "end", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "if", "(", "!", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "{", "InsertPt", "=", "MI", ";", "break", ";", "}", "}", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_range", "(", "InsertPt", ",", "EntryMBB", ".", "end", "(", ")", ")", ")", "{", "if", "(", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "{", "EntryMBB", ".", "insert", "(", "InsertPt", ",", "MI", ".", "removeFromParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Argument Move **********\\n\"", "\"********** Function: \"", "WebAssembly::isArgument", "WebAssembly::isArgument" ]

[]

[ "<s>", "bool", "MVEVPTBlock", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", "||", "!", "STI", ".", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "RDA", "=", "&", "getAnalysis", "<", "ReachingDefAnalysis", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM MVE VPT BLOCKS **********\\n\"", "<<", "\"********** Function: \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "InsertVPTBlocks", "(", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"********** ARM MVE VPT BLOCKS **********\\n\"", "\"********** Function: \"", "\"**************************************\\n\"" ]

[]

[ "<s>", "static", "void", "s390_restore_gprs_from_fprs", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_Z10", "||", "!", "TARGET_HARD_FLOAT", "||", "!", "crtl", "->", "is_leaf", ")", "return", ";", "for", "(", "i", "=", "6", ";", "i", "<", "16", ";", "i", "++", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "!", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "i", ")", ")", ")", "continue", ";", "rtx", "fpr", "=", "gen_rtx_REG", "(", "DImode", ",", "cfun_gpr_save_slot", "(", "i", ")", ")", ";", "if", "(", "i", "==", "STACK_POINTER_REGNUM", ")", "insn", "=", "emit_insn", "(", "gen_stack_restore_from_fpr", "(", "fpr", ")", ")", ";", "else", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "i", ")", ",", "fpr", ")", ";", "df_set_regs_ever_live", "(", "i", ",", "true", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "DImode", ",", "i", ")", ")", ";", "if", "(", "i", "==", "STACK_POINTER_REGNUM", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "STACK_POINTER_OFFSET", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Restore", "GPRs", "from", "FPR", "save", "slots", "." ]

[ "s390", "6", "16", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Cell SPU DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "CellSPU", "\"Cell SPU DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "do_ifelse", "(", "machine_mode", "cmpmode", ",", "rtx_code", "comparison", ",", "rtx", "a", ",", "rtx", "b", ",", "rtx", "cr", ",", "rtx", "true_label", ",", "profile_probability", "br_prob", ")", "{", "gcc_assert", "(", "(", "a", "==", "NULL_RTX", "&&", "b", "==", "NULL_RTX", "&&", "cr", "!=", "NULL_RTX", ")", "||", "(", "a", "!=", "NULL_RTX", "&&", "b", "!=", "NULL_RTX", ")", ")", ";", "if", "(", "cr", "!=", "NULL_RTX", ")", "gcc_assert", "(", "GET_MODE", "(", "cr", ")", "==", "cmpmode", ")", ";", "else", "cr", "=", "gen_reg_rtx", "(", "cmpmode", ")", ";", "rtx", "label_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "true_label", ")", ";", "if", "(", "a", "!=", "NULL_RTX", ")", "emit_move_insn", "(", "cr", ",", "gen_rtx_COMPARE", "(", "cmpmode", ",", "a", ",", "b", ")", ")", ";", "rtx", "cmp_rtx", "=", "gen_rtx_fmt_ee", "(", "comparison", ",", "VOIDmode", ",", "cr", ",", "const0_rtx", ")", ";", "rtx", "ifelse", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "label_ref", ",", "pc_rtx", ")", ";", "rtx_insn", "*", "j", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "ifelse", ")", ")", ";", "add_reg_br_prob_note", "(", "j", ",", "br_prob", ")", ";", "JUMP_LABEL", "(", "j", ")", "=", "true_label", ";", "LABEL_NUSES", "(", "true_label", ")", "+=", "1", ";", "}", "</s>" ]

[ "Do", "a", "branch", "for", "an", "if/else", "decision", ".", "CMPMODE", "is", "the", "mode", "to", "use", "for", "the", "comparison", ".", "COMPARISON", "is", "the", "rtx", "code", "for", "the", "compare", "needed", ".", "A", "is", "the", "first", "thing", "to", "be", "compared", ".", "B", "is", "the", "second", "thing", "to", "be", "compared", ".", "CR", "is", "the", "condition", "code", "reg", "input", ",", "or", "NULL_RTX", ".", "TRUE_LABEL", "is", "the", "label", "to", "branch", "to", "if", "the", "condition", "is", "true", ".", "The", "return", "value", "is", "the", "CR", "used", "for", "the", "comparison", ".", "If", "CR", "is", "null_rtx", ",", "then", "a", "new", "register", "of", "CMPMODE", "is", "generated", ".", "If", "A", "and", "B", "are", "both", "null_rtx", ",", "then", "CR", "must", "not", "be", "null", ",", "and", "the", "compare", "is", "not", "generated", "so", "you", "can", "use", "this", "with", "a", "dot", "form", "insn", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "virtual", "const", "TargetSubtargetInfo", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "LC3" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitInlineAsmStart", "(", ")", "const", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "TS", ".", "emitDirectiveSetPush", "(", ")", ";", "TS", ".", "emitDirectiveSetAt", "(", ")", ";", "TS", ".", "emitDirectiveSetMacro", "(", ")", ";", "TS", ".", "emitDirectiveSetReorder", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "Let", "the", "target", "do", "anything", "it", "needs", "to", "do", "before", "emitting", "inlineasm", "." ]

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

[]

[ "<s>", "static", "int", "ix86_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "class1_i", ",", "reg_class_t", "class2_i", ")", "{", "enum", "reg_class", "class1", "=", "(", "enum", "reg_class", ")", "class1_i", ";", "enum", "reg_class", "class2", "=", "(", "enum", "reg_class", ")", "class2_i", ";", "if", "(", "inline_secondary_memory_needed", "(", "class1", ",", "class2", ",", "mode", ",", "0", ")", ")", "{", "int", "cost", "=", "1", ";", "cost", "+=", "inline_memory_move_cost", "(", "mode", ",", "class1", ",", "2", ")", ";", "cost", "+=", "inline_memory_move_cost", "(", "mode", ",", "class2", ",", "2", ")", ";", "if", "(", "targetm", ".", "class_max_nregs", "(", "class1", ",", "mode", ")", ">", "targetm", ".", "class_max_nregs", "(", "class2", ",", "mode", ")", ")", "cost", "+=", "20", ";", "if", "(", "(", "MMX_CLASS_P", "(", "class1", ")", "&&", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", ")", "||", "(", "MMX_CLASS_P", "(", "class2", ")", "&&", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", ")", ")", "cost", "+=", "20", ";", "return", "cost", ";", "}", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", "||", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "return", "MAX", "(", "8", ",", "ix86_cost", "->", "mmxsse_to_integer", ")", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "fp_move", ";", "if", "(", "MAYBE_SSE_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "sse_move", ";", "if", "(", "MAYBE_MMX_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "mmx_move", ";", "return", "2", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "from", "a", "register", "in", "class", "CLASS1", "to", "one", "in", "class", "CLASS2", ".", "It", "is", "not", "required", "that", "the", "cost", "always", "equal", "2", "when", "FROM", "is", "the", "same", "as", "TO", ";", "on", "some", "machines", "it", "is", "expensive", "to", "move", "between", "registers", "if", "they", "are", "not", "general", "registers", "." ]

[ "i386", "0", "1", "2", "2", "20", "20", "8", "2" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "restoreWin32EHStackPointers", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "bool", "RestoreSP", ")", "const", "{", "assert", "(", "STI", ".", "isTargetWindowsMSVC", "(", ")", "&&", "\"funclets only supported in MSVC env\"", ")", ";", "assert", "(", "STI", ".", "isTargetWin32", "(", ")", "&&", "\"EBP/ESI restoration only required on win32\"", ")", ";", "assert", "(", "STI", ".", "is32Bit", "(", ")", "&&", "!", "Uses64BitFramePtr", "&&", "\"restoring EBP/ESI on non-32-bit target\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "Register", "FramePtr", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "Register", "BasePtr", "=", "TRI", "->", "getBaseRegister", "(", ")", ";", "WinEHFuncInfo", "&", "FuncInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "FuncInfo", ".", "EHRegNodeFrameIndex", ";", "int", "EHRegSize", "=", "MFI", ".", "getObjectSize", "(", "FI", ")", ";", "if", "(", "RestoreSP", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "X86", "::", "ESP", ")", ",", "X86", "::", "EBP", ",", "true", ",", "-", "EHRegSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "Register", "UsedReg", ";", "int", "EHRegOffset", "=", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "UsedReg", ")", ";", "int", "EndOffset", "=", "-", "EHRegOffset", "-", "EHRegSize", ";", "FuncInfo", ".", "EHRegNodeEndOffset", "=", "EndOffset", ";", "if", "(", "UsedReg", "==", "FramePtr", ")", "{", "unsigned", "ADDri", "=", "getADDriOpcode", "(", "false", ",", "EndOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "ADDri", ")", ",", "FramePtr", ")", ".", "addReg", "(", "FramePtr", ")", ".", "addImm", "(", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "assert", "(", "EndOffset", ">=", "0", "&&", "\"end of registration object above normal EBP position!\"", ")", ";", "}", "else", "if", "(", "UsedReg", "==", "BasePtr", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "LEA32r", ")", ",", "BasePtr", ")", ",", "FramePtr", ",", "false", ",", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "assert", "(", "X86FI", "->", "getHasSEHFramePtrSave", "(", ")", ")", ";", "int", "Offset", "=", "getFrameIndexReference", "(", "MF", ",", "X86FI", "->", "getSEHFramePtrSaveIndex", "(", ")", ",", "UsedReg", ")", ";", "assert", "(", "UsedReg", "==", "BasePtr", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "FramePtr", ")", ",", "UsedReg", ",", "true", ",", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"", ")", ";", "}", "return", "MBBI", ";", "}", "</s>" ]

[ "Sets", "up", "EBP", "and", "optionally", "ESI", "based", "on", "the", "incoming", "EBP", "value", "." ]

[ "X86", "X86", "\"funclets only supported in MSVC env\"", "\"EBP/ESI restoration only required on win32\"", "\"restoring EBP/ESI on non-32-bit target\"", "X86", "X86", "X86", "X86::MOV32rm", "X86::ESP", "X86::EBP", "3", "0", "\"end of registration object above normal EBP position!\"", "X86::LEA32r", "X86", "X86", "X86::MOV32rm", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"" ]

[]

[ "<s>", "static", "struct", "rbt_string_node", "*", "rbt_create_node", "(", "struct", "rbt_strings", "*", "t", ",", "char", "*", "str", ")", "{", "struct", "rbt_string_node", "*", "nodeptr", "=", "(", "struct", "rbt_string_node", "*", ")", "malloc", "(", "sizeof", "(", "rbt_string_node", ")", ")", ";", "nodeptr", "->", "str", "=", "str", ";", "nodeptr", "->", "left", "=", "t", "->", "rbt_nil", ";", "nodeptr", "->", "right", "=", "t", "->", "rbt_nil", ";", "nodeptr", "->", "par", "=", "NULL", ";", "nodeptr", "->", "color", "=", "RBT_RED", ";", "return", "nodeptr", ";", "}", "</s>" ]

[ "Create", "a", "new", "node", "to", "be", "inserted", "into", "the", "red-black", "tree", ".", "An", "inserted", "node", "starts", "out", "red", "." ]

[ "rs6000" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "Triple", "(", "getTargetTriple", "(", ")", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "SubExpr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "MOS" ]

[]

[ "<s>", "void", "TVMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "return", ";", "case", "ISD", "::", "GlobalAddress", ":", "Results", ".", "push_back", "(", "LowerGlobalAddress", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "ExternalSymbol", ":", "Results", ".", "push_back", "(", "LowerExternalSymbol", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "TargetFrameIndex", ":", "case", "ISD", "::", "FrameIndex", ":", "Results", ".", "push_back", "(", "LowerFrameIndex", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "LowerOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "TVM", "TVM", "\"Do not know how to custom type legalize this operation!\"", "ISD::GlobalAddress", "0", "ISD::ExternalSymbol", "0", "ISD::TargetFrameIndex", "ISD::FrameIndex", "0", "ISD::LOAD" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "SelectConstant", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "ConstantFP", ":", "SelectConstantFP", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "FrameIndex", ":", "SelectFrameIndex", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "ADD", ":", "SelectAdd", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "BITCAST", ":", "SelectBitcast", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "SHL", ":", "SelectSHL", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "SelectLoad", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "STORE", ":", "SelectStore", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "MUL", ":", "SelectMul", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FNEG", ":", "SelectBitOp", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "SelectZeroExtend", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "SelectIntrinsicWChain", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "SelectIntrinsicWOChain", "(", "N", ")", ";", "return", ";", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::FrameIndex", "ISD::ADD", "ISD::BITCAST", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::FABS", "ISD::FNEG", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetAndroid", "(", ")", ")", "return", "UseTlsOffset", "(", "IRB", ",", "0x48", ")", ";", "if", "(", "Subtarget", "->", "isTargetFuchsia", "(", ")", ")", "return", "UseTlsOffset", "(", "IRB", ",", "-", "0x8", ")", ";", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "AArch64", "AArch64", "0x48", "0x8" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "BP", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "S7_64", ":", "Mips", "::", "S7", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "FP", ")", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "BP", ")", ";", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "MipsFI", "->", "createEhDataRegsFI", "(", ")", ";", "if", "(", "MipsFI", "->", "isISR", "(", ")", ")", "MipsFI", "->", "createISRRegFI", "(", ")", ";", "if", "(", "ExpandPseudo", "(", "MF", ")", ".", "expand", "(", ")", ")", "{", "const", "TargetRegisterClass", "&", "RC", "=", "STI", ".", "hasMips64", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "uint64_t", "MaxSPOffset", "=", "estimateStackSize", "(", "MF", ")", ";", "if", "(", "isIntN", "(", "STI", ".", "hasMSA", "(", ")", "?", "10", ":", "16", ",", "MaxSPOffset", ")", "&&", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "return", ";", "const", "TargetRegisterClass", "&", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::S7_64", "Mips::S7", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "10", "16", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "bool", "mips_store_data_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "in_insn", ")", ")", "==", "UNSPEC_VOLATILE", ")", "return", "false", ";", "return", "!", "store_data_bypass_p", "(", "out_insn", ",", "in_insn", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "dependency", "between", "OUT_INSN", "and", "IN_INSN", "is", "on", "the", "store", "data", "rather", "than", "the", "address", ".", "We", "need", "this", "because", "the", "cprestore", "pattern", "is", "type", "``", "store", "''", ",", "but", "is", "defined", "using", "an", "UNSPEC_VOLATILE", ",", "which", "causes", "the", "default", "routine", "to", "abort", ".", "We", "just", "return", "false", "for", "that", "case", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "isTypeDesirableForOp", "(", "unsigned", "Opc", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "{", "return", "false", ";", "}", "if", "(", "Subtarget", ".", "is16Bit", "(", ")", ")", "{", "return", "true", ";", "}", "switch", "(", "Opc", ")", "{", "default", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "true", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "VT", "!=", "MVT", "::", "i16", ";", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "VT", "!=", "MVT", "::", "i24", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "for", "the", "given", "node", "type", "." ]

[ "Z80old", "Z80old", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::LOAD", "ISD::STORE", "ISD::ADD", "ISD::SUB", "MVT::i16", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SHL", "ISD::SRA", "ISD::SRL", "MVT::i24" ]

[]

[ "<s>", "static", "void", "r10k_needs_protection_p_store", "(", "rtx", "x", ",", "const_rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "rtx_insn", "*", "*", "insn_ptr", ";", "insn_ptr", "=", "(", "rtx_insn", "*", "*", ")", "data", ";", "if", "(", "*", "insn_ptr", "&&", "r10k_needs_protection_p_1", "(", "x", ",", "*", "insn_ptr", ")", ")", "*", "insn_ptr", "=", "NULL", ";", "}", "</s>" ]

[ "A", "note_stores", "callback", "for", "which", "DATA", "points", "to", "an", "instruction", "pointer", ".", "If", "*", "DATA", "is", "nonnull", ",", "make", "it", "null", "if", "it", "X", "contains", "a", "MEM", "that", "is", "not", "safe", "from", "R10K", "speculation", "." ]

[ "mips" ]

[]

[ "<s>", "int64_t", "getNamedImmOperand", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpName", ")", "const", "{", "int", "Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "OpName", ")", ";", "return", "MI", ".", "getOperand", "(", "Idx", ")", ".", "getImm", "(", ")", ";", "}", "</s>" ]

[ "Get", "required", "immediate", "operand", "." ]

[ "AMDGPU", "AMDGPU::getNamedOperandIdx" ]

[]

[ "<s>", "bool", "isIntDivCheap", "(", "EVT", ",", "AttributeList", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "VE" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "PPCRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "PPC", "::", "G8RCRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "else", "if", "(", "PPC", "::", "F8RCRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "PPC", "::", "F8RCRegClass", ";", "else", "if", "(", "PPC", "::", "CRRCRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "PPC", "::", "CRRCRegClass", ";", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "PPC", "::", "VRRCRegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::G8RCRegClass", "PPC::F8RCRegClass", "PPC::F8RCRegClass", "PPC::CRRCRegClass", "PPC::CRRCRegClass", "PPC::VRRCRegClass", "PPC::VRRCRegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "unsigned", "Flags", "=", "MI", "->", "getFlags", "(", ")", ";", "if", "(", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_LOCK", ")", ")", "OS", "<<", "\"\\tlock\\t\"", ";", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT_NE", ")", "OS", "<<", "\"\\trepne\\t\"", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT", ")", "OS", "<<", "\"\\trep\\t\"", ";", "if", "(", "(", "TSFlags", "&", "X86II", "::", "NOTRACK", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_NOTRACK", ")", ")", "OS", "<<", "\"\\tnotrack\\t\"", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "MII", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "X86", "X86", "X86II::LOCK", "X86::IP_HAS_LOCK", "\"\\tlock\\t\"", "X86::IP_HAS_REPEAT_NE", "\"\\trepne\\t\"", "X86::IP_HAS_REPEAT", "\"\\trep\\t\"", "X86II::NOTRACK", "X86::IP_HAS_NOTRACK", "\"\\tnotrack\\t\"", "X86" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "AMDGPUArgumentUsageInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "AMDGPUPerfHintAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "SelectionDAGISel", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "reg_class_t", "mmix_preferred_output_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "return", "GET_CODE", "(", "x", ")", "==", "MOD", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", "?", "REMAINDER_REG", ":", "rclass", ";", "}", "</s>" ]

[ "PREFERRED_OUTPUT_RELOAD_CLASS", ".", "We", "need", "to", "extend", "the", "reload", "class", "of", "REMAINDER_REG", "and", "HIMULT_REG", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ",", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "MI", ",", "Err", ")", ")", "{", "errs", "(", ")", "<<", "\"Warning: Illegal instruction detected: \"", "<<", "Err", "<<", "\"\\n\"", ";", "MI", "->", "dump", "(", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "++", "I", ";", "while", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "EmitInstruction", "(", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "if", "(", "DisasmEnabled", ")", "{", "DisasmLines", ".", "resize", "(", "DisasmLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "DisasmLine", "=", "DisasmLines", ".", "back", "(", ")", ";", "raw_string_ostream", "DisasmStream", "(", "DisasmLine", ")", ";", "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ")", ";", "SmallVector", "<", "MCFixup", ",", "4", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "16", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "MCObjectStreamer", "&", "ObjStreamer", "=", "(", "MCObjectStreamer", "&", ")", "OutStreamer", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "EncodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "MF", "->", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "CodeStream", ".", "flush", "(", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", ".", "back", "(", ")", ";", "raw_string_ostream", "HexStream", "(", "HexLine", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CodeBytes", ".", "size", "(", ")", ";", "i", "+=", "4", ")", "{", "unsigned", "int", "CodeDWord", "=", "*", "(", "unsigned", "int", "*", ")", "&", "CodeBytes", "[", "i", "]", ";", "HexStream", "<<", "format", "(", "\"%s%08X\"", ",", "(", "i", ">", "0", "?", "\" \"", ":", "\"\"", ")", ",", "CodeDWord", ")", ";", "}", "DisasmStream", ".", "flush", "(", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLine", ".", "size", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "R600", "\"Warning: Illegal instruction detected: \"", "\"\\n\"", "1", "4", "16", "1", "0", "4", "\"%s%08X\"", "0", "\" \"", "\"\"" ]

[]

[ "<s>", "bool", "WebAssemblyInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a condition expression\"", ")", ";", "Cond", ".", "front", "(", ")", "=", "MachineOperand", "::", "CreateImm", "(", "!", "Cond", ".", "front", "(", ")", ".", "getImm", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "WebAssembly", "WebAssembly", "2", "\"Expected a flag and a condition expression\"" ]

[]

[ "<s>", "static", "bool", "mips_expand_ghost_gp_insns", "(", "void", ")", "{", "if", "(", "!", "TARGET_USE_GOT", "||", "cfun", "->", "machine", "->", "global_pointer", "==", "INVALID_REGNUM", "||", "mips_must_initialize_gp_p", "(", ")", ")", "return", "false", ";", "if", "(", "!", "mips_has_long_branch_p", "(", ")", ")", "return", "false", ";", "cfun", "->", "machine", "->", "must_initialize_gp_p", "=", "true", ";", "split_all_insns_noflow", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "If", "we", "are", "using", "a", "GOT", ",", "but", "have", "not", "decided", "to", "use", "a", "global", "pointer", "yet", ",", "see", "whether", "we", "need", "one", "to", "implement", "long", "branches", ".", "Convert", "the", "ghost", "global-pointer", "instructions", "into", "real", "ones", "if", "so", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "TLCS900FrameLowering", "::", "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", "." ]

[ "TLCS900", "TLCS900" ]

[]