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>",
"void",
"SIInstrInfo",
"::",
"swapOperands",
"(",
"MachineBasicBlock",
"::",
"iterator",
"Inst",
")",
"const",
"{",
"assert",
"(",
"Inst",
"->",
"getNumExplicitOperands",
"(",
")",
"==",
"3",
")",
";",
"MachineOperand",
"Op1",
"=",
"Inst",
"->",
"getOperand",
"(",
"1",
")",
";",
"Inst",
"->",
"RemoveOperand",
"(",
"1",
")",
";",
"Inst",
"->",
"addOperand",
"(",
"Op1",
")",
";",
"}",
"</s>"
] | [
"Exchange",
"the",
"two",
"operands",
"to",
"this",
"instruction",
"in",
"such",
"a",
"way",
"that",
"it",
"does",
"not",
"modify",
"the",
"semantics",
"of",
"the",
"instruction",
"."
] | [
"AMDGPU",
"SI",
"3",
"1",
"1"
] | SIInstrInfo (3) | swapOperands | AMDGPU | GPU | LLVM | 16,300 | 48 | 1 | [] |
[
"<s>",
"static",
"void",
"output_btfext_header",
"(",
"void",
")",
"{",
"switch_to_section",
"(",
"btf_ext_info_section",
")",
";",
"ASM_OUTPUT_LABEL",
"(",
"asm_out_file",
",",
"btf_ext_info_section_label",
")",
";",
"dw2_asm_output_data",
"(",
"2",
",",
"BTF_MAGIC",
",",
"\"btf_magic\"",
")",
";",
"dw2_asm_output_data",
"(",
"1",
",",
"BTF_VERSION",
",",
"\"btfext_version\"",
")",
";",
"dw2_asm_output_data",
"(",
"1",
",",
"0",
",",
"\"btfext_flags\"",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"sizeof",
"(",
"struct",
"btf_ext_header",
")",
",",
"\"btfext_hdr_len\"",
")",
";",
"uint32_t",
"func_info_off",
"=",
"0",
",",
"func_info_len",
"=",
"0",
";",
"uint32_t",
"line_info_off",
"=",
"0",
",",
"line_info_len",
"=",
"0",
";",
"uint32_t",
"core_relo_off",
"=",
"0",
",",
"core_relo_len",
"=",
"0",
";",
"size_t",
"i",
";",
"bpf_core_section_ref",
"sec",
";",
"core_relo_len",
"+=",
"vec_safe_length",
"(",
"bpf_core_sections",
")",
"*",
"sizeof",
"(",
"struct",
"btf_ext_section_header",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"*",
"bpf_core_sections",
",",
"i",
",",
"sec",
")",
"core_relo_len",
"+=",
"vec_safe_length",
"(",
"sec",
"->",
"relocs",
")",
"*",
"sizeof",
"(",
"struct",
"btf_ext_reloc",
")",
";",
"if",
"(",
"core_relo_len",
")",
"core_relo_len",
"+=",
"sizeof",
"(",
"uint32_t",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"func_info_off",
",",
"\"func_info_offset\"",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"func_info_len",
",",
"\"func_info_len\"",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"line_info_off",
",",
"\"line_info_offset\"",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"line_info_len",
",",
"\"line_info_len\"",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"core_relo_off",
",",
"\"core_relo_offset\"",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"core_relo_len",
",",
"\"core_relo_len\"",
")",
";",
"}",
"</s>"
] | [
"Compute",
"and",
"output",
"the",
"header",
"of",
"a",
".BTF.ext",
"debug",
"info",
"section",
"."
] | [
"bpf",
"2",
"\"btf_magic\"",
"1",
"\"btfext_version\"",
"1",
"0",
"\"btfext_flags\"",
"4",
"\"btfext_hdr_len\"",
"0",
"0",
"0",
"0",
"0",
"0",
"4",
"\"func_info_offset\"",
"4",
"\"func_info_len\"",
"4",
"\"line_info_offset\"",
"4",
"\"line_info_len\"",
"4",
"\"core_relo_offset\"",
"4",
"\"core_relo_len\""
] | coreout | output_btfext_header | bpf | Virtual ISA | GCC | 16,301 | 195 | 1 | [] |
[
"<s>",
"const",
"uint16_t",
"*",
"Tile64RegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"static",
"const",
"uint16_t",
"CalleeSavedRegs",
"[",
"]",
"=",
"{",
"T64",
"::",
"R30",
",",
"T64",
"::",
"R31",
",",
"T64",
"::",
"R32",
",",
"T64",
"::",
"R33",
",",
"T64",
"::",
"R34",
",",
"T64",
"::",
"R35",
",",
"T64",
"::",
"R36",
",",
"T64",
"::",
"R37",
",",
"T64",
"::",
"R38",
",",
"T64",
"::",
"R39",
",",
"T64",
"::",
"R40",
",",
"T64",
"::",
"R41",
",",
"T64",
"::",
"R42",
",",
"T64",
"::",
"R43",
",",
"T64",
"::",
"R44",
",",
"T64",
"::",
"R45",
",",
"T64",
"::",
"R46",
",",
"T64",
"::",
"R47",
",",
"T64",
"::",
"R48",
",",
"T64",
"::",
"R49",
",",
"T64",
"::",
"R50",
",",
"T64",
"::",
"R51",
",",
"0",
"}",
";",
"return",
"CalleeSavedRegs",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Tile64",
"T64::R30",
"T64::R31",
"T64::R32",
"T64::R33",
"T64::R34",
"T64::R35",
"T64::R36",
"T64::R37",
"T64::R38",
"T64::R39",
"T64::R40",
"T64::R41",
"T64::R42",
"T64::R43",
"T64::R44",
"T64::R45",
"T64::R46",
"T64::R47",
"T64::R48",
"T64::R49",
"T64::R50",
"T64::R51",
"0"
] | Tile64RegisterInfo | getCalleeSavedRegs | Tile64 | VLIW | LLVM | 16,302 | 117 | 1 | [] |
[
"<s>",
"bool",
"VETargetLowering",
"::",
"CanLowerReturn",
"(",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"MachineFunction",
"&",
"MF",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"LLVMContext",
"&",
"Context",
")",
"const",
"{",
"CCAssignFn",
"*",
"RetCC",
"=",
"RetCC_VE",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"RVLocs",
",",
"Context",
")",
";",
"return",
"CCInfo",
".",
"CheckReturn",
"(",
"Outs",
",",
"RetCC",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"should",
"be",
"implemented",
"to",
"check",
"whether",
"the",
"return",
"values",
"described",
"by",
"the",
"Outs",
"array",
"can",
"fit",
"into",
"the",
"return",
"registers",
"."
] | [
"VE",
"VE",
"ISD::OutputArg",
"VE",
"16"
] | VEISelLowering | CanLowerReturn | VE | CPU | LLVM | 16,303 | 72 | 1 | [] |
[
"<s>",
"const",
"DataLayout",
"*",
"getDataLayout",
"(",
")",
"const",
"override",
"{",
"return",
"getSubtargetImpl",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"DataLayout",
"associated",
"with",
"the",
"module",
"this",
"SCEV",
"instance",
"is",
"operating",
"on",
"."
] | [
"SystemZ"
] | SystemZTargetMachine | getDataLayout | SystemZ | CPU | LLVM | 16,304 | 19 | 1 | [] |
[
"<s>",
"virtual",
"const",
"TargetRegisterInfo",
"&",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"XCore"
] | XCoreInstrInfo | getRegisterInfo | XCore | MPU | LLVM | 16,305 | 13 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"ix86_hard_regno_nregs",
"(",
"unsigned",
"int",
"regno",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"GENERAL_REGNO_P",
"(",
"regno",
")",
")",
"{",
"if",
"(",
"mode",
"==",
"XFmode",
")",
"return",
"TARGET_64BIT",
"?",
"2",
":",
"3",
";",
"if",
"(",
"mode",
"==",
"XCmode",
")",
"return",
"TARGET_64BIT",
"?",
"4",
":",
"6",
";",
"return",
"CEIL",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
",",
"UNITS_PER_WORD",
")",
";",
"}",
"if",
"(",
"COMPLEX_MODE_P",
"(",
"mode",
")",
")",
"return",
"2",
";",
"if",
"(",
"mode",
"==",
"P2QImode",
"||",
"mode",
"==",
"P2HImode",
")",
"return",
"2",
";",
"if",
"(",
"mode",
"==",
"V64SFmode",
"||",
"mode",
"==",
"V64SImode",
")",
"return",
"4",
";",
"return",
"1",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_HARD_REGNO_NREGS",
".",
"This",
"is",
"ordinarily",
"the",
"length",
"in",
"words",
"of",
"a",
"value",
"of",
"mode",
"MODE",
"but",
"can",
"be",
"less",
"for",
"certain",
"modes",
"in",
"special",
"long",
"registers",
".",
"Actually",
"there",
"are",
"no",
"two",
"word",
"move",
"instructions",
"for",
"consecutive",
"registers",
".",
"And",
"only",
"registers",
"0-3",
"may",
"have",
"mov",
"byte",
"instructions",
"applied",
"to",
"them",
"."
] | [
"i386",
"2",
"3",
"4",
"6",
"2",
"2",
"4",
"1"
] | i386 | ix86_hard_regno_nregs | i386 | CPU | GCC | 16,306 | 99 | 1 | [] |
[
"<s>",
"X86TargetMachine",
"::",
"X86TargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"TLOF",
"(",
"createTLOF",
"(",
"Triple",
"(",
"getTargetTriple",
"(",
")",
")",
")",
")",
",",
"DL",
"(",
"computeDataLayout",
"(",
"Triple",
"(",
"TT",
")",
")",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"*",
"this",
",",
"Options",
".",
"StackAlignmentOverride",
")",
"{",
"if",
"(",
"Options",
".",
"FloatABIType",
"==",
"FloatABI",
"::",
"Default",
")",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Hard",
";",
"if",
"(",
"Subtarget",
".",
"isTargetWin64",
"(",
")",
")",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"X86",
"target",
"."
] | [
"X86",
"X86",
"X86"
] | X86TargetMachine39 | X86TargetMachine | X86 | CPU | LLVM | 16,307 | 139 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isCheapToSpeculateCttz",
"(",
")",
"const",
"{",
"return",
"Subtarget",
".",
"hasStdExtZbb",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"cheap",
"to",
"speculate",
"a",
"call",
"to",
"intrinsic",
"cttz",
"."
] | [
"RISCV",
"RISCV"
] | RISCVISelLowering1 | isCheapToSpeculateCttz | RISCV | CPU | LLVM | 16,308 | 16 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmPrinter",
"::",
"lowerOperand",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"MCOperand",
"&",
"MCOp",
")",
"{",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"unknown operand type\"",
")",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"if",
"(",
"MO",
".",
"isImplicit",
"(",
")",
"&&",
"MO",
".",
"getReg",
"(",
")",
"!=",
"ARM",
"::",
"CPSR",
")",
"return",
"false",
";",
"assert",
"(",
"!",
"MO",
".",
"getSubReg",
"(",
")",
"&&",
"\"Subregs should be eliminated!\"",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateReg",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateImm",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_MachineBasicBlock",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateExpr",
"(",
"MCSymbolRefExpr",
"::",
"Create",
"(",
"MO",
".",
"getMBB",
"(",
")",
"->",
"getSymbol",
"(",
")",
",",
"OutContext",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"Mang",
"->",
"getSymbol",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetJTISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetCPISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_BlockAddress",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetBlockAddressSymbol",
"(",
"MO",
".",
"getBlockAddress",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_FPImmediate",
":",
"{",
"APFloat",
"Val",
"=",
"MO",
".",
"getFPImm",
"(",
")",
"->",
"getValueAPF",
"(",
")",
";",
"bool",
"ignored",
";",
"Val",
".",
"convert",
"(",
"APFloat",
"::",
"IEEEdouble",
",",
"APFloat",
"::",
"rmTowardZero",
",",
"&",
"ignored",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateFPImm",
"(",
"Val",
".",
"convertToDouble",
"(",
")",
")",
";",
"break",
";",
"}",
"case",
"MachineOperand",
"::",
"MO_RegisterMask",
":",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Wrapper",
"for",
"MCInstLowering.lowerOperand",
"(",
")",
"for",
"the",
"tblgen'erated",
"pseudo",
"lowering",
"."
] | [
"ARM",
"ARM",
"0",
"\"unknown operand type\"",
"ARM::CPSR",
"\"Subregs should be eliminated!\""
] | ARMMCInstLower28 | lowerOperand | ARM | CPU | LLVM | 16,309 | 324 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"F",
")",
"{",
"ARM64FI",
"=",
"F",
".",
"getInfo",
"<",
"ARM64FunctionInfo",
">",
"(",
")",
";",
"return",
"AsmPrinter",
"::",
"runOnMachineFunction",
"(",
"F",
")",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM64",
"ARM64",
"ARM64"
] | ARM64AsmPrinter | runOnMachineFunction | ARM64 | CPU | LLVM | 16,310 | 28 | 1 | [] |
[
"<s>",
"static",
"bool",
"spe_func_has_64bit_regs_p",
"(",
"void",
")",
"{",
"rtx",
"insns",
",",
"insn",
";",
"if",
"(",
"current_function_calls_eh_return",
"||",
"current_function_calls_setjmp",
"||",
"current_function_has_nonlocal_goto",
")",
"return",
"true",
";",
"insns",
"=",
"get_insns",
"(",
")",
";",
"for",
"(",
"insn",
"=",
"NEXT_INSN",
"(",
"insns",
")",
";",
"insn",
"!=",
"NULL_RTX",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"INSN_P",
"(",
"insn",
")",
")",
"{",
"rtx",
"i",
";",
"i",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"i",
")",
"==",
"SET",
")",
"{",
"enum",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"SET_SRC",
"(",
"i",
")",
")",
";",
"if",
"(",
"SPE_VECTOR_MODE",
"(",
"mode",
")",
")",
"return",
"true",
";",
"if",
"(",
"TARGET_E500_DOUBLE",
"&&",
"mode",
"==",
"DFmode",
")",
"return",
"true",
";",
"}",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"current",
"function",
"uses",
"any",
"GPRs",
"in",
"64-bit",
"SIMD",
"mode",
"."
] | [
"rs6000"
] | rs60003 | spe_func_has_64bit_regs_p | rs6000 | CPU | GCC | 16,311 | 118 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyOptimizeLiveIntervals",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** Optimize LiveIntervals **********\\n\"",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"&",
"LIS",
"=",
"getAnalysis",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"MRI",
".",
"leaveSSA",
"(",
")",
";",
"assert",
"(",
"MRI",
".",
"tracksLiveness",
"(",
")",
"&&",
"\"OptimizeLiveIntervals expects liveness\"",
")",
";",
"SmallVector",
"<",
"LiveInterval",
"*",
",",
"4",
">",
"SplitLIs",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
",",
"E",
"=",
"MRI",
".",
"getNumVirtRegs",
"(",
")",
";",
"I",
"<",
"E",
";",
"++",
"I",
")",
"{",
"unsigned",
"Reg",
"=",
"Register",
"::",
"index2VirtReg",
"(",
"I",
")",
";",
"auto",
"&",
"TRI",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"MRI",
".",
"reg_nodbg_empty",
"(",
"Reg",
")",
")",
"continue",
";",
"LIS",
".",
"splitSeparateComponents",
"(",
"LIS",
".",
"getInterval",
"(",
"Reg",
")",
",",
"SplitLIs",
")",
";",
"if",
"(",
"Reg",
"==",
"TRI",
".",
"getFrameRegister",
"(",
"MF",
")",
"&&",
"SplitLIs",
".",
"size",
"(",
")",
">",
"0",
")",
"{",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
"->",
"setFrameBaseVreg",
"(",
"SplitLIs",
".",
"back",
"(",
")",
"->",
"reg",
"(",
")",
")",
";",
"}",
"SplitLIs",
".",
"clear",
"(",
")",
";",
"}",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"llvm",
"::",
"make_early_inc_range",
"(",
"MF",
".",
"front",
"(",
")",
")",
")",
"{",
"if",
"(",
"MI",
".",
"isImplicitDef",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isDead",
"(",
")",
")",
"{",
"LiveInterval",
"&",
"LI",
"=",
"LIS",
".",
"getInterval",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
";",
"LIS",
".",
"removeVRegDefAt",
"(",
"LI",
",",
"LIS",
".",
"getInstructionIndex",
"(",
"MI",
")",
".",
"getRegSlot",
"(",
")",
")",
";",
"LIS",
".",
"RemoveMachineInstrFromMaps",
"(",
"MI",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Optimize LiveIntervals **********\\n\"",
"\"********** Function: \"",
"\"OptimizeLiveIntervals expects liveness\"",
"4",
"0",
"WebAssembly",
"0",
"WebAssembly",
"0",
"0"
] | WebAssemblyOptimizeLiveIntervals3 | runOnMachineFunction | WebAssembly | Virtual ISA | LLVM | 16,312 | 296 | 1 | [] |
[
"<s>",
"unsigned",
"SIRegisterInfo",
"::",
"getRegPressureLimit",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"Occupancy",
"=",
"ST",
".",
"getOccupancyWithLocalMemSize",
"(",
"MFI",
"->",
"getLDSSize",
"(",
")",
",",
"MF",
".",
"getFunction",
"(",
")",
")",
";",
"switch",
"(",
"RC",
"->",
"getID",
"(",
")",
")",
"{",
"default",
":",
"return",
"AMDGPURegisterInfo",
"::",
"getRegPressureLimit",
"(",
"RC",
",",
"MF",
")",
";",
"case",
"AMDGPU",
"::",
"VGPR_32RegClassID",
":",
"return",
"std",
"::",
"min",
"(",
"ST",
".",
"getMaxNumVGPRs",
"(",
"Occupancy",
")",
",",
"ST",
".",
"getMaxNumVGPRs",
"(",
"MF",
")",
")",
";",
"case",
"AMDGPU",
"::",
"SGPR_32RegClassID",
":",
"return",
"std",
"::",
"min",
"(",
"ST",
".",
"getMaxNumSGPRs",
"(",
"Occupancy",
",",
"true",
")",
",",
"ST",
".",
"getMaxNumSGPRs",
"(",
"MF",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"pressure",
"``",
"high",
"water",
"mark",
"''",
"for",
"the",
"specific",
"register",
"class",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU",
"AMDGPU::VGPR_32RegClassID",
"AMDGPU::SGPR_32RegClassID"
] | SIRegisterInfo111 | getRegPressureLimit | AMDGPU | GPU | LLVM | 16,313 | 125 | 1 | [] |
[
"<s>",
"bool",
"M68kInstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"MachineInstrBuilder",
"MIB",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"M68k",
"::",
"PUSH8d",
":",
"return",
"ExpandPUSH_POP",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"MOV8ed",
")",
",",
"true",
")",
";",
"case",
"M68k",
"::",
"PUSH16d",
":",
"return",
"ExpandPUSH_POP",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"MOV16er",
")",
",",
"true",
")",
";",
"case",
"M68k",
"::",
"PUSH32r",
":",
"return",
"ExpandPUSH_POP",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"MOV32er",
")",
",",
"true",
")",
";",
"case",
"M68k",
"::",
"POP8d",
":",
"return",
"ExpandPUSH_POP",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"MOV8do",
")",
",",
"false",
")",
";",
"case",
"M68k",
"::",
"POP16d",
":",
"return",
"ExpandPUSH_POP",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"MOV16ro",
")",
",",
"false",
")",
";",
"case",
"M68k",
"::",
"POP32r",
":",
"return",
"ExpandPUSH_POP",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"MOV32ro",
")",
",",
"false",
")",
";",
"case",
"M68k",
"::",
"SETCS_C8d",
":",
"return",
"Expand2AddrUndef",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"SUBX8dd",
")",
")",
";",
"case",
"M68k",
"::",
"SETCS_C16d",
":",
"return",
"Expand2AddrUndef",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"SUBX16dd",
")",
")",
";",
"case",
"M68k",
"::",
"SETCS_C32d",
":",
"return",
"Expand2AddrUndef",
"(",
"MIB",
",",
"get",
"(",
"M68k",
"::",
"SUBX32dd",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
] | [
"M68k",
"M68k",
"M68k::PUSH8d",
"M68k::MOV8ed",
"M68k::PUSH16d",
"M68k::MOV16er",
"M68k::PUSH32r",
"M68k::MOV32er",
"M68k::POP8d",
"M68k::MOV8do",
"M68k::POP16d",
"M68k::MOV16ro",
"M68k::POP32r",
"M68k::MOV32ro",
"M68k::SETCS_C8d",
"M68k::SUBX8dd",
"M68k::SETCS_C16d",
"M68k::SUBX16dd",
"M68k::SETCS_C32d",
"M68k::SUBX32dd"
] | M68kInstrInfo (2) | expandPostRAPseudo | M68k | MPU | LLVM | 16,314 | 216 | 1 | [] |
[
"<s>",
"bool",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"override",
"{",
"if",
"(",
"skipModule",
"(",
"M",
")",
")",
"return",
"false",
";",
"llvm",
"::",
"Function",
"*",
"ImplicitOffsetIntrinsic",
"=",
"M",
".",
"getFunction",
"(",
"Intrinsic",
"::",
"getName",
"(",
"Intrinsic",
"::",
"nvvm_implicit_offset",
")",
")",
";",
"if",
"(",
"!",
"ImplicitOffsetIntrinsic",
"||",
"ImplicitOffsetIntrinsic",
"->",
"use_empty",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"KernelImplicitArgumentType",
"=",
"ArrayType",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"M",
".",
"getContext",
"(",
")",
")",
",",
"3",
")",
";",
"ImplicitOffsetPtrType",
"=",
"Type",
"::",
"getInt32Ty",
"(",
"M",
".",
"getContext",
"(",
")",
")",
"->",
"getPointerTo",
"(",
")",
";",
"assert",
"(",
"(",
"!",
"ImplicitOffsetIntrinsic",
"||",
"ImplicitOffsetIntrinsic",
"->",
"getReturnType",
"(",
")",
"==",
"ImplicitOffsetPtrType",
")",
"&&",
"\"Intrinsic::nvvm_implicit_offset does not return the expected \"",
"\"type\"",
")",
";",
"EntryPointMetadata",
"=",
"getEntryPointMetadata",
"(",
"M",
")",
";",
"addImplicitParameterToCallers",
"(",
"M",
",",
"ImplicitOffsetIntrinsic",
",",
"nullptr",
")",
";",
"assert",
"(",
"ImplicitOffsetIntrinsic",
"->",
"use_empty",
"(",
")",
"&&",
"\"Not all uses of intrinsic removed\"",
")",
";",
"ImplicitOffsetIntrinsic",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"NVPTX",
"Intrinsic::getName",
"Intrinsic::nvvm_implicit_offset",
"3",
"\"Intrinsic::nvvm_implicit_offset does not return the expected \"",
"\"type\"",
"\"Not all uses of intrinsic removed\""
] | GlobalOffset | runOnModule | NVPTX | GPU | LLVM | 16,315 | 148 | 1 | [] |
[
"<s>",
"BitVector",
"MSP430RegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"const",
"MSP430FrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"PCB",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"SPB",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"SRB",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"CGB",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"PC",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"SR",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"CG",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"{",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"R4B",
")",
";",
"Reserved",
".",
"set",
"(",
"MSP430",
"::",
"R4",
")",
";",
"}",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"MSP430",
"MSP430",
"MSP430",
"MSP430::PCB",
"MSP430::SPB",
"MSP430::SRB",
"MSP430::CGB",
"MSP430::PC",
"MSP430::SP",
"MSP430::SR",
"MSP430::CG",
"MSP430::R4B",
"MSP430::R4"
] | MSP430RegisterInfo20 | getReservedRegs | MSP430 | MPU | LLVM | 16,316 | 135 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
")",
"{",
"tree",
"type",
",",
"decl_or_type",
";",
"rtx",
"a",
",",
"b",
";",
"if",
"(",
"!",
"TARGET_MACHO",
"&&",
"!",
"TARGET_64BIT",
"&&",
"flag_pic",
"&&",
"(",
"!",
"decl",
"||",
"!",
"targetm",
".",
"binds_local_p",
"(",
"decl",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"ix86_minimum_incoming_stack_boundary",
"(",
"true",
")",
"<",
"PREFERRED_STACK_BOUNDARY",
")",
"return",
"false",
";",
"if",
"(",
"decl",
")",
"{",
"decl_or_type",
"=",
"decl",
";",
"type",
"=",
"TREE_TYPE",
"(",
"decl",
")",
";",
"}",
"else",
"{",
"type",
"=",
"CALL_EXPR_FN",
"(",
"exp",
")",
";",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"decl_or_type",
"=",
"type",
";",
"}",
"a",
"=",
"ix86_function_value",
"(",
"TREE_TYPE",
"(",
"exp",
")",
",",
"decl_or_type",
",",
"false",
")",
";",
"b",
"=",
"ix86_function_value",
"(",
"TREE_TYPE",
"(",
"DECL_RESULT",
"(",
"cfun",
"->",
"decl",
")",
")",
",",
"cfun",
"->",
"decl",
",",
"false",
")",
";",
"if",
"(",
"STACK_REG_P",
"(",
"a",
")",
"||",
"STACK_REG_P",
"(",
"b",
")",
")",
"{",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"a",
",",
"b",
")",
")",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"VOID_TYPE_P",
"(",
"TREE_TYPE",
"(",
"DECL_RESULT",
"(",
"cfun",
"->",
"decl",
")",
")",
")",
")",
";",
"else",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"a",
",",
"b",
")",
")",
"return",
"false",
";",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"call_abi",
"==",
"MS_ABI",
"&&",
"ix86_function_type_abi",
"(",
"type",
")",
"==",
"SYSV_ABI",
")",
"return",
"false",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"decl",
"||",
"(",
"TARGET_DLLIMPORT_DECL_ATTRIBUTES",
"&&",
"DECL_DLLIMPORT_P",
"(",
"decl",
")",
")",
")",
"{",
"if",
"(",
"ix86_function_regparm",
"(",
"type",
",",
"NULL",
")",
">=",
"3",
")",
"{",
"return",
"false",
";",
"}",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Decide",
"whether",
"we",
"can",
"make",
"a",
"sibling",
"call",
"to",
"a",
"function",
".",
"DECL",
"is",
"the",
"declaration",
"of",
"the",
"function",
"being",
"targeted",
"by",
"the",
"call",
"and",
"EXP",
"is",
"the",
"CALL_EXPR",
"representing",
"the",
"call",
"."
] | [
"i386",
"3"
] | i3864 | ix86_function_ok_for_sibcall | i386 | CPU | GCC | 16,317 | 262 | 1 | [] |
[
"<s>",
"void",
"ia64_expand_dot_prod_v8qi",
"(",
"rtx",
"operands",
"[",
"4",
"]",
",",
"bool",
"unsignedp",
")",
"{",
"rtx",
"l1",
",",
"l2",
",",
"h1",
",",
"h2",
",",
"x1",
",",
"x2",
",",
"p1",
",",
"p2",
",",
"p3",
",",
"p4",
",",
"s1",
",",
"s2",
",",
"s3",
";",
"if",
"(",
"unsignedp",
")",
"x1",
"=",
"x2",
"=",
"CONST0_RTX",
"(",
"V8QImode",
")",
";",
"else",
"{",
"bool",
"neg",
";",
"x1",
"=",
"gen_reg_rtx",
"(",
"V8QImode",
")",
";",
"x2",
"=",
"gen_reg_rtx",
"(",
"V8QImode",
")",
";",
"neg",
"=",
"ia64_expand_vecint_compare",
"(",
"LT",
",",
"V8QImode",
",",
"x1",
",",
"operands",
"[",
"1",
"]",
",",
"CONST0_RTX",
"(",
"V8QImode",
")",
")",
";",
"gcc_assert",
"(",
"!",
"neg",
")",
";",
"neg",
"=",
"ia64_expand_vecint_compare",
"(",
"LT",
",",
"V8QImode",
",",
"x2",
",",
"operands",
"[",
"2",
"]",
",",
"CONST0_RTX",
"(",
"V8QImode",
")",
")",
";",
"gcc_assert",
"(",
"!",
"neg",
")",
";",
"}",
"l1",
"=",
"gen_reg_rtx",
"(",
"V4HImode",
")",
";",
"l2",
"=",
"gen_reg_rtx",
"(",
"V4HImode",
")",
";",
"h1",
"=",
"gen_reg_rtx",
"(",
"V4HImode",
")",
";",
"h2",
"=",
"gen_reg_rtx",
"(",
"V4HImode",
")",
";",
"emit_insn",
"(",
"gen_unpack1_l",
"(",
"gen_lowpart",
"(",
"V8QImode",
",",
"l1",
")",
",",
"operands",
"[",
"1",
"]",
",",
"x1",
")",
")",
";",
"emit_insn",
"(",
"gen_unpack1_l",
"(",
"gen_lowpart",
"(",
"V8QImode",
",",
"l2",
")",
",",
"operands",
"[",
"2",
"]",
",",
"x2",
")",
")",
";",
"emit_insn",
"(",
"gen_unpack1_h",
"(",
"gen_lowpart",
"(",
"V8QImode",
",",
"h1",
")",
",",
"operands",
"[",
"1",
"]",
",",
"x1",
")",
")",
";",
"emit_insn",
"(",
"gen_unpack1_h",
"(",
"gen_lowpart",
"(",
"V8QImode",
",",
"h2",
")",
",",
"operands",
"[",
"2",
"]",
",",
"x2",
")",
")",
";",
"p1",
"=",
"gen_reg_rtx",
"(",
"V2SImode",
")",
";",
"p2",
"=",
"gen_reg_rtx",
"(",
"V2SImode",
")",
";",
"p3",
"=",
"gen_reg_rtx",
"(",
"V2SImode",
")",
";",
"p4",
"=",
"gen_reg_rtx",
"(",
"V2SImode",
")",
";",
"emit_insn",
"(",
"gen_pmpy2_r",
"(",
"p1",
",",
"l1",
",",
"l2",
")",
")",
";",
"emit_insn",
"(",
"gen_pmpy2_l",
"(",
"p2",
",",
"l1",
",",
"l2",
")",
")",
";",
"emit_insn",
"(",
"gen_pmpy2_r",
"(",
"p3",
",",
"h1",
",",
"h2",
")",
")",
";",
"emit_insn",
"(",
"gen_pmpy2_l",
"(",
"p4",
",",
"h1",
",",
"h2",
")",
")",
";",
"s1",
"=",
"gen_reg_rtx",
"(",
"V2SImode",
")",
";",
"s2",
"=",
"gen_reg_rtx",
"(",
"V2SImode",
")",
";",
"s3",
"=",
"gen_reg_rtx",
"(",
"V2SImode",
")",
";",
"emit_insn",
"(",
"gen_addv2si3",
"(",
"s1",
",",
"p1",
",",
"p2",
")",
")",
";",
"emit_insn",
"(",
"gen_addv2si3",
"(",
"s2",
",",
"p3",
",",
"p4",
")",
")",
";",
"emit_insn",
"(",
"gen_addv2si3",
"(",
"s3",
",",
"s1",
",",
"operands",
"[",
"3",
"]",
")",
")",
";",
"emit_insn",
"(",
"gen_addv2si3",
"(",
"operands",
"[",
"0",
"]",
",",
"s2",
",",
"s3",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"signed",
"or",
"unsigned",
"V8QI",
"dot",
"product",
"operation",
"."
] | [
"ia64",
"4",
"1",
"2",
"1",
"2",
"1",
"2",
"3",
"0"
] | ia643 | ia64_expand_dot_prod_v8qi | ia64 | CPU | GCC | 16,318 | 387 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"XCoreTargetObjectFile",
"::",
"getExplicitSectionGlobal",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"SectionKind",
"Kind",
",",
"Mangler",
"&",
"Mang",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"const",
"{",
"StringRef",
"SectionName",
"=",
"GV",
"->",
"getSection",
"(",
")",
";",
"bool",
"IsCPRel",
"=",
"SectionName",
".",
"startswith",
"(",
"\".cp.\"",
")",
";",
"if",
"(",
"IsCPRel",
"&&",
"!",
"Kind",
".",
"isReadOnly",
"(",
")",
")",
"report_fatal_error",
"(",
"\"Using .cp. section for writeable object.\"",
")",
";",
"return",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"SectionName",
",",
"getXCoreSectionType",
"(",
"Kind",
")",
",",
"getXCoreSectionFlags",
"(",
"Kind",
",",
"IsCPRel",
")",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"method",
"to",
"assign",
"a",
"section",
"to",
"globals",
"with",
"an",
"explicit",
"section",
"specfied",
"."
] | [
"XCore",
"XCore",
"\".cp.\"",
"\"Using .cp. section for writeable object.\"",
"XCore",
"XCore"
] | XCoreTargetObjectFile (2) | getExplicitSectionGlobal | XCore | MPU | LLVM | 16,319 | 83 | 1 | [] |
[
"<s>",
"void",
"LC3AsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"char",
"*",
"Data",
",",
"unsigned",
"DataSize",
",",
"uint64_t",
"Value",
",",
"bool",
"isPCRel",
")",
"const",
"{",
"unsigned",
"NumBytes",
"=",
"4",
";",
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
",",
"Value",
")",
";",
"if",
"(",
"!",
"Value",
")",
"{",
"return",
";",
"}",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"assert",
"(",
"Offset",
"+",
"NumBytes",
"<=",
"DataSize",
"&&",
"\"Invalid fixup offset!\"",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"Data",
"[",
"Offset",
"+",
"i",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"LC3",
"LC3",
"4",
"\"Invalid fixup offset!\"",
"0",
"8",
"0xff"
] | LC3AsmBackend | applyFixup | LC3 | CPU | LLVM | 16,320 | 107 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUPassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"const",
"AMDGPUSubtarget",
"&",
"ST",
"=",
"TM",
"->",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
")",
";",
"if",
"(",
"ST",
".",
"getGeneration",
"(",
")",
"<=",
"AMDGPUSubtarget",
"::",
"NORTHERN_ISLANDS",
")",
"{",
"addPass",
"(",
"createR600VectorRegMerger",
"(",
"*",
"TM",
")",
")",
";",
"}",
"else",
"{",
"addPass",
"(",
"createSIFixSGPRCopiesPass",
"(",
"*",
"TM",
")",
")",
";",
"addPass",
"(",
"&",
"MachineCSEID",
")",
";",
"initializeSIFixSGPRLiveRangesPass",
"(",
"*",
"PassRegistry",
"::",
"getPassRegistry",
"(",
")",
")",
";",
"insertPass",
"(",
"&",
"RegisterCoalescerID",
",",
"&",
"SIFixSGPRLiveRangesID",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"R600",
"SI",
"SI",
"SI"
] | AMDGPUTargetMachine14 | addPreRegAlloc | R600 | GPU | LLVM | 16,321 | 85 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUAsmParser",
"::",
"validateTargetOperandClass",
"(",
"MCParsedAsmOperand",
"&",
"Op",
",",
"unsigned",
"Kind",
")",
"{",
"AMDGPUOperand",
"&",
"Operand",
"=",
"(",
"AMDGPUOperand",
"&",
")",
"Op",
";",
"switch",
"(",
"Kind",
")",
"{",
"case",
"MCK_addr64",
":",
"return",
"Operand",
".",
"isAddr64",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_gds",
":",
"return",
"Operand",
".",
"isGDS",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_glc",
":",
"return",
"Operand",
".",
"isGLC",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_d16",
":",
"return",
"Operand",
".",
"isD16",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_idxen",
":",
"return",
"Operand",
".",
"isIdxen",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_offen",
":",
"return",
"Operand",
".",
"isOffen",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_SSrcB32",
":",
"return",
"Operand",
".",
"isSSrcB32",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_SSrcF32",
":",
"return",
"Operand",
".",
"isSSrcF32",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_SoppBrTarget",
":",
"return",
"Operand",
".",
"isSoppBrTarget",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_VReg32OrOff",
":",
"return",
"Operand",
".",
"isVReg32OrOff",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_InterpSlot",
":",
"return",
"Operand",
".",
"isInterpSlot",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_Attr",
":",
"return",
"Operand",
".",
"isInterpAttr",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"case",
"MCK_AttrChan",
":",
"return",
"Operand",
".",
"isAttrChan",
"(",
")",
"?",
"Match_Success",
":",
"Match_InvalidOperand",
";",
"default",
":",
"return",
"Match_InvalidOperand",
";",
"}",
"}",
"</s>"
] | [
"Allow",
"a",
"target",
"to",
"add",
"special",
"case",
"operand",
"matching",
"for",
"things",
"that",
"tblgen",
"doesn't/ca",
"n't",
"handle",
"effectively",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPUAsmParser25 | validateTargetOperandClass | AMDGPU | GPU | LLVM | 16,322 | 217 | 1 | [] |
[
"<s>",
"BitVector",
"LC3RegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"LC3",
"::",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"LC3",
"::",
"LR",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"LC3",
"LC3",
"LC3::SP",
"LC3::LR"
] | LC3RegisterInfo | getReservedRegs | LC3 | CPU | LLVM | 16,323 | 42 | 1 | [] |
[
"<s>",
"unsigned",
"MipsMCCodeEmitter",
"::",
"getBranchTarget26OpValueMM",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
">>",
"1",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"\"getBranchTarget26OpValueMM expects only expressions or immediates\"",
")",
";",
"const",
"MCExpr",
"*",
"FixupExpression",
"=",
"MCBinaryExpr",
"::",
"createAdd",
"(",
"MO",
".",
"getExpr",
"(",
")",
",",
"MCConstantExpr",
"::",
"create",
"(",
"-",
"4",
",",
"Ctx",
")",
",",
"Ctx",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"FixupExpression",
",",
"MCFixupKind",
"(",
"Mips",
"::",
"fixup_MICROMIPS_PC26_S1",
")",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTarget26OpValueMM",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"1",
"\"getBranchTarget26OpValueMM expects only expressions or immediates\"",
"4",
"0",
"Mips::fixup_MICROMIPS_PC26_S1",
"0"
] | MipsMCCodeEmitter (2) | getBranchTarget26OpValueMM | Mips | CPU | LLVM | 16,324 | 120 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"shouldSinkOperands",
"(",
"Instruction",
"*",
"I",
",",
"SmallVectorImpl",
"<",
"Use",
"*",
">",
"&",
"Ops",
")",
"const",
"{",
"using",
"namespace",
"llvm",
"::",
"PatternMatch",
";",
"if",
"(",
"!",
"I",
"->",
"getType",
"(",
")",
"->",
"isVectorTy",
"(",
")",
"||",
"!",
"Subtarget",
".",
"hasStdExtV",
"(",
")",
")",
"return",
"false",
";",
"auto",
"IsSinker",
"=",
"[",
"&",
"]",
"(",
"Instruction",
"*",
"I",
",",
"int",
"Operand",
")",
"{",
"switch",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Instruction",
"::",
"Add",
":",
"case",
"Instruction",
"::",
"Sub",
":",
"case",
"Instruction",
"::",
"Mul",
":",
"case",
"Instruction",
"::",
"And",
":",
"case",
"Instruction",
"::",
"Or",
":",
"case",
"Instruction",
"::",
"Xor",
":",
"case",
"Instruction",
"::",
"FAdd",
":",
"case",
"Instruction",
"::",
"FSub",
":",
"case",
"Instruction",
"::",
"FMul",
":",
"case",
"Instruction",
"::",
"FDiv",
":",
"return",
"true",
";",
"case",
"Instruction",
"::",
"Shl",
":",
"case",
"Instruction",
"::",
"LShr",
":",
"case",
"Instruction",
"::",
"AShr",
":",
"return",
"Operand",
"==",
"1",
";",
"case",
"Instruction",
"::",
"Call",
":",
"if",
"(",
"auto",
"*",
"II",
"=",
"dyn_cast",
"<",
"IntrinsicInst",
">",
"(",
"I",
")",
")",
"{",
"switch",
"(",
"II",
"->",
"getIntrinsicID",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"fma",
":",
"return",
"Operand",
"==",
"0",
"||",
"Operand",
"==",
"1",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"return",
"false",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
";",
"for",
"(",
"auto",
"OpIdx",
":",
"enumerate",
"(",
"I",
"->",
"operands",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"IsSinker",
"(",
"I",
",",
"OpIdx",
".",
"index",
"(",
")",
")",
")",
"continue",
";",
"Instruction",
"*",
"Op",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"OpIdx",
".",
"value",
"(",
")",
".",
"get",
"(",
")",
")",
";",
"if",
"(",
"!",
"Op",
"||",
"any_of",
"(",
"Ops",
",",
"[",
"&",
"]",
"(",
"Use",
"*",
"U",
")",
"{",
"return",
"U",
"->",
"get",
"(",
")",
"==",
"Op",
";",
"}",
")",
")",
"continue",
";",
"if",
"(",
"!",
"match",
"(",
"Op",
",",
"m_Shuffle",
"(",
"m_InsertElt",
"(",
"m_Undef",
"(",
")",
",",
"m_Value",
"(",
")",
",",
"m_ZeroInt",
"(",
")",
")",
",",
"m_Undef",
"(",
")",
",",
"m_ZeroMask",
"(",
")",
")",
")",
")",
"continue",
";",
"for",
"(",
"Use",
"&",
"U",
":",
"Op",
"->",
"uses",
"(",
")",
")",
"{",
"Instruction",
"*",
"Insn",
"=",
"cast",
"<",
"Instruction",
">",
"(",
"U",
".",
"getUser",
"(",
")",
")",
";",
"if",
"(",
"!",
"IsSinker",
"(",
"Insn",
",",
"U",
".",
"getOperandNo",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"Ops",
".",
"push_back",
"(",
"&",
"Op",
"->",
"getOperandUse",
"(",
"0",
")",
")",
";",
"Ops",
".",
"push_back",
"(",
"&",
"OpIdx",
".",
"value",
"(",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"sinking",
"I",
"'s",
"operands",
"to",
"the",
"same",
"basic",
"block",
"as",
"I",
"is",
"profitable",
",",
"e.g",
"."
] | [
"RISCV",
"RISCV",
"1",
"Intrinsic::fma",
"0",
"1",
"0"
] | RISCVISelLowering1 | shouldSinkOperands | RISCV | CPU | LLVM | 16,325 | 402 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"ARM64RegisterInfo",
"::",
"getThisReturnPreservedMask",
"(",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"return",
"CSR_ARM64_AAPCS_ThisReturn_RegMask",
";",
"}",
"</s>"
] | [
"getThisReturnPreservedMask",
"-",
"Returns",
"a",
"call",
"preserved",
"mask",
"specific",
"to",
"the",
"case",
"that",
"'returned",
"'",
"is",
"on",
"an",
"i32",
"first",
"argument",
"if",
"the",
"calling",
"convention",
"is",
"one",
"that",
"can",
"(",
"partially",
")",
"model",
"this",
"attribute",
"with",
"a",
"preserved",
"mask",
"(",
"i.e",
"."
] | [
"ARM64",
"ARM64",
"ARM64"
] | ARM64RegisterInfo | getThisReturnPreservedMask | ARM64 | CPU | LLVM | 16,326 | 17 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"TargetLibraryInfoWrapperPass",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"DominatorTreeWrapperPass",
">",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"AMDGPU"
] | AMDGPUPrintfRuntimeBinding | getAnalysisUsage | AMDGPU | GPU | LLVM | 16,327 | 29 | 1 | [] |
[
"<s>",
"bool",
"alpha_split_const_mov",
"(",
"enum",
"machine_mode",
"mode",
",",
"rtx",
"*",
"operands",
")",
"{",
"HOST_WIDE_INT",
"i0",
",",
"i1",
";",
"rtx",
"temp",
"=",
"NULL_RTX",
";",
"alpha_extract_integer",
"(",
"operands",
"[",
"1",
"]",
",",
"&",
"i0",
",",
"&",
"i1",
")",
";",
"if",
"(",
"HOST_BITS_PER_WIDE_INT",
">=",
"64",
"||",
"i1",
"==",
"-",
"(",
"i0",
"<",
"0",
")",
")",
"temp",
"=",
"alpha_emit_set_const",
"(",
"operands",
"[",
"0",
"]",
",",
"mode",
",",
"i0",
",",
"3",
",",
"false",
")",
";",
"if",
"(",
"!",
"temp",
"&&",
"TARGET_BUILD_CONSTANTS",
")",
"temp",
"=",
"alpha_emit_set_long_const",
"(",
"operands",
"[",
"0",
"]",
",",
"i0",
",",
"i1",
")",
";",
"if",
"(",
"temp",
")",
"{",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"operands",
"[",
"0",
"]",
",",
"temp",
")",
")",
"emit_move_insn",
"(",
"operands",
"[",
"0",
"]",
",",
"temp",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Operand",
"1",
"is",
"known",
"to",
"be",
"a",
"constant",
",",
"and",
"should",
"require",
"more",
"than",
"one",
"instruction",
"to",
"load",
".",
"Emit",
"that",
"multi-part",
"load",
"."
] | [
"alpha",
"1",
"64",
"0",
"0",
"3",
"0",
"0",
"0"
] | alpha3 | alpha_split_const_mov | alpha | MPU | GCC | 16,328 | 126 | 1 | [] |
[
"<s>",
"void",
"XtensaFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"assert",
"(",
"false",
"&&",
"\"XtensaFrameLowering::emitPrologue not implemented\"",
")",
";",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"Xtensa",
"Xtensa",
"\"XtensaFrameLowering::emitPrologue not implemented\""
] | XtensaFrameLowering1 | emitPrologue | Xtensa | MPU | LLVM | 16,329 | 23 | 1 | [] |
[
"<s>",
"virtual",
"MVT",
"getShiftAmountTy",
"(",
"EVT",
"LHSTy",
")",
"const",
"{",
"return",
"MVT",
"::",
"i64",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"type",
"for",
"the",
"shift",
"amount",
"of",
"a",
"shift",
"opcode",
"."
] | [
"Alpha",
"MVT::i64"
] | AlphaISelLowering1 | getShiftAmountTy | Alpha | MPU | LLVM | 16,330 | 15 | 1 | [] |
[
"<s>",
"void",
"X86PassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createX86OptimizeLEAs",
"(",
")",
")",
";",
"addPass",
"(",
"createX86CallFrameOptimization",
"(",
")",
")",
";",
"addPass",
"(",
"createX86WinAllocaExpander",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine84 | addPreRegAlloc | X86 | CPU | LLVM | 16,331 | 39 | 1 | [] |
[
"<s>",
"static",
"void",
"make_type_sizeless",
"(",
"tree",
"type",
")",
"{",
"TYPE_ATTRIBUTES",
"(",
"type",
")",
"=",
"tree_cons",
"(",
"get_identifier",
"(",
"\"SVE sizeless type\"",
")",
",",
"NULL_TREE",
",",
"TYPE_ATTRIBUTES",
"(",
"type",
")",
")",
";",
"}",
"</s>"
] | [
"Force",
"TYPE",
"to",
"be",
"a",
"sizeless",
"type",
"."
] | [
"aarch64",
"\"SVE sizeless type\""
] | aarch64-sve-builtins | make_type_sizeless | aarch64 | CPU | GCC | 16,332 | 29 | 1 | [] |
[
"<s>",
"static",
"int",
"neon_pair_endian_lane_map",
"(",
"machine_mode",
"mode",
",",
"int",
"lane",
")",
"{",
"int",
"nelem",
"=",
"GET_MODE_NUNITS",
"(",
"mode",
")",
";",
"if",
"(",
"BYTES_BIG_ENDIAN",
")",
"lane",
"=",
"neon_endian_lane_map",
"(",
"mode",
",",
"lane",
"&",
"(",
"nelem",
"-",
"1",
")",
")",
"+",
"(",
"lane",
"&",
"nelem",
")",
";",
"return",
"lane",
";",
"}",
"</s>"
] | [
"Some",
"permutations",
"index",
"into",
"pairs",
"of",
"vectors",
",",
"this",
"is",
"a",
"helper",
"function",
"to",
"map",
"indexes",
"into",
"those",
"pairs",
"of",
"vectors",
"."
] | [
"arm",
"1"
] | arm | neon_pair_endian_lane_map | arm | CPU | GCC | 16,333 | 48 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"isProfitableToIfCvt",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"unsigned",
"NumCycles",
",",
"unsigned",
"ExtraPredCycles",
",",
"const",
"BranchProbability",
"&",
"Probability",
")",
"const",
"{",
"if",
"(",
"!",
"NumCycles",
")",
"return",
"false",
";",
"const",
"Function",
"*",
"F",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
")",
";",
"if",
"(",
"F",
"->",
"hasFnAttribute",
"(",
"Attribute",
"::",
"OptimizeForSize",
")",
"||",
"F",
"->",
"hasFnAttribute",
"(",
"Attribute",
"::",
"MinSize",
")",
")",
"{",
"MachineBasicBlock",
"*",
"Pred",
"=",
"*",
"MBB",
".",
"pred_begin",
"(",
")",
";",
"if",
"(",
"!",
"Pred",
"->",
"empty",
"(",
")",
")",
"{",
"MachineInstr",
"*",
"LastMI",
"=",
"&",
"*",
"Pred",
"->",
"rbegin",
"(",
")",
";",
"if",
"(",
"LastMI",
"->",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"t2Bcc",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"CmpMI",
"=",
"LastMI",
";",
"if",
"(",
"CmpMI",
"!=",
"Pred",
"->",
"begin",
"(",
")",
")",
"{",
"--",
"CmpMI",
";",
"if",
"(",
"CmpMI",
"->",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"tCMPi8",
"||",
"CmpMI",
"->",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"t2CMPri",
")",
"{",
"unsigned",
"Reg",
"=",
"CmpMI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"PredReg",
"=",
"0",
";",
"ARMCC",
"::",
"CondCodes",
"P",
"=",
"getInstrPredicate",
"(",
"CmpMI",
",",
"PredReg",
")",
";",
"if",
"(",
"P",
"==",
"ARMCC",
"::",
"AL",
"&&",
"CmpMI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"==",
"0",
"&&",
"isARMLowRegister",
"(",
"Reg",
")",
")",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"}",
"unsigned",
"UnpredCost",
"=",
"Probability",
".",
"getNumerator",
"(",
")",
"*",
"NumCycles",
";",
"UnpredCost",
"/=",
"Probability",
".",
"getDenominator",
"(",
")",
";",
"UnpredCost",
"+=",
"1",
";",
"UnpredCost",
"+=",
"Subtarget",
".",
"getMispredictionPenalty",
"(",
")",
"/",
"10",
";",
"return",
"(",
"NumCycles",
"+",
"ExtraPredCycles",
")",
"<=",
"UnpredCost",
";",
"}",
"</s>"
] | [
"Second",
"variant",
"of",
"isProfitableToIfCvt",
"."
] | [
"ARM",
"ARM",
"ARM::t2Bcc",
"ARM::tCMPi8",
"ARM::t2CMPri",
"0",
"0",
"ARMCC::CondCodes",
"ARMCC::AL",
"1",
"0",
"ARM",
"1",
"10"
] | ARMBaseInstrInfo85 | isProfitableToIfCvt | ARM | CPU | LLVM | 16,334 | 264 | 1 | [] |
[
"<s>",
"bool",
"M68kDAGToDAGISel",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"Subtarget",
"=",
"&",
"static_cast",
"<",
"const",
"M68kSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"return",
"SelectionDAGISel",
"::",
"runOnMachineFunction",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"M68k",
"M68k",
"M68k"
] | M68kISelDAGToDAG | runOnMachineFunction | M68k | MPU | LLVM | 16,335 | 36 | 1 | [] |
[
"<s>",
"void",
"MOSFrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"doesNotRecurse",
"(",
")",
")",
"{",
"int64_t",
"Offset",
"=",
"0",
";",
"for",
"(",
"int",
"Idx",
":",
"seq",
"(",
"0",
",",
"MFI",
".",
"getObjectIndexEnd",
"(",
")",
")",
")",
"{",
"if",
"(",
"MFI",
".",
"isDeadObjectIndex",
"(",
"Idx",
")",
"||",
"MFI",
".",
"isVariableSizedObjectIndex",
"(",
"Idx",
")",
")",
"continue",
";",
"MFI",
".",
"setStackID",
"(",
"Idx",
",",
"TargetStackID",
"::",
"NoAlloc",
")",
";",
"MFI",
".",
"setObjectOffset",
"(",
"Idx",
",",
"Offset",
")",
";",
"Offset",
"+=",
"MFI",
".",
"getObjectSize",
"(",
"Idx",
")",
";",
"}",
"return",
";",
"}",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"MOS",
"MOS",
"0",
"0"
] | MOSFrameLowering | processFunctionBeforeFrameFinalized | MOS | MPU | LLVM | 16,336 | 112 | 1 | [] |
[
"<s>",
"SDValue",
"SparcTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Should not custom lower this!\"",
")",
";",
"case",
"ISD",
"::",
"FNEG",
":",
"case",
"ISD",
"::",
"FABS",
":",
"return",
"LowerF64Op",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"llvm_unreachable",
"(",
"\"TLS not implemented for Sparc.\"",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"LowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"LowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_SINT",
":",
"return",
"LowerFP_TO_SINT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SINT_TO_FP",
":",
"return",
"LowerSINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BR_CC",
":",
"return",
"LowerBR_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
",",
"*",
"this",
")",
";",
"case",
"ISD",
"::",
"VAARG",
":",
"return",
"LowerVAARG",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"Sparc",
"Sparc",
"\"Should not custom lower this!\"",
"ISD::FNEG",
"ISD::FABS",
"ISD::RETURNADDR",
"ISD::FRAMEADDR",
"ISD::GlobalTLSAddress",
"\"TLS not implemented for Sparc.\"",
"ISD::GlobalAddress",
"ISD::BlockAddress",
"ISD::ConstantPool",
"ISD::FP_TO_SINT",
"ISD::SINT_TO_FP",
"ISD::BR_CC",
"ISD::SELECT_CC",
"ISD::VASTART",
"ISD::VAARG",
"ISD::DYNAMIC_STACKALLOC"
] | SparcISelLowering101 | LowerOperation | Sparc | CPU | LLVM | 16,337 | 219 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_valid_base_register_p",
"(",
"rtx",
"x",
",",
"enum",
"machine_mode",
"mode",
",",
"bool",
"strict_p",
")",
"{",
"if",
"(",
"!",
"strict_p",
"&&",
"GET_CODE",
"(",
"x",
")",
"==",
"SUBREG",
")",
"x",
"=",
"SUBREG_REG",
"(",
"x",
")",
";",
"return",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"riscv_regno_mode_ok_for_base_p",
"(",
"REGNO",
"(",
"x",
")",
",",
"mode",
",",
"strict_p",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"X",
"is",
"a",
"valid",
"base",
"register",
"for",
"mode",
"MODE",
".",
"STRICT_P",
"is",
"true",
"if",
"REG_OK_STRICT",
"is",
"in",
"effect",
"."
] | [
"riscv"
] | riscv2 | riscv_valid_base_register_p | riscv | CPU | GCC | 16,338 | 55 | 1 | [] |
[
"<s>",
"MVT",
"X86TargetLowering",
"::",
"getRegisterTypeForCallingConv",
"(",
"LLVMContext",
"&",
"Context",
",",
"CallingConv",
"::",
"ID",
"CC",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"v32i1",
"&&",
"Subtarget",
".",
"hasAVX512",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasBWI",
"(",
")",
")",
"return",
"MVT",
"::",
"v32i8",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
"&&",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i1",
"&&",
"Subtarget",
".",
"hasAVX512",
"(",
")",
"&&",
"(",
"!",
"isPowerOf2_32",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
")",
"||",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
">",
"16",
"&&",
"!",
"Subtarget",
".",
"hasBWI",
"(",
")",
")",
"||",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
">",
"64",
"&&",
"Subtarget",
".",
"hasBWI",
"(",
")",
")",
")",
")",
"return",
"MVT",
"::",
"i8",
";",
"if",
"(",
"(",
"VT",
"==",
"MVT",
"::",
"v32i16",
"||",
"VT",
"==",
"MVT",
"::",
"v64i8",
")",
"&&",
"Subtarget",
".",
"hasAVX512",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasBWI",
"(",
")",
"&&",
"!",
"EnableOldKNLABI",
")",
"return",
"MVT",
"::",
"v16i32",
";",
"return",
"TargetLowering",
"::",
"getRegisterTypeForCallingConv",
"(",
"Context",
",",
"CC",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Certain",
"combinations",
"of",
"ABIs",
",",
"Targets",
"and",
"features",
"require",
"that",
"types",
"are",
"legal",
"for",
"some",
"operations",
"and",
"not",
"for",
"other",
"operations",
"."
] | [
"X86",
"X86",
"MVT::v32i1",
"MVT::v32i8",
"MVT::i1",
"16",
"64",
"MVT::i8",
"MVT::v32i16",
"MVT::v64i8",
"MVT::v16i32"
] | X86ISelLowering (2)7 | getRegisterTypeForCallingConv | X86 | CPU | LLVM | 16,339 | 169 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_add_new_builtins",
"(",
"HOST_WIDE_INT",
"isa",
",",
"HOST_WIDE_INT",
"isa2",
")",
"{",
"isa",
"&=",
"~",
"OPTION_MASK_ISA_64BIT",
";",
"if",
"(",
"(",
"isa",
"&",
"deferred_isa_values",
")",
"==",
"0",
"&&",
"(",
"isa2",
"&",
"deferred_isa_values2",
")",
"==",
"0",
")",
"return",
";",
"deferred_isa_values",
"&=",
"~",
"isa",
";",
"deferred_isa_values2",
"&=",
"~",
"isa2",
";",
"int",
"i",
";",
"tree",
"saved_current_target_pragma",
"=",
"current_target_pragma",
";",
"current_target_pragma",
"=",
"NULL_TREE",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"(",
"int",
")",
"IX86_BUILTIN_MAX",
";",
"i",
"++",
")",
"{",
"if",
"(",
"(",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"isa",
"&",
"isa",
")",
"!=",
"0",
"||",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"isa2",
"&",
"isa2",
")",
"!=",
"0",
")",
"&&",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"set_and_not_built_p",
")",
"{",
"tree",
"decl",
",",
"type",
";",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"set_and_not_built_p",
"=",
"false",
";",
"type",
"=",
"ix86_get_builtin_func_type",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"tcode",
")",
";",
"decl",
"=",
"add_builtin_function_ext_scope",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"name",
",",
"type",
",",
"i",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"ix86_builtins",
"[",
"i",
"]",
"=",
"decl",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"const_p",
")",
"TREE_READONLY",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"pure_p",
")",
"DECL_PURE_P",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"leaf_p",
")",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
"=",
"build_tree_list",
"(",
"get_identifier",
"(",
"\"leaf\"",
")",
",",
"NULL_TREE",
")",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"nothrow_p",
")",
"TREE_NOTHROW",
"(",
"decl",
")",
"=",
"1",
";",
"}",
"}",
"current_target_pragma",
"=",
"saved_current_target_pragma",
";",
"}",
"</s>"
] | [
"Add",
"any",
"new",
"builtin",
"functions",
"for",
"a",
"given",
"ISA",
"that",
"may",
"not",
"have",
"been",
"declared",
".",
"This",
"saves",
"a",
"bit",
"of",
"space",
"compared",
"to",
"adding",
"all",
"of",
"the",
"declarations",
"to",
"the",
"tree",
",",
"even",
"if",
"we",
"did",
"n't",
"use",
"them",
"."
] | [
"i386",
"0",
"0",
"0",
"0",
"0",
"1",
"1",
"\"leaf\"",
"1"
] | i3867 | ix86_add_new_builtins | i386 | CPU | GCC | 16,340 | 247 | 1 | [] |
[
"<s>",
"unsigned",
"MipsMCCodeEmitter",
"::",
"getBranchTargetOpValueMM",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
">>",
"1",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"\"getBranchTargetOpValueMM expects only expressions or immediates\"",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"Create",
"(",
"0",
",",
"Expr",
",",
"MCFixupKind",
"(",
"Mips",
"::",
"fixup_MICROMIPS_PC16_S1",
")",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTargetOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"microMIPS",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"1",
"\"getBranchTargetOpValueMM expects only expressions or immediates\"",
"0",
"Mips",
"0"
] | MipsMCCodeEmitter2 | getBranchTargetOpValueMM | Mips | CPU | LLVM | 16,341 | 103 | 1 | [] |
[
"<s>",
"static",
"void",
"mmix_print_operand_address",
"(",
"FILE",
"*",
"stream",
",",
"machine_mode",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"REG_P",
"(",
"x",
")",
")",
"{",
"fprintf",
"(",
"stream",
",",
"\"%s,0\"",
",",
"reg_names",
"[",
"MMIX_OUTPUT_REGNO",
"(",
"REGNO",
"(",
"x",
")",
")",
"]",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
")",
"{",
"rtx",
"x1",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"rtx",
"x2",
"=",
"XEXP",
"(",
"x",
",",
"1",
")",
";",
"if",
"(",
"REG_P",
"(",
"x1",
")",
")",
"{",
"fprintf",
"(",
"stream",
",",
"\"%s,\"",
",",
"reg_names",
"[",
"MMIX_OUTPUT_REGNO",
"(",
"REGNO",
"(",
"x1",
")",
")",
"]",
")",
";",
"if",
"(",
"REG_P",
"(",
"x2",
")",
")",
"{",
"fprintf",
"(",
"stream",
",",
"\"%s\"",
",",
"reg_names",
"[",
"MMIX_OUTPUT_REGNO",
"(",
"REGNO",
"(",
"x2",
")",
")",
"]",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"satisfies_constraint_I",
"(",
"x2",
")",
")",
"{",
"output_addr_const",
"(",
"stream",
",",
"x2",
")",
";",
"return",
";",
"}",
"}",
"}",
"if",
"(",
"TARGET_BASE_ADDRESSES",
"&&",
"mmix_legitimate_constant_p",
"(",
"Pmode",
",",
"x",
")",
")",
"{",
"output_addr_const",
"(",
"stream",
",",
"x",
")",
";",
"return",
";",
"}",
"fatal_insn",
"(",
"\"MMIX Internal: This is not a recognized address\"",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"PRINT_OPERAND_ADDRESS",
"."
] | [
"mmix",
"\"%s,0\"",
"0",
"1",
"\"%s,\"",
"\"%s\"",
"\"MMIX Internal: This is not a recognized address\""
] | mmix | mmix_print_operand_address | mmix | CPU | GCC | 16,342 | 180 | 1 | [] |
[
"<s>",
"void",
"setKind",
"(",
"BaseKind",
"K",
")",
"{",
"assert",
"(",
"!",
"isSet",
"(",
")",
"&&",
"\"Can't change kind with non-zero base\"",
")",
";",
"Kind",
"=",
"K",
";",
"}",
"</s>"
] | [
"Setter",
"for",
"the",
"kind",
"of",
"this",
"node",
"."
] | [
"WebAssembly",
"\"Can't change kind with non-zero base\""
] | WebAssemblyFastISel (2)2 | setKind | WebAssembly | Virtual ISA | LLVM | 16,343 | 22 | 1 | [] |
[
"<s>",
"void",
"PPCDispatchGroupSBHazardRecognizer",
"::",
"EmitNoop",
"(",
")",
"{",
"unsigned",
"Directive",
"=",
"DAG",
"->",
"TM",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
".",
"getDarwinDirective",
"(",
")",
";",
"if",
"(",
"Directive",
"==",
"PPC",
"::",
"DIR_PWR6",
"||",
"Directive",
"==",
"PPC",
"::",
"DIR_PWR7",
"||",
"Directive",
"==",
"PPC",
"::",
"DIR_PWR8",
"||",
"CurSlots",
"==",
"6",
")",
"{",
"CurGroup",
".",
"clear",
"(",
")",
";",
"CurSlots",
"=",
"CurBranches",
"=",
"0",
";",
"}",
"else",
"{",
"CurGroup",
".",
"push_back",
"(",
"nullptr",
")",
";",
"++",
"CurSlots",
";",
"}",
"}",
"</s>"
] | [
"EmitNoop",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"a",
"noop",
"was",
"added",
"to",
"the",
"instruction",
"stream",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC::DIR_PWR6",
"PPC::DIR_PWR7",
"PPC::DIR_PWR8",
"6",
"0"
] | PPCHazardRecognizers29 | EmitNoop | PowerPC | CPU | LLVM | 16,344 | 77 | 1 | [] |
[
"<s>",
"DEBUG_FUNCTION",
"char",
"*",
"rs6000_debug_addr_mask",
"(",
"addr_mask_type",
"mask",
",",
"bool",
"keep_spaces",
")",
"{",
"static",
"char",
"ret",
"[",
"8",
"]",
";",
"char",
"*",
"p",
"=",
"ret",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_VALID",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'v'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_MULTIPLE",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'m'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_INDEXED",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'i'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_QUAD_OFFSET",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'O'",
";",
"else",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_OFFSET",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'o'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_PRE_INCDEC",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'+'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_PRE_MODIFY",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'+'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_AND_M16",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'&'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"*",
"p",
"=",
"'\\0'",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Inner",
"function",
"printing",
"just",
"the",
"address",
"mask",
"for",
"a",
"particular",
"reload",
"register",
"class",
"."
] | [
"rs6000",
"8",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] | rs6000 | rs6000_debug_addr_mask | rs6000 | CPU | GCC | 16,345 | 240 | 1 | [] |
[
"<s>",
"BitVector",
"RISCVRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"RISCVFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"for",
"(",
"size_t",
"Reg",
"=",
"0",
";",
"Reg",
"<",
"getNumRegs",
"(",
")",
";",
"Reg",
"++",
")",
"{",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
".",
"isRegisterReservedByUser",
"(",
"Reg",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"Reg",
")",
";",
"}",
"markSuperRegs",
"(",
"Reserved",
",",
"RISCV",
"::",
"X0",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"RISCV",
"::",
"X2",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"RISCV",
"::",
"X3",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"RISCV",
"::",
"X4",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"RISCV",
"::",
"X8",
")",
";",
"if",
"(",
"TFI",
"->",
"hasBP",
"(",
"MF",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"RISCVABI",
"::",
"getBPReg",
"(",
")",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"RISCV",
"::",
"VL",
")",
";",
"assert",
"(",
"checkAllSuperRegsMarked",
"(",
"Reserved",
")",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"0",
"RISCV",
"RISCV::X0",
"RISCV::X2",
"RISCV::X3",
"RISCV::X4",
"RISCV::X8",
"RISCVABI::getBPReg",
"RISCV::VL"
] | RISCVRegisterInfo21 | getReservedRegs | RISCV | CPU | LLVM | 16,346 | 166 | 1 | [] |
[
"<s>",
"void",
"SIRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"*",
"FrameInfo",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"const",
"SIInstrInfo",
"*",
"TII",
"=",
"static_cast",
"<",
"const",
"SIInstrInfo",
"*",
">",
"(",
"ST",
".",
"getInstrInfo",
"(",
")",
")",
";",
"MachineOperand",
"&",
"FIOp",
"=",
"MI",
"->",
"getOperand",
"(",
"FIOperandNum",
")",
";",
"int",
"Index",
"=",
"MI",
"->",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getIndex",
"(",
")",
";",
"int64_t",
"Offset",
"=",
"FrameInfo",
"->",
"getObjectOffset",
"(",
"Index",
")",
";",
"FIOp",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"if",
"(",
"!",
"TII",
"->",
"isImmOperandLegal",
"(",
"MI",
",",
"FIOperandNum",
",",
"FIOp",
")",
")",
"{",
"unsigned",
"TmpReg",
"=",
"RS",
"->",
"scavengeRegister",
"(",
"&",
"AMDGPU",
"::",
"VReg_32RegClass",
",",
"MI",
",",
"SPAdj",
")",
";",
"BuildMI",
"(",
"*",
"MI",
"->",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"V_MOV_B32_e32",
")",
",",
"TmpReg",
")",
".",
"addImm",
"(",
"Offset",
")",
";",
"FIOp",
".",
"ChangeToRegister",
"(",
"TmpReg",
",",
"false",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"R600",
"SI",
"SI",
"SI"
] | SIRegisterInfo102 | eliminateFrameIndex | R600 | GPU | LLVM | 16,347 | 184 | 1 | [] |
[
"<s>",
"BitVector",
"SIRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"INDIRECT_BASE_ADDR",
")",
";",
"const",
"SIInstrInfo",
"*",
"TII",
"=",
"static_cast",
"<",
"const",
"SIInstrInfo",
"*",
">",
"(",
"ST",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TII",
"->",
"reserveIndirectRegisters",
"(",
"Reserved",
",",
"MF",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"R600",
"SI",
"SI",
"SI"
] | SIRegisterInfo3 | getReservedRegs | R600 | GPU | LLVM | 16,348 | 70 | 1 | [] |
[
"<s>",
"void",
"SITargetLowering",
"::",
"finalizeLowering",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"Info",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"Info",
"->",
"isEntryFunction",
"(",
")",
")",
"{",
"reservePrivateMemoryRegs",
"(",
"getTargetMachine",
"(",
")",
",",
"MF",
",",
"*",
"TRI",
",",
"*",
"Info",
")",
";",
"}",
"bool",
"NeedSP",
"=",
"!",
"Info",
"->",
"isEntryFunction",
"(",
")",
"||",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
".",
"hasCalls",
"(",
")",
";",
"if",
"(",
"NeedSP",
")",
"{",
"unsigned",
"ReservedStackPtrOffsetReg",
"=",
"TRI",
"->",
"reservedStackPtrOffsetReg",
"(",
"MF",
")",
";",
"Info",
"->",
"setStackPtrOffsetReg",
"(",
"ReservedStackPtrOffsetReg",
")",
";",
"assert",
"(",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
"!=",
"Info",
"->",
"getFrameOffsetReg",
"(",
")",
")",
";",
"assert",
"(",
"!",
"TRI",
"->",
"isSubRegister",
"(",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
")",
";",
"if",
"(",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"SP_REG",
")",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"SP_REG",
",",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
";",
"}",
"if",
"(",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"PRIVATE_RSRC_REG",
")",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"PRIVATE_RSRC_REG",
",",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
")",
";",
"if",
"(",
"Info",
"->",
"getFrameOffsetReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"FP_REG",
")",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"FP_REG",
",",
"Info",
"->",
"getFrameOffsetReg",
"(",
")",
")",
";",
"if",
"(",
"Info",
"->",
"getScratchWaveOffsetReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"SCRATCH_WAVE_OFFSET_REG",
")",
"{",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"SCRATCH_WAVE_OFFSET_REG",
",",
"Info",
"->",
"getScratchWaveOffsetReg",
"(",
")",
")",
";",
"}",
"Info",
"->",
"limitOccupancy",
"(",
"MF",
")",
";",
"TargetLoweringBase",
"::",
"finalizeLowering",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Execute",
"target",
"specific",
"actions",
"to",
"finalize",
"target",
"lowering",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"AMDGPU::SP_REG",
"AMDGPU::SP_REG",
"AMDGPU::PRIVATE_RSRC_REG",
"AMDGPU::PRIVATE_RSRC_REG",
"AMDGPU::FP_REG",
"AMDGPU::FP_REG",
"AMDGPU::SCRATCH_WAVE_OFFSET_REG",
"AMDGPU::SCRATCH_WAVE_OFFSET_REG"
] | SIISelLowering103 | finalizeLowering | AMDGPU | GPU | LLVM | 16,349 | 287 | 1 | [] |
[
"<s>",
"static",
"rtx",
"altivec_expand_st_builtin",
"(",
"tree",
"exp",
",",
"rtx",
"target",
"ATTRIBUTE_UNUSED",
",",
"bool",
"*",
"expandedp",
")",
"{",
"tree",
"fndecl",
"=",
"TREE_OPERAND",
"(",
"CALL_EXPR_FN",
"(",
"exp",
")",
",",
"0",
")",
";",
"unsigned",
"int",
"fcode",
"=",
"DECL_FUNCTION_CODE",
"(",
"fndecl",
")",
";",
"tree",
"arg0",
",",
"arg1",
";",
"machine_mode",
"mode0",
",",
"mode1",
";",
"rtx",
"pat",
",",
"op0",
",",
"op1",
";",
"enum",
"insn_code",
"icode",
";",
"switch",
"(",
"fcode",
")",
"{",
"case",
"ALTIVEC_BUILTIN_ST_INTERNAL_16qi",
":",
"icode",
"=",
"CODE_FOR_vector_altivec_store_v16qi",
";",
"break",
";",
"case",
"ALTIVEC_BUILTIN_ST_INTERNAL_8hi",
":",
"icode",
"=",
"CODE_FOR_vector_altivec_store_v8hi",
";",
"break",
";",
"case",
"ALTIVEC_BUILTIN_ST_INTERNAL_4si",
":",
"icode",
"=",
"CODE_FOR_vector_altivec_store_v4si",
";",
"break",
";",
"case",
"ALTIVEC_BUILTIN_ST_INTERNAL_4sf",
":",
"icode",
"=",
"CODE_FOR_vector_altivec_store_v4sf",
";",
"break",
";",
"case",
"ALTIVEC_BUILTIN_ST_INTERNAL_2df",
":",
"icode",
"=",
"CODE_FOR_vector_altivec_store_v2df",
";",
"break",
";",
"case",
"ALTIVEC_BUILTIN_ST_INTERNAL_2di",
":",
"icode",
"=",
"CODE_FOR_vector_altivec_store_v2di",
";",
"break",
";",
"case",
"ALTIVEC_BUILTIN_ST_INTERNAL_1ti",
":",
"icode",
"=",
"CODE_FOR_vector_altivec_store_v1ti",
";",
"break",
";",
"default",
":",
"*",
"expandedp",
"=",
"false",
";",
"return",
"NULL_RTX",
";",
"}",
"arg0",
"=",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"0",
")",
";",
"arg1",
"=",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"1",
")",
";",
"op0",
"=",
"expand_normal",
"(",
"arg0",
")",
";",
"op1",
"=",
"expand_normal",
"(",
"arg1",
")",
";",
"mode0",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"mode",
";",
"mode1",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"1",
"]",
".",
"mode",
";",
"if",
"(",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"predicate",
")",
"(",
"op0",
",",
"mode0",
")",
")",
"op0",
"=",
"gen_rtx_MEM",
"(",
"mode0",
",",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"op0",
")",
")",
";",
"if",
"(",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"1",
"]",
".",
"predicate",
")",
"(",
"op1",
",",
"mode1",
")",
")",
"op1",
"=",
"copy_to_mode_reg",
"(",
"mode1",
",",
"op1",
")",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"op0",
",",
"op1",
")",
";",
"if",
"(",
"pat",
")",
"emit_insn",
"(",
"pat",
")",
";",
"*",
"expandedp",
"=",
"true",
";",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"stvx",
"builtins",
"."
] | [
"rs6000",
"0",
"0",
"1",
"0",
"1",
"0",
"1"
] | rs60006 | altivec_expand_st_builtin | rs6000 | CPU | GCC | 16,350 | 297 | 1 | [] |
[
"<s>",
"bool",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCRelaxableFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"override",
"{",
"llvm_unreachable",
"(",
"\"RelaxInstruction() unimplemented\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"Nios2",
"\"RelaxInstruction() unimplemented\""
] | Nios2AsmBackend | fixupNeedsRelaxation | Nios2 | MPU | LLVM | 16,351 | 33 | 1 | [] |
[
"<s>",
"void",
"MipsTargetStreamer",
"::",
"emitLoadWithImmOffset",
"(",
"unsigned",
"Opcode",
",",
"unsigned",
"DstReg",
",",
"unsigned",
"BaseReg",
",",
"int64_t",
"Offset",
",",
"unsigned",
"TmpReg",
",",
"SMLoc",
"IDLoc",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"{",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Offset",
")",
")",
"{",
"emitRRI",
"(",
"Opcode",
",",
"DstReg",
",",
"BaseReg",
",",
"Offset",
",",
"IDLoc",
",",
"STI",
")",
";",
"return",
";",
"}",
"unsigned",
"LoOffset",
"=",
"Offset",
"&",
"0x0000ffff",
";",
"unsigned",
"HiOffset",
"=",
"(",
"Offset",
"&",
"0xffff0000",
")",
">>",
"16",
";",
"if",
"(",
"LoOffset",
"&",
"0x8000",
")",
"HiOffset",
"++",
";",
"emitRI",
"(",
"Mips",
"::",
"LUi",
",",
"TmpReg",
",",
"HiOffset",
",",
"IDLoc",
",",
"STI",
")",
";",
"if",
"(",
"BaseReg",
"!=",
"Mips",
"::",
"ZERO",
")",
"emitRRR",
"(",
"Mips",
"::",
"ADDu",
",",
"TmpReg",
",",
"TmpReg",
",",
"BaseReg",
",",
"IDLoc",
",",
"STI",
")",
";",
"emitRRI",
"(",
"Opcode",
",",
"DstReg",
",",
"TmpReg",
",",
"LoOffset",
",",
"IDLoc",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"load",
"instruction",
"with",
"an",
"immediate",
"offset",
"."
] | [
"Mips",
"Mips",
"16",
"0x0000ffff",
"0xffff0000",
"16",
"0x8000",
"Mips::LUi",
"Mips::ZERO",
"Mips::ADDu"
] | MipsTargetStreamer (2)1 | emitLoadWithImmOffset | Mips | CPU | LLVM | 16,352 | 141 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Lanai DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Lanai",
"\"Lanai DAG->DAG Pattern Instruction Selection\""
] | LanaiISelDAGToDAG12 | getPassName | Lanai | CPU | LLVM | 16,353 | 11 | 1 | [] |
[
"<s>",
"DEBUG_FUNCTION",
"char",
"*",
"rs6000_debug_addr_mask",
"(",
"addr_mask_type",
"mask",
",",
"bool",
"keep_spaces",
")",
"{",
"static",
"char",
"ret",
"[",
"8",
"]",
";",
"char",
"*",
"p",
"=",
"ret",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_VALID",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'v'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_MULTIPLE",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'m'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_INDEXED",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'i'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_QUAD_OFFSET",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'O'",
";",
"else",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_OFFSET",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'o'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_PRE_INCDEC",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'+'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_PRE_MODIFY",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'+'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"(",
"mask",
"&",
"RELOAD_REG_AND_M16",
")",
"!=",
"0",
")",
"*",
"p",
"++",
"=",
"'&'",
";",
"else",
"if",
"(",
"keep_spaces",
")",
"*",
"p",
"++",
"=",
"' '",
";",
"*",
"p",
"=",
"'\\0'",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Inner",
"function",
"printing",
"just",
"the",
"address",
"mask",
"for",
"a",
"particular",
"reload",
"register",
"class",
"."
] | [
"powerpcspe",
"8",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] | powerpcspe | rs6000_debug_addr_mask | powerpcspe | CPU | GCC | 16,354 | 240 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_i387_mode_needed",
"(",
"int",
"entity",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"enum",
"attr_i387_cw",
"mode",
";",
"if",
"(",
"CALL_P",
"(",
"insn",
")",
"||",
"(",
"NONJUMP_INSN_P",
"(",
"insn",
")",
"&&",
"(",
"asm_noperands",
"(",
"PATTERN",
"(",
"insn",
")",
")",
">=",
"0",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"ASM_INPUT",
")",
")",
")",
"return",
"I387_CW_UNINITIALIZED",
";",
"if",
"(",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"return",
"I387_CW_ANY",
";",
"mode",
"=",
"get_attr_i387_cw",
"(",
"insn",
")",
";",
"switch",
"(",
"entity",
")",
"{",
"case",
"I387_TRUNC",
":",
"if",
"(",
"mode",
"==",
"I387_CW_TRUNC",
")",
"return",
"mode",
";",
"break",
";",
"case",
"I387_FLOOR",
":",
"if",
"(",
"mode",
"==",
"I387_CW_FLOOR",
")",
"return",
"mode",
";",
"break",
";",
"case",
"I387_CEIL",
":",
"if",
"(",
"mode",
"==",
"I387_CW_CEIL",
")",
"return",
"mode",
";",
"break",
";",
"case",
"I387_MASK_PM",
":",
"if",
"(",
"mode",
"==",
"I387_CW_MASK_PM",
")",
"return",
"mode",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"I387_CW_ANY",
";",
"}",
"</s>"
] | [
"Return",
"mode",
"that",
"i387",
"must",
"be",
"switched",
"into",
"prior",
"to",
"the",
"execution",
"of",
"insn",
"."
] | [
"i386",
"0",
"0"
] | i3864 | ix86_i387_mode_needed | i386 | CPU | GCC | 16,355 | 146 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_emit_probe_stack_range",
"(",
"HOST_WIDE_INT",
"first",
",",
"HOST_WIDE_INT",
"size",
",",
"unsigned",
"int",
"regno1",
",",
"unsigned",
"long",
"live_regs",
")",
"{",
"rtx",
"reg1",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"regno1",
")",
";",
"if",
"(",
"size",
"<=",
"PROBE_INTERVAL",
")",
"{",
"emit_move_insn",
"(",
"reg1",
",",
"GEN_INT",
"(",
"first",
"+",
"PROBE_INTERVAL",
")",
")",
";",
"emit_set_insn",
"(",
"reg1",
",",
"gen_rtx_MINUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"reg1",
")",
")",
";",
"emit_stack_probe",
"(",
"plus_constant",
"(",
"Pmode",
",",
"reg1",
",",
"PROBE_INTERVAL",
"-",
"size",
")",
")",
";",
"}",
"else",
"if",
"(",
"size",
"<=",
"5",
"*",
"PROBE_INTERVAL",
")",
"{",
"HOST_WIDE_INT",
"i",
",",
"rem",
";",
"emit_move_insn",
"(",
"reg1",
",",
"GEN_INT",
"(",
"first",
"+",
"PROBE_INTERVAL",
")",
")",
";",
"emit_set_insn",
"(",
"reg1",
",",
"gen_rtx_MINUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"reg1",
")",
")",
";",
"emit_stack_probe",
"(",
"reg1",
")",
";",
"for",
"(",
"i",
"=",
"2",
"*",
"PROBE_INTERVAL",
";",
"i",
"<",
"size",
";",
"i",
"+=",
"PROBE_INTERVAL",
")",
"{",
"emit_set_insn",
"(",
"reg1",
",",
"plus_constant",
"(",
"Pmode",
",",
"reg1",
",",
"-",
"PROBE_INTERVAL",
")",
")",
";",
"emit_stack_probe",
"(",
"reg1",
")",
";",
"}",
"rem",
"=",
"size",
"-",
"(",
"i",
"-",
"PROBE_INTERVAL",
")",
";",
"if",
"(",
"rem",
">",
"4095",
"||",
"(",
"TARGET_THUMB2",
"&&",
"rem",
">",
"255",
")",
")",
"{",
"emit_set_insn",
"(",
"reg1",
",",
"plus_constant",
"(",
"Pmode",
",",
"reg1",
",",
"-",
"PROBE_INTERVAL",
")",
")",
";",
"emit_stack_probe",
"(",
"plus_constant",
"(",
"Pmode",
",",
"reg1",
",",
"PROBE_INTERVAL",
"-",
"rem",
")",
")",
";",
"}",
"else",
"emit_stack_probe",
"(",
"plus_constant",
"(",
"Pmode",
",",
"reg1",
",",
"-",
"rem",
")",
")",
";",
"}",
"else",
"{",
"HOST_WIDE_INT",
"rounded_size",
";",
"struct",
"scratch_reg",
"sr",
";",
"get_scratch_register_on_entry",
"(",
"&",
"sr",
",",
"regno1",
",",
"live_regs",
")",
";",
"emit_move_insn",
"(",
"reg1",
",",
"GEN_INT",
"(",
"first",
")",
")",
";",
"rounded_size",
"=",
"size",
"&",
"-",
"PROBE_INTERVAL",
";",
"emit_move_insn",
"(",
"sr",
".",
"reg",
",",
"GEN_INT",
"(",
"rounded_size",
")",
")",
";",
"emit_set_insn",
"(",
"reg1",
",",
"gen_rtx_MINUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"reg1",
")",
")",
";",
"emit_set_insn",
"(",
"sr",
".",
"reg",
",",
"gen_rtx_MINUS",
"(",
"Pmode",
",",
"reg1",
",",
"sr",
".",
"reg",
")",
")",
";",
"emit_insn",
"(",
"gen_probe_stack_range",
"(",
"reg1",
",",
"reg1",
",",
"sr",
".",
"reg",
")",
")",
";",
"if",
"(",
"size",
"!=",
"rounded_size",
")",
"{",
"HOST_WIDE_INT",
"rem",
"=",
"size",
"-",
"rounded_size",
";",
"if",
"(",
"rem",
">",
"4095",
"||",
"(",
"TARGET_THUMB2",
"&&",
"rem",
">",
"255",
")",
")",
"{",
"emit_set_insn",
"(",
"sr",
".",
"reg",
",",
"plus_constant",
"(",
"Pmode",
",",
"sr",
".",
"reg",
",",
"-",
"PROBE_INTERVAL",
")",
")",
";",
"emit_stack_probe",
"(",
"plus_constant",
"(",
"Pmode",
",",
"sr",
".",
"reg",
",",
"PROBE_INTERVAL",
"-",
"rem",
")",
")",
";",
"}",
"else",
"emit_stack_probe",
"(",
"plus_constant",
"(",
"Pmode",
",",
"sr",
".",
"reg",
",",
"-",
"rem",
")",
")",
";",
"}",
"release_scratch_register_on_entry",
"(",
"&",
"sr",
")",
";",
"}",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"probe",
"a",
"range",
"of",
"stack",
"addresses",
"from",
"FIRST",
"to",
"FIRST+SIZE",
",",
"inclusive",
".",
"These",
"are",
"offsets",
"from",
"the",
"current",
"stack",
"pointer",
".",
"REGNO1",
"is",
"the",
"index",
"number",
"of",
"the",
"1st",
"scratch",
"register",
"and",
"LIVE_REGS",
"is",
"the",
"mask",
"of",
"live",
"registers",
"."
] | [
"arm",
"5",
"2",
"4095",
"255",
"4095",
"255"
] | arm | arm_emit_probe_stack_range | arm | CPU | GCC | 16,356 | 422 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"X86InstrInfo",
"::",
"insertOutlinedCall",
"(",
"Module",
"&",
"M",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"It",
",",
"MachineFunction",
"&",
"MF",
",",
"outliner",
"::",
"Candidate",
"&",
"C",
")",
"const",
"{",
"if",
"(",
"C",
".",
"CallConstructionID",
"==",
"MachineOutlinerTailCall",
")",
"{",
"It",
"=",
"MBB",
".",
"insert",
"(",
"It",
",",
"BuildMI",
"(",
"MF",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"TAILJMPd64",
")",
")",
".",
"addGlobalAddress",
"(",
"M",
".",
"getNamedValue",
"(",
"MF",
".",
"getName",
"(",
")",
")",
")",
")",
";",
"}",
"else",
"{",
"It",
"=",
"MBB",
".",
"insert",
"(",
"It",
",",
"BuildMI",
"(",
"MF",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"CALL64pcrel32",
")",
")",
".",
"addGlobalAddress",
"(",
"M",
".",
"getNamedValue",
"(",
"MF",
".",
"getName",
"(",
")",
")",
")",
")",
";",
"}",
"return",
"It",
";",
"}",
"</s>"
] | [
"Insert",
"a",
"call",
"to",
"an",
"outlined",
"function",
"into",
"the",
"program",
"."
] | [
"X86",
"X86",
"X86::TAILJMPd64",
"X86::CALL64pcrel32"
] | X86InstrInfo64 | insertOutlinedCall | X86 | CPU | LLVM | 16,357 | 128 | 1 | [] |
[
"<s>",
"void",
"MipsTargetLowering",
"::",
"getOpndList",
"(",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"std",
"::",
"deque",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"SDValue",
">",
">",
"&",
"RegsToPass",
",",
"bool",
"IsPICCall",
",",
"bool",
"GlobalOrExternal",
",",
"bool",
"InternalLinkage",
",",
"CallLoweringInfo",
"&",
"CLI",
",",
"SDValue",
"Callee",
",",
"SDValue",
"Chain",
")",
"const",
"{",
"if",
"(",
"IsPICCall",
"&&",
"!",
"InternalLinkage",
")",
"{",
"unsigned",
"GPReg",
"=",
"Subtarget",
"->",
"isABI_N64",
"(",
")",
"?",
"Mips",
"::",
"GP_64",
":",
"Mips",
"::",
"GP",
";",
"EVT",
"Ty",
"=",
"Subtarget",
"->",
"isABI_N64",
"(",
")",
"?",
"MVT",
"::",
"i64",
":",
"MVT",
"::",
"i32",
";",
"RegsToPass",
".",
"push_back",
"(",
"std",
"::",
"make_pair",
"(",
"GPReg",
",",
"getGlobalReg",
"(",
"CLI",
".",
"DAG",
",",
"Ty",
")",
")",
")",
";",
"}",
"SDValue",
"InFlag",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RegsToPass",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"Chain",
"=",
"CLI",
".",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"CLI",
".",
"DL",
",",
"RegsToPass",
"[",
"i",
"]",
".",
"first",
",",
"RegsToPass",
"[",
"i",
"]",
".",
"second",
",",
"InFlag",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RegsToPass",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"Ops",
".",
"push_back",
"(",
"CLI",
".",
"DAG",
".",
"getRegister",
"(",
"RegsToPass",
"[",
"i",
"]",
".",
"first",
",",
"RegsToPass",
"[",
"i",
"]",
".",
"second",
".",
"getValueType",
"(",
")",
")",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"getTargetMachine",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"uint32_t",
"*",
"Mask",
"=",
"TRI",
"->",
"getCallPreservedMask",
"(",
"CLI",
".",
"CallConv",
")",
";",
"assert",
"(",
"Mask",
"&&",
"\"Missing call preserved mask for calling convention\"",
")",
";",
"if",
"(",
"Subtarget",
"->",
"inMips16HardFloat",
"(",
")",
")",
"{",
"if",
"(",
"GlobalAddressSDNode",
"*",
"G",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"CLI",
".",
"Callee",
")",
")",
"{",
"llvm",
"::",
"StringRef",
"Sym",
"=",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"getName",
"(",
")",
";",
"Function",
"*",
"F",
"=",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
"Sym",
")",
";",
"if",
"(",
"F",
"&&",
"F",
"->",
"hasFnAttribute",
"(",
"\"__Mips16RetHelper\"",
")",
")",
"{",
"Mask",
"=",
"MipsRegisterInfo",
"::",
"getMips16RetHelperMask",
"(",
")",
";",
"}",
"}",
"}",
"Ops",
".",
"push_back",
"(",
"CLI",
".",
"DAG",
".",
"getRegisterMask",
"(",
"Mask",
")",
")",
";",
"if",
"(",
"InFlag",
".",
"getNode",
"(",
")",
")",
"Ops",
".",
"push_back",
"(",
"InFlag",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"fills",
"Ops",
",",
"which",
"is",
"the",
"list",
"of",
"operands",
"that",
"will",
"later",
"be",
"used",
"when",
"a",
"function",
"call",
"node",
"is",
"created",
"."
] | [
"Mips",
"Mips",
"Mips::GP_64",
"Mips::GP",
"MVT::i64",
"MVT::i32",
"0",
"1",
"0",
"\"Missing call preserved mask for calling convention\"",
"Mips",
"\"__Mips16RetHelper\"",
"Mips",
"Mips"
] | MipsISelLowering (2)1 | getOpndList | Mips | CPU | LLVM | 16,358 | 379 | 1 | [] |
[
"<s>",
"unsigned",
"getPointerSize",
"(",
")",
"const",
"{",
"return",
"4",
";",
"}",
"</s>"
] | [
"Layout",
"pointer",
"size",
"in",
"bytes",
",",
"rounded",
"up",
"to",
"a",
"whole",
"number",
"of",
"bytes",
"."
] | [
"TOY",
"4"
] | TOYAsmBackend1 | getPointerSize | TOY | CPU | LLVM | 16,359 | 10 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"mayBeEmittedAsTailCall",
"(",
"CallInst",
"*",
"CI",
")",
"const",
"{",
"return",
"CI",
"->",
"isTailCall",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"may",
"be",
"able",
"emit",
"the",
"call",
"instruction",
"as",
"a",
"tail",
"call",
"."
] | [
"AArch64",
"AArch64"
] | AArch64ISelLowering (2) | mayBeEmittedAsTailCall | AArch64 | CPU | LLVM | 16,360 | 19 | 1 | [] |
[
"<s>",
"bool",
"isEmpty",
"(",
")",
"const",
"{",
"return",
"Size",
"==",
"0",
";",
"}",
"</s>"
] | [
"isEmpty",
"-",
"Return",
"true",
"if",
"there",
"are",
"no",
"jump",
"tables",
"."
] | [
"TPC",
"0"
] | TPCFrameLowering | isEmpty | TPC | Virtual ISA | LLVM | 16,361 | 12 | 1 | [] |
[
"<s>",
"static",
"void",
"computeKnownBits",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"SDValue",
"Op",
",",
"APInt",
"&",
"KnownZero",
",",
"APInt",
"&",
"KnownOne",
")",
"{",
"if",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"==",
"ARMISD",
"::",
"BFI",
")",
"{",
"computeKnownBits",
"(",
"DAG",
",",
"Op",
".",
"getOperand",
"(",
"0",
")",
",",
"KnownZero",
",",
"KnownOne",
")",
";",
"ConstantSDNode",
"*",
"CI",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
";",
"APInt",
"Mask",
"=",
"CI",
"->",
"getAPIntValue",
"(",
")",
";",
"KnownZero",
"&=",
"Mask",
";",
"KnownOne",
"&=",
"Mask",
";",
"return",
";",
"}",
"if",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"==",
"ARMISD",
"::",
"CMOV",
")",
"{",
"APInt",
"KZ2",
"(",
"KnownZero",
".",
"getBitWidth",
"(",
")",
",",
"0",
")",
";",
"APInt",
"KO2",
"(",
"KnownOne",
".",
"getBitWidth",
"(",
")",
",",
"0",
")",
";",
"computeKnownBits",
"(",
"DAG",
",",
"Op",
".",
"getOperand",
"(",
"1",
")",
",",
"KnownZero",
",",
"KnownOne",
")",
";",
"computeKnownBits",
"(",
"DAG",
",",
"Op",
".",
"getOperand",
"(",
"2",
")",
",",
"KZ2",
",",
"KO2",
")",
";",
"KnownZero",
"&=",
"KZ2",
";",
"KnownOne",
"&=",
"KO2",
";",
"return",
";",
"}",
"return",
"DAG",
".",
"computeKnownBits",
"(",
"Op",
",",
"KnownZero",
",",
"KnownOne",
")",
";",
"}",
"</s>"
] | [
"Determine",
"which",
"bits",
"of",
"Op",
"are",
"known",
"to",
"be",
"either",
"zero",
"or",
"one",
"and",
"return",
"them",
"in",
"Known",
"."
] | [
"ARM",
"ARMISD::BFI",
"0",
"2",
"ARMISD::CMOV",
"0",
"0",
"1",
"2"
] | ARMISelLowering (2)2 | computeKnownBits | ARM | CPU | LLVM | 16,362 | 179 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonTTIImpl",
"::",
"getCacheLineSize",
"(",
")",
"const",
"{",
"return",
"ST",
".",
"getL1CacheLineSize",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"target",
"cache",
"line",
"size",
"in",
"bytes",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo | getCacheLineSize | Hexagon | DSP | LLVM | 16,363 | 16 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_return_in_memory",
"(",
"const_tree",
"type",
",",
"const_tree",
"fndecl",
"ATTRIBUTE_UNUSED",
")",
"{",
"CUMULATIVE_ARGS",
"args",
";",
"cumulative_args_t",
"cum",
"=",
"pack_cumulative_args",
"(",
"&",
"args",
")",
";",
"memset",
"(",
"&",
"args",
",",
"0",
",",
"sizeof",
"args",
")",
";",
"return",
"riscv_pass_by_reference",
"(",
"cum",
",",
"TYPE_MODE",
"(",
"type",
")",
",",
"type",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_RETURN_IN_MEMORY",
"."
] | [
"riscv",
"0"
] | riscv2 | riscv_return_in_memory | riscv | CPU | GCC | 16,364 | 51 | 1 | [] |
[
"<s>",
"void",
"assignValueToAddress",
"(",
"unsigned",
"ValVReg",
",",
"unsigned",
"Addr",
",",
"uint64_t",
"Size",
",",
"MachinePointerInfo",
"&",
"MPO",
",",
"CCValAssign",
"&",
"VA",
")",
"override",
"{",
"assert",
"(",
"(",
"Size",
"==",
"1",
"||",
"Size",
"==",
"2",
"||",
"Size",
"==",
"4",
"||",
"Size",
"==",
"8",
")",
"&&",
"\"Unsupported size\"",
")",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"SExt",
"||",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"ZExt",
")",
"{",
"Size",
"=",
"4",
";",
"assert",
"(",
"MRI",
".",
"getType",
"(",
"ValVReg",
")",
".",
"isScalar",
"(",
")",
"&&",
"\"Only scalars supported atm\"",
")",
";",
"MRI",
".",
"setType",
"(",
"ValVReg",
",",
"LLT",
"::",
"scalar",
"(",
"32",
")",
")",
";",
"}",
"auto",
"MMO",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getMachineMemOperand",
"(",
"MPO",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"Size",
",",
"0",
")",
";",
"MIRBuilder",
".",
"buildLoad",
"(",
"ValVReg",
",",
"Addr",
",",
"*",
"MMO",
")",
";",
"}",
"</s>"
] | [
"An",
"overload",
"which",
"takes",
"an",
"ArgInfo",
"if",
"additional",
"information",
"about",
"the",
"arg",
"is",
"needed",
"."
] | [
"ARM",
"1",
"2",
"4",
"8",
"\"Unsupported size\"",
"4",
"\"Only scalars supported atm\"",
"32",
"0"
] | ARMCallLowering18 | assignValueToAddress | ARM | CPU | LLVM | 16,365 | 138 | 1 | [] |
[
"<s>",
"bool",
"isValid",
"(",
")",
"const",
"{",
"return",
"Valid",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"this",
"iterator",
"is",
"still",
"pointing",
"at",
"a",
"valid",
"entry",
"."
] | [
"Hexagon"
] | HexagonShuffler | isValid | Hexagon | DSP | LLVM | 16,366 | 10 | 1 | [] |
[
"<s>",
"int",
"arm_early_load_addr_dep_ptr",
"(",
"rtx",
"producer",
",",
"rtx",
"consumer",
")",
"{",
"rtx",
"value",
"=",
"arm_find_sub_rtx_with_code",
"(",
"PATTERN",
"(",
"producer",
")",
",",
"SET",
",",
"false",
")",
";",
"rtx",
"addr",
"=",
"arm_find_sub_rtx_with_code",
"(",
"PATTERN",
"(",
"consumer",
")",
",",
"SET",
",",
"false",
")",
";",
"if",
"(",
"!",
"value",
"||",
"!",
"addr",
"||",
"!",
"MEM_P",
"(",
"SET_SRC",
"(",
"value",
")",
")",
")",
"return",
"0",
";",
"value",
"=",
"SET_DEST",
"(",
"value",
")",
";",
"addr",
"=",
"SET_SRC",
"(",
"addr",
")",
";",
"return",
"GET_MODE",
"(",
"value",
")",
"==",
"Pmode",
"&&",
"reg_overlap_mentioned_p",
"(",
"value",
",",
"addr",
")",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"the",
"CONSUMER",
"instruction",
"(",
"a",
"load",
")",
"does",
"need",
"a",
"Pmode",
"PRODUCER",
"'s",
"value",
"to",
"calculate",
"the",
"address",
"."
] | [
"arm",
"0"
] | aarch-common | arm_early_load_addr_dep_ptr | arm | CPU | GCC | 16,367 | 90 | 1 | [] |
[
"<s>",
"void",
"NVPTXPassConfig",
"::",
"addFastRegAlloc",
"(",
"FunctionPass",
"*",
"RegAllocPass",
")",
"{",
"assert",
"(",
"!",
"RegAllocPass",
"&&",
"\"NVPTX uses no regalloc!\"",
")",
";",
"addPass",
"(",
"&",
"StrongPHIEliminationID",
")",
";",
"}",
"</s>"
] | [
"addFastRegAlloc",
"-",
"Add",
"the",
"minimum",
"set",
"of",
"target-independent",
"passes",
"that",
"are",
"required",
"for",
"fast",
"register",
"allocation",
"."
] | [
"NVPTX",
"NVPTX",
"\"NVPTX uses no regalloc!\""
] | NVPTXTargetMachine3 | addFastRegAlloc | NVPTX | GPU | LLVM | 16,368 | 25 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"replaceBranchWithTailCall",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"BranchCond",
",",
"const",
"MachineInstr",
"&",
"TailCall",
")",
"const",
"{",
"assert",
"(",
"canMakeTailCallConditional",
"(",
"BranchCond",
",",
"TailCall",
")",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"--",
"I",
";",
"if",
"(",
"I",
"->",
"isDebugValue",
"(",
")",
")",
"continue",
";",
"if",
"(",
"!",
"I",
"->",
"isBranch",
"(",
")",
")",
"assert",
"(",
"0",
"&&",
"\"Can't find the branch to replace!\"",
")",
";",
"X86",
"::",
"CondCode",
"CC",
"=",
"X86",
"::",
"getCondFromBranchOpc",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
";",
"assert",
"(",
"BranchCond",
".",
"size",
"(",
")",
"==",
"1",
")",
";",
"if",
"(",
"CC",
"!=",
"BranchCond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
"continue",
";",
"break",
";",
"}",
"unsigned",
"Opc",
"=",
"TailCall",
".",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"TCRETURNdi",
"?",
"X86",
"::",
"TCRETURNdicc",
":",
"X86",
"::",
"TCRETURNdi64cc",
";",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"MBB",
".",
"findDebugLoc",
"(",
"I",
")",
",",
"get",
"(",
"Opc",
")",
")",
";",
"MIB",
"->",
"addOperand",
"(",
"TailCall",
".",
"getOperand",
"(",
"0",
")",
")",
";",
"MIB",
".",
"addImm",
"(",
"0",
")",
";",
"MIB",
"->",
"addOperand",
"(",
"BranchCond",
"[",
"0",
"]",
")",
";",
"MIB",
".",
"copyImplicitOps",
"(",
"TailCall",
")",
";",
"LivePhysRegs",
"LiveRegs",
"(",
"getRegisterInfo",
"(",
")",
")",
";",
"LiveRegs",
".",
"addLiveOuts",
"(",
"MBB",
")",
";",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"MachineOperand",
"*",
">",
",",
"8",
">",
"Clobbers",
";",
"LiveRegs",
".",
"stepForward",
"(",
"*",
"MIB",
",",
"Clobbers",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"C",
":",
"Clobbers",
")",
"{",
"MIB",
".",
"addReg",
"(",
"C",
".",
"first",
",",
"RegState",
"::",
"Implicit",
")",
";",
"MIB",
".",
"addReg",
"(",
"C",
".",
"first",
",",
"RegState",
"::",
"Implicit",
"|",
"RegState",
"::",
"Define",
")",
";",
"}",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"</s>"
] | [
"Replace",
"the",
"conditional",
"branch",
"in",
"MBB",
"with",
"a",
"conditional",
"tail",
"call",
"."
] | [
"X86",
"X86",
"0",
"\"Can't find the branch to replace!\"",
"X86::CondCode",
"X86::getCondFromBranchOpc",
"1",
"0",
"X86::TCRETURNdi",
"X86::TCRETURNdicc",
"X86::TCRETURNdi64cc",
"0",
"0",
"0",
"8"
] | X86InstrInfo113 | replaceBranchWithTailCall | X86 | CPU | LLVM | 16,369 | 298 | 1 | [] |
[
"<s>",
"void",
"mips_output_ascii",
"(",
"FILE",
"*",
"stream",
",",
"const",
"char",
"*",
"string",
",",
"size_t",
"len",
")",
"{",
"size_t",
"i",
";",
"int",
"cur_pos",
";",
"cur_pos",
"=",
"17",
";",
"fprintf",
"(",
"stream",
",",
"\"\\t.ascii\\t\\\"\"",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"len",
";",
"i",
"++",
")",
"{",
"int",
"c",
";",
"c",
"=",
"(",
"unsigned",
"char",
")",
"string",
"[",
"i",
"]",
";",
"if",
"(",
"ISPRINT",
"(",
"c",
")",
")",
"{",
"if",
"(",
"c",
"==",
"'\\\\'",
"||",
"c",
"==",
"'\\\"'",
")",
"{",
"putc",
"(",
"'\\\\'",
",",
"stream",
")",
";",
"cur_pos",
"++",
";",
"}",
"putc",
"(",
"c",
",",
"stream",
")",
";",
"cur_pos",
"++",
";",
"}",
"else",
"{",
"fprintf",
"(",
"stream",
",",
"\"\\\\%03o\"",
",",
"c",
")",
";",
"cur_pos",
"+=",
"4",
";",
"}",
"if",
"(",
"cur_pos",
">",
"72",
"&&",
"i",
"+",
"1",
"<",
"len",
")",
"{",
"cur_pos",
"=",
"17",
";",
"fprintf",
"(",
"stream",
",",
"\"\\\"\\n\\t.ascii\\t\\\"\"",
")",
";",
"}",
"}",
"fprintf",
"(",
"stream",
",",
"\"\\\"\\n\"",
")",
";",
"}",
"</s>"
] | [
"Output",
"an",
"ASCII",
"string",
",",
"in",
"a",
"space-saving",
"way",
".",
"PREFIX",
"is",
"the",
"string",
"that",
"should",
"be",
"written",
"before",
"the",
"opening",
"quote",
",",
"such",
"as",
"``",
"\\t.ascii\\t",
"''",
"for",
"real",
"string",
"data",
"or",
"``",
"\\t",
"#",
"``",
"for",
"a",
"comment",
"."
] | [
"mips",
"17",
"\"\\t.ascii\\t\\\"\"",
"0",
"\"\\\\%03o\"",
"4",
"72",
"1",
"17",
"\"\\\"\\n\\t.ascii\\t\\\"\"",
"\"\\\"\\n\""
] | mips | mips_output_ascii | mips | CPU | GCC | 16,370 | 152 | 1 | [] |
[
"<s>",
"SDValue",
"LanaiSelectionDAGInfo",
"::",
"EmitTargetCodeForMemcpy",
"(",
"SelectionDAG",
"&",
",",
"const",
"SDLoc",
"&",
",",
"SDValue",
",",
"SDValue",
",",
"SDValue",
",",
"SDValue",
"Size",
",",
"Align",
",",
"bool",
",",
"bool",
",",
"bool",
",",
"MachinePointerInfo",
",",
"MachinePointerInfo",
")",
"const",
"{",
"ConstantSDNode",
"*",
"ConstantSize",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
";",
"if",
"(",
"!",
"ConstantSize",
")",
"return",
"SDValue",
"(",
")",
";",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memcpy",
"."
] | [
"Lanai",
"Lanai"
] | LanaiSelectionDAGInfo4 | EmitTargetCodeForMemcpy | Lanai | CPU | LLVM | 16,371 | 63 | 1 | [] |
[
"<s>",
"FastISel",
"*",
"PPC",
"::",
"createFastISel",
"(",
"FunctionLoweringInfo",
"&",
"FuncInfo",
",",
"const",
"TargetLibraryInfo",
"*",
"LibInfo",
")",
"{",
"const",
"TargetMachine",
"&",
"TM",
"=",
"FuncInfo",
".",
"MF",
"->",
"getTarget",
"(",
")",
";",
"const",
"PPCSubtarget",
"*",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isPPC64",
"(",
")",
"&&",
"Subtarget",
"->",
"isSVR4ABI",
"(",
")",
")",
"return",
"new",
"PPCFastISel",
"(",
"FuncInfo",
",",
"LibInfo",
")",
";",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"This",
"method",
"returns",
"a",
"target",
"specific",
"FastISel",
"object",
",",
"or",
"null",
"if",
"the",
"target",
"does",
"not",
"support",
"``",
"fast",
"''",
"ISel",
"."
] | [
"PowerPC",
"PPC::createFastISel",
"PPC",
"PPC",
"PPC",
"PPC"
] | PPCFastISel1 | createFastISel | PowerPC | CPU | LLVM | 16,372 | 71 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"HexagonTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"nullptr",
";",
"case",
"HexagonISD",
"::",
"CONST32",
":",
"return",
"\"HexagonISD::CONST32\"",
";",
"case",
"HexagonISD",
"::",
"CONST32_GP",
":",
"return",
"\"HexagonISD::CONST32_GP\"",
";",
"case",
"HexagonISD",
"::",
"CONST32_Int_Real",
":",
"return",
"\"HexagonISD::CONST32_Int_Real\"",
";",
"case",
"HexagonISD",
"::",
"ADJDYNALLOC",
":",
"return",
"\"HexagonISD::ADJDYNALLOC\"",
";",
"case",
"HexagonISD",
"::",
"CMPICC",
":",
"return",
"\"HexagonISD::CMPICC\"",
";",
"case",
"HexagonISD",
"::",
"CMPFCC",
":",
"return",
"\"HexagonISD::CMPFCC\"",
";",
"case",
"HexagonISD",
"::",
"BRICC",
":",
"return",
"\"HexagonISD::BRICC\"",
";",
"case",
"HexagonISD",
"::",
"BRFCC",
":",
"return",
"\"HexagonISD::BRFCC\"",
";",
"case",
"HexagonISD",
"::",
"SELECT_ICC",
":",
"return",
"\"HexagonISD::SELECT_ICC\"",
";",
"case",
"HexagonISD",
"::",
"SELECT_FCC",
":",
"return",
"\"HexagonISD::SELECT_FCC\"",
";",
"case",
"HexagonISD",
"::",
"Hi",
":",
"return",
"\"HexagonISD::Hi\"",
";",
"case",
"HexagonISD",
"::",
"Lo",
":",
"return",
"\"HexagonISD::Lo\"",
";",
"case",
"HexagonISD",
"::",
"FTOI",
":",
"return",
"\"HexagonISD::FTOI\"",
";",
"case",
"HexagonISD",
"::",
"ITOF",
":",
"return",
"\"HexagonISD::ITOF\"",
";",
"case",
"HexagonISD",
"::",
"CALLv3",
":",
"return",
"\"HexagonISD::CALLv3\"",
";",
"case",
"HexagonISD",
"::",
"CALLv3nr",
":",
"return",
"\"HexagonISD::CALLv3nr\"",
";",
"case",
"HexagonISD",
"::",
"CALLR",
":",
"return",
"\"HexagonISD::CALLR\"",
";",
"case",
"HexagonISD",
"::",
"RET_FLAG",
":",
"return",
"\"HexagonISD::RET_FLAG\"",
";",
"case",
"HexagonISD",
"::",
"BR_JT",
":",
"return",
"\"HexagonISD::BR_JT\"",
";",
"case",
"HexagonISD",
"::",
"TC_RETURN",
":",
"return",
"\"HexagonISD::TC_RETURN\"",
";",
"case",
"HexagonISD",
"::",
"EH_RETURN",
":",
"return",
"\"HexagonISD::EH_RETURN\"",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"Hexagon",
"Hexagon",
"HexagonISD::CONST32",
"\"HexagonISD::CONST32\"",
"HexagonISD::CONST32_GP",
"\"HexagonISD::CONST32_GP\"",
"HexagonISD::CONST32_Int_Real",
"\"HexagonISD::CONST32_Int_Real\"",
"HexagonISD::ADJDYNALLOC",
"\"HexagonISD::ADJDYNALLOC\"",
"HexagonISD::CMPICC",
"\"HexagonISD::CMPICC\"",
"HexagonISD::CMPFCC",
"\"HexagonISD::CMPFCC\"",
"HexagonISD::BRICC",
"\"HexagonISD::BRICC\"",
"HexagonISD::BRFCC",
"\"HexagonISD::BRFCC\"",
"HexagonISD::SELECT_ICC",
"\"HexagonISD::SELECT_ICC\"",
"HexagonISD::SELECT_FCC",
"\"HexagonISD::SELECT_FCC\"",
"HexagonISD::Hi",
"\"HexagonISD::Hi\"",
"HexagonISD::Lo",
"\"HexagonISD::Lo\"",
"HexagonISD::FTOI",
"\"HexagonISD::FTOI\"",
"HexagonISD::ITOF",
"\"HexagonISD::ITOF\"",
"HexagonISD::CALLv3",
"\"HexagonISD::CALLv3\"",
"HexagonISD::CALLv3nr",
"\"HexagonISD::CALLv3nr\"",
"HexagonISD::CALLR",
"\"HexagonISD::CALLR\"",
"HexagonISD::RET_FLAG",
"\"HexagonISD::RET_FLAG\"",
"HexagonISD::BR_JT",
"\"HexagonISD::BR_JT\"",
"HexagonISD::TC_RETURN",
"\"HexagonISD::TC_RETURN\"",
"HexagonISD::EH_RETURN",
"\"HexagonISD::EH_RETURN\""
] | HexagonISelLowering (2)2 | getTargetNodeName | Hexagon | DSP | LLVM | 16,373 | 192 | 1 | [] |
[
"<s>",
"bool",
"X86DiscriminateMemOps",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"DISubprogram",
"*",
"FDI",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"getSubprogram",
"(",
")",
";",
"if",
"(",
"!",
"FDI",
"||",
"!",
"FDI",
"->",
"getUnit",
"(",
")",
"->",
"getDebugInfoForProfiling",
"(",
")",
")",
"return",
"false",
";",
"const",
"DILocation",
"*",
"ReferenceDI",
"=",
"DILocation",
"::",
"get",
"(",
"FDI",
"->",
"getContext",
"(",
")",
",",
"FDI",
"->",
"getLine",
"(",
")",
",",
"0",
",",
"FDI",
")",
";",
"DenseMap",
"<",
"Location",
",",
"unsigned",
">",
"MemOpDiscriminators",
";",
"MemOpDiscriminators",
"[",
"diToLocation",
"(",
"ReferenceDI",
")",
"]",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"auto",
"&",
"MI",
":",
"MBB",
")",
"{",
"const",
"auto",
"&",
"DI",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"!",
"DI",
")",
"continue",
";",
"Location",
"Loc",
"=",
"diToLocation",
"(",
"DI",
")",
";",
"MemOpDiscriminators",
"[",
"Loc",
"]",
"=",
"std",
"::",
"max",
"(",
"MemOpDiscriminators",
"[",
"Loc",
"]",
",",
"DI",
"->",
"getBaseDiscriminator",
"(",
")",
")",
";",
"}",
"}",
"DenseMap",
"<",
"Location",
",",
"DenseSet",
"<",
"unsigned",
">>",
"Seen",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"auto",
"&",
"MI",
":",
"MBB",
")",
"{",
"if",
"(",
"X86II",
"::",
"getMemoryOperandNo",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"TSFlags",
")",
"<",
"0",
")",
"continue",
";",
"const",
"DILocation",
"*",
"DI",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"!",
"DI",
")",
"{",
"DI",
"=",
"ReferenceDI",
";",
"}",
"DenseSet",
"<",
"unsigned",
">",
"&",
"Set",
"=",
"Seen",
"[",
"diToLocation",
"(",
"DI",
")",
"]",
";",
"const",
"std",
"::",
"pair",
"<",
"DenseSet",
"<",
"unsigned",
">",
"::",
"iterator",
",",
"bool",
">",
"TryInsert",
"=",
"Set",
".",
"insert",
"(",
"DI",
"->",
"getBaseDiscriminator",
"(",
")",
")",
";",
"if",
"(",
"!",
"TryInsert",
".",
"second",
")",
"{",
"DI",
"=",
"DI",
"->",
"setBaseDiscriminator",
"(",
"++",
"MemOpDiscriminators",
"[",
"diToLocation",
"(",
"DI",
")",
"]",
")",
";",
"updateDebugInfo",
"(",
"&",
"MI",
",",
"DI",
")",
";",
"Changed",
"=",
"true",
";",
"const",
"std",
"::",
"pair",
"<",
"DenseSet",
"<",
"unsigned",
">",
"::",
"iterator",
",",
"bool",
">",
"MustInsert",
"=",
"Set",
".",
"insert",
"(",
"DI",
"->",
"getBaseDiscriminator",
"(",
")",
")",
";",
"if",
"(",
"!",
"MustInsert",
".",
"second",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Unable to create a unique discriminator in \"",
"<<",
"DI",
"->",
"getFilename",
"(",
")",
"<<",
"\" Line: \"",
"<<",
"DI",
"->",
"getLine",
"(",
")",
"<<",
"\" Column: \"",
"<<",
"DI",
"->",
"getColumn",
"(",
")",
"<<",
"\". This is likely due to a large macro expansion.\\n\"",
")",
";",
"}",
"}",
"ReferenceDI",
"=",
"DI",
";",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"0",
"0",
"X86II::getMemoryOperandNo",
"0",
"\"Unable to create a unique discriminator in \"",
"\" Line: \"",
"\" Column: \"",
"\". This is likely due to a large macro expansion.\\n\""
] | X86DiscriminateMemOps1 | runOnMachineFunction | X86 | CPU | LLVM | 16,374 | 386 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"Res",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Don't know how to custom expand this!\"",
")",
";",
"case",
"ISD",
"::",
"READ_REGISTER",
":",
"ExpandREAD_REGISTER",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"BITCAST",
":",
"Res",
"=",
"ExpandBITCAST",
"(",
"N",
",",
"DAG",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SRL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SHL",
":",
"Res",
"=",
"Expand64BitShift",
"(",
"N",
",",
"DAG",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SREM",
":",
"case",
"ISD",
"::",
"UREM",
":",
"Res",
"=",
"LowerREM",
"(",
"N",
",",
"DAG",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SDIVREM",
":",
"case",
"ISD",
"::",
"UDIVREM",
":",
"Res",
"=",
"LowerDivRem",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
")",
";",
"assert",
"(",
"Res",
".",
"getNumOperands",
"(",
")",
"==",
"2",
"&&",
"\"DivRem needs two values\"",
")",
";",
"Results",
".",
"push_back",
"(",
"Res",
".",
"getValue",
"(",
"0",
")",
")",
";",
"Results",
".",
"push_back",
"(",
"Res",
".",
"getValue",
"(",
"1",
")",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"SADDSAT",
":",
"case",
"ISD",
"::",
"SSUBSAT",
":",
"Res",
"=",
"LowerSADDSUBSAT",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"READCYCLECOUNTER",
":",
"ReplaceREADCYCLECOUNTER",
"(",
"N",
",",
"Results",
",",
"DAG",
",",
"Subtarget",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"UDIV",
":",
"case",
"ISD",
"::",
"SDIV",
":",
"assert",
"(",
"Subtarget",
"->",
"isTargetWindows",
"(",
")",
"&&",
"\"can only expand DIV on Windows\"",
")",
";",
"return",
"ExpandDIV_Windows",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
",",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
",",
"Results",
")",
";",
"case",
"ISD",
"::",
"ATOMIC_CMP_SWAP",
":",
"ReplaceCMP_SWAP_64Results",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"ReplaceLongIntrinsic",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ABS",
":",
"lowerABS",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"return",
";",
"}",
"if",
"(",
"Res",
".",
"getNode",
"(",
")",
")",
"Results",
".",
"push_back",
"(",
"Res",
")",
";",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"ARM",
"ARM",
"\"Don't know how to custom expand this!\"",
"ISD::READ_REGISTER",
"ISD::BITCAST",
"ISD::SRL",
"ISD::SRA",
"ISD::SHL",
"ISD::SREM",
"ISD::UREM",
"ISD::SDIVREM",
"ISD::UDIVREM",
"0",
"2",
"\"DivRem needs two values\"",
"0",
"1",
"ISD::SADDSAT",
"ISD::SSUBSAT",
"0",
"ISD::READCYCLECOUNTER",
"ISD::UDIV",
"ISD::SDIV",
"\"can only expand DIV on Windows\"",
"0",
"ISD::SDIV",
"ISD::ATOMIC_CMP_SWAP",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::ABS"
] | ARMISelLowering (2)6 | ReplaceNodeResults | ARM | CPU | LLVM | 16,375 | 343 | 1 | [] |
[
"<s>",
"rtx",
"crx_function_arg",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"enum",
"machine_mode",
"mode",
",",
"tree",
"type",
",",
"int",
"named",
"ATTRIBUTE_UNUSED",
")",
"{",
"last_parm_in_reg",
"=",
"0",
";",
"if",
"(",
"type",
"==",
"void_type_node",
")",
"return",
"NULL_RTX",
";",
"if",
"(",
"targetm",
".",
"calls",
".",
"must_pass_in_stack",
"(",
"mode",
",",
"type",
")",
"||",
"(",
"cum",
"->",
"ints",
"<",
"0",
")",
")",
"return",
"NULL_RTX",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"{",
"if",
"(",
"enough_regs_for_param",
"(",
"cum",
",",
"type",
",",
"mode",
")",
"!=",
"0",
")",
"{",
"last_parm_in_reg",
"=",
"1",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"MIN_REG_FOR_PASSING_ARGS",
"+",
"cum",
"->",
"ints",
")",
";",
"}",
"}",
"if",
"(",
"MIN_REG_FOR_PASSING_ARGS",
"+",
"cum",
"->",
"ints",
">",
"MAX_REG_FOR_PASSING_ARGS",
")",
"return",
"NULL_RTX",
";",
"else",
"{",
"if",
"(",
"enough_regs_for_param",
"(",
"cum",
",",
"type",
",",
"mode",
")",
"!=",
"0",
")",
"{",
"last_parm_in_reg",
"=",
"1",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"MIN_REG_FOR_PASSING_ARGS",
"+",
"cum",
"->",
"ints",
")",
";",
"}",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Implements",
"the",
"macro",
"FUNCTION_ARG",
"defined",
"in",
"crx.h",
"."
] | [
"crx",
"0",
"0",
"0",
"1",
"0",
"1"
] | crx | crx_function_arg | crx | CPU | GCC | 16,376 | 146 | 1 | [] |
[
"<s>",
"unsigned",
"ARMBaseInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ARM",
"::",
"STR",
":",
"case",
"ARM",
"::",
"t2STRs",
":",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
"==",
"0",
"&&",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";",
"case",
"ARM",
"::",
"t2STRi12",
":",
"case",
"ARM",
"::",
"tSpill",
":",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";",
"case",
"ARM",
"::",
"FSTD",
":",
"case",
"ARM",
"::",
"FSTS",
":",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"ARM",
"ARM",
"ARM::STR",
"ARM::t2STRs",
"1",
"2",
"3",
"2",
"0",
"3",
"0",
"1",
"0",
"ARM::t2STRi12",
"ARM::tSpill",
"1",
"2",
"2",
"0",
"1",
"0",
"ARM::FSTD",
"ARM::FSTS",
"1",
"2",
"2",
"0",
"1",
"0",
"0"
] | ARMBaseInstrInfo31 | isStoreToStackSlot | ARM | CPU | LLVM | 16,377 | 286 | 1 | [] |
[
"<s>",
"void",
"ARMElfTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"bool",
"isAAPCS_ABI",
"=",
"static_cast",
"<",
"const",
"ARMTargetMachine",
"&",
">",
"(",
"TM",
")",
".",
"TargetABI",
"==",
"ARMTargetMachine",
"::",
"ARMABI",
"::",
"ARM_ABI_AAPCS",
";",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"InitializeELF",
"(",
"isAAPCS_ABI",
")",
";",
"if",
"(",
"isAAPCS_ABI",
"&&",
"!",
"Triple",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
")",
".",
"isOSNaCl",
"(",
")",
")",
"{",
"LSDASection",
"=",
"nullptr",
";",
"}",
"AttributesSection",
"=",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".ARM.attributes\"",
",",
"ELF",
"::",
"SHT_ARM_ATTRIBUTES",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARMABI::ARM_ABI_AAPCS",
"\".ARM.attributes\"",
"ARM",
"0"
] | ARMTargetObjectFile32 | Initialize | ARM | CPU | LLVM | 16,378 | 92 | 1 | [] |
[
"<s>",
"static",
"rtx",
"nds32_expand_priority_builtin",
"(",
"enum",
"insn_code",
"icode",
",",
"tree",
"exp",
",",
"rtx",
"target",
",",
"const",
"char",
"*",
"name",
")",
"{",
"rtx",
"pat",
";",
"rtx",
"op0",
"=",
"nds32_read_argument",
"(",
"exp",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"nds32_read_argument",
"(",
"exp",
",",
"1",
")",
";",
"if",
"(",
"!",
"nds32_check_constant_argument",
"(",
"icode",
",",
"0",
",",
"op0",
",",
"name",
")",
")",
"return",
"NULL_RTX",
";",
"if",
"(",
"!",
"nds32_check_constant_argument",
"(",
"icode",
",",
"1",
",",
"op1",
",",
"name",
")",
")",
"return",
"NULL_RTX",
";",
"op0",
"=",
"nds32_legitimize_argument",
"(",
"icode",
",",
"0",
",",
"op0",
")",
";",
"op1",
"=",
"nds32_legitimize_argument",
"(",
"icode",
",",
"1",
",",
"op1",
")",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"op0",
",",
"op1",
")",
";",
"if",
"(",
"!",
"pat",
")",
"return",
"NULL_RTX",
";",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Expand",
"set",
"int",
"priority",
"builtins",
"."
] | [
"nds32",
"0",
"1",
"0",
"1",
"0",
"1"
] | nds32-intrinsic | nds32_expand_priority_builtin | nds32 | CPU | GCC | 16,379 | 128 | 1 | [] |
[
"<s>",
"rtx",
"mips_expand_builtin",
"(",
"tree",
"exp",
",",
"rtx",
"target",
",",
"rtx",
"subtarget",
"ATTRIBUTE_UNUSED",
",",
"enum",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"int",
"ignore",
"ATTRIBUTE_UNUSED",
")",
"{",
"enum",
"insn_code",
"icode",
";",
"enum",
"mips_builtin_type",
"type",
";",
"tree",
"fndecl",
",",
"arglist",
";",
"unsigned",
"int",
"fcode",
";",
"const",
"struct",
"builtin_description",
"*",
"bdesc",
";",
"const",
"struct",
"bdesc_map",
"*",
"m",
";",
"fndecl",
"=",
"TREE_OPERAND",
"(",
"TREE_OPERAND",
"(",
"exp",
",",
"0",
")",
",",
"0",
")",
";",
"arglist",
"=",
"TREE_OPERAND",
"(",
"exp",
",",
"1",
")",
";",
"fcode",
"=",
"DECL_FUNCTION_CODE",
"(",
"fndecl",
")",
";",
"bdesc",
"=",
"NULL",
";",
"for",
"(",
"m",
"=",
"bdesc_arrays",
";",
"m",
"<",
"&",
"bdesc_arrays",
"[",
"ARRAY_SIZE",
"(",
"bdesc_arrays",
")",
"]",
";",
"m",
"++",
")",
"{",
"if",
"(",
"fcode",
"<",
"m",
"->",
"size",
")",
"{",
"bdesc",
"=",
"m",
"->",
"bdesc",
";",
"icode",
"=",
"bdesc",
"[",
"fcode",
"]",
".",
"icode",
";",
"type",
"=",
"bdesc",
"[",
"fcode",
"]",
".",
"builtin_type",
";",
"break",
";",
"}",
"fcode",
"-=",
"m",
"->",
"size",
";",
"}",
"if",
"(",
"bdesc",
"==",
"NULL",
")",
"return",
"0",
";",
"switch",
"(",
"type",
")",
"{",
"case",
"MIPS_BUILTIN_DIRECT",
":",
"return",
"mips_expand_builtin_direct",
"(",
"icode",
",",
"target",
",",
"arglist",
",",
"true",
")",
";",
"case",
"MIPS_BUILTIN_DIRECT_NO_TARGET",
":",
"return",
"mips_expand_builtin_direct",
"(",
"icode",
",",
"target",
",",
"arglist",
",",
"false",
")",
";",
"case",
"MIPS_BUILTIN_MOVT",
":",
"case",
"MIPS_BUILTIN_MOVF",
":",
"return",
"mips_expand_builtin_movtf",
"(",
"type",
",",
"icode",
",",
"bdesc",
"[",
"fcode",
"]",
".",
"cond",
",",
"target",
",",
"arglist",
")",
";",
"case",
"MIPS_BUILTIN_CMP_ANY",
":",
"case",
"MIPS_BUILTIN_CMP_ALL",
":",
"case",
"MIPS_BUILTIN_CMP_UPPER",
":",
"case",
"MIPS_BUILTIN_CMP_LOWER",
":",
"case",
"MIPS_BUILTIN_CMP_SINGLE",
":",
"return",
"mips_expand_builtin_compare",
"(",
"type",
",",
"icode",
",",
"bdesc",
"[",
"fcode",
"]",
".",
"cond",
",",
"target",
",",
"arglist",
")",
";",
"case",
"MIPS_BUILTIN_BPOSGE32",
":",
"return",
"mips_expand_builtin_bposge",
"(",
"type",
",",
"target",
")",
";",
"default",
":",
"return",
"0",
";",
"}",
"}",
"</s>"
] | [
"Expand",
"builtin",
"functions",
".",
"This",
"is",
"called",
"from",
"TARGET_EXPAND_BUILTIN",
"."
] | [
"mips",
"0",
"0",
"1",
"0",
"0"
] | mips3 | mips_expand_builtin | mips | CPU | GCC | 16,380 | 271 | 1 | [] |
[
"<s>",
"void",
"LanaiTargetLowering",
"::",
"computeKnownBitsForTargetNode",
"(",
"const",
"SDValue",
"Op",
",",
"KnownBits",
"&",
"Known",
",",
"const",
"APInt",
"&",
"DemandedElts",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"unsigned",
"BitWidth",
"=",
"Known",
".",
"getBitWidth",
"(",
")",
";",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"LanaiISD",
"::",
"SETCC",
":",
"Known",
"=",
"KnownBits",
"(",
"BitWidth",
")",
";",
"Known",
".",
"Zero",
".",
"setBits",
"(",
"1",
",",
"BitWidth",
")",
";",
"break",
";",
"case",
"LanaiISD",
"::",
"SELECT_CC",
":",
"KnownBits",
"Known2",
";",
"Known",
"=",
"DAG",
".",
"computeKnownBits",
"(",
"Op",
"->",
"getOperand",
"(",
"0",
")",
",",
"Depth",
"+",
"1",
")",
";",
"Known2",
"=",
"DAG",
".",
"computeKnownBits",
"(",
"Op",
"->",
"getOperand",
"(",
"1",
")",
",",
"Depth",
"+",
"1",
")",
";",
"Known",
".",
"Zero",
"&=",
"Known2",
".",
"Zero",
";",
"Known",
".",
"One",
"&=",
"Known2",
".",
"One",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"Determine",
"which",
"of",
"the",
"bits",
"specified",
"in",
"Mask",
"are",
"known",
"to",
"be",
"either",
"zero",
"or",
"one",
"and",
"return",
"them",
"in",
"the",
"KnownZero/KnownOne",
"bitsets",
"."
] | [
"Lanai",
"Lanai",
"LanaiISD::SETCC",
"1",
"LanaiISD::SELECT_CC",
"0",
"1",
"1",
"1"
] | LanaiISelLowering11 | computeKnownBitsForTargetNode | Lanai | CPU | LLVM | 16,381 | 139 | 1 | [] |
[
"<s>",
"void",
"SIFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"SIMachineFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"FuncInfo",
"->",
"isEntryFunction",
"(",
")",
")",
"{",
"emitEntryFunctionPrologue",
"(",
"MF",
",",
"MBB",
")",
";",
"return",
";",
"}",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"SISubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"SISubtarget",
">",
"(",
")",
";",
"const",
"SIInstrInfo",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"unsigned",
"StackPtrReg",
"=",
"FuncInfo",
"->",
"getStackPtrOffsetReg",
"(",
")",
";",
"unsigned",
"FramePtrReg",
"=",
"FuncInfo",
"->",
"getFrameOffsetReg",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"bool",
"NeedFP",
"=",
"hasFP",
"(",
"MF",
")",
";",
"if",
"(",
"NeedFP",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"COPY",
")",
",",
"FramePtrReg",
")",
".",
"addReg",
"(",
"StackPtrReg",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"uint32_t",
"NumBytes",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"if",
"(",
"NumBytes",
"!=",
"0",
"&&",
"hasSP",
"(",
"MF",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_ADD_U32",
")",
",",
"StackPtrReg",
")",
".",
"addReg",
"(",
"StackPtrReg",
")",
".",
"addImm",
"(",
"NumBytes",
"*",
"ST",
".",
"getWavefrontSize",
"(",
")",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"for",
"(",
"const",
"SIMachineFunctionInfo",
"::",
"SGPRSpillVGPRCSR",
"&",
"Reg",
":",
"FuncInfo",
"->",
"getSGPRSpillVGPRs",
"(",
")",
")",
"{",
"if",
"(",
"!",
"Reg",
".",
"FI",
".",
"hasValue",
"(",
")",
")",
"continue",
";",
"TII",
"->",
"storeRegToStackSlot",
"(",
"MBB",
",",
"MBBI",
",",
"Reg",
".",
"VGPR",
",",
"true",
",",
"Reg",
".",
"FI",
".",
"getValue",
"(",
")",
",",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
",",
"&",
"TII",
"->",
"getRegisterInfo",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"AMDGPU::COPY",
"0",
"AMDGPU::S_ADD_U32",
"SI",
"AMDGPU::VGPR_32RegClass"
] | SIFrameLowering13 | emitPrologue | AMDGPU | GPU | LLVM | 16,382 | 293 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"BlackfinDAGToDAGISel",
"::",
"Select",
"(",
"SDValue",
"Op",
")",
"{",
"SDNode",
"*",
"N",
"=",
"Op",
".",
"getNode",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"N",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"NULL",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"FrameIndex",
":",
"{",
"int",
"FI",
"=",
"cast",
"<",
"FrameIndexSDNode",
">",
"(",
"N",
")",
"->",
"getIndex",
"(",
")",
";",
"SDValue",
"TFI",
"=",
"CurDAG",
"->",
"getTargetFrameIndex",
"(",
"FI",
",",
"MVT",
"::",
"i32",
")",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"BF",
"::",
"ADDpp",
",",
"MVT",
"::",
"i32",
",",
"TFI",
",",
"CurDAG",
"->",
"getTargetConstant",
"(",
"0",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"}",
"return",
"SelectCode",
"(",
"Op",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Blackfin",
"ISD::FrameIndex",
"MVT::i32",
"BF::ADDpp",
"MVT::i32",
"0",
"MVT::i32"
] | BlackfinISelDAGToDAG3 | Select | Blackfin | DSP | LLVM | 16,383 | 126 | 1 | [] |
[
"<s>",
"static",
"void",
"init_frame",
"(",
"FILE",
"*",
"file",
",",
"int",
"regno",
",",
"unsigned",
"align",
",",
"unsigned",
"size",
")",
"{",
"if",
"(",
"size",
")",
"fprintf",
"(",
"file",
",",
"\"\\t.local .align %d .b8 %s_ar[%u];\\n\"",
",",
"align",
",",
"reg_names",
"[",
"regno",
"]",
",",
"size",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.reg.u%d %s;\\n\"",
",",
"POINTER_SIZE",
",",
"reg_names",
"[",
"regno",
"]",
")",
";",
"fprintf",
"(",
"file",
",",
"(",
"size",
"?",
"\"\\tcvta.local.u%d %s, %s_ar;\\n\"",
":",
"\"\\tmov.u%d %s, 0;\\n\"",
")",
",",
"POINTER_SIZE",
",",
"reg_names",
"[",
"regno",
"]",
",",
"reg_names",
"[",
"regno",
"]",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"local",
"array",
"to",
"hold",
"some",
"part",
"of",
"a",
"conventional",
"stack",
"frame",
"and",
"initialize",
"REGNO",
"to",
"point",
"to",
"it",
".",
"If",
"the",
"size",
"is",
"zero",
",",
"it",
"'ll",
"never",
"be",
"valid",
"to",
"dereference",
",",
"so",
"we",
"can",
"simply",
"initialize",
"to",
"zero",
"."
] | [
"nvptx",
"\"\\t.local .align %d .b8 %s_ar[%u];\\n\"",
"\"\\t.reg.u%d %s;\\n\"",
"\"\\tcvta.local.u%d %s, %s_ar;\\n\"",
"\"\\tmov.u%d %s, 0;\\n\""
] | nvptx | init_frame | nvptx | GPU | GCC | 16,384 | 78 | 1 | [] |
[
"<s>",
"void",
"func_fma_steering",
"::",
"update_balance",
"(",
"int",
"parity",
")",
"{",
"this",
"->",
"m_fpu_balance",
"=",
"parity",
"?",
"this",
"->",
"m_fpu_balance",
"+",
"1",
":",
"this",
"->",
"m_fpu_balance",
"-",
"1",
";",
"}",
"</s>"
] | [
"Update",
"the",
"current",
"balance",
"considering",
"a",
"node",
"with",
"the",
"given",
"PARITY",
"."
] | [
"aarch64",
"1",
"1"
] | cortex-a57-fma-steering | update_balance | aarch64 | CPU | GCC | 16,385 | 28 | 1 | [] |
[
"<s>",
"unsigned",
"PPCMCCodeEmitter",
"::",
"getInstSizeInBytes",
"(",
"const",
"MCInst",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"Opcode",
")",
";",
"return",
"Desc",
".",
"getSize",
"(",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"PowerPC",
"PPC"
] | PPCMCCodeEmitter13 | getInstSizeInBytes | PowerPC | CPU | LLVM | 16,386 | 41 | 1 | [] |
[
"<s>",
"unsigned",
"getGlobalBaseReg",
"(",
")",
"const",
"{",
"return",
"GlobalBaseReg",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"Sparc"
] | SparcMachineFunctionInfo13 | getGlobalBaseReg | Sparc | CPU | LLVM | 16,387 | 10 | 1 | [] |
[
"<s>",
"unsigned",
"PPCRegisterInfo",
"::",
"getRegPressureLimit",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"Subtarget",
".",
"getFrameLowering",
"(",
")",
";",
"const",
"unsigned",
"DefaultSafety",
"=",
"1",
";",
"switch",
"(",
"RC",
"->",
"getID",
"(",
")",
")",
"{",
"default",
":",
"return",
"0",
";",
"case",
"PPC",
"::",
"G8RC_NOX0RegClassID",
":",
"case",
"PPC",
"::",
"GPRC_NOR0RegClassID",
":",
"case",
"PPC",
"::",
"G8RCRegClassID",
":",
"case",
"PPC",
"::",
"GPRCRegClassID",
":",
"{",
"unsigned",
"FP",
"=",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"1",
":",
"0",
";",
"return",
"32",
"-",
"FP",
"-",
"DefaultSafety",
";",
"}",
"case",
"PPC",
"::",
"F8RCRegClassID",
":",
"case",
"PPC",
"::",
"F4RCRegClassID",
":",
"case",
"PPC",
"::",
"VRRCRegClassID",
":",
"case",
"PPC",
"::",
"VFRCRegClassID",
":",
"case",
"PPC",
"::",
"VSLRCRegClassID",
":",
"case",
"PPC",
"::",
"VSHRCRegClassID",
":",
"return",
"32",
"-",
"DefaultSafety",
";",
"case",
"PPC",
"::",
"VSRCRegClassID",
":",
"case",
"PPC",
"::",
"VSFRCRegClassID",
":",
"return",
"64",
"-",
"DefaultSafety",
";",
"case",
"PPC",
"::",
"CRRCRegClassID",
":",
"return",
"8",
"-",
"DefaultSafety",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"pressure",
"``",
"high",
"water",
"mark",
"''",
"for",
"the",
"specific",
"register",
"class",
"."
] | [
"PowerPC",
"PPC",
"1",
"0",
"PPC::G8RC_NOX0RegClassID",
"PPC::GPRC_NOR0RegClassID",
"PPC::G8RCRegClassID",
"PPC::GPRCRegClassID",
"1",
"0",
"32",
"PPC::F8RCRegClassID",
"PPC::F4RCRegClassID",
"PPC::VRRCRegClassID",
"PPC::VFRCRegClassID",
"PPC::VSLRCRegClassID",
"PPC::VSHRCRegClassID",
"32",
"PPC::VSRCRegClassID",
"PPC::VSFRCRegClassID",
"64",
"PPC::CRRCRegClassID",
"8"
] | PPCRegisterInfo22 | getRegPressureLimit | PowerPC | CPU | LLVM | 16,388 | 152 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"PPCTargetLowering",
"::",
"getPICJumpTableRelocBaseExpr",
"(",
"const",
"MachineFunction",
"*",
"MF",
",",
"unsigned",
"JTI",
",",
"MCContext",
"&",
"Ctx",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"isPPC64",
"(",
")",
")",
"return",
"TargetLowering",
"::",
"getPICJumpTableRelocBaseExpr",
"(",
"MF",
",",
"JTI",
",",
"Ctx",
")",
";",
"switch",
"(",
"getTargetMachine",
"(",
")",
".",
"getCodeModel",
"(",
")",
")",
"{",
"case",
"CodeModel",
"::",
"Small",
":",
"case",
"CodeModel",
"::",
"Medium",
":",
"return",
"TargetLowering",
"::",
"getPICJumpTableRelocBaseExpr",
"(",
"MF",
",",
"JTI",
",",
"Ctx",
")",
";",
"default",
":",
"return",
"MCSymbolRefExpr",
"::",
"create",
"(",
"MF",
"->",
"getPICBaseSymbol",
"(",
")",
",",
"Ctx",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"returns",
"the",
"relocation",
"base",
"for",
"the",
"given",
"PIC",
"jumptable",
",",
"the",
"same",
"as",
"getPICJumpTableRelocBase",
",",
"but",
"as",
"an",
"MCExpr",
"."
] | [
"PowerPC",
"PPC",
"PPC"
] | PPCISelLowering (2)7 | getPICJumpTableRelocBaseExpr | PowerPC | CPU | LLVM | 16,389 | 93 | 1 | [] |
[
"<s>",
"bool",
"MipsFastISel",
"::",
"fastSelectInstruction",
"(",
"const",
"Instruction",
"*",
"I",
")",
"{",
"switch",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Instruction",
"::",
"Load",
":",
"return",
"selectLoad",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Store",
":",
"return",
"selectStore",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"SDiv",
":",
"if",
"(",
"!",
"selectBinaryOp",
"(",
"I",
",",
"ISD",
"::",
"SDIV",
")",
")",
"return",
"selectDivRem",
"(",
"I",
",",
"ISD",
"::",
"SDIV",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"UDiv",
":",
"if",
"(",
"!",
"selectBinaryOp",
"(",
"I",
",",
"ISD",
"::",
"UDIV",
")",
")",
"return",
"selectDivRem",
"(",
"I",
",",
"ISD",
"::",
"UDIV",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"SRem",
":",
"if",
"(",
"!",
"selectBinaryOp",
"(",
"I",
",",
"ISD",
"::",
"SREM",
")",
")",
"return",
"selectDivRem",
"(",
"I",
",",
"ISD",
"::",
"SREM",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"URem",
":",
"if",
"(",
"!",
"selectBinaryOp",
"(",
"I",
",",
"ISD",
"::",
"UREM",
")",
")",
"return",
"selectDivRem",
"(",
"I",
",",
"ISD",
"::",
"UREM",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"Shl",
":",
"case",
"Instruction",
"::",
"LShr",
":",
"case",
"Instruction",
"::",
"AShr",
":",
"return",
"selectShift",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"And",
":",
"case",
"Instruction",
"::",
"Or",
":",
"case",
"Instruction",
"::",
"Xor",
":",
"return",
"selectLogicalOp",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Br",
":",
"return",
"selectBranch",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Ret",
":",
"return",
"selectRet",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Trunc",
":",
"return",
"selectTrunc",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"ZExt",
":",
"case",
"Instruction",
"::",
"SExt",
":",
"return",
"selectIntExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FPTrunc",
":",
"return",
"selectFPTrunc",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FPExt",
":",
"return",
"selectFPExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FPToSI",
":",
"return",
"selectFPToInt",
"(",
"I",
",",
"true",
")",
";",
"case",
"Instruction",
"::",
"FPToUI",
":",
"return",
"selectFPToInt",
"(",
"I",
",",
"false",
")",
";",
"case",
"Instruction",
"::",
"ICmp",
":",
"case",
"Instruction",
"::",
"FCmp",
":",
"return",
"selectCmp",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Select",
":",
"return",
"selectSelect",
"(",
"I",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"by",
"target-independent",
"code",
"when",
"the",
"normal",
"FastISel",
"process",
"fails",
"to",
"select",
"an",
"instruction",
"."
] | [
"Mips",
"Mips",
"ISD::SDIV",
"ISD::SDIV",
"ISD::UDIV",
"ISD::UDIV",
"ISD::SREM",
"ISD::SREM",
"ISD::UREM",
"ISD::UREM"
] | MipsFastISel10 | fastSelectInstruction | Mips | CPU | LLVM | 16,390 | 337 | 1 | [] |
[
"<s>",
"static",
"void",
"tilegx_expand_high_multiply",
"(",
"rtx",
"result",
",",
"rtx",
"op1",
",",
"rtx",
"op2",
",",
"bool",
"sign",
")",
"{",
"rtx",
"tmp0",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp1",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp2",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp3",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp4",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp5",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp6",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp7",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp8",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp9",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp10",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp11",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp12",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"tmp13",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"rtx",
"result_lo",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"if",
"(",
"sign",
")",
"{",
"emit_insn",
"(",
"gen_insn_mul_hs_lu",
"(",
"tmp0",
",",
"op1",
",",
"op2",
")",
")",
";",
"emit_insn",
"(",
"gen_insn_mul_hs_lu",
"(",
"tmp1",
",",
"op2",
",",
"op1",
")",
")",
";",
"emit_insn",
"(",
"gen_insn_mul_lu_lu",
"(",
"tmp2",
",",
"op1",
",",
"op2",
")",
")",
";",
"emit_insn",
"(",
"gen_insn_mul_hs_hs",
"(",
"tmp3",
",",
"op1",
",",
"op2",
")",
")",
";",
"}",
"else",
"{",
"emit_insn",
"(",
"gen_insn_mul_hu_lu",
"(",
"tmp0",
",",
"op1",
",",
"op2",
")",
")",
";",
"emit_insn",
"(",
"gen_insn_mul_hu_lu",
"(",
"tmp1",
",",
"op2",
",",
"op1",
")",
")",
";",
"emit_insn",
"(",
"gen_insn_mul_lu_lu",
"(",
"tmp2",
",",
"op1",
",",
"op2",
")",
")",
";",
"emit_insn",
"(",
"gen_insn_mul_hu_hu",
"(",
"tmp3",
",",
"op1",
",",
"op2",
")",
")",
";",
"}",
"emit_move_insn",
"(",
"tmp4",
",",
"(",
"gen_rtx_ASHIFT",
"(",
"DImode",
",",
"tmp0",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tmp5",
",",
"(",
"gen_rtx_ASHIFT",
"(",
"DImode",
",",
"tmp1",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tmp6",
",",
"(",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"tmp4",
",",
"tmp5",
")",
")",
")",
";",
"emit_move_insn",
"(",
"result_lo",
",",
"(",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"tmp2",
",",
"tmp6",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tmp7",
",",
"gen_rtx_LTU",
"(",
"DImode",
",",
"tmp6",
",",
"tmp4",
")",
")",
";",
"emit_move_insn",
"(",
"tmp8",
",",
"gen_rtx_LTU",
"(",
"DImode",
",",
"result_lo",
",",
"tmp2",
")",
")",
";",
"if",
"(",
"sign",
")",
"{",
"emit_move_insn",
"(",
"tmp9",
",",
"(",
"gen_rtx_ASHIFTRT",
"(",
"DImode",
",",
"tmp0",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tmp10",
",",
"(",
"gen_rtx_ASHIFTRT",
"(",
"DImode",
",",
"tmp1",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
")",
";",
"}",
"else",
"{",
"emit_move_insn",
"(",
"tmp9",
",",
"(",
"gen_rtx_LSHIFTRT",
"(",
"DImode",
",",
"tmp0",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tmp10",
",",
"(",
"gen_rtx_LSHIFTRT",
"(",
"DImode",
",",
"tmp1",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
")",
";",
"}",
"emit_move_insn",
"(",
"tmp11",
",",
"(",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"tmp3",
",",
"tmp7",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tmp12",
",",
"(",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"tmp8",
",",
"tmp9",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tmp13",
",",
"(",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"tmp11",
",",
"tmp12",
")",
")",
")",
";",
"emit_move_insn",
"(",
"result",
",",
"(",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"tmp13",
",",
"tmp10",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"high",
"multiply",
"pattern",
"in",
"DImode",
".",
"RESULT",
",",
"OP1",
",",
"OP2",
"are",
"the",
"operands",
",",
"and",
"SIGN",
"is",
"true",
"if",
"it",
"'s",
"a",
"signed",
"multiply",
",",
"and",
"false",
"if",
"it",
"'s",
"an",
"unsigned",
"multiply",
"."
] | [
"tilegx",
"32",
"32",
"32",
"32",
"32",
"32"
] | tilegx | tilegx_expand_high_multiply | tilegx | VLIW | GCC | 16,391 | 490 | 1 | [] |
[
"<s>",
"bool",
"PTXFPRoundingModePass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"bbi",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"bbe",
"=",
"MF",
".",
"end",
"(",
")",
";",
"bbi",
"!=",
"bbe",
";",
"++",
"bbi",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"bbi",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"ii",
"=",
"MBB",
".",
"begin",
"(",
")",
",",
"ie",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"ii",
"!=",
"ie",
";",
"++",
"ii",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"ii",
";",
"processInstruction",
"(",
"MI",
")",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"PTX",
"PTX"
] | PTXFPRoundingModePass | runOnMachineFunction | PTX | GPU | LLVM | 16,392 | 93 | 1 | [] |
[
"<s>",
"SparcTargetMachine",
"::",
"SparcTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"bool",
"is64bit",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
")",
",",
"Subtarget",
"(",
"TT",
",",
"FS",
",",
"is64bit",
")",
",",
"DataLayout",
"(",
"Subtarget",
".",
"getDataLayout",
"(",
")",
")",
",",
"TLInfo",
"(",
"*",
"this",
")",
",",
"InstrInfo",
"(",
"Subtarget",
")",
",",
"FrameInfo",
"(",
"TargetFrameInfo",
"::",
"StackGrowsDown",
",",
"8",
",",
"0",
")",
"{",
"}",
"</s>"
] | [
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"8",
"0"
] | SparcTargetMachine5 | SparcTargetMachine | Sparc | CPU | LLVM | 16,393 | 75 | 1 | [] |
[
"<s>",
"bool",
"HexagonTargetLowering",
"::",
"mayBeEmittedAsTailCall",
"(",
"const",
"CallInst",
"*",
"CI",
")",
"const",
"{",
"return",
"CI",
"->",
"isTailCall",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"may",
"be",
"able",
"emit",
"the",
"call",
"instruction",
"as",
"a",
"tail",
"call",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonISelLowering100 | mayBeEmittedAsTailCall | Hexagon | DSP | LLVM | 16,394 | 20 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"isCopyInstr",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"MachineOperand",
"&",
"Src",
",",
"MachineOperand",
"&",
"Dest",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
".",
"isMoveReg",
"(",
")",
"||",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"VORRq",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"!=",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"Dest",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"Src",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"return",
"true",
";",
"}",
"</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",
"."
] | [
"ARM",
"ARM",
"ARM::VORRq",
"1",
"2",
"0",
"1"
] | ARMBaseInstrInfo44 | isCopyInstr | ARM | CPU | LLVM | 16,395 | 88 | 1 | [] |
[
"<s>",
"unsigned",
"X86RegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameInfo",
"*",
"TFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"FramePtr",
":",
"StackPtr",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"X86",
"X86"
] | X86RegisterInfo40 | getFrameRegister | X86 | CPU | LLVM | 16,396 | 40 | 1 | [] |
[
"<s>",
"tree",
"loongarch_build_builtin_va_list",
"(",
"void",
")",
"{",
"return",
"ptr_type_node",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_BUILTIN_VA_LIST",
"."
] | [
"loongarch"
] | loongarch-builtins | loongarch_build_builtin_va_list | loongarch | CPU | GCC | 16,397 | 10 | 1 | [] |
[
"<s>",
"void",
"Initialize",
"(",
"MCContext",
"&",
"ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"override",
"{",
"TargetLoweringObjectFile",
"::",
"Initialize",
"(",
"ctx",
",",
"TM",
")",
";",
"TextSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getText",
"(",
")",
")",
";",
"DataSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getDataRel",
"(",
")",
")",
";",
"BSSSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getBSS",
"(",
")",
")",
";",
"ReadOnlySection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getReadOnly",
"(",
")",
")",
";",
"StaticCtorSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"StaticDtorSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"LSDASection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"EHFrameSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfAbbrevSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfInfoSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfLineSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfFrameSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfPubTypesSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfDebugInlineSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfStrSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfLocSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfARangesSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"DwarfRangesSection",
"=",
"new",
"NVPTXSection",
"(",
"MCSection",
"::",
"SV_ELF",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX"
] | NVPTXTargetObjectFile1 | Initialize | NVPTX | GPU | LLVM | 16,398 | 312 | 1 | [] |
[
"<s>",
"void",
"print",
"(",
")",
"{",
"if",
"(",
"numSymbols",
"==",
"0",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"++",
")",
"{",
"if",
"(",
"i",
")",
"O",
"<<",
"\", \"",
";",
"O",
"<<",
"(",
"unsigned",
"int",
")",
"buffer",
"[",
"i",
"]",
";",
"}",
"}",
"else",
"{",
"unsigned",
"int",
"pos",
"=",
"0",
";",
"unsigned",
"int",
"nSym",
"=",
"0",
";",
"unsigned",
"int",
"nextSymbolPos",
"=",
"symbolPosInBuffer",
"[",
"nSym",
"]",
";",
"unsigned",
"int",
"nBytes",
"=",
"4",
";",
"if",
"(",
"AP",
".",
"nvptxSubtarget",
".",
"is64Bit",
"(",
")",
")",
"nBytes",
"=",
"8",
";",
"for",
"(",
"pos",
"=",
"0",
";",
"pos",
"<",
"size",
";",
"pos",
"+=",
"nBytes",
")",
"{",
"if",
"(",
"pos",
")",
"O",
"<<",
"\", \"",
";",
"if",
"(",
"pos",
"==",
"nextSymbolPos",
")",
"{",
"const",
"Value",
"*",
"v",
"=",
"Symbols",
"[",
"nSym",
"]",
";",
"if",
"(",
"const",
"GlobalValue",
"*",
"GVar",
"=",
"dyn_cast",
"<",
"GlobalValue",
">",
"(",
"v",
")",
")",
"{",
"MCSymbol",
"*",
"Name",
"=",
"AP",
".",
"Mang",
"->",
"getSymbol",
"(",
"GVar",
")",
";",
"O",
"<<",
"*",
"Name",
";",
"}",
"else",
"if",
"(",
"const",
"ConstantExpr",
"*",
"Cexpr",
"=",
"dyn_cast",
"<",
"ConstantExpr",
">",
"(",
"v",
")",
")",
"{",
"O",
"<<",
"*",
"nvptx",
"::",
"LowerConstant",
"(",
"Cexpr",
",",
"AP",
")",
";",
"}",
"else",
"llvm_unreachable",
"(",
"\"symbol type unknown\"",
")",
";",
"nSym",
"++",
";",
"if",
"(",
"nSym",
">=",
"numSymbols",
")",
"nextSymbolPos",
"=",
"size",
"+",
"1",
";",
"else",
"nextSymbolPos",
"=",
"symbolPosInBuffer",
"[",
"nSym",
"]",
";",
"}",
"else",
"if",
"(",
"nBytes",
"==",
"4",
")",
"O",
"<<",
"*",
"(",
"unsigned",
"int",
"*",
")",
"(",
"buffer",
"+",
"pos",
")",
";",
"else",
"O",
"<<",
"*",
"(",
"unsigned",
"long",
"long",
"*",
")",
"(",
"buffer",
"+",
"pos",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"NVPTX",
"0",
"0",
"\", \"",
"0",
"0",
"4",
"8",
"0",
"\", \"",
"nvptx::LowerConstant",
"\"symbol type unknown\"",
"1",
"4"
] | NVPTXAsmPrinter2 | print | NVPTX | GPU | LLVM | 16,399 | 266 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.