ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"static",
"bool",
"x86_can_output_mi_thunk",
"(",
"tree",
"thunk",
"ATTRIBUTE_UNUSED",
",",
"HOST_WIDE_INT",
"delta",
"ATTRIBUTE_UNUSED",
",",
"HOST_WIDE_INT",
"vcall_offset",
",",
"tree",
"function",
")",
"{",
"if",
"(",
"TARGET_64BIT",
")",
"return",
"true",
";",
"if",
"(",
"ix86_function_regparm",
"(",
"TREE_TYPE",
"(",
"function",
")",
",",
"function",
")",
"<",
"3",
")",
"return",
"true",
";",
"if",
"(",
"vcall_offset",
")",
"return",
"false",
";",
"if",
"(",
"flag_pic",
"&&",
"!",
"(",
"*",
"targetm",
".",
"binds_local_p",
")",
"(",
"function",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"x86_output_mi_thunk",
"can",
"succeed",
"."
] | [
"i386",
"3"
] | i3863 | x86_can_output_mi_thunk | i386 | CPU | GCC | 20,000 | 72 | 1 | [] |
[
"<s>",
"unsigned",
"ARMRegisterInfo",
"::",
"getFrameRegister",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"STI",
".",
"isTargetDarwin",
"(",
")",
"||",
"hasFP",
"(",
"MF",
")",
")",
"return",
"(",
"STI",
".",
"useThumbBacktraces",
"(",
")",
"||",
"STI",
".",
"isThumb",
"(",
")",
")",
"?",
"ARM",
"::",
"R7",
":",
"ARM",
"::",
"R11",
";",
"else",
"return",
"ARM",
"::",
"SP",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"ARM",
"ARM",
"ARM::R7",
"ARM::R11",
"ARM::SP"
] | ARMRegisterInfo13 | getFrameRegister | ARM | CPU | LLVM | 20,001 | 54 | 1 | [] |
[
"<s>",
"bool",
"ARMLowOverheadLoops",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"mf",
")",
"{",
"const",
"ARMSubtarget",
"&",
"ST",
"=",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"mf",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"!",
"ST",
".",
"hasLOB",
"(",
")",
")",
"return",
"false",
";",
"MF",
"=",
"&",
"mf",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"ARM Loops on \"",
"<<",
"MF",
"->",
"getName",
"(",
")",
"<<",
"\" ------------- \\n\"",
")",
";",
"MLI",
"=",
"&",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"RDA",
"=",
"&",
"getAnalysis",
"<",
"ReachingDefAnalysis",
">",
"(",
")",
";",
"MF",
"->",
"getProperties",
"(",
")",
".",
"set",
"(",
"MachineFunctionProperties",
"::",
"Property",
"::",
"TracksLiveness",
")",
";",
"MRI",
"=",
"&",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"ST",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"BBUtils",
"=",
"std",
"::",
"unique_ptr",
"<",
"ARMBasicBlockUtils",
">",
"(",
"new",
"ARMBasicBlockUtils",
"(",
"*",
"MF",
")",
")",
";",
"BBUtils",
"->",
"computeAllBlockSizes",
"(",
")",
";",
"BBUtils",
"->",
"adjustBBOffsetsAfter",
"(",
"&",
"MF",
"->",
"front",
"(",
")",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"ML",
":",
"*",
"MLI",
")",
"{",
"if",
"(",
"!",
"ML",
"->",
"getParentLoop",
"(",
")",
")",
"Changed",
"|=",
"ProcessLoop",
"(",
"ML",
")",
";",
"}",
"Changed",
"|=",
"RevertNonLoops",
"(",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"\"ARM Loops on \"",
"\" ------------- \\n\"",
"ARM",
"ARM",
"ARM"
] | ARMLowOverheadLoops10 | runOnMachineFunction | ARM | CPU | LLVM | 20,002 | 207 | 1 | [] |
[
"<s>",
"bool",
"CAHPFrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetRegisterInfo",
"*",
"RegInfo",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"RegInfo",
"->",
"needsStackRealignment",
"(",
"MF",
")",
"||",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
".",
"isFrameAddressTaken",
"(",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"CAHP",
"CAHP"
] | CAHPFrameLowering | hasFP | CAHP | CPU | LLVM | 20,003 | 72 | 1 | [] |
[
"<s>",
"static",
"bool",
"xscale_sched_adjust_cost",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"dep_type",
",",
"rtx_insn",
"*",
"dep",
",",
"int",
"*",
"cost",
")",
"{",
"if",
"(",
"dep_type",
"==",
"0",
"&&",
"recog_memoized",
"(",
"insn",
")",
">=",
"0",
"&&",
"recog_memoized",
"(",
"dep",
")",
">=",
"0",
")",
"{",
"int",
"shift_opnum",
"=",
"get_attr_shift",
"(",
"insn",
")",
";",
"enum",
"attr_type",
"attr_type",
"=",
"get_attr_type",
"(",
"dep",
")",
";",
"if",
"(",
"shift_opnum",
"!=",
"0",
"&&",
"(",
"attr_type",
"==",
"TYPE_ALU_SHIFT_IMM_LSL_1TO4",
"||",
"attr_type",
"==",
"TYPE_ALU_SHIFT_IMM_OTHER",
"||",
"attr_type",
"==",
"TYPE_ALUS_SHIFT_IMM",
"||",
"attr_type",
"==",
"TYPE_LOGIC_SHIFT_IMM",
"||",
"attr_type",
"==",
"TYPE_LOGICS_SHIFT_IMM",
"||",
"attr_type",
"==",
"TYPE_ALU_SHIFT_REG",
"||",
"attr_type",
"==",
"TYPE_ALUS_SHIFT_REG",
"||",
"attr_type",
"==",
"TYPE_LOGIC_SHIFT_REG",
"||",
"attr_type",
"==",
"TYPE_LOGICS_SHIFT_REG",
"||",
"attr_type",
"==",
"TYPE_MOV_SHIFT",
"||",
"attr_type",
"==",
"TYPE_MVN_SHIFT",
"||",
"attr_type",
"==",
"TYPE_MOV_SHIFT_REG",
"||",
"attr_type",
"==",
"TYPE_MVN_SHIFT_REG",
")",
")",
"{",
"rtx",
"shifted_operand",
";",
"int",
"opno",
";",
"extract_insn",
"(",
"insn",
")",
";",
"shifted_operand",
"=",
"recog_data",
".",
"operand",
"[",
"shift_opnum",
"]",
";",
"extract_insn",
"(",
"dep",
")",
";",
"preprocess_constraints",
"(",
"dep",
")",
";",
"for",
"(",
"opno",
"=",
"0",
";",
"opno",
"<",
"recog_data",
".",
"n_operands",
";",
"opno",
"++",
")",
"{",
"if",
"(",
"recog_data",
".",
"operand_type",
"[",
"opno",
"]",
"==",
"OP_IN",
")",
"continue",
";",
"if",
"(",
"reg_overlap_mentioned_p",
"(",
"recog_data",
".",
"operand",
"[",
"opno",
"]",
",",
"shifted_operand",
")",
")",
"{",
"*",
"cost",
"=",
"2",
";",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Adjust",
"cost",
"hook",
"for",
"XScale",
"."
] | [
"arm",
"0",
"0",
"0",
"0",
"0",
"2"
] | arm | xscale_sched_adjust_cost | arm | CPU | GCC | 20,004 | 209 | 1 | [] |
[
"<s>",
"bool",
"JVMPassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"(",
"void",
")",
"TargetPassConfig",
"::",
"addInstSelector",
"(",
")",
";",
"addPass",
"(",
"createJVMISelDag",
"(",
"getJVMTargetMachine",
"(",
")",
",",
"getOptLevel",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"JVM",
"JVM",
"JVM",
"JVM"
] | JVMTargetMachine | addInstSelector | JVM | Virtual ISA | LLVM | 20,005 | 34 | 1 | [] |
[
"<s>",
"AVR",
"::",
"Fixups",
"AVRMCExpr",
"::",
"getFixupKind",
"(",
")",
"const",
"{",
"AVR",
"::",
"Fixups",
"Kind",
"=",
"AVR",
"::",
"Fixups",
"::",
"LastTargetFixupKind",
";",
"switch",
"(",
"getKind",
"(",
")",
")",
"{",
"case",
"VK_AVR_LO8",
":",
"Kind",
"=",
"isNegated",
"(",
")",
"?",
"AVR",
"::",
"fixup_lo8_ldi_neg",
":",
"AVR",
"::",
"fixup_lo8_ldi",
";",
"break",
";",
"case",
"VK_AVR_HI8",
":",
"Kind",
"=",
"isNegated",
"(",
")",
"?",
"AVR",
"::",
"fixup_hi8_ldi_neg",
":",
"AVR",
"::",
"fixup_hi8_ldi",
";",
"break",
";",
"case",
"VK_AVR_HH8",
":",
"Kind",
"=",
"isNegated",
"(",
")",
"?",
"AVR",
"::",
"fixup_hh8_ldi_neg",
":",
"AVR",
"::",
"fixup_hh8_ldi",
";",
"break",
";",
"case",
"VK_AVR_HHI8",
":",
"Kind",
"=",
"isNegated",
"(",
")",
"?",
"AVR",
"::",
"fixup_ms8_ldi_neg",
":",
"AVR",
"::",
"fixup_ms8_ldi",
";",
"break",
";",
"case",
"VK_AVR_PM_LO8",
":",
"Kind",
"=",
"isNegated",
"(",
")",
"?",
"AVR",
"::",
"fixup_lo8_ldi_pm_neg",
":",
"AVR",
"::",
"fixup_lo8_ldi_pm",
";",
"break",
";",
"case",
"VK_AVR_PM_HI8",
":",
"Kind",
"=",
"isNegated",
"(",
")",
"?",
"AVR",
"::",
"fixup_hi8_ldi_pm_neg",
":",
"AVR",
"::",
"fixup_hi8_ldi_pm",
";",
"break",
";",
"case",
"VK_AVR_PM_HH8",
":",
"Kind",
"=",
"isNegated",
"(",
")",
"?",
"AVR",
"::",
"fixup_hh8_ldi_pm_neg",
":",
"AVR",
"::",
"fixup_hh8_ldi_pm",
";",
"break",
";",
"case",
"VK_AVR_GS",
":",
"Kind",
"=",
"AVR",
"::",
"fixup_16_pm",
";",
"break",
";",
"case",
"VK_AVR_LO8_GS",
":",
"Kind",
"=",
"AVR",
"::",
"fixup_lo8_ldi_gs",
";",
"break",
";",
"case",
"VK_AVR_HI8_GS",
":",
"Kind",
"=",
"AVR",
"::",
"fixup_hi8_ldi_gs",
";",
"break",
";",
"case",
"VK_AVR_None",
":",
"llvm_unreachable",
"(",
"\"Uninitialized expression\"",
")",
";",
"}",
"return",
"Kind",
";",
"}",
"</s>"
] | [
"getFixupKind",
"-",
"Get",
"the",
"fixup",
"kind",
"of",
"this",
"expression",
"."
] | [
"AVR",
"AVR::Fixups",
"AVR",
"AVR::Fixups",
"AVR::Fixups",
"AVR",
"AVR::fixup_lo8_ldi_neg",
"AVR::fixup_lo8_ldi",
"AVR",
"AVR::fixup_hi8_ldi_neg",
"AVR::fixup_hi8_ldi",
"AVR",
"AVR::fixup_hh8_ldi_neg",
"AVR::fixup_hh8_ldi",
"AVR",
"AVR::fixup_ms8_ldi_neg",
"AVR::fixup_ms8_ldi",
"AVR",
"AVR::fixup_lo8_ldi_pm_neg",
"AVR::fixup_lo8_ldi_pm",
"AVR",
"AVR::fixup_hi8_ldi_pm_neg",
"AVR::fixup_hi8_ldi_pm",
"AVR",
"AVR::fixup_hh8_ldi_pm_neg",
"AVR::fixup_hh8_ldi_pm",
"AVR",
"AVR::fixup_16_pm",
"AVR",
"AVR::fixup_lo8_ldi_gs",
"AVR",
"AVR::fixup_hi8_ldi_gs",
"AVR",
"\"Uninitialized expression\""
] | AVRMCExpr10 | getFixupKind | AVR | MPU | LLVM | 20,006 | 207 | 1 | [] |
[
"<s>",
"void",
"RV16KAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"if",
"(",
"emitPseudoExpansionLowering",
"(",
"*",
"OutStreamer",
",",
"MI",
")",
")",
"return",
";",
"MCInst",
"TmpInst",
";",
"LowerRV16KMachineInstrToMCInst",
"(",
"MI",
",",
"TmpInst",
",",
"*",
"this",
")",
";",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"TmpInst",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"RV16K",
"RV16K",
"RV16K"
] | RV16KAsmPrinter | EmitInstruction | RV16K | Virtual ISA | LLVM | 20,007 | 45 | 1 | [] |
[
"<s>",
"SDValue",
"PatmosTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"LowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"LowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SMUL_LOHI",
":",
"case",
"ISD",
"::",
"UMUL_LOHI",
":",
"return",
"LowerMUL_LOHI",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"unimplemented operation\"",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"Patmos",
"Patmos",
"ISD::LOAD",
"ISD::STORE",
"ISD::SMUL_LOHI",
"ISD::UMUL_LOHI",
"ISD::VASTART",
"ISD::FRAMEADDR",
"ISD::RETURNADDR",
"\"unimplemented operation\""
] | PatmosISelLowering | LowerOperation | Patmos | VLIW | LLVM | 20,008 | 115 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_cmp_autovec_modes",
"(",
"machine_mode",
"sve_m",
",",
"machine_mode",
"asimd_m",
")",
"{",
"bool",
"only_asimd_p",
"=",
"aarch64_autovec_preference",
"==",
"1",
";",
"bool",
"only_sve_p",
"=",
"aarch64_autovec_preference",
"==",
"2",
";",
"if",
"(",
"only_asimd_p",
")",
"return",
"false",
";",
"if",
"(",
"only_sve_p",
")",
"return",
"true",
";",
"bool",
"prefer_asimd",
"=",
"aarch64_autovec_preference",
"==",
"3",
";",
"bool",
"prefer_sve",
"=",
"aarch64_autovec_preference",
"==",
"4",
";",
"aarch64_sve_vector_bits_enum",
"tune_width",
"=",
"aarch64_tune_params",
".",
"sve_width",
";",
"poly_int64",
"nunits_sve",
"=",
"GET_MODE_NUNITS",
"(",
"sve_m",
")",
";",
"poly_int64",
"nunits_asimd",
"=",
"GET_MODE_NUNITS",
"(",
"asimd_m",
")",
";",
"if",
"(",
"tune_width",
"==",
"SVE_SCALABLE",
"&&",
"!",
"prefer_asimd",
"&&",
"!",
"prefer_sve",
")",
"return",
"maybe_gt",
"(",
"nunits_sve",
",",
"nunits_asimd",
")",
";",
"HOST_WIDE_INT",
"est_sve",
"=",
"estimated_poly_value",
"(",
"nunits_sve",
")",
";",
"HOST_WIDE_INT",
"est_asimd",
"=",
"estimated_poly_value",
"(",
"nunits_asimd",
")",
";",
"if",
"(",
"prefer_sve",
")",
"return",
"est_sve",
">=",
"est_asimd",
";",
"if",
"(",
"prefer_asimd",
")",
"return",
"est_sve",
">",
"est_asimd",
";",
"return",
"est_sve",
">",
"est_asimd",
";",
"}",
"</s>"
] | [
"Compare",
"an",
"SVE",
"mode",
"SVE_M",
"and",
"an",
"Advanced",
"SIMD",
"mode",
"ASIMD_M",
"and",
"return",
"whether",
"the",
"SVE",
"mode",
"should",
"be",
"preferred",
"over",
"the",
"Advanced",
"SIMD",
"one",
"in",
"aarch64_autovectorize_vector_modes",
"."
] | [
"aarch64",
"1",
"2",
"3",
"4"
] | aarch641 | aarch64_cmp_autovec_modes | aarch64 | CPU | GCC | 20,009 | 136 | 1 | [] |
[
"<s>",
"void",
"RISCVFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"RISCV",
"RISCV"
] | RISCVFrameLowering24 | emitEpilogue | RISCV | CPU | LLVM | 20,010 | 16 | 1 | [] |
[
"<s>",
"void",
"addExpr",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"MCExpr",
"*",
"Expr",
")",
"const",
"{",
"if",
"(",
"!",
"Expr",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"0",
")",
")",
";",
"else",
"if",
"(",
"auto",
"*",
"CE",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"Expr",
")",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"CE",
"->",
"getValue",
"(",
")",
")",
")",
";",
"else",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createExpr",
"(",
"Expr",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"new",
"MCExpr",
"operand",
"."
] | [
"M88k",
"0"
] | M88kAsmParser | addExpr | M88k | MPU | LLVM | 20,011 | 76 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_darwin64_record_arg_recurse",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"const_tree",
"type",
",",
"HOST_WIDE_INT",
"startbitpos",
",",
"rtx",
"rvec",
"[",
"]",
",",
"int",
"*",
"k",
")",
"{",
"tree",
"f",
";",
"for",
"(",
"f",
"=",
"TYPE_FIELDS",
"(",
"type",
")",
";",
"f",
";",
"f",
"=",
"DECL_CHAIN",
"(",
"f",
")",
")",
"if",
"(",
"TREE_CODE",
"(",
"f",
")",
"==",
"FIELD_DECL",
")",
"{",
"HOST_WIDE_INT",
"bitpos",
"=",
"startbitpos",
";",
"tree",
"ftype",
"=",
"TREE_TYPE",
"(",
"f",
")",
";",
"machine_mode",
"mode",
";",
"if",
"(",
"ftype",
"==",
"error_mark_node",
")",
"continue",
";",
"mode",
"=",
"TYPE_MODE",
"(",
"ftype",
")",
";",
"if",
"(",
"DECL_SIZE",
"(",
"f",
")",
"!=",
"0",
"&&",
"tree_fits_uhwi_p",
"(",
"bit_position",
"(",
"f",
")",
")",
")",
"bitpos",
"+=",
"int_bit_position",
"(",
"f",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"ftype",
")",
"==",
"RECORD_TYPE",
")",
"rs6000_darwin64_record_arg_recurse",
"(",
"cum",
",",
"ftype",
",",
"bitpos",
",",
"rvec",
",",
"k",
")",
";",
"else",
"if",
"(",
"cum",
"->",
"named",
"&&",
"USE_FP_FOR_ARG_P",
"(",
"cum",
",",
"mode",
")",
")",
"{",
"unsigned",
"n_fpreg",
"=",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"+",
"7",
")",
">>",
"3",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"SCmode",
":",
"mode",
"=",
"SFmode",
";",
"break",
";",
"case",
"DCmode",
":",
"mode",
"=",
"DFmode",
";",
"break",
";",
"case",
"TCmode",
":",
"mode",
"=",
"TFmode",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"rs6000_darwin64_record_arg_flush",
"(",
"cum",
",",
"bitpos",
",",
"rvec",
",",
"k",
")",
";",
"if",
"(",
"cum",
"->",
"fregno",
"+",
"n_fpreg",
">",
"FP_ARG_MAX_REG",
"+",
"1",
")",
"{",
"gcc_assert",
"(",
"cum",
"->",
"fregno",
"==",
"FP_ARG_MAX_REG",
"&&",
"(",
"mode",
"==",
"TFmode",
"||",
"mode",
"==",
"TDmode",
")",
")",
";",
"mode",
"=",
"DECIMAL_FLOAT_MODE_P",
"(",
"mode",
")",
"?",
"DDmode",
":",
"DFmode",
";",
"cum",
"->",
"use_stack",
"=",
"1",
";",
"}",
"rvec",
"[",
"(",
"*",
"k",
")",
"++",
"]",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"mode",
",",
"cum",
"->",
"fregno",
"++",
")",
",",
"GEN_INT",
"(",
"bitpos",
"/",
"BITS_PER_UNIT",
")",
")",
";",
"if",
"(",
"FLOAT128_2REG_P",
"(",
"mode",
")",
")",
"cum",
"->",
"fregno",
"++",
";",
"}",
"else",
"if",
"(",
"cum",
"->",
"named",
"&&",
"USE_ALTIVEC_FOR_ARG_P",
"(",
"cum",
",",
"mode",
",",
"1",
")",
")",
"{",
"rs6000_darwin64_record_arg_flush",
"(",
"cum",
",",
"bitpos",
",",
"rvec",
",",
"k",
")",
";",
"rvec",
"[",
"(",
"*",
"k",
")",
"++",
"]",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"mode",
",",
"cum",
"->",
"vregno",
"++",
")",
",",
"GEN_INT",
"(",
"bitpos",
"/",
"BITS_PER_UNIT",
")",
")",
";",
"}",
"else",
"if",
"(",
"cum",
"->",
"intoffset",
"==",
"-",
"1",
")",
"cum",
"->",
"intoffset",
"=",
"bitpos",
";",
"}",
"}",
"</s>"
] | [
"Recursive",
"workhorse",
"for",
"the",
"following",
"."
] | [
"rs6000",
"0",
"7",
"3",
"1",
"1",
"1",
"1"
] | rs60005 | rs6000_darwin64_record_arg_recurse | rs6000 | CPU | GCC | 20,012 | 381 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"areMemAccessesTriviallyDisjoint",
"(",
"const",
"MachineInstr",
"&",
"MIa",
",",
"const",
"MachineInstr",
"&",
"MIb",
")",
"const",
"{",
"assert",
"(",
"MIa",
".",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIa must load from or modify a memory location\"",
")",
";",
"assert",
"(",
"MIb",
".",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIb must load from or modify a memory location\"",
")",
";",
"if",
"(",
"MIa",
".",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIb",
".",
"hasUnmodeledSideEffects",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MIa",
".",
"hasOrderedMemoryRef",
"(",
")",
"||",
"MIb",
".",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"isDS",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isDS",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"||",
"isSegmentSpecificFLAT",
"(",
"MIb",
")",
";",
"}",
"if",
"(",
"isMUBUF",
"(",
"MIa",
")",
"||",
"isMTBUF",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isMUBUF",
"(",
"MIb",
")",
"||",
"isMTBUF",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"&&",
"!",
"isSMRD",
"(",
"MIb",
")",
";",
"}",
"if",
"(",
"isSMRD",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isSMRD",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"&&",
"!",
"isMUBUF",
"(",
"MIa",
")",
"&&",
"!",
"isMTBUF",
"(",
"MIa",
")",
";",
"}",
"if",
"(",
"isFLAT",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isFLAT",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Sometimes",
",",
"it",
"is",
"possible",
"for",
"the",
"target",
"to",
"tell",
",",
"even",
"without",
"aliasing",
"information",
",",
"that",
"two",
"MIs",
"access",
"different",
"memory",
"addresses",
"."
] | [
"AMDGPU",
"SI",
"\"MIa must load from or modify a memory location\"",
"\"MIb must load from or modify a memory location\""
] | SIInstrInfo140 | areMemAccessesTriviallyDisjoint | AMDGPU | GPU | LLVM | 20,013 | 230 | 1 | [] |
[
"<s>",
"bool",
"rs6000_linux_float_exceptions_rounding_supported_p",
"(",
"void",
")",
"{",
"if",
"(",
"OPTION_GLIBC",
")",
"return",
"true",
";",
"else",
"return",
"TARGET_HARD_FLOAT",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P",
"."
] | [
"rs6000"
] | rs6000-linux | rs6000_linux_float_exceptions_rounding_supported_p | rs6000 | CPU | GCC | 20,014 | 18 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonTTIImpl",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"TTI",
"::",
"OperandValueKind",
"Opd1Info",
",",
"TTI",
"::",
"OperandValueKind",
"Opd2Info",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd1PropInfo",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd2PropInfo",
",",
"ArrayRef",
"<",
"const",
"Value",
"*",
">",
"Args",
")",
"{",
"if",
"(",
"Ty",
"->",
"isVectorTy",
"(",
")",
")",
"{",
"std",
"::",
"pair",
"<",
"int",
",",
"MVT",
">",
"LT",
"=",
"TLI",
".",
"getTypeLegalizationCost",
"(",
"DL",
",",
"Ty",
")",
";",
"if",
"(",
"LT",
".",
"second",
".",
"isFloatingPoint",
"(",
")",
")",
"return",
"LT",
".",
"first",
"+",
"FloatFactor",
"*",
"getTypeNumElements",
"(",
"Ty",
")",
";",
"}",
"return",
"BaseT",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
",",
"Args",
")",
";",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo11 | getArithmeticInstrCost | Hexagon | DSP | LLVM | 20,015 | 113 | 1 | [] |
[
"<s>",
"unsigned",
"PatmosMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"unsigned",
"RegNo",
"=",
"getPatmosRegisterNumbering",
"(",
"Reg",
")",
";",
"return",
"RegNo",
";",
"}",
"else",
"{",
"return",
"getImmediateEncoding",
"(",
"MI",
",",
"MO",
",",
"Fixups",
")",
";",
"}",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"Patmos",
"Patmos",
"Patmos"
] | PatmosMCCodeEmitter | getMachineOpValue | Patmos | VLIW | LLVM | 20,016 | 68 | 1 | [] |
[
"<s>",
"bool",
"MSP430AsmPrinter",
"::",
"doFinalization",
"(",
"Module",
"&",
"M",
")",
"{",
"return",
"AsmPrinter",
"::",
"doFinalization",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"doFinalization",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"any",
"necessary",
"clean",
"up",
"after",
"all",
"passes",
"have",
"run",
"."
] | [
"MSP430",
"MSP430"
] | MSP430AsmPrinter8 | doFinalization | MSP430 | MPU | LLVM | 20,017 | 19 | 1 | [] |
[
"<s>",
"bool",
"LinuxAsmPrinter",
"::",
"doInitialization",
"(",
"Module",
"&",
"M",
")",
"{",
"bool",
"Result",
"=",
"AsmPrinter",
"::",
"doInitialization",
"(",
"M",
")",
";",
"DW",
"=",
"getAnalysisIfAvailable",
"<",
"DwarfWriter",
">",
"(",
")",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"CellSPU"
] | SPUAsmPrinter1 | doInitialization | CellSPU | MPU | LLVM | 20,018 | 33 | 1 | [] |
[
"<s>",
"void",
"M68kPassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"addPass",
"(",
"createM68kCollapseMOVEMPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"M68k",
"M68k",
"M68k"
] | M68kTargetMachine | addPreEmitPass | M68k | MPU | LLVM | 20,019 | 15 | 1 | [] |
[
"<s>",
"SDValue",
"X86TargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"bool",
"Is64Bit",
"=",
"Subtarget",
"->",
"is64Bit",
"(",
")",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_X86",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RVLocs",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"EVT",
"CopyVT",
"=",
"VA",
".",
"getValVT",
"(",
")",
";",
"if",
"(",
"(",
"CopyVT",
"==",
"MVT",
"::",
"f32",
"||",
"CopyVT",
"==",
"MVT",
"::",
"f64",
")",
"&&",
"(",
"(",
"Is64Bit",
"||",
"Ins",
"[",
"i",
"]",
".",
"Flags",
".",
"isInReg",
"(",
")",
")",
"&&",
"!",
"Subtarget",
"->",
"hasSSE1",
"(",
")",
")",
")",
"{",
"report_fatal_error",
"(",
"\"SSE register return with SSE disabled\"",
")",
";",
"}",
"SDValue",
"Val",
";",
"if",
"(",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"ST0",
"||",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"ST1",
")",
"{",
"if",
"(",
"isScalarFPTypeInSSEReg",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
"CopyVT",
"=",
"MVT",
"::",
"f80",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"Chain",
",",
"InFlag",
"}",
";",
"Chain",
"=",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"X86",
"::",
"FpPOP_RETVAL",
",",
"dl",
",",
"CopyVT",
",",
"MVT",
"::",
"Other",
",",
"MVT",
"::",
"Glue",
",",
"Ops",
",",
"2",
")",
",",
"1",
")",
";",
"Val",
"=",
"Chain",
".",
"getValue",
"(",
"0",
")",
";",
"if",
"(",
"CopyVT",
"!=",
"VA",
".",
"getValVT",
"(",
")",
")",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FP_ROUND",
",",
"dl",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"Val",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"1",
")",
")",
";",
"}",
"else",
"{",
"Chain",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"CopyVT",
",",
"InFlag",
")",
".",
"getValue",
"(",
"1",
")",
";",
"Val",
"=",
"Chain",
".",
"getValue",
"(",
"0",
")",
";",
"}",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"2",
")",
";",
"InVals",
".",
"push_back",
"(",
"Val",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"X86",
"X86",
"ISD::InputArg",
"16",
"X86",
"0",
"MVT::f32",
"MVT::f64",
"\"SSE register return with SSE disabled\"",
"X86::ST0",
"X86::ST1",
"MVT::f80",
"X86::FpPOP_RETVAL",
"MVT::Other",
"MVT::Glue",
"2",
"1",
"0",
"ISD::FP_ROUND",
"1",
"1",
"0",
"2"
] | X86ISelLowering121 | LowerCallResult | X86 | CPU | LLVM | 20,020 | 379 | 1 | [] |
[
"<s>",
"static",
"char",
"*",
"rs6000_offload_options",
"(",
"void",
")",
"{",
"if",
"(",
"TARGET_64BIT",
")",
"return",
"xstrdup",
"(",
"\"-foffload-abi=lp64\"",
")",
";",
"else",
"return",
"xstrdup",
"(",
"\"-foffload-abi=ilp32\"",
")",
";",
"}",
"</s>"
] | [
"Implement",
"the",
"TARGET_OFFLOAD_OPTIONS",
"hook",
"."
] | [
"powerpcspe",
"\"-foffload-abi=lp64\"",
"\"-foffload-abi=ilp32\""
] | powerpcspe | rs6000_offload_options | powerpcspe | CPU | GCC | 20,021 | 26 | 1 | [] |
[
"<s>",
"bool",
"s390_vectorize_vec_perm_const",
"(",
"machine_mode",
"vmode",
",",
"machine_mode",
"op_mode",
",",
"rtx",
"target",
",",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"const",
"vec_perm_indices",
"&",
"sel",
")",
"{",
"if",
"(",
"vmode",
"!=",
"op_mode",
")",
"return",
"false",
";",
"struct",
"expand_vec_perm_d",
"d",
";",
"unsigned",
"int",
"i",
",",
"nelt",
";",
"if",
"(",
"!",
"s390_vector_mode_supported_p",
"(",
"vmode",
")",
"||",
"GET_MODE_SIZE",
"(",
"vmode",
")",
"!=",
"16",
")",
"return",
"false",
";",
"d",
".",
"target",
"=",
"target",
";",
"d",
".",
"op0",
"=",
"op0",
";",
"d",
".",
"op1",
"=",
"op1",
";",
"d",
".",
"vmode",
"=",
"vmode",
";",
"gcc_assert",
"(",
"VECTOR_MODE_P",
"(",
"d",
".",
"vmode",
")",
")",
";",
"d",
".",
"nelt",
"=",
"nelt",
"=",
"GET_MODE_NUNITS",
"(",
"d",
".",
"vmode",
")",
";",
"d",
".",
"testing_p",
"=",
"target",
"==",
"NULL_RTX",
";",
"d",
".",
"only_op0",
"=",
"false",
";",
"d",
".",
"only_op1",
"=",
"false",
";",
"gcc_assert",
"(",
"target",
"==",
"NULL_RTX",
"||",
"REG_P",
"(",
"target",
")",
")",
";",
"gcc_assert",
"(",
"sel",
".",
"length",
"(",
")",
"==",
"nelt",
")",
";",
"unsigned",
"int",
"highest",
"=",
"0",
",",
"lowest",
"=",
"2",
"*",
"nelt",
"-",
"1",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nelt",
";",
"i",
"++",
")",
"{",
"unsigned",
"char",
"e",
"=",
"sel",
"[",
"i",
"]",
";",
"lowest",
"=",
"MIN",
"(",
"lowest",
",",
"e",
")",
";",
"highest",
"=",
"MAX",
"(",
"highest",
",",
"e",
")",
";",
"gcc_assert",
"(",
"e",
"<",
"2",
"*",
"nelt",
")",
";",
"d",
".",
"perm",
"[",
"i",
"]",
"=",
"e",
";",
"}",
"if",
"(",
"lowest",
"<",
"nelt",
"&&",
"highest",
"<",
"nelt",
")",
"d",
".",
"only_op0",
"=",
"true",
";",
"else",
"if",
"(",
"lowest",
">=",
"nelt",
"&&",
"highest",
">=",
"nelt",
")",
"d",
".",
"only_op1",
"=",
"true",
";",
"return",
"vectorize_vec_perm_const_1",
"(",
"d",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"can",
"emit",
"instructions",
"for",
"the",
"constant",
"permutation",
"vector",
"in",
"SEL",
".",
"If",
"OUTPUT",
",",
"IN0",
",",
"IN1",
"are",
"non-null",
"the",
"hook",
"is",
"supposed",
"to",
"emit",
"the",
"required",
"INSNs",
"."
] | [
"s390",
"16",
"0",
"2",
"1",
"0",
"2"
] | s3901 | s390_vectorize_vec_perm_const | s390 | MPU | GCC | 20,022 | 265 | 1 | [] |
[
"<s>",
"static",
"std",
"::",
"unique_ptr",
"<",
"MipsOperand",
">",
"CreateMem",
"(",
"std",
"::",
"unique_ptr",
"<",
"MipsOperand",
">",
"Base",
",",
"const",
"MCExpr",
"*",
"Off",
",",
"SMLoc",
"S",
",",
"SMLoc",
"E",
",",
"MipsAsmParser",
"&",
"Parser",
")",
"{",
"auto",
"Op",
"=",
"std",
"::",
"make_unique",
"<",
"MipsOperand",
">",
"(",
"k_Memory",
",",
"Parser",
")",
";",
"Op",
"->",
"Mem",
".",
"Base",
"=",
"Base",
".",
"release",
"(",
")",
";",
"Op",
"->",
"Mem",
".",
"Off",
"=",
"Off",
";",
"Op",
"->",
"StartLoc",
"=",
"S",
";",
"Op",
"->",
"EndLoc",
"=",
"E",
";",
"return",
"Op",
";",
"}",
"</s>"
] | [
"Create",
"a",
"generalized",
"memory",
"operand",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips"
] | MipsAsmParser (2)4 | CreateMem | Mips | CPU | LLVM | 20,023 | 84 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"isCopyInstr",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineOperand",
"*",
"&",
"Src",
",",
"const",
"MachineOperand",
"*",
"&",
"Dest",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isMoveReg",
"(",
")",
")",
"{",
"Dest",
"=",
"&",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"Src",
"=",
"&",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"If",
"the",
"specific",
"machine",
"instruction",
"is",
"a",
"instruction",
"that",
"moves/copies",
"value",
"from",
"one",
"register",
"to",
"another",
"register",
"return",
"destination",
"and",
"source",
"registers",
"as",
"machine",
"operands",
"."
] | [
"X86",
"X86",
"0",
"1"
] | X86InstrInfo | isCopyInstr | X86 | CPU | LLVM | 20,024 | 61 | 1 | [] |
[
"<s>",
"Nios2Subtarget",
"&",
"Nios2Subtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"if",
"(",
"TargetTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"nios2",
")",
"{",
"if",
"(",
"CPU",
"!=",
"\"nios2r2\"",
")",
"{",
"CPU",
"=",
"\"nios2r1\"",
";",
"Nios2ArchVersion",
"=",
"Nios2r1",
";",
"}",
"else",
"{",
"Nios2ArchVersion",
"=",
"Nios2r2",
";",
"}",
"}",
"else",
"{",
"errs",
"(",
")",
"<<",
"\"!!!Error, TargetTriple.getArch() = \"",
"<<",
"TargetTriple",
".",
"getArch",
"(",
")",
"<<",
"\"CPU = \"",
"<<",
"CPU",
"<<",
"\"\\n\"",
";",
"exit",
"(",
"0",
")",
";",
"}",
"ParseSubtargetFeatures",
"(",
"CPU",
",",
"FS",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"Nios2",
"Nios2",
"Nios2",
"\"nios2r2\"",
"\"nios2r1\"",
"Nios2",
"Nios2",
"Nios2",
"Nios2",
"\"!!!Error, TargetTriple.getArch() = \"",
"\"CPU = \"",
"\"\\n\"",
"0"
] | Nios2Subtarget | initializeSubtargetDependencies | Nios2 | MPU | LLVM | 20,025 | 88 | 1 | [] |
[
"<s>",
"bool",
"ARMLoadStoreOpt",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"Fn",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"MF",
"=",
"&",
"Fn",
";",
"STI",
"=",
"&",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"Fn",
".",
"getSubtarget",
"(",
")",
")",
";",
"TL",
"=",
"STI",
"->",
"getTargetLowering",
"(",
")",
";",
"AFI",
"=",
"Fn",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"STI",
"->",
"getRegisterInfo",
"(",
")",
";",
"RegClassInfoValid",
"=",
"false",
";",
"isThumb2",
"=",
"AFI",
"->",
"isThumb2Function",
"(",
")",
";",
"isThumb1",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
"&&",
"!",
"isThumb2",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"Fn",
")",
"{",
"Modified",
"|=",
"LoadStoreMultipleOpti",
"(",
"MBB",
")",
";",
"if",
"(",
"STI",
"->",
"hasV5TOps",
"(",
")",
"&&",
"!",
"AFI",
"->",
"shouldSignReturnAddress",
"(",
")",
")",
"Modified",
"|=",
"MergeReturnIntoLDM",
"(",
"MBB",
")",
";",
"if",
"(",
"isThumb1",
")",
"Modified",
"|=",
"CombineMovBx",
"(",
"MBB",
")",
";",
"}",
"Allocator",
".",
"DestroyAll",
"(",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMLoadStoreOptimizer38 | runOnMachineFunction | ARM | CPU | LLVM | 20,026 | 169 | 1 | [] |
[
"<s>",
"static",
"int",
"csky_sched_issue_rate",
"(",
"void",
")",
"{",
"if",
"(",
"CSKY_TARGET_ARCH",
"(",
"CK810",
")",
")",
"return",
"2",
";",
"else",
"return",
"1",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_SCHED_ISSUE_RATE",
".",
"Lookup",
"the",
"issue",
"rate",
"in",
"the",
"per-core",
"tuning",
"structs",
"."
] | [
"csky",
"2",
"1"
] | csky | csky_sched_issue_rate | csky | CPU | GCC | 20,027 | 22 | 1 | [] |
[
"<s>",
"static",
"bool",
"frv_registers_conflict_p_1",
"(",
"rtx",
"pat",
",",
"regstate_t",
"cond",
")",
"{",
"subrtx_var_iterator",
"::",
"array_type",
"array",
";",
"FOR_EACH_SUBRTX_VAR",
"(",
"iter",
",",
"array",
",",
"pat",
",",
"NONCONST",
")",
"{",
"rtx",
"x",
"=",
"*",
"iter",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"REG",
")",
"{",
"unsigned",
"int",
"regno",
";",
"FOR_EACH_REGNO",
"(",
"regno",
",",
"x",
")",
"if",
"(",
"(",
"frv_packet",
".",
"regstate",
"[",
"regno",
"]",
"&",
"REGSTATE_MODIFIED",
")",
"!=",
"0",
")",
"if",
"(",
"frv_regstate_conflict_p",
"(",
"frv_packet",
".",
"regstate",
"[",
"regno",
"]",
",",
"cond",
")",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"MEM",
")",
"{",
"if",
"(",
"frv_packet",
".",
"num_mems",
">",
"ARRAY_SIZE",
"(",
"frv_packet",
".",
"mems",
")",
")",
"return",
"1",
";",
"for",
"(",
"unsigned",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"frv_packet",
".",
"num_mems",
";",
"i",
"++",
")",
"if",
"(",
"frv_regstate_conflict_p",
"(",
"frv_packet",
".",
"mems",
"[",
"i",
"]",
".",
"cond",
",",
"cond",
")",
")",
"{",
"if",
"(",
"true_dependence",
"(",
"frv_packet",
".",
"mems",
"[",
"i",
"]",
".",
"mem",
",",
"VOIDmode",
",",
"x",
")",
")",
"return",
"true",
";",
"if",
"(",
"output_dependence",
"(",
"frv_packet",
".",
"mems",
"[",
"i",
"]",
".",
"mem",
",",
"x",
")",
")",
"return",
"true",
";",
"}",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SET",
"&&",
"GET_CODE",
"(",
"SET_SRC",
"(",
"x",
")",
")",
"==",
"CALL",
")",
"iter",
".",
"substitute",
"(",
"SET_SRC",
"(",
"x",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"A",
"for_each_rtx",
"callback",
".",
"Return",
"1",
"if",
"*",
"X",
"depends",
"on",
"an",
"instruction",
"in",
"the",
"current",
"packet",
".",
"DATA",
"points",
"to",
"a",
"regstate_t",
"that",
"describes",
"the",
"condition",
"under",
"which",
"*",
"X",
"might",
"be",
"set",
"or",
"used",
"."
] | [
"frv",
"0",
"1",
"0"
] | frv | frv_registers_conflict_p_1 | frv | VLIW | GCC | 20,028 | 224 | 1 | [] |
[
"<s>",
"Optional",
"<",
"DestSourcePair",
">",
"M88kInstrInfo",
"::",
"isCopyInstrImpl",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isMoveReg",
"(",
")",
"||",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"M88k",
"::",
"ORri",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
")",
"return",
"DestSourcePair",
"{",
"MI",
".",
"getOperand",
"(",
"0",
")",
",",
"MI",
".",
"getOperand",
"(",
"1",
")",
"}",
";",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"M88k",
"::",
"ORrr",
")",
"{",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
"==",
"M88k",
"::",
"R0",
")",
"return",
"DestSourcePair",
"{",
"MI",
".",
"getOperand",
"(",
"0",
")",
",",
"MI",
".",
"getOperand",
"(",
"1",
")",
"}",
";",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"M88k",
"::",
"R0",
")",
"return",
"DestSourcePair",
"{",
"MI",
".",
"getOperand",
"(",
"0",
")",
",",
"MI",
".",
"getOperand",
"(",
"2",
")",
"}",
";",
"}",
"return",
"None",
";",
"}",
"</s>"
] | [
"If",
"the",
"specific",
"machine",
"instruction",
"is",
"a",
"instruction",
"that",
"moves/copies",
"value",
"from",
"one",
"register",
"to",
"another",
"register",
"return",
"destination",
"and",
"source",
"registers",
"as",
"machine",
"operands",
"."
] | [
"M88k",
"M88k",
"M88k::ORri",
"2",
"0",
"0",
"1",
"M88k::ORrr",
"2",
"M88k::R0",
"0",
"1",
"1",
"M88k::R0",
"0",
"2"
] | M88kInstrInfo | isCopyInstrImpl | M88k | MPU | LLVM | 20,029 | 154 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAlwaysInline",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"std",
"::",
"vector",
"<",
"GlobalAlias",
"*",
">",
"AliasesToRemove",
";",
"std",
"::",
"vector",
"<",
"Function",
"*",
">",
"FuncsToClone",
";",
"for",
"(",
"GlobalAlias",
"&",
"A",
":",
"M",
".",
"aliases",
"(",
")",
")",
"{",
"if",
"(",
"Function",
"*",
"F",
"=",
"dyn_cast",
"<",
"Function",
">",
"(",
"A",
".",
"getAliasee",
"(",
")",
")",
")",
"{",
"A",
".",
"replaceAllUsesWith",
"(",
"F",
")",
";",
"AliasesToRemove",
".",
"push_back",
"(",
"&",
"A",
")",
";",
"}",
"}",
"if",
"(",
"GlobalOpt",
")",
"{",
"for",
"(",
"GlobalAlias",
"*",
"A",
":",
"AliasesToRemove",
")",
"{",
"A",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"}",
"auto",
"NewAttr",
"=",
"StressCalls",
"?",
"Attribute",
"::",
"NoInline",
":",
"Attribute",
"::",
"AlwaysInline",
";",
"auto",
"IncompatAttr",
"=",
"StressCalls",
"?",
"Attribute",
"::",
"AlwaysInline",
":",
"Attribute",
"::",
"NoInline",
";",
"for",
"(",
"Function",
"&",
"F",
":",
"M",
")",
"{",
"if",
"(",
"!",
"F",
".",
"hasLocalLinkage",
"(",
")",
"&&",
"!",
"F",
".",
"isDeclaration",
"(",
")",
"&&",
"!",
"F",
".",
"use_empty",
"(",
")",
"&&",
"!",
"F",
".",
"hasFnAttribute",
"(",
"IncompatAttr",
")",
")",
"FuncsToClone",
".",
"push_back",
"(",
"&",
"F",
")",
";",
"}",
"for",
"(",
"Function",
"*",
"F",
":",
"FuncsToClone",
")",
"{",
"ValueToValueMapTy",
"VMap",
";",
"Function",
"*",
"NewFunc",
"=",
"CloneFunction",
"(",
"F",
",",
"VMap",
")",
";",
"NewFunc",
"->",
"setLinkage",
"(",
"GlobalValue",
"::",
"InternalLinkage",
")",
";",
"F",
"->",
"replaceAllUsesWith",
"(",
"NewFunc",
")",
";",
"}",
"for",
"(",
"Function",
"&",
"F",
":",
"M",
")",
"{",
"if",
"(",
"F",
".",
"hasLocalLinkage",
"(",
")",
"&&",
"!",
"F",
".",
"hasFnAttribute",
"(",
"IncompatAttr",
")",
")",
"{",
"F",
".",
"addFnAttr",
"(",
"NewAttr",
")",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUAlwaysInlinePass9 | runOnModule | AMDGPU | GPU | LLVM | 20,030 | 253 | 1 | [] |
[
"<s>",
"static",
"SDValue",
"matchBinOpReduction",
"(",
"SDNode",
"*",
"Extract",
",",
"ISD",
"::",
"NodeType",
"BinOp",
")",
"{",
"if",
"(",
"(",
"Extract",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
")",
"||",
"!",
"isNullConstant",
"(",
"Extract",
"->",
"getOperand",
"(",
"1",
")",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"unsigned",
"Stages",
"=",
"Log2_32",
"(",
"Extract",
"->",
"getOperand",
"(",
"0",
")",
".",
"getValueType",
"(",
")",
".",
"getVectorNumElements",
"(",
")",
")",
";",
"SDValue",
"Op",
"=",
"Extract",
"->",
"getOperand",
"(",
"0",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Stages",
";",
"++",
"i",
")",
"{",
"if",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"!=",
"BinOp",
")",
"return",
"SDValue",
"(",
")",
";",
"ShuffleVectorSDNode",
"*",
"Shuffle",
"=",
"dyn_cast",
"<",
"ShuffleVectorSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
".",
"getNode",
"(",
")",
")",
";",
"if",
"(",
"Shuffle",
")",
"{",
"Op",
"=",
"Op",
".",
"getOperand",
"(",
"1",
")",
";",
"}",
"else",
"{",
"Shuffle",
"=",
"dyn_cast",
"<",
"ShuffleVectorSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"1",
")",
".",
"getNode",
"(",
")",
")",
";",
"Op",
"=",
"Op",
".",
"getOperand",
"(",
"0",
")",
";",
"}",
"if",
"(",
"!",
"Shuffle",
"||",
"(",
"Shuffle",
"->",
"getOperand",
"(",
"0",
")",
"!=",
"Op",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"for",
"(",
"int",
"Index",
"=",
"0",
",",
"MaskEnd",
"=",
"1",
"<<",
"i",
";",
"Index",
"<",
"MaskEnd",
";",
"++",
"Index",
")",
"if",
"(",
"Shuffle",
"->",
"getMaskElt",
"(",
"Index",
")",
"!=",
"MaskEnd",
"+",
"Index",
")",
"return",
"SDValue",
"(",
")",
";",
"}",
"return",
"Op",
";",
"}",
"</s>"
] | [
"Match",
"a",
"binop",
"+",
"shuffle",
"pyramid",
"that",
"represents",
"a",
"horizontal",
"reduction",
"over",
"the",
"elements",
"of",
"a",
"vector",
"starting",
"from",
"the",
"EXTRACT_VECTOR_ELT",
"node",
"/p",
"Extract",
"."
] | [
"X86",
"ISD::NodeType",
"ISD::EXTRACT_VECTOR_ELT",
"1",
"0",
"0",
"0",
"0",
"1",
"1",
"0",
"0",
"0",
"1"
] | X86ISelLowering10 | matchBinOpReduction | X86 | CPU | LLVM | 20,031 | 236 | 1 | [] |
[
"<s>",
"static",
"MBlazeOperand",
"*",
"CreateMem",
"(",
"unsigned",
"Base",
",",
"unsigned",
"Off",
",",
"SMLoc",
"S",
",",
"SMLoc",
"E",
")",
"{",
"MBlazeOperand",
"*",
"Op",
"=",
"new",
"MBlazeOperand",
"(",
"Memory",
")",
";",
"Op",
"->",
"Mem",
".",
"Base",
"=",
"Base",
";",
"Op",
"->",
"Mem",
".",
"OffReg",
"=",
"Off",
";",
"Op",
"->",
"Mem",
".",
"Off",
"=",
"0",
";",
"Op",
"->",
"StartLoc",
"=",
"S",
";",
"Op",
"->",
"EndLoc",
"=",
"E",
";",
"return",
"Op",
";",
"}",
"</s>"
] | [
"Create",
"a",
"generalized",
"memory",
"operand",
"."
] | [
"MBlaze",
"MBlaze",
"MBlaze",
"MBlaze",
"0"
] | MBlazeAsmParser1 | CreateMem | MBlaze | MPU | LLVM | 20,032 | 68 | 1 | [] |
[
"<s>",
"tree",
"function_resolver",
"::",
"report_no_such_form",
"(",
"type_suffix_index",
"type",
")",
"{",
"error_at",
"(",
"location",
",",
"\"%qE has no form that takes %qT arguments\"",
",",
"fndecl",
",",
"get_vector_type",
"(",
"type",
")",
")",
";",
"return",
"error_mark_node",
";",
"}",
"</s>"
] | [
"Report",
"that",
"the",
"function",
"has",
"no",
"form",
"that",
"takes",
"type",
"suffix",
"TYPE",
".",
"Return",
"error_mark_node",
"."
] | [
"aarch64",
"\"%qE has no form that takes %qT arguments\""
] | aarch64-sve-builtins | report_no_such_form | aarch64 | CPU | GCC | 20,033 | 27 | 1 | [] |
[
"<s>",
"void",
"XCoreAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"SmallString",
"<",
"128",
">",
"Str",
";",
"raw_svector_ostream",
"O",
"(",
"Str",
")",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"XCore",
"::",
"DBG_VALUE",
":",
"{",
"if",
"(",
"isVerbose",
"(",
")",
"&&",
"OutStreamer",
".",
"hasRawTextSupport",
"(",
")",
")",
"{",
"SmallString",
"<",
"128",
">",
"TmpStr",
";",
"raw_svector_ostream",
"OS",
"(",
"TmpStr",
")",
";",
"PrintDebugValueComment",
"(",
"MI",
",",
"OS",
")",
";",
"OutStreamer",
".",
"EmitRawText",
"(",
"StringRef",
"(",
"OS",
".",
"str",
"(",
")",
")",
")",
";",
"}",
"return",
";",
"}",
"case",
"XCore",
"::",
"ADD_2rus",
":",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"O",
"<<",
"\"\\tmov \"",
"<<",
"getRegisterName",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
"<<",
"\", \"",
"<<",
"getRegisterName",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
")",
";",
"OutStreamer",
".",
"EmitRawText",
"(",
"O",
".",
"str",
"(",
")",
")",
";",
"return",
";",
"}",
"break",
";",
"}",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"OutStreamer",
".",
"EmitRawText",
"(",
"O",
".",
"str",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"XCore",
"XCore",
"128",
"XCore::DBG_VALUE",
"128",
"XCore::ADD_2rus",
"2",
"0",
"\"\\tmov \"",
"0",
"\", \"",
"1"
] | XCoreAsmPrinter29 | EmitInstruction | XCore | MPU | LLVM | 20,034 | 179 | 1 | [] |
[
"<s>",
"void",
"X86FrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MF",
".",
"setHasWinCFI",
"(",
"false",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"if",
"(",
"!",
"STI",
".",
"is64Bit",
"(",
")",
"||",
"!",
"MF",
".",
"hasEHFunclets",
"(",
")",
"||",
"classifyEHPersonality",
"(",
"F",
".",
"getPersonalityFn",
"(",
")",
")",
"!=",
"EHPersonality",
"::",
"MSVC_CXX",
")",
"return",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"WinEHFuncInfo",
"&",
"EHInfo",
"=",
"*",
"MF",
".",
"getWinEHFuncInfo",
"(",
")",
";",
"int64_t",
"MinFixedObjOffset",
"=",
"-",
"SlotSize",
";",
"for",
"(",
"int",
"I",
"=",
"MFI",
".",
"getObjectIndexBegin",
"(",
")",
";",
"I",
"<",
"0",
";",
"++",
"I",
")",
"MinFixedObjOffset",
"=",
"std",
"::",
"min",
"(",
"MinFixedObjOffset",
",",
"MFI",
".",
"getObjectOffset",
"(",
"I",
")",
")",
";",
"for",
"(",
"WinEHTryBlockMapEntry",
"&",
"TBME",
":",
"EHInfo",
".",
"TryBlockMap",
")",
"{",
"for",
"(",
"WinEHHandlerType",
"&",
"H",
":",
"TBME",
".",
"HandlerArray",
")",
"{",
"int",
"FrameIndex",
"=",
"H",
".",
"CatchObj",
".",
"FrameIndex",
";",
"if",
"(",
"FrameIndex",
"!=",
"INT_MAX",
")",
"{",
"unsigned",
"Align",
"=",
"MFI",
".",
"getObjectAlign",
"(",
"FrameIndex",
")",
".",
"value",
"(",
")",
";",
"MinFixedObjOffset",
"-=",
"std",
"::",
"abs",
"(",
"MinFixedObjOffset",
")",
"%",
"Align",
";",
"MinFixedObjOffset",
"-=",
"MFI",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
";",
"MFI",
".",
"setObjectOffset",
"(",
"FrameIndex",
",",
"MinFixedObjOffset",
")",
";",
"}",
"}",
"}",
"MinFixedObjOffset",
"-=",
"std",
"::",
"abs",
"(",
"MinFixedObjOffset",
")",
"%",
"8",
";",
"int64_t",
"UnwindHelpOffset",
"=",
"MinFixedObjOffset",
"-",
"SlotSize",
";",
"int",
"UnwindHelpFI",
"=",
"MFI",
".",
"CreateFixedObject",
"(",
"SlotSize",
",",
"UnwindHelpOffset",
",",
"false",
")",
";",
"EHInfo",
".",
"UnwindHelpFrameIdx",
"=",
"UnwindHelpFI",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"auto",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"while",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"MBBI",
"->",
"getFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
")",
"++",
"MBBI",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MBBI",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"X86",
"::",
"MOV64mi32",
")",
")",
",",
"UnwindHelpFI",
")",
".",
"addImm",
"(",
"-",
"2",
")",
";",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"X86",
"X86",
"0",
"8",
"X86::MOV64mi32",
"2"
] | X86FrameLowering101 | processFunctionBeforeFrameFinalized | X86 | CPU | LLVM | 20,035 | 328 | 1 | [] |
[
"<s>",
"void",
"RISCVFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedRegs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedRegs",
",",
"RS",
")",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"SavedRegs",
".",
"set",
"(",
"RISCV",
"::",
"X1",
")",
";",
"SavedRegs",
".",
"set",
"(",
"RISCV",
"::",
"X8",
")",
";",
"}",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"\"interrupt\"",
")",
"&&",
"MFI",
".",
"hasCalls",
"(",
")",
")",
"{",
"static",
"const",
"MCPhysReg",
"CSRegs",
"[",
"]",
"=",
"{",
"RISCV",
"::",
"X1",
",",
"RISCV",
"::",
"X5",
",",
"RISCV",
"::",
"X6",
",",
"RISCV",
"::",
"X7",
",",
"RISCV",
"::",
"X10",
",",
"RISCV",
"::",
"X11",
",",
"RISCV",
"::",
"X12",
",",
"RISCV",
"::",
"X13",
",",
"RISCV",
"::",
"X14",
",",
"RISCV",
"::",
"X15",
",",
"RISCV",
"::",
"X16",
",",
"RISCV",
"::",
"X17",
",",
"RISCV",
"::",
"X28",
",",
"RISCV",
"::",
"X29",
",",
"RISCV",
"::",
"X30",
",",
"RISCV",
"::",
"X31",
",",
"0",
"}",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"CSRegs",
"[",
"i",
"]",
";",
"++",
"i",
")",
"SavedRegs",
".",
"set",
"(",
"CSRegs",
"[",
"i",
"]",
")",
";",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
".",
"hasStdExtD",
"(",
")",
"||",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
".",
"hasStdExtF",
"(",
")",
")",
"{",
"const",
"MCPhysReg",
"*",
"Regs",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"getCalleeSavedRegs",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"Regs",
"[",
"i",
"]",
";",
"++",
"i",
")",
"if",
"(",
"RISCV",
"::",
"FPR32RegClass",
".",
"contains",
"(",
"Regs",
"[",
"i",
"]",
")",
"||",
"RISCV",
"::",
"FPR64RegClass",
".",
"contains",
"(",
"Regs",
"[",
"i",
"]",
")",
")",
"SavedRegs",
".",
"set",
"(",
"Regs",
"[",
"i",
"]",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"RISCV",
"RISCV",
"RISCV::X1",
"RISCV::X8",
"\"interrupt\"",
"RISCV::X1",
"RISCV::X5",
"RISCV::X6",
"RISCV::X7",
"RISCV::X10",
"RISCV::X11",
"RISCV::X12",
"RISCV::X13",
"RISCV::X14",
"RISCV::X15",
"RISCV::X16",
"RISCV::X17",
"RISCV::X28",
"RISCV::X29",
"RISCV::X30",
"RISCV::X31",
"0",
"0",
"RISCV",
"RISCV",
"0",
"RISCV::FPR32RegClass",
"RISCV::FPR64RegClass"
] | RISCVFrameLowering10 | determineCalleeSaves | RISCV | CPU | LLVM | 20,036 | 285 | 1 | [] |
[
"<s>",
"bool",
"UPTInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
"AllowModify",
")",
"const",
"{",
"bool",
"HasCondBranch",
"=",
"false",
";",
"TBB",
"=",
"nullptr",
";",
"FBB",
"=",
"nullptr",
";",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"MBB",
")",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"UPT",
"::",
"JMP",
")",
"{",
"MachineBasicBlock",
"*",
"TargetBB",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"if",
"(",
"HasCondBranch",
")",
"{",
"FBB",
"=",
"TargetBB",
";",
"}",
"else",
"{",
"TBB",
"=",
"TargetBB",
";",
"}",
"}",
"else",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"UPT",
"::",
"Bcc",
")",
"{",
"MachineBasicBlock",
"*",
"TargetBB",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getMBB",
"(",
")",
";",
"TBB",
"=",
"TargetBB",
";",
"Cond",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
")",
";",
"HasCondBranch",
"=",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"UPT",
"UPT",
"UPT::JMP",
"0",
"UPT::Bcc",
"1",
"0"
] | UPTInstrInfo | analyzeBranch | UPT | CPU | LLVM | 20,037 | 154 | 1 | [] |
[
"<s>",
"static",
"rtx",
"ix86_expand_sse_round",
"(",
"const",
"struct",
"builtin_description",
"*",
"d",
",",
"tree",
"exp",
",",
"rtx",
"target",
")",
"{",
"rtx",
"pat",
";",
"tree",
"arg0",
"=",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"0",
")",
";",
"rtx",
"op1",
",",
"op0",
"=",
"expand_normal",
"(",
"arg0",
")",
";",
"machine_mode",
"tmode",
"=",
"insn_data",
"[",
"d",
"->",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"mode",
";",
"machine_mode",
"mode0",
"=",
"insn_data",
"[",
"d",
"->",
"icode",
"]",
".",
"operand",
"[",
"1",
"]",
".",
"mode",
";",
"if",
"(",
"optimize",
"||",
"target",
"==",
"0",
"||",
"GET_MODE",
"(",
"target",
")",
"!=",
"tmode",
"||",
"!",
"insn_data",
"[",
"d",
"->",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"predicate",
"(",
"target",
",",
"tmode",
")",
")",
"target",
"=",
"gen_reg_rtx",
"(",
"tmode",
")",
";",
"if",
"(",
"VECTOR_MODE_P",
"(",
"mode0",
")",
")",
"op0",
"=",
"safe_vector_operand",
"(",
"op0",
",",
"mode0",
")",
";",
"if",
"(",
"(",
"optimize",
"&&",
"!",
"register_operand",
"(",
"op0",
",",
"mode0",
")",
")",
"||",
"!",
"insn_data",
"[",
"d",
"->",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"predicate",
"(",
"op0",
",",
"mode0",
")",
")",
"op0",
"=",
"copy_to_mode_reg",
"(",
"mode0",
",",
"op0",
")",
";",
"op1",
"=",
"GEN_INT",
"(",
"d",
"->",
"comparison",
")",
";",
"pat",
"=",
"GEN_FCN",
"(",
"d",
"->",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"op1",
")",
";",
"if",
"(",
"!",
"pat",
")",
"return",
"0",
";",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Subroutines",
"of",
"ix86_expand_args_builtin",
"to",
"take",
"care",
"of",
"round",
"insns",
"."
] | [
"i386",
"0",
"0",
"1",
"0",
"0",
"0",
"0"
] | i386-expand | ix86_expand_sse_round | i386 | CPU | GCC | 20,038 | 217 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"Z80TargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"Z80PassConfig",
"(",
"this",
",",
"PM",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"Z80",
"Z80",
"Z80"
] | Z80TargetMachine (2) | createPassConfig | Z80 | MPU | LLVM | 20,039 | 21 | 1 | [] |
[
"<s>",
"bool",
"X86PassConfig",
"::",
"addILPOpts",
"(",
")",
"{",
"if",
"(",
"X86EarlyIfConv",
"&&",
"getX86Subtarget",
"(",
")",
".",
"hasCMov",
"(",
")",
")",
"{",
"addPass",
"(",
"&",
"EarlyIfConverterID",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Add",
"passes",
"that",
"optimize",
"instruction",
"level",
"parallelism",
"for",
"out-of-order",
"targets",
"."
] | [
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine1 | addILPOpts | X86 | CPU | LLVM | 20,040 | 34 | 1 | [] |
[
"<s>",
"int",
"MipsSEFrameLowering",
"::",
"getFrameIndexReference",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
",",
"unsigned",
"&",
"FrameReg",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MipsABIInfo",
"ABI",
"=",
"STI",
".",
"getABI",
"(",
")",
";",
"if",
"(",
"MFI",
"->",
"isFixedObjectIndex",
"(",
"FI",
")",
")",
"FrameReg",
"=",
"hasFP",
"(",
"MF",
")",
"?",
"ABI",
".",
"GetFramePtr",
"(",
")",
":",
"ABI",
".",
"GetStackPtr",
"(",
")",
";",
"else",
"FrameReg",
"=",
"hasBP",
"(",
"MF",
")",
"?",
"ABI",
".",
"GetBasePtr",
"(",
")",
":",
"ABI",
".",
"GetStackPtr",
"(",
")",
";",
"return",
"MFI",
"->",
"getObjectOffset",
"(",
"FI",
")",
"+",
"MFI",
"->",
"getStackSize",
"(",
")",
"-",
"getOffsetOfLocalArea",
"(",
")",
"+",
"MFI",
"->",
"getOffsetAdjustment",
"(",
")",
";",
"}",
"</s>"
] | [
"getFrameIndexReference",
"-",
"This",
"method",
"should",
"return",
"the",
"base",
"register",
"and",
"offset",
"used",
"to",
"reference",
"a",
"frame",
"index",
"location",
"."
] | [
"Mips",
"Mips",
"Mips"
] | MipsSEFrameLowering1 | getFrameIndexReference | Mips | CPU | LLVM | 20,041 | 112 | 1 | [] |
[
"<s>",
"unsigned",
"getMinPrefetchStride",
"(",
")",
"const",
"{",
"return",
"MinPrefetchStride",
";",
"}",
"</s>"
] | [
"Some",
"HW",
"prefetchers",
"can",
"handle",
"accesses",
"up",
"to",
"a",
"certain",
"constant",
"stride",
"."
] | [
"AArch64"
] | AArch64Subtarget10 | getMinPrefetchStride | AArch64 | CPU | LLVM | 20,042 | 10 | 1 | [] |
[
"<s>",
"bool",
"ix86_check_movabs",
"(",
"rtx",
"insn",
",",
"int",
"opnum",
")",
"{",
"rtx",
"set",
",",
"mem",
";",
"set",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"set",
")",
"==",
"PARALLEL",
")",
"set",
"=",
"XVECEXP",
"(",
"set",
",",
"0",
",",
"0",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"set",
")",
"==",
"SET",
")",
";",
"mem",
"=",
"XEXP",
"(",
"set",
",",
"opnum",
")",
";",
"while",
"(",
"SUBREG_P",
"(",
"mem",
")",
")",
"mem",
"=",
"SUBREG_REG",
"(",
"mem",
")",
";",
"gcc_assert",
"(",
"MEM_P",
"(",
"mem",
")",
")",
";",
"return",
"volatile_ok",
"||",
"!",
"MEM_VOLATILE_P",
"(",
"mem",
")",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"OPNUM",
"'s",
"MEM",
"should",
"be",
"matched",
"in",
"movabs",
"*",
"patterns",
"."
] | [
"i386",
"0",
"0"
] | i386 | ix86_check_movabs | i386 | CPU | GCC | 20,043 | 93 | 1 | [] |
[
"<s>",
"rtx",
"sh_load_function_descriptor",
"(",
"rtx",
"funcdesc",
")",
"{",
"rtx",
"r1",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"R1_REG",
")",
";",
"rtx",
"pic_reg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"PIC_REG",
")",
";",
"rtx",
"fnaddr",
"=",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"funcdesc",
")",
";",
"rtx",
"gotaddr",
"=",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"plus_constant",
"(",
"Pmode",
",",
"funcdesc",
",",
"4",
")",
")",
";",
"emit_move_insn",
"(",
"r1",
",",
"fnaddr",
")",
";",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"emit_move_insn",
"(",
"pic_reg",
",",
"gotaddr",
")",
";",
"return",
"r1",
";",
"}",
"</s>"
] | [
"Emit",
"insns",
"to",
"load",
"the",
"function",
"address",
"from",
"FUNCDESC",
"(",
"an",
"FDPIC",
"function",
"descriptor",
")",
"into",
"r1",
"and",
"the",
"GOT",
"address",
"into",
"r12",
",",
"returning",
"an",
"rtx",
"for",
"r1",
"."
] | [
"sh",
"4"
] | sh | sh_load_function_descriptor | sh | CPU | GCC | 20,044 | 79 | 1 | [] |
[
"<s>",
"static",
"rtx",
"find_alignment_op",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"base_reg",
")",
"{",
"df_ref",
"base_use",
";",
"struct",
"df_insn_info",
"*",
"insn_info",
"=",
"DF_INSN_INFO_GET",
"(",
"insn",
")",
";",
"rtx",
"and_operation",
"=",
"0",
";",
"FOR_EACH_INSN_INFO_USE",
"(",
"base_use",
",",
"insn_info",
")",
"{",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"DF_REF_REG",
"(",
"base_use",
")",
",",
"base_reg",
")",
")",
"continue",
";",
"struct",
"df_link",
"*",
"base_def_link",
"=",
"DF_REF_CHAIN",
"(",
"base_use",
")",
";",
"if",
"(",
"!",
"base_def_link",
"||",
"base_def_link",
"->",
"next",
")",
"break",
";",
"if",
"(",
"DF_REF_IS_ARTIFICIAL",
"(",
"base_def_link",
"->",
"ref",
")",
")",
"break",
";",
"rtx_insn",
"*",
"and_insn",
"=",
"DF_REF_INSN",
"(",
"base_def_link",
"->",
"ref",
")",
";",
"and_operation",
"=",
"alignment_mask",
"(",
"and_insn",
")",
";",
"if",
"(",
"and_operation",
"!=",
"0",
")",
"break",
";",
"}",
"return",
"and_operation",
";",
"}",
"</s>"
] | [
"Given",
"INSN",
"that",
"'s",
"a",
"load",
"or",
"store",
"based",
"at",
"BASE_REG",
",",
"check",
"if",
"all",
"of",
"its",
"feeding",
"computations",
"align",
"its",
"address",
"on",
"a",
"16-byte",
"boundary",
".",
"If",
"so",
",",
"return",
"true",
"and",
"add",
"all",
"definition",
"insns",
"into",
"AND_INSNS",
"and",
"their",
"corresponding",
"fully-expanded",
"rtxes",
"for",
"the",
"masking",
"operations",
"into",
"AND_OPS",
"."
] | [
"rs6000",
"0",
"0"
] | rs60006 | find_alignment_op | rs6000 | CPU | GCC | 20,045 | 115 | 1 | [] |
[
"<s>",
"inline",
"bool",
"registered_function_hasher",
"::",
"equal",
"(",
"value_type",
"value",
",",
"const",
"compare_type",
"&",
"key",
")",
"{",
"return",
"value",
"->",
"instance",
"==",
"key",
";",
"}",
"</s>"
] | [
"Compare",
"H1",
"and",
"H2",
"for",
"equivalence",
"."
] | [
"aarch64"
] | aarch64-sve-builtins | equal | aarch64 | CPU | GCC | 20,046 | 23 | 1 | [] |
[
"<s>",
"void",
"SystemZAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"SystemZMCInstLower",
"Lower",
"(",
"MF",
"->",
"getContext",
"(",
")",
",",
"*",
"this",
")",
";",
"MCInst",
"LoweredMI",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"SystemZ",
"::",
"Return",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BR",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R14D",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallBRASL",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BRASL",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R14D",
")",
".",
"addExpr",
"(",
"Lower",
".",
"getExpr",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
",",
"MCSymbolRefExpr",
"::",
"VK_PLT",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallBASR",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BASR",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R14D",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallJG",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"JG",
")",
".",
"addExpr",
"(",
"Lower",
".",
"getExpr",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
",",
"MCSymbolRefExpr",
"::",
"VK_PLT",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallBR",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BR",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R1D",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"IILF64",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"IILF",
")",
".",
"addReg",
"(",
"SystemZMC",
"::",
"getRegAsGR32",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
".",
"addImm",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"IIHF64",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"IIHF",
")",
".",
"addReg",
"(",
"SystemZMC",
"::",
"getRegAsGRH32",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
".",
"addImm",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"RISBHH",
":",
"case",
"SystemZ",
"::",
"RISBHL",
":",
"LoweredMI",
"=",
"lowerRIEfLow",
"(",
"MI",
",",
"SystemZ",
"::",
"RISBHG",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"RISBLH",
":",
"case",
"SystemZ",
"::",
"RISBLL",
":",
"LoweredMI",
"=",
"lowerRIEfLow",
"(",
"MI",
",",
"SystemZ",
"::",
"RISBLG",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"NAME",
"##",
"64",
":",
"LoweredMI",
"=",
"lowerRILow",
"(",
"MI",
",",
"SystemZ",
"::",
"NAME",
")",
";",
"break",
"LOWER_LOW",
"(",
"IILL",
")",
";",
"LOWER_LOW",
"(",
"IILH",
")",
";",
"LOWER_LOW",
"(",
"TMLL",
")",
";",
"LOWER_LOW",
"(",
"TMLH",
")",
";",
"LOWER_LOW",
"(",
"NILL",
")",
";",
"LOWER_LOW",
"(",
"NILH",
")",
";",
"LOWER_LOW",
"(",
"NILF",
")",
";",
"LOWER_LOW",
"(",
"OILL",
")",
";",
"LOWER_LOW",
"(",
"OILH",
")",
";",
"LOWER_LOW",
"(",
"OILF",
")",
";",
"LOWER_LOW",
"(",
"XILF",
")",
";",
"case",
"SystemZ",
"::",
"NAME",
"##",
"64",
":",
"LoweredMI",
"=",
"lowerRIHigh",
"(",
"MI",
",",
"SystemZ",
"::",
"NAME",
")",
";",
"break",
"LOWER_HIGH",
"(",
"IIHL",
")",
";",
"LOWER_HIGH",
"(",
"IIHH",
")",
";",
"LOWER_HIGH",
"(",
"TMHL",
")",
";",
"LOWER_HIGH",
"(",
"TMHH",
")",
";",
"LOWER_HIGH",
"(",
"NIHL",
")",
";",
"LOWER_HIGH",
"(",
"NIHH",
")",
";",
"LOWER_HIGH",
"(",
"NIHF",
")",
";",
"LOWER_HIGH",
"(",
"OIHL",
")",
";",
"LOWER_HIGH",
"(",
"OIHH",
")",
";",
"LOWER_HIGH",
"(",
"OIHF",
")",
";",
"LOWER_HIGH",
"(",
"XIHF",
")",
";",
"default",
":",
"Lower",
".",
"lower",
"(",
"MI",
",",
"LoweredMI",
")",
";",
"break",
";",
"}",
"OutStreamer",
".",
"EmitInstruction",
"(",
"LoweredMI",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ::Return",
"SystemZ::BR",
"SystemZ::R14D",
"SystemZ::CallBRASL",
"SystemZ::BRASL",
"SystemZ::R14D",
"0",
"SystemZ::CallBASR",
"SystemZ::BASR",
"SystemZ::R14D",
"0",
"SystemZ::CallJG",
"SystemZ::JG",
"0",
"SystemZ::CallBR",
"SystemZ::BR",
"SystemZ::R1D",
"SystemZ::IILF64",
"SystemZ::IILF",
"SystemZMC::getRegAsGR32",
"0",
"2",
"SystemZ::IIHF64",
"SystemZ::IIHF",
"SystemZMC::getRegAsGRH32",
"0",
"2",
"SystemZ::RISBHH",
"SystemZ::RISBHL",
"SystemZ::RISBHG",
"SystemZ::RISBLH",
"SystemZ::RISBLL",
"SystemZ::RISBLG",
"SystemZ::NAME",
"64",
"SystemZ::NAME",
"SystemZ::NAME",
"64",
"SystemZ::NAME"
] | SystemZAsmPrinter34 | EmitInstruction | SystemZ | CPU | LLVM | 20,047 | 510 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyTargetLowering",
"::",
"getTgtMemIntrinsic",
"(",
"IntrinsicInfo",
"&",
"Info",
",",
"const",
"CallInst",
"&",
"I",
",",
"MachineFunction",
"&",
"MF",
",",
"unsigned",
"Intrinsic",
")",
"const",
"{",
"switch",
"(",
"Intrinsic",
")",
"{",
"case",
"Intrinsic",
"::",
"wasm_memory_atomic_notify",
":",
"Info",
".",
"opc",
"=",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
";",
"Info",
".",
"memVT",
"=",
"MVT",
"::",
"i32",
";",
"Info",
".",
"ptrVal",
"=",
"I",
".",
"getArgOperand",
"(",
"0",
")",
";",
"Info",
".",
"offset",
"=",
"0",
";",
"Info",
".",
"align",
"=",
"Align",
"(",
"4",
")",
";",
"Info",
".",
"flags",
"=",
"MachineMemOperand",
"::",
"MOVolatile",
"|",
"MachineMemOperand",
"::",
"MOLoad",
";",
"return",
"true",
";",
"case",
"Intrinsic",
"::",
"wasm_memory_atomic_wait32",
":",
"Info",
".",
"opc",
"=",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
";",
"Info",
".",
"memVT",
"=",
"MVT",
"::",
"i32",
";",
"Info",
".",
"ptrVal",
"=",
"I",
".",
"getArgOperand",
"(",
"0",
")",
";",
"Info",
".",
"offset",
"=",
"0",
";",
"Info",
".",
"align",
"=",
"Align",
"(",
"4",
")",
";",
"Info",
".",
"flags",
"=",
"MachineMemOperand",
"::",
"MOVolatile",
"|",
"MachineMemOperand",
"::",
"MOLoad",
";",
"return",
"true",
";",
"case",
"Intrinsic",
"::",
"wasm_memory_atomic_wait64",
":",
"Info",
".",
"opc",
"=",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
";",
"Info",
".",
"memVT",
"=",
"MVT",
"::",
"i64",
";",
"Info",
".",
"ptrVal",
"=",
"I",
".",
"getArgOperand",
"(",
"0",
")",
";",
"Info",
".",
"offset",
"=",
"0",
";",
"Info",
".",
"align",
"=",
"Align",
"(",
"8",
")",
";",
"Info",
".",
"flags",
"=",
"MachineMemOperand",
"::",
"MOVolatile",
"|",
"MachineMemOperand",
"::",
"MOLoad",
";",
"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",
")",
"."
] | [
"WebAssembly",
"WebAssembly",
"Intrinsic::wasm_memory_atomic_notify",
"ISD::INTRINSIC_W_CHAIN",
"MVT::i32",
"0",
"0",
"4",
"Intrinsic::wasm_memory_atomic_wait32",
"ISD::INTRINSIC_W_CHAIN",
"MVT::i32",
"0",
"0",
"4",
"Intrinsic::wasm_memory_atomic_wait64",
"ISD::INTRINSIC_W_CHAIN",
"MVT::i64",
"0",
"0",
"8"
] | WebAssemblyISelLowering15 | getTgtMemIntrinsic | WebAssembly | Virtual ISA | LLVM | 20,048 | 221 | 1 | [] |
[
"<s>",
"static",
"int",
"avr_register_move_cost",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"reg_class_t",
"from",
",",
"reg_class_t",
"to",
")",
"{",
"return",
"(",
"from",
"==",
"STACK_REG",
"?",
"6",
":",
"to",
"==",
"STACK_REG",
"?",
"12",
":",
"2",
")",
";",
"}",
"</s>"
] | [
"Implement",
"`",
"TARGET_REGISTER_MOVE_COST",
"'"
] | [
"avr",
"6",
"12",
"2"
] | avr | avr_register_move_cost | avr | MPU | GCC | 20,049 | 33 | 1 | [] |
[
"<s>",
"static",
"int",
"arc_arg_partial_bytes",
"(",
"cumulative_args_t",
"cum_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"int",
"bytes",
"=",
"arg",
".",
"promoted_size_in_bytes",
"(",
")",
";",
"int",
"words",
"=",
"(",
"bytes",
"+",
"UNITS_PER_WORD",
"-",
"1",
")",
"/",
"UNITS_PER_WORD",
";",
"int",
"arg_num",
"=",
"*",
"cum",
";",
"int",
"ret",
";",
"arg_num",
"=",
"ROUND_ADVANCE_CUM",
"(",
"arg_num",
",",
"arg",
".",
"mode",
",",
"arg",
".",
"type",
")",
";",
"ret",
"=",
"GPR_REST_ARG_REGS",
"(",
"arg_num",
")",
";",
"ret",
"=",
"(",
"ret",
">=",
"words",
"?",
"0",
":",
"ret",
"*",
"UNITS_PER_WORD",
")",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ARG_PARTIAL_BYTES",
"."
] | [
"arc",
"1",
"0"
] | arc | arc_arg_partial_bytes | arc | MPU | GCC | 20,050 | 93 | 1 | [] |
[
"<s>",
"void",
"PPCPassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"initializePPCVSXFMAMutatePass",
"(",
"*",
"PassRegistry",
"::",
"getPassRegistry",
"(",
")",
")",
";",
"insertPass",
"(",
"VSXFMAMutateEarly",
"?",
"&",
"RegisterCoalescerID",
":",
"&",
"MachineSchedulerID",
",",
"&",
"PPCVSXFMAMutateID",
")",
";",
"}",
"if",
"(",
"getPPCTargetMachine",
"(",
")",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"{",
"addPass",
"(",
"&",
"LiveVariablesID",
",",
"false",
")",
";",
"addPass",
"(",
"createPPCTLSDynamicCallPass",
"(",
")",
")",
";",
"}",
"if",
"(",
"EnableExtraTOCRegDeps",
")",
"addPass",
"(",
"createPPCTOCRegDepsPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"PPC",
"PPC",
"PPC"
] | PPCTargetMachine63 | addPreRegAlloc | PowerPC | CPU | LLVM | 20,051 | 86 | 1 | [] |
[
"<s>",
"static",
"void",
"mmix_output_shifted_value",
"(",
"FILE",
"*",
"stream",
",",
"int64_t",
"value",
")",
"{",
"int",
"i",
";",
"if",
"(",
"!",
"mmix_shiftable_wyde_value",
"(",
"value",
")",
")",
"{",
"char",
"s",
"[",
"16",
"+",
"2",
"+",
"1",
"]",
";",
"sprintf",
"(",
"s",
",",
"\"%#\"",
"PRIx64",
",",
"value",
")",
";",
"internal_error",
"(",
"\"MMIX Internal: %s is not a shiftable int\"",
",",
"s",
")",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"4",
";",
"i",
"++",
")",
"{",
"if",
"(",
"value",
"&",
"0xffff",
")",
"{",
"fprintf",
"(",
"stream",
",",
"\"#%x\"",
",",
"(",
"int",
")",
"(",
"value",
"&",
"0xffff",
")",
")",
";",
"return",
";",
"}",
"value",
">>=",
"16",
";",
"}",
"fprintf",
"(",
"stream",
",",
"\"0\"",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"presumed",
"shiftable",
"wyde",
"argument",
"shifted",
"into",
"place",
"(",
"to",
"be",
"output",
"with",
"an",
"operand",
")",
"."
] | [
"mmix",
"16",
"2",
"1",
"\"%#\"",
"\"MMIX Internal: %s is not a shiftable int\"",
"0",
"4",
"0xffff",
"\"#%x\"",
"0xffff",
"16",
"\"0\""
] | mmix4 | mmix_output_shifted_value | mmix | CPU | GCC | 20,052 | 105 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_canonicalize_int_order_test",
"(",
"enum",
"rtx_code",
"*",
"code",
",",
"rtx",
"*",
"cmp1",
",",
"machine_mode",
"mode",
")",
"{",
"HOST_WIDE_INT",
"plus_one",
";",
"if",
"(",
"riscv_int_order_operand_ok_p",
"(",
"*",
"code",
",",
"*",
"cmp1",
")",
")",
"return",
"true",
";",
"if",
"(",
"CONST_INT_P",
"(",
"*",
"cmp1",
")",
")",
"switch",
"(",
"*",
"code",
")",
"{",
"case",
"LE",
":",
"plus_one",
"=",
"trunc_int_for_mode",
"(",
"UINTVAL",
"(",
"*",
"cmp1",
")",
"+",
"1",
",",
"mode",
")",
";",
"if",
"(",
"INTVAL",
"(",
"*",
"cmp1",
")",
"<",
"plus_one",
")",
"{",
"*",
"code",
"=",
"LT",
";",
"*",
"cmp1",
"=",
"force_reg",
"(",
"mode",
",",
"GEN_INT",
"(",
"plus_one",
")",
")",
";",
"return",
"true",
";",
"}",
"break",
";",
"case",
"LEU",
":",
"plus_one",
"=",
"trunc_int_for_mode",
"(",
"UINTVAL",
"(",
"*",
"cmp1",
")",
"+",
"1",
",",
"mode",
")",
";",
"if",
"(",
"plus_one",
"!=",
"0",
")",
"{",
"*",
"code",
"=",
"LTU",
";",
"*",
"cmp1",
"=",
"force_reg",
"(",
"mode",
",",
"GEN_INT",
"(",
"plus_one",
")",
")",
";",
"return",
"true",
";",
"}",
"break",
";",
"default",
":",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"*",
"CMP1",
"(",
"of",
"mode",
"MODE",
")",
"is",
"a",
"valid",
"second",
"operand",
"for",
"integer",
"ordering",
"test",
"*",
"CODE",
",",
"or",
"if",
"an",
"equivalent",
"combination",
"can",
"be",
"formed",
"by",
"adjusting",
"*",
"CODE",
"and",
"*",
"CMP1",
".",
"When",
"returning",
"true",
",",
"update",
"*",
"CODE",
"and",
"*",
"CMP1",
"with",
"the",
"chosen",
"code",
"and",
"operand",
",",
"otherwise",
"leave",
"them",
"alone",
"."
] | [
"riscv",
"1",
"1",
"0"
] | riscv | riscv_canonicalize_int_order_test | riscv | CPU | GCC | 20,053 | 159 | 1 | [] |
[
"<s>",
"HexagonSubtarget",
"&",
"HexagonSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"CPUString",
"=",
"Hexagon_MC",
"::",
"selectHexagonCPU",
"(",
"getTargetTriple",
"(",
")",
",",
"CPU",
")",
";",
"static",
"std",
"::",
"map",
"<",
"StringRef",
",",
"HexagonArchEnum",
">",
"CpuTable",
"{",
"{",
"\"hexagonv4\"",
",",
"V4",
"}",
",",
"{",
"\"hexagonv5\"",
",",
"V5",
"}",
",",
"{",
"\"hexagonv55\"",
",",
"V55",
"}",
",",
"{",
"\"hexagonv60\"",
",",
"V60",
"}",
",",
"{",
"\"hexagonv62\"",
",",
"V62",
"}",
",",
"}",
";",
"auto",
"foundIt",
"=",
"CpuTable",
".",
"find",
"(",
"CPUString",
")",
";",
"if",
"(",
"foundIt",
"!=",
"CpuTable",
".",
"end",
"(",
")",
")",
"HexagonArchVersion",
"=",
"foundIt",
"->",
"second",
";",
"else",
"llvm_unreachable",
"(",
"\"Unrecognized Hexagon processor version\"",
")",
";",
"UseHVXOps",
"=",
"false",
";",
"UseHVXDblOps",
"=",
"false",
";",
"UseLongCalls",
"=",
"false",
";",
"ParseSubtargetFeatures",
"(",
"CPUString",
",",
"FS",
")",
";",
"if",
"(",
"EnableHexagonHVX",
".",
"getPosition",
"(",
")",
")",
"UseHVXOps",
"=",
"EnableHexagonHVX",
";",
"if",
"(",
"EnableHexagonHVXDouble",
".",
"getPosition",
"(",
")",
")",
"UseHVXDblOps",
"=",
"EnableHexagonHVXDouble",
";",
"if",
"(",
"OverrideLongCalls",
".",
"getPosition",
"(",
")",
")",
"UseLongCalls",
"=",
"OverrideLongCalls",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"\"hexagonv4\"",
"\"hexagonv5\"",
"\"hexagonv55\"",
"\"hexagonv60\"",
"\"hexagonv62\"",
"Hexagon",
"\"Unrecognized Hexagon processor version\"",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonSubtarget10 | initializeSubtargetDependencies | Hexagon | DSP | LLVM | 20,054 | 161 | 1 | [] |
[
"<s>",
"static",
"rtx",
"csky_legitimize_address",
"(",
"rtx",
"x",
",",
"rtx",
"orig_x",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"csky_tls_symbol_p",
"(",
"x",
")",
")",
"return",
"csky_legitimize_tls_address",
"(",
"x",
",",
"NULL_RTX",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
")",
"{",
"rtx",
"xop0",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"rtx",
"xop1",
"=",
"XEXP",
"(",
"x",
",",
"1",
")",
";",
"if",
"(",
"is_csky_address_register_rtx_p",
"(",
"xop0",
",",
"0",
")",
"&&",
"CONST_INT_P",
"(",
"xop1",
")",
")",
"{",
"HOST_WIDE_INT",
"offset",
"=",
"INTVAL",
"(",
"xop1",
")",
";",
"if",
"(",
"optimize_size",
"&&",
"offset",
">",
"CSKY_LD16_MAX_OFFSET",
"(",
"mode",
")",
"&&",
"offset",
"<=",
"(",
"CSKY_ADDI16_MAX_IMM",
"+",
"CSKY_LD16_MAX_OFFSET",
"(",
"mode",
")",
")",
")",
"{",
"HOST_WIDE_INT",
"new_ld_offset",
"=",
"offset",
"&",
"CSKY_LD16_OFFSET_MASK",
"(",
"mode",
")",
";",
"xop0",
"=",
"force_operand",
"(",
"plus_constant",
"(",
"Pmode",
",",
"xop0",
",",
"offset",
"-",
"new_ld_offset",
")",
",",
"NULL_RTX",
")",
";",
"x",
"=",
"plus_constant",
"(",
"Pmode",
",",
"xop0",
",",
"new_ld_offset",
")",
";",
"}",
"else",
"if",
"(",
"offset",
"<",
"0",
"&&",
"offset",
">=",
"(",
"-",
"CSKY_SUBI16_MAX_IMM",
")",
")",
"x",
"=",
"force_operand",
"(",
"x",
",",
"NULL_RTX",
")",
";",
"else",
"if",
"(",
"offset",
">",
"CSKY_LD16_MAX_OFFSET",
"(",
"mode",
")",
"||",
"offset",
"<",
"0",
")",
"{",
"xop1",
"=",
"force_reg",
"(",
"SImode",
",",
"xop1",
")",
";",
"x",
"=",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"xop0",
",",
"xop1",
")",
";",
"}",
"}",
"if",
"(",
"is_csky_address_register_rtx_p",
"(",
"xop1",
",",
"0",
")",
"&&",
"!",
"is_csky_address_register_rtx_p",
"(",
"xop0",
",",
"0",
")",
")",
"{",
"xop0",
"=",
"force_operand",
"(",
"xop0",
",",
"NULL_RTX",
")",
";",
"x",
"=",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"xop0",
",",
"xop1",
")",
";",
"}",
"}",
"else",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
"&&",
"optimize",
">",
"0",
")",
"{",
"HOST_WIDE_INT",
"mask",
",",
"base",
",",
"index",
";",
"rtx",
"base_reg",
";",
"mask",
"=",
"CSKY_LD16_OFFSET_MASK",
"(",
"mode",
")",
";",
"base",
"=",
"INTVAL",
"(",
"x",
")",
"&",
"~",
"mask",
";",
"index",
"=",
"INTVAL",
"(",
"x",
")",
"&",
"mask",
";",
"base_reg",
"=",
"force_reg",
"(",
"SImode",
",",
"GEN_INT",
"(",
"base",
")",
")",
";",
"x",
"=",
"plus_constant",
"(",
"Pmode",
",",
"base_reg",
",",
"index",
")",
";",
"}",
"return",
"x",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMIZE_ADDRESS",
"."
] | [
"csky",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"0"
] | csky | csky_legitimize_address | csky | CPU | GCC | 20,055 | 323 | 1 | [] |
[
"<s>",
"bool",
"PatmosLatencyQueue",
"::",
"empty",
"(",
")",
"{",
"return",
"AvailableQueue",
".",
"empty",
"(",
")",
"&&",
"PendingQueue",
".",
"empty",
"(",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"this",
"version",
"information",
"is",
"empty",
"(",
"e.g.",
",",
"all",
"version",
"components",
"are",
"zero",
")",
"."
] | [
"Patmos",
"Patmos"
] | PatmosSchedStrategy | empty | Patmos | VLIW | LLVM | 20,056 | 21 | 1 | [] |
[
"<s>",
"bool",
"needAddressOf",
"(",
")",
"const",
"override",
"{",
"return",
"AddressOf",
";",
"}",
"</s>"
] | [
"needAddressOf",
"-",
"Do",
"we",
"need",
"to",
"emit",
"code",
"to",
"get",
"the",
"address",
"of",
"the",
"variable/label",
"?",
"Only",
"valid",
"when",
"parsing",
"MS-style",
"inline",
"assembly",
"."
] | [
"X86"
] | X86Operand (2) | needAddressOf | X86 | CPU | LLVM | 20,057 | 11 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"ARM Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM",
"\"ARM Instruction Selection\""
] | ARMISelDAGToDAG (2)4 | getPassName | ARM | CPU | LLVM | 20,058 | 13 | 1 | [] |
[
"<s>",
"static",
"int",
"m68k_sched_adjust_cost",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
",",
"rtx_insn",
"*",
"def_insn",
",",
"int",
"cost",
",",
"unsigned",
"int",
")",
"{",
"int",
"delay",
";",
"if",
"(",
"recog_memoized",
"(",
"def_insn",
")",
"<",
"0",
"||",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"return",
"cost",
";",
"if",
"(",
"sched_cfv4_bypass_data",
".",
"scale",
"==",
"1",
")",
"{",
"gcc_assert",
"(",
"sched_cfv4_bypass_data",
".",
"pro",
"==",
"def_insn",
"&&",
"sched_cfv4_bypass_data",
".",
"con",
"==",
"insn",
")",
";",
"if",
"(",
"cost",
"<",
"3",
")",
"cost",
"=",
"3",
";",
"sched_cfv4_bypass_data",
".",
"pro",
"=",
"NULL",
";",
"sched_cfv4_bypass_data",
".",
"con",
"=",
"NULL",
";",
"sched_cfv4_bypass_data",
".",
"scale",
"=",
"0",
";",
"}",
"else",
"gcc_assert",
"(",
"sched_cfv4_bypass_data",
".",
"pro",
"==",
"NULL",
"&&",
"sched_cfv4_bypass_data",
".",
"con",
"==",
"NULL",
"&&",
"sched_cfv4_bypass_data",
".",
"scale",
"==",
"0",
")",
";",
"delay",
"=",
"min_insn_conflict_delay",
"(",
"sched_adjust_cost_state",
",",
"def_insn",
",",
"insn",
")",
";",
"if",
"(",
"delay",
">",
"cost",
")",
"cost",
"=",
"delay",
";",
"return",
"cost",
";",
"}",
"</s>"
] | [
"Implement",
"adjust_cost",
"scheduler",
"hook",
".",
"Return",
"adjusted",
"COST",
"of",
"dependency",
"LINK",
"between",
"DEF_INSN",
"and",
"INSN",
"."
] | [
"m68k",
"0",
"0",
"1",
"3",
"3",
"0",
"0"
] | m68k | m68k_sched_adjust_cost | m68k | MPU | GCC | 20,059 | 143 | 1 | [] |
[
"<s>",
"bool",
"HexagonPassConfig",
"::",
"addPreSched2",
"(",
")",
"{",
"const",
"HexagonTargetMachine",
"&",
"TM",
"=",
"getHexagonTargetMachine",
"(",
")",
";",
"const",
"HexagonTargetObjectFile",
"&",
"TLOF",
"=",
"(",
"const",
"HexagonTargetObjectFile",
"&",
")",
"getTargetLowering",
"(",
")",
"->",
"getObjFileLowering",
"(",
")",
";",
"addPass",
"(",
"createHexagonCopyToCombine",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"&",
"IfConverterID",
")",
";",
"if",
"(",
"!",
"TLOF",
".",
"IsSmallDataEnabled",
"(",
")",
")",
"{",
"addPass",
"(",
"createHexagonSplitConst32AndConst64",
"(",
"TM",
")",
")",
";",
"printAndVerify",
"(",
"\"After hexagon split const32/64 pass\"",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"prolog-epilog",
"insertion",
"and",
"before",
"the",
"second",
"instruction",
"scheduling",
"pass",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"\"After hexagon split const32/64 pass\""
] | HexagonTargetMachine16 | addPreSched2 | Hexagon | DSP | LLVM | 20,060 | 85 | 1 | [] |
[
"<s>",
"void",
"SystemZTargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"SDValue",
"Op",
",",
"std",
"::",
"string",
"&",
"Constraint",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"length",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'I'",
":",
"if",
"(",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
")",
"if",
"(",
"isUInt",
"<",
"8",
">",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
")",
")",
"Ops",
".",
"push_back",
"(",
"DAG",
".",
"getTargetConstant",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
")",
";",
"return",
";",
"case",
"'J'",
":",
"if",
"(",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
")",
"if",
"(",
"isUInt",
"<",
"12",
">",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
")",
")",
"Ops",
".",
"push_back",
"(",
"DAG",
".",
"getTargetConstant",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
")",
";",
"return",
";",
"case",
"'K'",
":",
"if",
"(",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
")",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
")",
")",
"Ops",
".",
"push_back",
"(",
"DAG",
".",
"getTargetConstant",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
")",
";",
"return",
";",
"case",
"'L'",
":",
"if",
"(",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
")",
"if",
"(",
"isInt",
"<",
"20",
">",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
")",
")",
"Ops",
".",
"push_back",
"(",
"DAG",
".",
"getTargetConstant",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
")",
";",
"return",
";",
"case",
"'M'",
":",
"if",
"(",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
")",
"if",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"==",
"0x7fffffff",
")",
"Ops",
".",
"push_back",
"(",
"DAG",
".",
"getTargetConstant",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
")",
";",
"return",
";",
"}",
"}",
"TargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"Op",
",",
"Constraint",
",",
"Ops",
",",
"DAG",
")",
";",
"}",
"</s>"
] | [
"Lower",
"the",
"specified",
"operand",
"into",
"the",
"Ops",
"vector",
"."
] | [
"SystemZ",
"SystemZ",
"1",
"0",
"8",
"12",
"16",
"20",
"0x7fffffff"
] | SystemZISelLowering (2)1 | LowerAsmOperandForConstraint | SystemZ | CPU | LLVM | 20,061 | 360 | 1 | [] |
[
"<s>",
"bool",
"RISCVAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"OS",
")",
"{",
"if",
"(",
"AsmVariant",
"!=",
"0",
")",
"report_fatal_error",
"(",
"\"There are no defined alternate asm variants\"",
")",
";",
"if",
"(",
"!",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNo",
",",
"AsmVariant",
",",
"ExtraCode",
",",
"OS",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"ExtraCode",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNo",
")",
";",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"OS",
"<<",
"MO",
".",
"getImm",
"(",
")",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"OS",
"<<",
"RISCVInstPrinter",
"::",
"getRegisterName",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"return",
"false",
";",
"default",
":",
"break",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"RISCV",
"RISCV",
"0",
"\"There are no defined alternate asm variants\"",
"RISCV"
] | RISCVAsmPrinter14 | PrintAsmOperand | RISCV | CPU | LLVM | 20,062 | 132 | 1 | [] |
[
"<s>",
"void",
"AMDGPUInstPrinter",
"::",
"printRegName",
"(",
"raw_ostream",
"&",
"OS",
",",
"unsigned",
"RegNo",
")",
"const",
"{",
"OS",
"<<",
"RegNo",
";",
"}",
"</s>"
] | [
"Print",
"the",
"assembler",
"register",
"name",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUInstPrinter23 | printRegName | AMDGPU | GPU | LLVM | 20,063 | 19 | 1 | [] |
[
"<s>",
"bool",
"isToken",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"k_Tok",
";",
"}",
"</s>"
] | [
"isToken",
"-",
"Is",
"this",
"a",
"token",
"operand",
"?"
] | [
"MSP430"
] | MSP430AsmParser11 | isToken | MSP430 | MPU | LLVM | 20,064 | 13 | 1 | [] |
[
"<s>",
"int",
"ARMTTIImpl",
"::",
"getIntrinsicInstrCost",
"(",
"const",
"IntrinsicCostAttributes",
"&",
"ICA",
",",
"TTI",
"::",
"TargetCostKind",
"CostKind",
")",
"{",
"switch",
"(",
"ICA",
".",
"getID",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"get_active_lane_mask",
":",
"if",
"(",
"ST",
"->",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"0",
";",
"break",
";",
"case",
"Intrinsic",
"::",
"sadd_sat",
":",
"case",
"Intrinsic",
"::",
"ssub_sat",
":",
"case",
"Intrinsic",
"::",
"uadd_sat",
":",
"case",
"Intrinsic",
"::",
"usub_sat",
":",
"{",
"if",
"(",
"!",
"ST",
"->",
"hasMVEIntegerOps",
"(",
")",
")",
"break",
";",
"Type",
"*",
"VT",
"=",
"ICA",
".",
"getReturnType",
"(",
")",
";",
"if",
"(",
"!",
"VT",
"->",
"isVectorTy",
"(",
")",
"&&",
"!",
"ICA",
".",
"getVectorFactor",
"(",
")",
".",
"isScalar",
"(",
")",
")",
"VT",
"=",
"VectorType",
"::",
"get",
"(",
"VT",
",",
"ICA",
".",
"getVectorFactor",
"(",
")",
")",
";",
"std",
"::",
"pair",
"<",
"int",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"DL",
",",
"VT",
")",
";",
"if",
"(",
"LT",
".",
"second",
"==",
"MVT",
"::",
"v4i32",
"||",
"LT",
".",
"second",
"==",
"MVT",
"::",
"v8i16",
"||",
"LT",
".",
"second",
"==",
"MVT",
"::",
"v16i8",
")",
"{",
"unsigned",
"Instrs",
"=",
"LT",
".",
"second",
".",
"getScalarSizeInBits",
"(",
")",
"==",
"ICA",
".",
"getReturnType",
"(",
")",
"->",
"getScalarSizeInBits",
"(",
")",
"?",
"1",
":",
"4",
";",
"return",
"LT",
".",
"first",
"*",
"ST",
"->",
"getMVEVectorCostFactor",
"(",
")",
"*",
"Instrs",
";",
"}",
"break",
";",
"}",
"}",
"return",
"BaseT",
"::",
"getIntrinsicInstrCost",
"(",
"ICA",
",",
"CostKind",
")",
";",
"}",
"</s>"
] | [
"Get",
"intrinsic",
"cost",
"based",
"on",
"arguments",
"."
] | [
"ARM",
"ARM",
"Intrinsic::get_active_lane_mask",
"0",
"Intrinsic::sadd_sat",
"Intrinsic::ssub_sat",
"Intrinsic::uadd_sat",
"Intrinsic::usub_sat",
"MVT::v4i32",
"MVT::v8i16",
"MVT::v16i8",
"1",
"4"
] | ARMTargetTransformInfo29 | getIntrinsicInstrCost | ARM | CPU | LLVM | 20,065 | 220 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"mips_get_compress_on_name",
"(",
"unsigned",
"int",
"flags",
")",
"{",
"if",
"(",
"flags",
"==",
"MASK_MIPS16",
")",
"return",
"\"mips16\"",
";",
"return",
"\"micromips\"",
";",
"}",
"</s>"
] | [
"Return",
"the",
"attribute",
"name",
"associated",
"with",
"MASK_MIPS16",
"and",
"MASK_MICROMIPS",
"flags",
"FLAGS",
"."
] | [
"mips",
"\"mips16\"",
"\"micromips\""
] | mips | mips_get_compress_on_name | mips | CPU | GCC | 20,066 | 24 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"Op",
".",
"getNode",
"(",
")",
"->",
"dump",
"(",
")",
";",
"llvm_unreachable",
"(",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"LowerSIGN_EXTEND_INREG",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"CONCAT_VECTORS",
":",
"return",
"LowerCONCAT_VECTORS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
":",
"return",
"LowerEXTRACT_SUBVECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FrameIndex",
":",
"return",
"LowerFrameIndex",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"UDIVREM",
":",
"return",
"LowerUDIVREM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SDIVREM",
":",
"return",
"LowerSDIVREM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FCEIL",
":",
"return",
"LowerFCEIL",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FTRUNC",
":",
"return",
"LowerFTRUNC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRINT",
":",
"return",
"LowerFRINT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FNEARBYINT",
":",
"return",
"LowerFNEARBYINT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FFLOOR",
":",
"return",
"LowerFFLOOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"UINT_TO_FP",
":",
"return",
"LowerUINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"Op",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"R600",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
"ISD::SIGN_EXTEND_INREG",
"SI",
"ISD::CONCAT_VECTORS",
"ISD::EXTRACT_SUBVECTOR",
"ISD::FrameIndex",
"ISD::INTRINSIC_WO_CHAIN",
"SI",
"ISD::UDIVREM",
"ISD::SDIVREM",
"ISD::FCEIL",
"ISD::FTRUNC",
"ISD::FRINT",
"ISD::FNEARBYINT",
"ISD::FFLOOR",
"ISD::UINT_TO_FP"
] | AMDGPUISelLowering125 | LowerOperation | R600 | GPU | LLVM | 20,067 | 217 | 1 | [] |
[
"<s>",
"void",
"MSP430InstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"unsigned",
"Opc",
";",
"if",
"(",
"MSP430",
"::",
"GR16RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"MSP430",
"::",
"MOV16rr",
";",
"else",
"if",
"(",
"MSP430",
"::",
"GR8RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"MSP430",
"::",
"MOV8rr",
";",
"else",
"llvm_unreachable",
"(",
"\"Impossible reg-to-reg copy\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"MSP430",
"MSP430",
"MSP430::GR16RegClass",
"MSP430::MOV16rr",
"MSP430::GR8RegClass",
"MSP430::MOV8rr",
"\"Impossible reg-to-reg copy\""
] | MSP430InstrInfo10 | copyPhysReg | MSP430 | MPU | LLVM | 20,068 | 105 | 1 | [] |
[
"<s>",
"void",
"AMDGPUMCInstLower",
"::",
"lower",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"const",
"auto",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"S_SETPC_B64_return",
")",
"Opcode",
"=",
"AMDGPU",
"::",
"S_SETPC_B64",
";",
"else",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"SI_CALL",
")",
"{",
"OutMI",
".",
"setOpcode",
"(",
"TII",
"->",
"pseudoToMCOpcode",
"(",
"AMDGPU",
"::",
"S_SWAPPC_B64",
")",
")",
";",
"MCOperand",
"Dest",
",",
"Src",
";",
"lowerOperand",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
",",
"Dest",
")",
";",
"lowerOperand",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
",",
"Src",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"Dest",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"Src",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"SI_TCRETURN",
")",
"{",
"Opcode",
"=",
"AMDGPU",
"::",
"S_SETPC_B64",
";",
"}",
"int",
"MCOpcode",
"=",
"TII",
"->",
"pseudoToMCOpcode",
"(",
"Opcode",
")",
";",
"if",
"(",
"MCOpcode",
"==",
"-",
"1",
")",
"{",
"LLVMContext",
"&",
"C",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
")",
".",
"getContext",
"(",
")",
";",
"C",
".",
"emitError",
"(",
"\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"",
"\"a target-specific version: \"",
"+",
"Twine",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
";",
"}",
"OutMI",
".",
"setOpcode",
"(",
"MCOpcode",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
"->",
"explicit_operands",
"(",
")",
")",
"{",
"MCOperand",
"MCOp",
";",
"lowerOperand",
"(",
"MO",
",",
"MCOp",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"MCOp",
")",
";",
"}",
"}",
"</s>"
] | [
"The",
"instruction",
"is",
"lowered",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::S_SETPC_B64_return",
"AMDGPU::S_SETPC_B64",
"AMDGPU::SI_CALL",
"AMDGPU::S_SWAPPC_B64",
"0",
"1",
"AMDGPU::SI_TCRETURN",
"AMDGPU::S_SETPC_B64",
"1",
"\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"",
"\"a target-specific version: \""
] | AMDGPUMCInstLower13 | lower | AMDGPU | GPU | LLVM | 20,069 | 235 | 1 | [] |
[
"<s>",
"ARCTargetMachine",
"::",
"ARCTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Optional",
"<",
"Reloc",
"::",
"Model",
">",
"RM",
",",
"Optional",
"<",
"CodeModel",
"::",
"Model",
">",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"JIT",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"",
"\"f32:32:32-i64:32-f64:32-a:0:32-n32\"",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"getRelocModel",
"(",
"RM",
")",
",",
"getEffectiveCodeModel",
"(",
"CM",
",",
"CodeModel",
"::",
"Small",
")",
",",
"OL",
")",
",",
"TLOF",
"(",
"make_unique",
"<",
"TargetLoweringObjectFileELF",
">",
"(",
")",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"*",
"this",
")",
"{",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"ARCTargetMachine",
"ctor",
"-",
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"ARC",
"ARC",
"ARC",
"\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"",
"\"f32:32:32-i64:32-f64:32-a:0:32-n32\""
] | ARCTargetMachine1 | ARCTargetMachine | ARC | MPU | LLVM | 20,070 | 109 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"produceSameValue",
"(",
"const",
"MachineInstr",
"*",
"MI0",
",",
"const",
"MachineInstr",
"*",
"MI1",
")",
"const",
"{",
"int",
"Opcode",
"=",
"MI0",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"ARM",
"::",
"t2LDRpci",
"||",
"Opcode",
"==",
"ARM",
"::",
"t2LDRpci_pic",
"||",
"Opcode",
"==",
"ARM",
"::",
"tLDRpci",
"||",
"Opcode",
"==",
"ARM",
"::",
"tLDRpci_pic",
")",
"{",
"if",
"(",
"MI1",
"->",
"getOpcode",
"(",
")",
"!=",
"Opcode",
")",
"return",
"false",
";",
"if",
"(",
"MI0",
"->",
"getNumOperands",
"(",
")",
"!=",
"MI1",
"->",
"getNumOperands",
"(",
")",
")",
"return",
"false",
";",
"const",
"MachineOperand",
"&",
"MO0",
"=",
"MI0",
"->",
"getOperand",
"(",
"1",
")",
";",
"const",
"MachineOperand",
"&",
"MO1",
"=",
"MI1",
"->",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"MO0",
".",
"getOffset",
"(",
")",
"!=",
"MO1",
".",
"getOffset",
"(",
")",
")",
"return",
"false",
";",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MI0",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"MachineConstantPool",
"*",
"MCP",
"=",
"MF",
"->",
"getConstantPool",
"(",
")",
";",
"int",
"CPI0",
"=",
"MO0",
".",
"getIndex",
"(",
")",
";",
"int",
"CPI1",
"=",
"MO1",
".",
"getIndex",
"(",
")",
";",
"const",
"MachineConstantPoolEntry",
"&",
"MCPE0",
"=",
"MCP",
"->",
"getConstants",
"(",
")",
"[",
"CPI0",
"]",
";",
"const",
"MachineConstantPoolEntry",
"&",
"MCPE1",
"=",
"MCP",
"->",
"getConstants",
"(",
")",
"[",
"CPI1",
"]",
";",
"ARMConstantPoolValue",
"*",
"ACPV0",
"=",
"static_cast",
"<",
"ARMConstantPoolValue",
"*",
">",
"(",
"MCPE0",
".",
"Val",
".",
"MachineCPVal",
")",
";",
"ARMConstantPoolValue",
"*",
"ACPV1",
"=",
"static_cast",
"<",
"ARMConstantPoolValue",
"*",
">",
"(",
"MCPE1",
".",
"Val",
".",
"MachineCPVal",
")",
";",
"return",
"ACPV0",
"->",
"hasSameValue",
"(",
"ACPV1",
")",
";",
"}",
"return",
"MI0",
"->",
"isIdenticalTo",
"(",
"MI1",
",",
"MachineInstr",
"::",
"IgnoreVRegDefs",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"two",
"machine",
"instructions",
"would",
"produce",
"identical",
"values",
"."
] | [
"ARM",
"ARM",
"ARM::t2LDRpci",
"ARM::t2LDRpci_pic",
"ARM::tLDRpci",
"ARM::tLDRpci_pic",
"1",
"1",
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMBaseInstrInfo114 | produceSameValue | ARM | CPU | LLVM | 20,071 | 252 | 1 | [] |
[
"<s>",
"int",
"aarch64_simd_attr_length_rglist",
"(",
"enum",
"machine_mode",
"mode",
")",
"{",
"return",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"/",
"UNITS_PER_VREG",
")",
"*",
"4",
";",
"}",
"</s>"
] | [
"Compute",
"and",
"return",
"the",
"length",
"of",
"aarch64_simd_reglist",
"<",
"mode",
">",
",",
"where",
"<",
"mode",
">",
"is",
"one",
"of",
"VSTRUCT",
"modes",
":",
"OI",
",",
"CI",
",",
"EI",
",",
"or",
"XI",
"."
] | [
"aarch64",
"4"
] | aarch642 | aarch64_simd_attr_length_rglist | aarch64 | CPU | GCC | 20,072 | 21 | 1 | [] |
[
"<s>",
"void",
"or1k_expand_eh_return",
"(",
"rtx",
"eh_addr",
")",
"{",
"rtx",
"lraddr",
";",
"lraddr",
"=",
"gen_frame_mem",
"(",
"Pmode",
",",
"plus_constant",
"(",
"Pmode",
",",
"arg_pointer_rtx",
",",
"-",
"UNITS_PER_WORD",
")",
")",
";",
"MEM_VOLATILE_P",
"(",
"lraddr",
")",
"=",
"true",
";",
"emit_move_insn",
"(",
"lraddr",
",",
"eh_addr",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"``",
"eh_return",
"''",
"pattern",
".",
"Used",
"for",
"defining",
"__builtin_eh_return",
",",
"this",
"will",
"emit",
"RTX",
"to",
"override",
"the",
"current",
"function",
"'s",
"return",
"address",
"stored",
"on",
"the",
"stack",
".",
"The",
"emitted",
"RTX",
"is",
"inserted",
"before",
"the",
"epilogue",
"so",
"we",
"ca",
"n't",
"just",
"update",
"the",
"link",
"register",
".",
"This",
"is",
"used",
"when",
"handling",
"exceptions",
"to",
"jump",
"into",
"the",
"exception",
"handler",
"catch",
"block",
"upon",
"return",
"from",
"_Unwind_RaiseException",
"."
] | [
"or1k"
] | or1k | or1k_expand_eh_return | or1k | CPU | GCC | 20,073 | 42 | 1 | [] |
[
"<s>",
"SDValue",
"JVMTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"return",
"SDValue",
"(",
"N",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"JVM",
"JVM",
"0"
] | JVMISelLowering | PerformDAGCombine | JVM | Virtual ISA | LLVM | 20,074 | 24 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_init_builtins",
"(",
"void",
")",
"{",
"(",
"nvptx_builtin_decls",
"[",
"NVPTX_BUILTIN_",
"##",
"ID",
"]",
"\\",
"=",
"add_builtin_function",
"(",
"\"__builtin_nvptx_\"",
"NAME",
",",
"\\",
"build_function_type_list",
"T",
",",
"\\",
"NVPTX_BUILTIN_",
"##",
"ID",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL",
")",
")",
"DEF",
"(",
"SHUFFLE",
",",
"\"shuffle\"",
",",
"(",
"UINT",
",",
"UINT",
",",
"UINT",
",",
"UINT",
",",
"NULL_TREE",
")",
")",
";",
"DEF",
"(",
"SHUFFLELL",
",",
"\"shufflell\"",
",",
"(",
"LLUINT",
",",
"LLUINT",
",",
"UINT",
",",
"UINT",
",",
"NULL_TREE",
")",
")",
";",
"DEF",
"(",
"WORKER_ADDR",
",",
"\"worker_addr\"",
",",
"(",
"PTRVOID",
",",
"ST",
",",
"UINT",
",",
"UINT",
",",
"NULL_TREE",
")",
")",
";",
"DEF",
"(",
"CMP_SWAP",
",",
"\"cmp_swap\"",
",",
"(",
"UINT",
",",
"PTRVOID",
",",
"UINT",
",",
"UINT",
",",
"NULL_TREE",
")",
")",
";",
"DEF",
"(",
"CMP_SWAPLL",
",",
"\"cmp_swapll\"",
",",
"(",
"LLUINT",
",",
"PTRVOID",
",",
"LLUINT",
",",
"LLUINT",
",",
"NULL_TREE",
")",
")",
";",
"}",
"</s>"
] | [
"Set",
"up",
"all",
"builtin",
"functions",
"for",
"this",
"target",
"."
] | [
"nvptx",
"\"__builtin_nvptx_\"",
"\"shuffle\"",
"\"shufflell\"",
"\"worker_addr\"",
"\"cmp_swap\"",
"\"cmp_swapll\""
] | nvptx3 | nvptx_init_builtins | nvptx | GPU | GCC | 20,075 | 133 | 1 | [] |
[
"<s>",
"static",
"void",
"mmix_asm_trampoline_template",
"(",
"FILE",
"*",
"stream",
")",
"{",
"fprintf",
"(",
"stream",
",",
"\"\\tGETA $255,1F\\n\\t\"",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"LDOU %s,$255,0\\n\\t\"",
",",
"reg_names",
"[",
"MMIX_STATIC_CHAIN_REGNUM",
"]",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"LDOU $255,$255,8\\n\\t\"",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"GO $255,$255,0\\n\"",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"1H\\tOCTA 0\\n\\t\"",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"OCTA 0\\n\"",
")",
";",
"}",
"</s>"
] | [
"TARGET_ASM_TRAMPOLINE_TEMPLATE",
"."
] | [
"mmix",
"\"\\tGETA $255,1F\\n\\t\"",
"\"LDOU %s,$255,0\\n\\t\"",
"\"LDOU $255,$255,8\\n\\t\"",
"\"GO $255,$255,0\\n\"",
"\"1H\\tOCTA 0\\n\\t\"",
"\"OCTA 0\\n\""
] | mmix | mmix_asm_trampoline_template | mmix | CPU | GCC | 20,076 | 57 | 1 | [] |
[
"<s>",
"static",
"void",
"process_args",
"(",
"int",
"argc",
",",
"char",
"*",
"*",
"argv",
")",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"argc",
";",
"i",
"++",
")",
"{",
"if",
"(",
"startswith",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-L\"",
")",
")",
"{",
"search_dirs",
"=",
"XRESIZEVEC",
"(",
"const",
"char",
"*",
",",
"search_dirs",
",",
"search_dirs_len",
"+",
"1",
")",
";",
"search_dirs",
"[",
"search_dirs_len",
"++",
"]",
"=",
"&",
"argv",
"[",
"i",
"]",
"[",
"2",
"]",
";",
"}",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-v\"",
")",
"==",
"0",
")",
"verbose",
"++",
";",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"--version\"",
")",
"==",
"0",
")",
"{",
"fprintf",
"(",
"stdout",
",",
"\"VMS Linker\\n\"",
")",
";",
"exit",
"(",
"EXIT_SUCCESS",
")",
";",
"}",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"--help\"",
")",
"==",
"0",
")",
"{",
"fprintf",
"(",
"stdout",
",",
"\"VMS Linker\\n\"",
")",
";",
"exit",
"(",
"EXIT_SUCCESS",
")",
";",
"}",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-g0\"",
")",
"==",
"0",
")",
"addarg",
"(",
"\"/notraceback\"",
")",
";",
"else",
"if",
"(",
"startswith",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-g\"",
")",
")",
"{",
"addarg",
"(",
"\"/debug\"",
")",
";",
"debug",
"=",
"1",
";",
"}",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-static\"",
")",
"==",
"0",
")",
"staticp",
"=",
"1",
";",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-map\"",
")",
"==",
"0",
")",
"{",
"char",
"*",
"buff",
",",
"*",
"ptr",
";",
"buff",
"=",
"(",
"char",
"*",
")",
"xstrdup",
"(",
"exefullfilename",
")",
";",
"ptr",
"=",
"strrchr",
"(",
"buff",
",",
"'.'",
")",
";",
"if",
"(",
"ptr",
")",
"*",
"ptr",
"=",
"0",
";",
"strcat",
"(",
"buff",
",",
"\".map\"",
")",
";",
"addarg",
"(",
"\"/map=\"",
")",
";",
"addarg",
"(",
"buff",
")",
";",
"addarg",
"(",
"\".map\"",
")",
";",
"addarg",
"(",
"\"/full\"",
")",
";",
"free",
"(",
"buff",
")",
";",
"}",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-save-temps\"",
")",
"==",
"0",
")",
"save_temps",
"=",
"1",
";",
"else",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"--noinhibit-exec\"",
")",
"==",
"0",
")",
"inhibit_exec",
"=",
"0",
";",
"}",
"}",
"</s>"
] | [
"Preprocess",
"the",
"number",
"of",
"args",
"ARGC",
"in",
"ARGV",
".",
"Look",
"for",
"special",
"flags",
",",
"etc",
".",
"that",
"must",
"be",
"handled",
"for",
"the",
"VMS",
"linker",
"."
] | [
"vms",
"1",
"\"-L\"",
"1",
"2",
"\"-v\"",
"0",
"\"--version\"",
"0",
"\"VMS Linker\\n\"",
"\"--help\"",
"0",
"\"VMS Linker\\n\"",
"\"-g0\"",
"0",
"\"/notraceback\"",
"\"-g\"",
"\"/debug\"",
"1",
"\"-static\"",
"0",
"1",
"\"-map\"",
"0",
"0",
"\".map\"",
"\"/map=\"",
"\".map\"",
"\"/full\"",
"\"-save-temps\"",
"0",
"1",
"\"--noinhibit-exec\"",
"0",
"0"
] | vms-ld2 | process_args | vms | Virtual ISA | GCC | 20,077 | 338 | 1 | [] |
[
"<s>",
"int",
"ARMBaseInstrInfo",
"::",
"getInstrLatency",
"(",
"const",
"InstrItineraryData",
"*",
"ItinData",
",",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"*",
"PredCost",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"isCopyLike",
"(",
")",
"||",
"MI",
"->",
"isInsertSubreg",
"(",
")",
"||",
"MI",
"->",
"isRegSequence",
"(",
")",
"||",
"MI",
"->",
"isImplicitDef",
"(",
")",
")",
"return",
"1",
";",
"if",
"(",
"!",
"ItinData",
"||",
"ItinData",
"->",
"isEmpty",
"(",
")",
")",
"return",
"1",
";",
"if",
"(",
"MI",
"->",
"isBundle",
"(",
")",
")",
"{",
"int",
"Latency",
"=",
"0",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"I",
"=",
"MI",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"E",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"instr_end",
"(",
")",
";",
"while",
"(",
"++",
"I",
"!=",
"E",
"&&",
"I",
"->",
"isInsideBundle",
"(",
")",
")",
"{",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"!=",
"ARM",
"::",
"t2IT",
")",
"Latency",
"+=",
"getInstrLatency",
"(",
"ItinData",
",",
"I",
",",
"PredCost",
")",
";",
"}",
"return",
"Latency",
";",
"}",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"unsigned",
"Class",
"=",
"MCID",
".",
"getSchedClass",
"(",
")",
";",
"unsigned",
"UOps",
"=",
"ItinData",
"->",
"Itineraries",
"[",
"Class",
"]",
".",
"NumMicroOps",
";",
"if",
"(",
"PredCost",
"&&",
"MCID",
".",
"hasImplicitDefOfPhysReg",
"(",
"ARM",
"::",
"CPSR",
")",
")",
"*",
"PredCost",
"=",
"1",
";",
"if",
"(",
"UOps",
")",
"return",
"ItinData",
"->",
"getStageLatency",
"(",
"Class",
")",
";",
"return",
"getNumMicroOps",
"(",
"ItinData",
",",
"MI",
")",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"instruction",
"latency",
"of",
"a",
"given",
"instruction",
"."
] | [
"ARM",
"ARM",
"1",
"1",
"0",
"ARM::t2IT",
"ARM::CPSR",
"1"
] | ARMBaseInstrInfo83 | getInstrLatency | ARM | CPU | LLVM | 20,078 | 213 | 1 | [] |
[
"<s>",
"void",
"AArch64RegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
"&&",
"\"Unexpected\"",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"AArch64InstrInfo",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"AArch64FrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"FrameReg",
";",
"int",
"Offset",
";",
"if",
"(",
"MI",
".",
"isDebugValue",
"(",
")",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"STACKMAP",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"PATCHPOINT",
")",
"{",
"Offset",
"=",
"TFI",
"->",
"resolveFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"FrameReg",
",",
"true",
",",
"false",
")",
";",
"Offset",
"+=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"getImm",
"(",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"FrameReg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"LOCAL_ESCAPE",
")",
"{",
"MachineOperand",
"&",
"FI",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
";",
"Offset",
"=",
"TFI",
"->",
"getNonLocalFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
")",
";",
"FI",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"Offset",
"=",
"TFI",
"->",
"resolveFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"FrameReg",
",",
"false",
",",
"true",
")",
";",
"if",
"(",
"rewriteAArch64FrameIndex",
"(",
"MI",
",",
"FIOperandNum",
",",
"FrameReg",
",",
"Offset",
",",
"TII",
")",
")",
"return",
";",
"assert",
"(",
"(",
"!",
"RS",
"||",
"!",
"RS",
"->",
"isScavengingFrameIndex",
"(",
"FrameIndex",
")",
")",
"&&",
"\"Emergency spill slot is out of reach\"",
")",
";",
"unsigned",
"ScratchReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"&",
"AArch64",
"::",
"GPR64RegClass",
")",
";",
"emitFrameOffset",
"(",
"MBB",
",",
"II",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"ScratchReg",
",",
"FrameReg",
",",
"Offset",
",",
"TII",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"ScratchReg",
",",
"false",
",",
"false",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"AArch64",
"AArch64",
"0",
"\"Unexpected\"",
"AArch64",
"AArch64",
"AArch64",
"1",
"1",
"AArch64",
"\"Emergency spill slot is out of reach\"",
"AArch64::GPR64RegClass"
] | AArch64RegisterInfo14 | eliminateFrameIndex | AArch64 | CPU | LLVM | 20,079 | 354 | 1 | [] |
[
"<s>",
"void",
"F2003fMCAsmStreamer",
"::",
"emitFill",
"(",
"const",
"MCExpr",
"&",
"NumValues",
",",
"int64_t",
"Size",
",",
"int64_t",
"Expr",
",",
"SMLoc",
"Loc",
")",
"{",
"llvm_unreachable",
"(",
"\"2003lk doesn't support this directive\"",
")",
";",
"}",
"</s>"
] | [
"Emit",
"Size",
"bytes",
"worth",
"of",
"the",
"value",
"specified",
"by",
"FillValue",
"."
] | [
"F2003f",
"F2003f",
"\"2003lk doesn't support this directive\""
] | F2003fMCAsmStreamer | emitFill | F2003f | CPU | LLVM | 20,080 | 26 | 1 | [] |
[
"<s>",
"void",
"NVPTXPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"disablePass",
"(",
"&",
"PrologEpilogCodeInserterID",
")",
";",
"disablePass",
"(",
"&",
"MachineCopyPropagationID",
")",
";",
"disablePass",
"(",
"&",
"TailDuplicateID",
")",
";",
"disablePass",
"(",
"&",
"StackMapLivenessID",
")",
";",
"disablePass",
"(",
"&",
"LiveDebugValuesID",
")",
";",
"disablePass",
"(",
"&",
"PostRAMachineSinkingID",
")",
";",
"disablePass",
"(",
"&",
"PostRASchedulerID",
")",
";",
"disablePass",
"(",
"&",
"FuncletLayoutID",
")",
";",
"disablePass",
"(",
"&",
"PatchableFunctionID",
")",
";",
"disablePass",
"(",
"&",
"ShrinkWrapID",
")",
";",
"addPass",
"(",
"createNVVMReflectPass",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createNVPTXImageOptimizerPass",
"(",
")",
")",
";",
"addPass",
"(",
"createNVPTXAssignValidGlobalNamesPass",
"(",
")",
")",
";",
"addPass",
"(",
"createGenericToNVVMPass",
"(",
")",
")",
";",
"addPass",
"(",
"createNVPTXLowerArgsPass",
"(",
"&",
"getNVPTXTargetMachine",
"(",
")",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addAddressSpaceInferencePasses",
"(",
")",
";",
"if",
"(",
"!",
"DisableLoadStoreVectorizer",
")",
"addPass",
"(",
"createLoadStoreVectorizerPass",
"(",
")",
")",
";",
"addStraightLineScalarOptimizationPasses",
"(",
")",
";",
"}",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addEarlyCSEOrGVNPass",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX"
] | NVPTXTargetMachine44 | addIRPasses | NVPTX | GPU | LLVM | 20,081 | 169 | 1 | [] |
[
"<s>",
"static",
"FunctionType",
"*",
"getType",
"(",
"LLVMContext",
"&",
"Context",
",",
"unsigned",
"id",
")",
"{",
"Type",
"*",
"ResultTy",
"=",
"NULL",
";",
"std",
"::",
"vector",
"<",
"Type",
"*",
">",
"ArgTys",
";",
"bool",
"IsVarArg",
"=",
"false",
";",
"return",
"FunctionType",
"::",
"get",
"(",
"ResultTy",
",",
"ArgTys",
",",
"IsVarArg",
")",
";",
"}",
"</s>"
] | [
"Overload",
"to",
"return",
"most",
"specific",
"vector",
"type",
"."
] | [
"MBlaze"
] | MBlazeIntrinsicInfo8 | getType | MBlaze | MPU | LLVM | 20,082 | 46 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_chunkify_cancel",
"(",
"struct",
"constant_pool",
"*",
"pool_list",
")",
"{",
"struct",
"constant_pool",
"*",
"curr_pool",
"=",
"NULL",
";",
"rtx",
"insn",
";",
"for",
"(",
"curr_pool",
"=",
"pool_list",
";",
"curr_pool",
";",
"curr_pool",
"=",
"curr_pool",
"->",
"next",
")",
"{",
"rtx",
"barrier",
"=",
"PREV_INSN",
"(",
"curr_pool",
"->",
"pool_insn",
")",
";",
"rtx",
"jump",
"=",
"barrier",
"?",
"PREV_INSN",
"(",
"barrier",
")",
":",
"NULL_RTX",
";",
"rtx",
"label",
"=",
"NEXT_INSN",
"(",
"curr_pool",
"->",
"pool_insn",
")",
";",
"if",
"(",
"jump",
"&&",
"GET_CODE",
"(",
"jump",
")",
"==",
"JUMP_INSN",
"&&",
"barrier",
"&&",
"GET_CODE",
"(",
"barrier",
")",
"==",
"BARRIER",
"&&",
"label",
"&&",
"GET_CODE",
"(",
"label",
")",
"==",
"CODE_LABEL",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"jump",
")",
")",
"==",
"SET",
"&&",
"SET_DEST",
"(",
"PATTERN",
"(",
"jump",
")",
")",
"==",
"pc_rtx",
"&&",
"GET_CODE",
"(",
"SET_SRC",
"(",
"PATTERN",
"(",
"jump",
")",
")",
")",
"==",
"LABEL_REF",
"&&",
"XEXP",
"(",
"SET_SRC",
"(",
"PATTERN",
"(",
"jump",
")",
")",
",",
"0",
")",
"==",
"label",
")",
"{",
"remove_insn",
"(",
"jump",
")",
";",
"remove_insn",
"(",
"barrier",
")",
";",
"remove_insn",
"(",
"label",
")",
";",
"}",
"remove_insn",
"(",
"curr_pool",
"->",
"pool_insn",
")",
";",
"}",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
")",
"{",
"rtx",
"next_insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"INSN",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"SET",
"&&",
"GET_CODE",
"(",
"SET_SRC",
"(",
"PATTERN",
"(",
"insn",
")",
")",
")",
"==",
"UNSPEC",
"&&",
"XINT",
"(",
"SET_SRC",
"(",
"PATTERN",
"(",
"insn",
")",
")",
",",
"1",
")",
"==",
"UNSPEC_RELOAD_BASE",
")",
"remove_insn",
"(",
"insn",
")",
";",
"insn",
"=",
"next_insn",
";",
"}",
"while",
"(",
"pool_list",
")",
"{",
"struct",
"constant_pool",
"*",
"next",
"=",
"pool_list",
"->",
"next",
";",
"s390_free_pool",
"(",
"pool_list",
")",
";",
"pool_list",
"=",
"next",
";",
"}",
"}",
"</s>"
] | [
"POOL_LIST",
"is",
"a",
"chunk",
"list",
"as",
"prepared",
"by",
"s390_chunkify_start",
".",
"We",
"have",
"decided",
"we",
"can",
"not",
"use",
"this",
"list",
",",
"so",
"revert",
"all",
"changes",
"to",
"the",
"current",
"function",
"that",
"were",
"done",
"by",
"s390_chunkify_start",
"."
] | [
"s390",
"0",
"1"
] | s3903 | s390_chunkify_cancel | s390 | MPU | GCC | 20,083 | 271 | 1 | [] |
[
"<s>",
"llvm",
"::",
"FastISel",
"*",
"ARM",
"::",
"createFastISel",
"(",
"FunctionLoweringInfo",
"&",
"funcInfo",
")",
"{",
"const",
"TargetMachine",
"&",
"TM",
"=",
"funcInfo",
".",
"MF",
"->",
"getTarget",
"(",
")",
";",
"const",
"ARMSubtarget",
"*",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetIOS",
"(",
")",
"&&",
"!",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
"&&",
"!",
"DisableARMFastISel",
")",
"return",
"new",
"ARMFastISel",
"(",
"funcInfo",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"This",
"method",
"returns",
"a",
"target",
"specific",
"FastISel",
"object",
",",
"or",
"null",
"if",
"the",
"target",
"does",
"not",
"support",
"``",
"fast",
"''",
"ISel",
"."
] | [
"ARM",
"ARM::createFastISel",
"ARM",
"ARM",
"ARM",
"ARM",
"0"
] | ARMFastISel56 | createFastISel | ARM | CPU | LLVM | 20,084 | 70 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"LLT",
"Ty",
",",
"unsigned",
"AddrSpace",
",",
"unsigned",
"Align",
",",
"MachineMemOperand",
"::",
"Flags",
"Flags",
",",
"bool",
"*",
"Fast",
")",
"const",
"{",
"if",
"(",
"Subtarget",
"->",
"requiresStrictAlign",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Fast",
")",
"{",
"*",
"Fast",
"=",
"!",
"Subtarget",
"->",
"isMisaligned128StoreSlow",
"(",
")",
"||",
"Ty",
".",
"getSizeInBytes",
"(",
")",
"!=",
"16",
"||",
"Align",
"<=",
"2",
"||",
"Ty",
"==",
"LLT",
"::",
"vector",
"(",
"2",
",",
"64",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"AArch64",
"AArch64",
"16",
"2",
"2",
"64"
] | AArch64ISelLowering (2)3 | allowsMisalignedMemoryAccesses | AArch64 | CPU | LLVM | 20,085 | 79 | 1 | [] |
[
"<s>",
"bool",
"RISCVFrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"RISCV",
"RISCV"
] | RISCVFrameLowering24 | hasFP | RISCV | CPU | LLVM | 20,086 | 16 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"decomposeMulByConstant",
"(",
"EVT",
"VT",
",",
"SDValue",
"C",
")",
"const",
"{",
"APInt",
"MulC",
";",
"if",
"(",
"!",
"ISD",
"::",
"isConstantSplatVector",
"(",
"C",
".",
"getNode",
"(",
")",
",",
"MulC",
")",
")",
"return",
"false",
";",
"if",
"(",
"isOperationLegal",
"(",
"ISD",
"::",
"MUL",
",",
"VT",
")",
")",
"return",
"false",
";",
"return",
"(",
"MulC",
"+",
"1",
")",
".",
"isPowerOf2",
"(",
")",
"||",
"(",
"MulC",
"-",
"1",
")",
".",
"isPowerOf2",
"(",
")",
"||",
"(",
"1",
"-",
"MulC",
")",
".",
"isPowerOf2",
"(",
")",
"||",
"(",
"-",
"(",
"MulC",
"+",
"1",
")",
")",
".",
"isPowerOf2",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"profitable",
"to",
"transform",
"an",
"integer",
"multiplication-by-constant",
"into",
"simpler",
"operations",
"like",
"shifts",
"and",
"adds",
"."
] | [
"X86",
"X86",
"ISD::isConstantSplatVector",
"ISD::MUL",
"1",
"1",
"1",
"1"
] | X86ISelLowering (2)8 | decomposeMulByConstant | X86 | CPU | LLVM | 20,087 | 94 | 1 | [] |
[
"<s>",
"void",
"VEDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"N",
")",
"{",
"SDLoc",
"dl",
"(",
"N",
")",
";",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"N",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
";",
"}",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"VEISD",
"::",
"GLOBAL_BASE_REG",
":",
"ReplaceNode",
"(",
"N",
",",
"getGlobalBaseReg",
"(",
")",
")",
";",
"return",
";",
"}",
"SelectCode",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"VE",
"VE",
"1",
"VEISD::GLOBAL_BASE_REG"
] | VEISelDAGToDAG | Select | VE | CPU | LLVM | 20,088 | 68 | 1 | [] |
[
"<s>",
"bool",
"requiresRegisterScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"(",
"and",
"can",
"make",
"use",
"of",
")",
"the",
"register",
"scavenger",
"."
] | [
"RV16K"
] | RV16KRegisterInfo | requiresRegisterScavenging | RV16K | Virtual ISA | LLVM | 20,089 | 15 | 1 | [] |
[
"<s>",
"bool",
"MVEVPTOptimisations",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"Fn",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"!",
"STI",
".",
"isThumb2",
"(",
")",
"||",
"!",
"STI",
".",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"false",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"Thumb2InstrInfo",
"*",
">",
"(",
"STI",
".",
"getInstrInfo",
"(",
")",
")",
";",
"MRI",
"=",
"&",
"Fn",
".",
"getRegInfo",
"(",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** ARM MVE VPT Optimisations **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"Fn",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"Fn",
")",
"Modified",
"|=",
"ReplaceVCMPsByVPNOTs",
"(",
"MBB",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"**************************************\\n\"",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"\"********** ARM MVE VPT Optimisations **********\\n\"",
"\"********** Function: \"",
"\"**************************************\\n\""
] | MVEVPTOptimisationsPass3 | runOnMachineFunction | ARM | CPU | LLVM | 20,090 | 125 | 1 | [] |
[
"<s>",
"bool",
"OR1KDAGToDAGISel",
"::",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"unsigned",
"ConstraintID",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"{",
"SDValue",
"Op0",
",",
"Op1",
";",
"switch",
"(",
"ConstraintID",
")",
"{",
"default",
":",
"return",
"true",
";",
"case",
"InlineAsm",
"::",
"Constraint_m",
":",
"if",
"(",
"!",
"SelectAddr",
"(",
"Op",
",",
"Op0",
",",
"Op1",
")",
")",
"return",
"true",
";",
"break",
";",
"}",
"OutOps",
".",
"push_back",
"(",
"Op0",
")",
";",
"OutOps",
".",
"push_back",
"(",
"Op1",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"OR1K",
"OR1K"
] | OR1KISelDAGToDAG1 | SelectInlineAsmMemoryOperand | OR1K | CPU | LLVM | 20,091 | 79 | 1 | [] |
[
"<s>",
"bool",
"AArch64FrameLowering",
"::",
"canUseRedZone",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"!",
"EnableRedZone",
")",
"return",
"false",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getAttributes",
"(",
")",
".",
"hasAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"Attribute",
"::",
"NoRedZone",
")",
")",
"return",
"false",
";",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"AArch64FunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"AArch64FunctionInfo",
">",
"(",
")",
";",
"unsigned",
"NumBytes",
"=",
"AFI",
"->",
"getLocalStackSize",
"(",
")",
";",
"if",
"(",
"MFI",
"->",
"hasCalls",
"(",
")",
"||",
"hasFP",
"(",
"MF",
")",
"||",
"NumBytes",
">",
"128",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Can",
"this",
"function",
"use",
"the",
"red",
"zone",
"for",
"local",
"allocations",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"128"
] | AArch64FrameLowering34 | canUseRedZone | AArch64 | CPU | LLVM | 20,092 | 104 | 1 | [] |
[
"<s>",
"int",
"csky_register_move_cost",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"reg_class_t",
"from",
",",
"reg_class_t",
"to",
")",
"{",
"(",
"(",
"CLASS",
")",
"==",
"GENERAL_REGS",
"||",
"(",
"CLASS",
")",
"==",
"MINI_REGS",
"||",
"(",
"CLASS",
")",
"==",
"SP_REGS",
"\\",
"||",
"(",
"CLASS",
")",
"==",
"LOW_REGS",
")",
"(",
"(",
"CLASS",
")",
"==",
"HILO_REGS",
")",
"(",
"(",
"CLASS",
")",
"==",
"V_REGS",
")",
"if",
"(",
"V_REG_CLASS_P",
"(",
"from",
")",
"&&",
"V_REG_CLASS_P",
"(",
"to",
")",
")",
"return",
"2",
";",
"if",
"(",
"(",
"V_REG_CLASS_P",
"(",
"from",
")",
"&&",
"GR_REG_CLASS_P",
"(",
"to",
")",
")",
"||",
"(",
"GR_REG_CLASS_P",
"(",
"from",
")",
"&&",
"V_REG_CLASS_P",
"(",
"to",
")",
")",
")",
"return",
"6",
";",
"if",
"(",
"(",
"HILO_REG_CLASS_P",
"(",
"from",
")",
"&&",
"GR_REG_CLASS_P",
"(",
"to",
")",
")",
"||",
"(",
"GR_REG_CLASS_P",
"(",
"from",
")",
"&&",
"HILO_REG_CLASS_P",
"(",
"to",
")",
")",
")",
"return",
"16",
";",
"if",
"(",
"HILO_REG_CLASS_P",
"(",
"from",
")",
"&&",
"HILO_REG_CLASS_P",
"(",
"to",
")",
")",
"return",
"32",
";",
"if",
"(",
"(",
"HILO_REG_CLASS_P",
"(",
"from",
")",
"&&",
"V_REG_CLASS_P",
"(",
"to",
")",
")",
"||",
"(",
"V_REG_CLASS_P",
"(",
"from",
")",
"&&",
"HILO_REG_CLASS_P",
"(",
"to",
")",
")",
")",
"return",
"64",
";",
"return",
"2",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_REGISTER_MOVE_COST",
":",
"compute",
"extra",
"cost",
"of",
"moving",
"data",
"between",
"one",
"register",
"class",
"and",
"another",
"."
] | [
"csky",
"2",
"6",
"16",
"32",
"64",
"2"
] | csky | csky_register_move_cost | csky | CPU | GCC | 20,093 | 175 | 1 | [] |
[
"<s>",
"void",
"Z80AsmPrinter",
"::",
"emitInlineAsmEnd",
"(",
"const",
"MCSubtargetInfo",
"&",
"StartInfo",
",",
"const",
"MCSubtargetInfo",
"*",
"EndInfo",
")",
"const",
"{",
"if",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
".",
"getArch",
"(",
")",
"!=",
"Triple",
"::",
"ez80",
")",
"return",
";",
"bool",
"Was16",
"=",
"isCode16",
"(",
"StartInfo",
".",
"getTargetTriple",
"(",
")",
")",
";",
"if",
"(",
"!",
"EndInfo",
"||",
"Was16",
"!=",
"isCode16",
"(",
"EndInfo",
"->",
"getTargetTriple",
"(",
")",
")",
")",
"OutStreamer",
"->",
"EmitAssemblerFlag",
"(",
"Was16",
"?",
"MCAF_Code16",
":",
"MCAF_Code24",
")",
";",
"}",
"</s>"
] | [
"Let",
"the",
"target",
"do",
"anything",
"it",
"needs",
"to",
"do",
"after",
"emitting",
"inlineasm",
"."
] | [
"Z80",
"Z80"
] | Z80AsmPrinter2 | emitInlineAsmEnd | Z80 | MPU | LLVM | 20,094 | 75 | 1 | [] |
[
"<s>",
"bool",
"SystemZMCAsmBackend",
"::",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCRelaxableFragment",
"*",
"Fragment",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"{",
"Value",
"=",
"extractBitsForFixup",
"(",
"Fixup",
".",
"getKind",
"(",
")",
",",
"Value",
")",
";",
"return",
"(",
"int16_t",
")",
"Value",
"!=",
"(",
"int64_t",
")",
"Value",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZMCAsmBackend28 | fixupNeedsRelaxation | SystemZ | CPU | LLVM | 20,095 | 50 | 1 | [] |
[
"<s>",
"GBSectionType",
"getType",
"(",
")",
"const",
"{",
"return",
"Type",
";",
"}",
"</s>"
] | [
"Overload",
"to",
"return",
"most",
"specific",
"vector",
"type",
"."
] | [
"GBZ80",
"GB"
] | GBZ80TargetObjectFile | getType | GBZ80 | MPU | LLVM | 20,096 | 10 | 1 | [] |
[
"<s>",
"bool",
"P2AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"bool",
"Error",
"=",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNum",
",",
"ExtraCode",
",",
"O",
")",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
";",
"if",
"(",
"Error",
"&&",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"1",
"]",
"!=",
"0",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"case",
"'#'",
":",
"if",
"(",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"!=",
"MachineOperand",
"::",
"MO_Immediate",
")",
"return",
"true",
";",
"O",
"<<",
"\"#\"",
"<<",
"MO",
".",
"getImm",
"(",
")",
";",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"Error",
")",
"printOperand",
"(",
"MI",
",",
"OpNum",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"P2",
"P2",
"0",
"1",
"0",
"0",
"\"#\""
] | P2AsmPrinter | PrintAsmOperand | P2 | MPU | LLVM | 20,097 | 135 | 1 | [] |
[
"<s>",
"char",
"*",
"output_cbranch",
"(",
"rtx",
"op",
",",
"const",
"char",
"*",
"label",
",",
"int",
"reversed",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"static",
"char",
"string",
"[",
"64",
"]",
";",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"op",
")",
";",
"rtx",
"cc_reg",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"cc_reg",
")",
";",
"int",
"cc_regno",
"=",
"REGNO",
"(",
"cc_reg",
")",
"-",
"CR0_REGNO",
";",
"int",
"need_longbranch",
"=",
"label",
"!=",
"NULL",
"&&",
"get_attr_length",
"(",
"insn",
")",
"==",
"8",
";",
"int",
"really_reversed",
"=",
"reversed",
"^",
"need_longbranch",
";",
"char",
"*",
"s",
"=",
"string",
";",
"const",
"char",
"*",
"ccode",
";",
"const",
"char",
"*",
"pred",
";",
"rtx",
"note",
";",
"validate_condition_mode",
"(",
"code",
",",
"mode",
")",
";",
"if",
"(",
"really_reversed",
")",
"{",
"if",
"(",
"mode",
"==",
"CCFPmode",
")",
"code",
"=",
"reverse_condition_maybe_unordered",
"(",
"code",
")",
";",
"else",
"code",
"=",
"reverse_condition",
"(",
"code",
")",
";",
"}",
"switch",
"(",
"code",
")",
"{",
"case",
"NE",
":",
"case",
"LTGT",
":",
"ccode",
"=",
"\"ne\"",
";",
"break",
";",
"case",
"EQ",
":",
"case",
"UNEQ",
":",
"ccode",
"=",
"\"eq\"",
";",
"break",
";",
"case",
"GE",
":",
"case",
"GEU",
":",
"ccode",
"=",
"\"ge\"",
";",
"break",
";",
"case",
"GT",
":",
"case",
"GTU",
":",
"case",
"UNGT",
":",
"ccode",
"=",
"\"gt\"",
";",
"break",
";",
"case",
"LE",
":",
"case",
"LEU",
":",
"ccode",
"=",
"\"le\"",
";",
"break",
";",
"case",
"LT",
":",
"case",
"LTU",
":",
"case",
"UNLT",
":",
"ccode",
"=",
"\"lt\"",
";",
"break",
";",
"case",
"UNORDERED",
":",
"ccode",
"=",
"\"un\"",
";",
"break",
";",
"case",
"ORDERED",
":",
"ccode",
"=",
"\"nu\"",
";",
"break",
";",
"case",
"UNGE",
":",
"ccode",
"=",
"\"nl\"",
";",
"break",
";",
"case",
"UNLE",
":",
"ccode",
"=",
"\"ng\"",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"pred",
"=",
"\"\"",
";",
"note",
"=",
"find_reg_note",
"(",
"insn",
",",
"REG_BR_PROB",
",",
"NULL_RTX",
")",
";",
"if",
"(",
"note",
"!=",
"NULL_RTX",
")",
"{",
"int",
"prob",
"=",
"profile_probability",
"::",
"from_reg_br_prob_note",
"(",
"XINT",
"(",
"note",
",",
"0",
")",
")",
".",
"to_reg_br_prob_base",
"(",
")",
"-",
"REG_BR_PROB_BASE",
"/",
"2",
";",
"if",
"(",
"rs6000_always_hint",
"||",
"(",
"abs",
"(",
"prob",
")",
">",
"REG_BR_PROB_BASE",
"/",
"100",
"*",
"48",
"&&",
"(",
"profile_status_for_fn",
"(",
"cfun",
")",
"!=",
"PROFILE_GUESSED",
")",
"&&",
"br_prob_note_reliable_p",
"(",
"note",
")",
")",
")",
"{",
"if",
"(",
"abs",
"(",
"prob",
")",
">",
"REG_BR_PROB_BASE",
"/",
"20",
"&&",
"(",
"(",
"prob",
">",
"0",
")",
"^",
"need_longbranch",
")",
")",
"pred",
"=",
"\"+\"",
";",
"else",
"pred",
"=",
"\"-\"",
";",
"}",
"}",
"if",
"(",
"label",
"==",
"NULL",
")",
"s",
"+=",
"sprintf",
"(",
"s",
",",
"\"b%slr%s \"",
",",
"ccode",
",",
"pred",
")",
";",
"else",
"s",
"+=",
"sprintf",
"(",
"s",
",",
"\"b%s%s \"",
",",
"ccode",
",",
"pred",
")",
";",
"if",
"(",
"reg_names",
"[",
"cc_regno",
"+",
"CR0_REGNO",
"]",
"[",
"0",
"]",
"==",
"'%'",
")",
"*",
"s",
"++",
"=",
"'%'",
";",
"s",
"+=",
"sprintf",
"(",
"s",
",",
"\"%s\"",
",",
"reg_names",
"[",
"cc_regno",
"+",
"CR0_REGNO",
"]",
")",
";",
"if",
"(",
"label",
"!=",
"NULL",
")",
"{",
"if",
"(",
"need_longbranch",
")",
"s",
"+=",
"sprintf",
"(",
"s",
",",
"\",$+8\\n\\tb %s\"",
",",
"label",
")",
";",
"else",
"s",
"+=",
"sprintf",
"(",
"s",
",",
"\",%s\"",
",",
"label",
")",
";",
"}",
"return",
"string",
";",
"}",
"</s>"
] | [
"Output",
"a",
"conditional",
"branch",
"to",
"LABEL",
".",
"CODE",
"is",
"the",
"comparison",
"code",
".",
"CC_MODE",
"is",
"the",
"mode",
"of",
"the",
"CC",
"register",
".",
"REVERSED",
"is",
"non-zero",
"if",
"we",
"should",
"reverse",
"the",
"sense",
"of",
"the",
"comparison",
".",
"INSN",
"is",
"the",
"instruction",
"."
] | [
"rs6000",
"64",
"0",
"8",
"\"ne\"",
"\"eq\"",
"\"ge\"",
"\"gt\"",
"\"le\"",
"\"lt\"",
"\"un\"",
"\"nu\"",
"\"nl\"",
"\"ng\"",
"\"\"",
"0",
"2",
"100",
"48",
"20",
"0",
"\"+\"",
"\"-\"",
"\"b%slr%s \"",
"\"b%s%s \"",
"0",
"\"%s\"",
"\",$+8\\n\\tb %s\"",
"\",%s\""
] | rs6000 | output_cbranch | rs6000 | CPU | GCC | 20,098 | 481 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_elf_output_toc_section_asm_op",
"(",
"const",
"void",
"*",
"data",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
"||",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
")",
"&&",
"TARGET_MINIMAL_TOC",
"&&",
"!",
"TARGET_RELOCATABLE",
")",
"{",
"if",
"(",
"!",
"toc_initialized",
")",
"{",
"toc_initialized",
"=",
"1",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"%s\\n\"",
",",
"TOC_SECTION_ASM_OP",
")",
";",
"(",
"*",
"targetm",
".",
"asm_out",
".",
"internal_label",
")",
"(",
"asm_out_file",
",",
"\"LCTOC\"",
",",
"0",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.tc \"",
")",
";",
"ASM_OUTPUT_INTERNAL_LABEL_PREFIX",
"(",
"asm_out_file",
",",
"\"LCTOC1[TC],\"",
")",
";",
"ASM_OUTPUT_INTERNAL_LABEL_PREFIX",
"(",
"asm_out_file",
",",
"\"LCTOC1\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\n\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"%s\\n\"",
",",
"MINIMAL_TOC_SECTION_ASM_OP",
")",
";",
"ASM_OUTPUT_INTERNAL_LABEL_PREFIX",
"(",
"asm_out_file",
",",
"\"LCTOC1\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\" = .+32768\\n\"",
")",
";",
"}",
"else",
"fprintf",
"(",
"asm_out_file",
",",
"\"%s\\n\"",
",",
"MINIMAL_TOC_SECTION_ASM_OP",
")",
";",
"}",
"else",
"if",
"(",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
"||",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
")",
"&&",
"!",
"TARGET_RELOCATABLE",
")",
"fprintf",
"(",
"asm_out_file",
",",
"\"%s\\n\"",
",",
"TOC_SECTION_ASM_OP",
")",
";",
"else",
"{",
"fprintf",
"(",
"asm_out_file",
",",
"\"%s\\n\"",
",",
"MINIMAL_TOC_SECTION_ASM_OP",
")",
";",
"if",
"(",
"!",
"toc_initialized",
")",
"{",
"ASM_OUTPUT_INTERNAL_LABEL_PREFIX",
"(",
"asm_out_file",
",",
"\"LCTOC1\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\" = .+32768\\n\"",
")",
";",
"toc_initialized",
"=",
"1",
";",
"}",
"}",
"}",
"</s>"
] | [
"A",
"get_unnamed_section",
"callback",
",",
"used",
"for",
"switching",
"to",
"toc_section",
"."
] | [
"rs6000",
"1",
"\"%s\\n\"",
"\"LCTOC\"",
"0",
"\"\\t.tc \"",
"\"LCTOC1[TC],\"",
"\"LCTOC1\"",
"\"\\n\"",
"\"%s\\n\"",
"\"LCTOC1\"",
"\" = .+32768\\n\"",
"\"%s\\n\"",
"\"%s\\n\"",
"\"%s\\n\"",
"\"LCTOC1\"",
"\" = .+32768\\n\"",
"1"
] | rs60004 | rs6000_elf_output_toc_section_asm_op | rs6000 | CPU | GCC | 20,099 | 190 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.