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>",
"bool",
"AVRShiftExpand",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"SmallVector",
"<",
"BinaryOperator",
"*",
",",
"1",
">",
"ShiftInsts",
";",
"auto",
"&",
"Ctx",
"=",
"F",
".",
"getContext",
"(",
")",
";",
"for",
"(",
"Instruction",
"&",
"I",
":",
"instructions",
"(",
"F",
")",
")",
"{",
"if",
"(",
"!",
"I",
".",
"isShift",
"(",
")",
")",
"continue",
";",
"if",
"(",
"I",
".",
"getType",
"(",
")",
"!=",
"Type",
"::",
"getInt32Ty",
"(",
"Ctx",
")",
")",
"continue",
";",
"if",
"(",
"isa",
"<",
"ConstantInt",
">",
"(",
"I",
".",
"getOperand",
"(",
"1",
")",
")",
")",
"continue",
";",
"ShiftInsts",
".",
"push_back",
"(",
"cast",
"<",
"BinaryOperator",
">",
"(",
"&",
"I",
")",
")",
";",
"}",
"for",
"(",
"auto",
"*",
"I",
":",
"ShiftInsts",
")",
"{",
"expand",
"(",
"I",
")",
";",
"}",
"return",
"ShiftInsts",
".",
"size",
"(",
")",
">",
"0",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"AVR",
"AVR",
"1",
"1",
"0"
] | AVRShiftExpand | runOnFunction | AVR | MPU | LLVM | 17,300 | 126 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyInstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"MCRegister",
"DestReg",
",",
"MCRegister",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"auto",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"Register",
"::",
"isVirtualRegister",
"(",
"DestReg",
")",
"?",
"MRI",
".",
"getRegClass",
"(",
"DestReg",
")",
":",
"MRI",
".",
"getTargetRegisterInfo",
"(",
")",
"->",
"getMinimalPhysRegClass",
"(",
"DestReg",
")",
";",
"unsigned",
"CopyOpcode",
";",
"if",
"(",
"RC",
"==",
"&",
"WebAssembly",
"::",
"I32RegClass",
")",
"CopyOpcode",
"=",
"WebAssembly",
"::",
"COPY_I32",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"WebAssembly",
"::",
"I64RegClass",
")",
"CopyOpcode",
"=",
"WebAssembly",
"::",
"COPY_I64",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"WebAssembly",
"::",
"F32RegClass",
")",
"CopyOpcode",
"=",
"WebAssembly",
"::",
"COPY_F32",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"WebAssembly",
"::",
"F64RegClass",
")",
"CopyOpcode",
"=",
"WebAssembly",
"::",
"COPY_F64",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"WebAssembly",
"::",
"V128RegClass",
")",
"CopyOpcode",
"=",
"WebAssembly",
"::",
"COPY_V128",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"WebAssembly",
"::",
"EXNREFRegClass",
")",
"CopyOpcode",
"=",
"WebAssembly",
"::",
"COPY_EXNREF",
";",
"else",
"llvm_unreachable",
"(",
"\"Unexpected register class\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"CopyOpcode",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"KillSrc",
"?",
"RegState",
"::",
"Kill",
":",
"0",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly::I32RegClass",
"WebAssembly::COPY_I32",
"WebAssembly::I64RegClass",
"WebAssembly::COPY_I64",
"WebAssembly::F32RegClass",
"WebAssembly::COPY_F32",
"WebAssembly::F64RegClass",
"WebAssembly::COPY_F64",
"WebAssembly::V128RegClass",
"WebAssembly::COPY_V128",
"WebAssembly::EXNREFRegClass",
"WebAssembly::COPY_EXNREF",
"\"Unexpected register class\"",
"0"
] | WebAssemblyInstrInfo15 | copyPhysReg | WebAssembly | Virtual ISA | LLVM | 17,301 | 208 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
",",
"unsigned",
"Align",
",",
"bool",
"*",
"IsFast",
")",
"const",
"{",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"Other",
"||",
"(",
"VT",
"!=",
"MVT",
"::",
"Other",
"&&",
"VT",
".",
"getSizeInBits",
"(",
")",
">",
"1024",
"&&",
"VT",
".",
"getStoreSize",
"(",
")",
">",
"16",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"LOCAL_ADDRESS",
"||",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"REGION_ADDRESS",
")",
"{",
"bool",
"AlignedBy4",
"=",
"(",
"Align",
"%",
"4",
"==",
"0",
")",
";",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"AlignedBy4",
";",
"return",
"AlignedBy4",
";",
"}",
"if",
"(",
"!",
"Subtarget",
"->",
"hasUnalignedScratchAccess",
"(",
")",
"&&",
"(",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"PRIVATE_ADDRESS",
"||",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"FLAT_ADDRESS",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"Subtarget",
"->",
"hasUnalignedBufferAccess",
"(",
")",
")",
"{",
"if",
"(",
"IsFast",
")",
"{",
"*",
"IsFast",
"=",
"(",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"CONSTANT_ADDRESS",
"||",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"CONSTANT_ADDRESS_32BIT",
")",
"?",
"(",
"Align",
"%",
"4",
"==",
"0",
")",
":",
"true",
";",
"}",
"return",
"true",
";",
"}",
"if",
"(",
"VT",
".",
"bitsLT",
"(",
"MVT",
"::",
"i32",
")",
")",
"return",
"false",
";",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"true",
";",
"return",
"VT",
".",
"bitsGT",
"(",
"MVT",
"::",
"i32",
")",
"&&",
"Align",
"%",
"4",
"==",
"0",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"AMDGPU",
"SI",
"MVT::Other",
"MVT::Other",
"1024",
"16",
"SI",
"SI",
"4",
"0",
"SI",
"SI",
"SI",
"SI",
"4",
"0",
"MVT::i32",
"MVT::i32",
"4",
"0"
] | SIISelLowering | allowsMisalignedMemoryAccesses | AMDGPU | GPU | LLVM | 17,302 | 219 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"mips_output_probe_stack_range",
"(",
"rtx",
"reg1",
",",
"rtx",
"reg2",
")",
"{",
"static",
"int",
"labelno",
"=",
"0",
";",
"char",
"loop_lab",
"[",
"32",
"]",
",",
"end_lab",
"[",
"32",
"]",
",",
"tmp",
"[",
"64",
"]",
";",
"rtx",
"xops",
"[",
"2",
"]",
";",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"loop_lab",
",",
"\"LPSRL\"",
",",
"labelno",
")",
";",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"end_lab",
",",
"\"LPSRE\"",
",",
"labelno",
"++",
")",
";",
"ASM_OUTPUT_INTERNAL_LABEL",
"(",
"asm_out_file",
",",
"loop_lab",
")",
";",
"xops",
"[",
"0",
"]",
"=",
"reg1",
";",
"xops",
"[",
"1",
"]",
"=",
"reg2",
";",
"strcpy",
"(",
"tmp",
",",
"\"%(%<beq\\t%0,%1,\"",
")",
";",
"output_asm_insn",
"(",
"strcat",
"(",
"tmp",
",",
"&",
"end_lab",
"[",
"1",
"]",
")",
",",
"xops",
")",
";",
"xops",
"[",
"1",
"]",
"=",
"GEN_INT",
"(",
"-",
"PROBE_INTERVAL",
")",
";",
"if",
"(",
"TARGET_64BIT",
"&&",
"TARGET_LONG64",
")",
"output_asm_insn",
"(",
"\"daddiu\\t%0,%0,%1\"",
",",
"xops",
")",
";",
"else",
"output_asm_insn",
"(",
"\"addiu\\t%0,%0,%1\"",
",",
"xops",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\tb\\t\"",
")",
";",
"assemble_name_raw",
"(",
"asm_out_file",
",",
"loop_lab",
")",
";",
"fputc",
"(",
"'\\n'",
",",
"asm_out_file",
")",
";",
"if",
"(",
"TARGET_64BIT",
")",
"output_asm_insn",
"(",
"\"sd\\t$0,0(%0)%)\"",
",",
"xops",
")",
";",
"else",
"output_asm_insn",
"(",
"\"sw\\t$0,0(%0)%)\"",
",",
"xops",
")",
";",
"ASM_OUTPUT_INTERNAL_LABEL",
"(",
"asm_out_file",
",",
"end_lab",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"Probe",
"a",
"range",
"of",
"stack",
"addresses",
"from",
"REG1",
"to",
"REG2",
"inclusive",
".",
"These",
"are",
"absolute",
"addresses",
"."
] | [
"mips",
"0",
"32",
"32",
"64",
"2",
"\"LPSRL\"",
"\"LPSRE\"",
"0",
"1",
"\"%(%<beq\\t%0,%1,\"",
"1",
"1",
"\"daddiu\\t%0,%0,%1\"",
"\"addiu\\t%0,%0,%1\"",
"\"\\tb\\t\"",
"\"sd\\t$0,0(%0)%)\"",
"\"sw\\t$0,0(%0)%)\"",
"\"\""
] | mips4 | mips_output_probe_stack_range | mips | CPU | GCC | 17,303 | 186 | 1 | [] |
[
"<s>",
"bool",
"trackLivenessAfterRegAlloc",
"(",
"const",
"MachineFunction",
"&",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"live-ins",
"should",
"be",
"tracked",
"after",
"register",
"allocation",
"."
] | [
"AArch64"
] | AArch64RegisterInfo | trackLivenessAfterRegAlloc | AArch64 | CPU | LLVM | 17,304 | 14 | 1 | [] |
[
"<s>",
"static",
"void",
"cris_output_addr_const",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"x",
")",
"{",
"in_code",
"++",
";",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"in_code",
"--",
";",
"}",
"</s>"
] | [
"Use",
"from",
"within",
"code",
",",
"from",
"e.g",
".",
"PRINT_OPERAND",
"and",
"PRINT_OPERAND_ADDRESS",
".",
"Macros",
"used",
"in",
"output_addr_const",
"need",
"to",
"emit",
"different",
"things",
"depending",
"on",
"whether",
"code",
"operand",
"or",
"constant",
"is",
"emitted",
"."
] | [
"cris"
] | cris | cris_output_addr_const | cris | MPU | GCC | 17,305 | 26 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"isHighLatencyDef",
"(",
"int",
"opc",
")",
"const",
"{",
"switch",
"(",
"opc",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"X86",
"::",
"DIVSDrm",
":",
"case",
"X86",
"::",
"DIVSDrm_Int",
":",
"case",
"X86",
"::",
"DIVSDrr",
":",
"case",
"X86",
"::",
"DIVSDrr_Int",
":",
"case",
"X86",
"::",
"DIVSSrm",
":",
"case",
"X86",
"::",
"DIVSSrm_Int",
":",
"case",
"X86",
"::",
"DIVSSrr",
":",
"case",
"X86",
"::",
"DIVSSrr_Int",
":",
"case",
"X86",
"::",
"SQRTPDm",
":",
"case",
"X86",
"::",
"SQRTPDr",
":",
"case",
"X86",
"::",
"SQRTPSm",
":",
"case",
"X86",
"::",
"SQRTPSr",
":",
"case",
"X86",
"::",
"SQRTSDm",
":",
"case",
"X86",
"::",
"SQRTSDm_Int",
":",
"case",
"X86",
"::",
"SQRTSDr",
":",
"case",
"X86",
"::",
"SQRTSDr_Int",
":",
"case",
"X86",
"::",
"SQRTSSm",
":",
"case",
"X86",
"::",
"SQRTSSm_Int",
":",
"case",
"X86",
"::",
"SQRTSSr",
":",
"case",
"X86",
"::",
"SQRTSSr_Int",
":",
"case",
"X86",
"::",
"VDIVSDrm",
":",
"case",
"X86",
"::",
"VDIVSDrm_Int",
":",
"case",
"X86",
"::",
"VDIVSDrr",
":",
"case",
"X86",
"::",
"VDIVSDrr_Int",
":",
"case",
"X86",
"::",
"VDIVSSrm",
":",
"case",
"X86",
"::",
"VDIVSSrm_Int",
":",
"case",
"X86",
"::",
"VDIVSSrr",
":",
"case",
"X86",
"::",
"VDIVSSrr_Int",
":",
"case",
"X86",
"::",
"VSQRTPDm",
":",
"case",
"X86",
"::",
"VSQRTPDr",
":",
"case",
"X86",
"::",
"VSQRTPSm",
":",
"case",
"X86",
"::",
"VSQRTPSr",
":",
"case",
"X86",
"::",
"VSQRTSDm",
":",
"case",
"X86",
"::",
"VSQRTSDm_Int",
":",
"case",
"X86",
"::",
"VSQRTSDr",
":",
"case",
"X86",
"::",
"VSQRTSSm",
":",
"case",
"X86",
"::",
"VSQRTSSm_Int",
":",
"case",
"X86",
"::",
"VSQRTSSr",
":",
"case",
"X86",
"::",
"VSQRTPDZm",
":",
"case",
"X86",
"::",
"VSQRTPDZr",
":",
"case",
"X86",
"::",
"VSQRTPSZm",
":",
"case",
"X86",
"::",
"VSQRTPSZr",
":",
"case",
"X86",
"::",
"VSQRTSDZm",
":",
"case",
"X86",
"::",
"VSQRTSDZm_Int",
":",
"case",
"X86",
"::",
"VSQRTSDZr",
":",
"case",
"X86",
"::",
"VSQRTSSZm_Int",
":",
"case",
"X86",
"::",
"VSQRTSSZr",
":",
"case",
"X86",
"::",
"VSQRTSSZm",
":",
"case",
"X86",
"::",
"VDIVSDZrm",
":",
"case",
"X86",
"::",
"VDIVSDZrr",
":",
"case",
"X86",
"::",
"VDIVSSZrm",
":",
"case",
"X86",
"::",
"VDIVSSZrr",
":",
"case",
"X86",
"::",
"VGATHERQPSZrm",
":",
"case",
"X86",
"::",
"VGATHERQPDZrm",
":",
"case",
"X86",
"::",
"VGATHERDPDZrm",
":",
"case",
"X86",
"::",
"VGATHERDPSZrm",
":",
"case",
"X86",
"::",
"VPGATHERQDZrm",
":",
"case",
"X86",
"::",
"VPGATHERQQZrm",
":",
"case",
"X86",
"::",
"VPGATHERDDZrm",
":",
"case",
"X86",
"::",
"VPGATHERDQZrm",
":",
"case",
"X86",
"::",
"VSCATTERQPDZmr",
":",
"case",
"X86",
"::",
"VSCATTERQPSZmr",
":",
"case",
"X86",
"::",
"VSCATTERDPDZmr",
":",
"case",
"X86",
"::",
"VSCATTERDPSZmr",
":",
"case",
"X86",
"::",
"VPSCATTERQDZmr",
":",
"case",
"X86",
"::",
"VPSCATTERQQZmr",
":",
"case",
"X86",
"::",
"VPSCATTERDDZmr",
":",
"case",
"X86",
"::",
"VPSCATTERDQZmr",
":",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"opcode",
"has",
"high",
"latency",
"to",
"its",
"result",
"."
] | [
"X86",
"X86",
"X86::DIVSDrm",
"X86::DIVSDrm_Int",
"X86::DIVSDrr",
"X86::DIVSDrr_Int",
"X86::DIVSSrm",
"X86::DIVSSrm_Int",
"X86::DIVSSrr",
"X86::DIVSSrr_Int",
"X86::SQRTPDm",
"X86::SQRTPDr",
"X86::SQRTPSm",
"X86::SQRTPSr",
"X86::SQRTSDm",
"X86::SQRTSDm_Int",
"X86::SQRTSDr",
"X86::SQRTSDr_Int",
"X86::SQRTSSm",
"X86::SQRTSSm_Int",
"X86::SQRTSSr",
"X86::SQRTSSr_Int",
"X86::VDIVSDrm",
"X86::VDIVSDrm_Int",
"X86::VDIVSDrr",
"X86::VDIVSDrr_Int",
"X86::VDIVSSrm",
"X86::VDIVSSrm_Int",
"X86::VDIVSSrr",
"X86::VDIVSSrr_Int",
"X86::VSQRTPDm",
"X86::VSQRTPDr",
"X86::VSQRTPSm",
"X86::VSQRTPSr",
"X86::VSQRTSDm",
"X86::VSQRTSDm_Int",
"X86::VSQRTSDr",
"X86::VSQRTSSm",
"X86::VSQRTSSm_Int",
"X86::VSQRTSSr",
"X86::VSQRTPDZm",
"X86::VSQRTPDZr",
"X86::VSQRTPSZm",
"X86::VSQRTPSZr",
"X86::VSQRTSDZm",
"X86::VSQRTSDZm_Int",
"X86::VSQRTSDZr",
"X86::VSQRTSSZm_Int",
"X86::VSQRTSSZr",
"X86::VSQRTSSZm",
"X86::VDIVSDZrm",
"X86::VDIVSDZrr",
"X86::VDIVSSZrm",
"X86::VDIVSSZrr",
"X86::VGATHERQPSZrm",
"X86::VGATHERQPDZrm",
"X86::VGATHERDPDZrm",
"X86::VGATHERDPSZrm",
"X86::VPGATHERQDZrm",
"X86::VPGATHERQQZrm",
"X86::VPGATHERDDZrm",
"X86::VPGATHERDQZrm",
"X86::VSCATTERQPDZmr",
"X86::VSCATTERQPSZmr",
"X86::VSCATTERDPDZmr",
"X86::VSCATTERDPSZmr",
"X86::VPSCATTERQDZmr",
"X86::VPSCATTERQQZmr",
"X86::VPSCATTERDDZmr",
"X86::VPSCATTERDQZmr"
] | X86InstrInfo (2)1 | isHighLatencyDef | X86 | CPU | LLVM | 17,306 | 365 | 1 | [] |
[
"<s>",
"static",
"int",
"arc_compute_millicode_save_restore_regs",
"(",
"uint64_t",
"gmask",
",",
"struct",
"arc_frame_info",
"*",
"frame",
")",
"{",
"int",
"regno",
";",
"int",
"start_reg",
"=",
"13",
",",
"end_reg",
"=",
"25",
";",
"for",
"(",
"regno",
"=",
"start_reg",
";",
"regno",
"<=",
"end_reg",
"&&",
"(",
"gmask",
"&",
"(",
"1ULL",
"<<",
"regno",
")",
")",
";",
")",
"regno",
"++",
";",
"end_reg",
"=",
"regno",
"-",
"1",
";",
"if",
"(",
"regno",
"-",
"start_reg",
">=",
"3",
"-",
"(",
"crtl",
"->",
"is_leaf",
"==",
"0",
")",
")",
"{",
"frame",
"->",
"millicode_start_reg",
"=",
"13",
";",
"frame",
"->",
"millicode_end_reg",
"=",
"regno",
"-",
"1",
";",
"return",
"1",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"non-zero",
"if",
"there",
"are",
"registers",
"to",
"be",
"saved",
"or",
"loaded",
"using",
"millicode",
"thunks",
".",
"We",
"can",
"only",
"use",
"consecutive",
"sequences",
"starting",
"with",
"r13",
",",
"and",
"not",
"going",
"beyond",
"r25",
".",
"GMASK",
"is",
"a",
"bitmask",
"of",
"registers",
"to",
"save",
".",
"This",
"function",
"sets",
"FRAME-",
">",
"millicod_start_reg",
"..",
"FRAME-",
">",
"millicode_end_reg",
"to",
"the",
"range",
"of",
"registers",
"to",
"be",
"saved",
"/",
"restored",
"with",
"a",
"millicode",
"call",
"."
] | [
"arc",
"13",
"25",
"1ULL",
"1",
"3",
"0",
"13",
"1",
"1",
"0"
] | arc | arc_compute_millicode_save_restore_regs | arc | MPU | GCC | 17,307 | 94 | 1 | [] |
[
"<s>",
"bool",
"umips_save_restore_pattern_p",
"(",
"bool",
"save_p",
",",
"rtx",
"pattern",
")",
"{",
"int",
"n",
";",
"unsigned",
"int",
"i",
";",
"HOST_WIDE_INT",
"first_offset",
"=",
"0",
";",
"rtx",
"first_base",
"=",
"0",
";",
"unsigned",
"int",
"regmask",
"=",
"0",
";",
"for",
"(",
"n",
"=",
"0",
";",
"n",
"<",
"XVECLEN",
"(",
"pattern",
",",
"0",
")",
";",
"n",
"++",
")",
"{",
"rtx",
"set",
",",
"reg",
",",
"mem",
",",
"this_base",
";",
"HOST_WIDE_INT",
"this_offset",
";",
"set",
"=",
"XVECEXP",
"(",
"pattern",
",",
"0",
",",
"n",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"set",
")",
"!=",
"SET",
")",
"return",
"false",
";",
"mem",
"=",
"save_p",
"?",
"SET_DEST",
"(",
"set",
")",
":",
"SET_SRC",
"(",
"set",
")",
";",
"if",
"(",
"!",
"MEM_P",
"(",
"mem",
")",
"||",
"MEM_VOLATILE_P",
"(",
"mem",
")",
")",
"return",
"false",
";",
"mips_split_plus",
"(",
"XEXP",
"(",
"mem",
",",
"0",
")",
",",
"&",
"this_base",
",",
"&",
"this_offset",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"this_base",
")",
")",
"return",
"false",
";",
"if",
"(",
"n",
"==",
"0",
")",
"{",
"if",
"(",
"!",
"UMIPS_12BIT_OFFSET_P",
"(",
"this_offset",
")",
")",
"return",
"false",
";",
"first_base",
"=",
"this_base",
";",
"first_offset",
"=",
"this_offset",
";",
"}",
"else",
"{",
"if",
"(",
"REGNO",
"(",
"this_base",
")",
"!=",
"REGNO",
"(",
"first_base",
")",
"||",
"this_offset",
"!=",
"first_offset",
"+",
"UNITS_PER_WORD",
"*",
"n",
")",
"return",
"false",
";",
"}",
"reg",
"=",
"save_p",
"?",
"SET_SRC",
"(",
"set",
")",
":",
"SET_DEST",
"(",
"set",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"reg",
")",
")",
"return",
"false",
";",
"regmask",
"|=",
"1",
"<<",
"REGNO",
"(",
"reg",
")",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"umips_swm_mask",
")",
";",
"i",
"++",
")",
"if",
"(",
"regmask",
"==",
"umips_swm_mask",
"[",
"i",
"]",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"PATTERN",
"matches",
"the",
"kind",
"of",
"instruction",
"generated",
"by",
"umips_build_save_restore",
".",
"SAVE_P",
"is",
"true",
"for",
"store",
"."
] | [
"mips",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"0"
] | mips | umips_save_restore_pattern_p | mips | CPU | GCC | 17,308 | 264 | 1 | [] |
[
"<s>",
"void",
"SIMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"uint64_t",
"Encoding",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"unsigned",
"bytes",
"=",
"Desc",
".",
"getSize",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"bytes",
";",
"i",
"++",
")",
"{",
"OS",
".",
"write",
"(",
"(",
"uint8_t",
")",
"(",
"(",
"Encoding",
">>",
"(",
"8",
"*",
"i",
")",
")",
"&",
"0xff",
")",
")",
";",
"}",
"if",
"(",
"bytes",
">",
"4",
")",
"return",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"!",
"isSrcOperand",
"(",
"Desc",
",",
"i",
")",
")",
"continue",
";",
"int",
"RCID",
"=",
"Desc",
".",
"OpInfo",
"[",
"i",
"]",
".",
"RegClass",
";",
"const",
"MCRegisterClass",
"&",
"RC",
"=",
"MRI",
".",
"getRegClass",
"(",
"RCID",
")",
";",
"const",
"MCOperand",
"&",
"Op",
"=",
"MI",
".",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"getLitEncoding",
"(",
"Op",
",",
"RC",
".",
"getSize",
"(",
")",
")",
"!=",
"255",
")",
"continue",
";",
"int64_t",
"Imm",
"=",
"0",
";",
"if",
"(",
"Op",
".",
"isImm",
"(",
")",
")",
"Imm",
"=",
"Op",
".",
"getImm",
"(",
")",
";",
"else",
"if",
"(",
"!",
"Op",
".",
"isExpr",
"(",
")",
")",
"llvm_unreachable",
"(",
"\"Must be immediate or expr\"",
")",
";",
"for",
"(",
"unsigned",
"j",
"=",
"0",
";",
"j",
"<",
"4",
";",
"j",
"++",
")",
"{",
"OS",
".",
"write",
"(",
"(",
"uint8_t",
")",
"(",
"(",
"Imm",
">>",
"(",
"8",
"*",
"j",
")",
")",
"&",
"0xff",
")",
")",
";",
"}",
"break",
";",
"}",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"AMDGPU",
"SI",
"0",
"8",
"0xff",
"4",
"0",
"255",
"0",
"\"Must be immediate or expr\"",
"0",
"4",
"8",
"0xff"
] | SIMCCodeEmitter (2) | encodeInstruction | AMDGPU | GPU | LLVM | 17,309 | 277 | 1 | [] |
[
"<s>",
"TargetLoweringBase",
"::",
"LegalizeTypeAction",
"HexagonTargetLowering",
"::",
"getPreferredVectorAction",
"(",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
"==",
"1",
")",
"return",
"TargetLoweringBase",
"::",
"TypeScalarizeVector",
";",
"MVT",
"ElemTy",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"if",
"(",
"ElemTy",
"==",
"MVT",
"::",
"i1",
")",
"return",
"TargetLoweringBase",
"::",
"TypeWidenVector",
";",
"if",
"(",
"Subtarget",
".",
"useHVXOps",
"(",
")",
")",
"{",
"ArrayRef",
"<",
"MVT",
">",
"Tys",
"=",
"Subtarget",
".",
"getHVXElementTypes",
"(",
")",
";",
"if",
"(",
"llvm",
"::",
"find",
"(",
"Tys",
",",
"ElemTy",
")",
"!=",
"Tys",
".",
"end",
"(",
")",
")",
"{",
"unsigned",
"HwWidth",
"=",
"8",
"*",
"Subtarget",
".",
"getVectorLength",
"(",
")",
";",
"unsigned",
"VecWidth",
"=",
"VT",
".",
"getSizeInBits",
"(",
")",
";",
"if",
"(",
"VecWidth",
">=",
"HwWidth",
"/",
"2",
"&&",
"VecWidth",
"<",
"HwWidth",
")",
"return",
"TargetLoweringBase",
"::",
"TypeWidenVector",
";",
"}",
"}",
"return",
"TargetLoweringBase",
"::",
"TypeSplitVector",
";",
"}",
"</s>"
] | [
"Customize",
"the",
"preferred",
"legalization",
"strategy",
"for",
"certain",
"types",
"."
] | [
"Hexagon",
"Hexagon",
"1",
"MVT::i1",
"8",
"2"
] | HexagonISelLowering1 | getPreferredVectorAction | Hexagon | DSP | LLVM | 17,310 | 133 | 1 | [] |
[
"<s>",
"int",
"h8300_shift_needs_scratch_p",
"(",
"int",
"count",
",",
"machine_mode",
"mode",
",",
"enum",
"rtx_code",
"type",
")",
"{",
"enum",
"h8_cpu",
"cpu",
";",
"int",
"a",
",",
"lr",
",",
"ar",
";",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"<=",
"count",
")",
"return",
"1",
";",
"if",
"(",
"TARGET_H8300S",
")",
"cpu",
"=",
"H8_S",
";",
"else",
"cpu",
"=",
"H8_300H",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_QImode",
":",
"a",
"=",
"shift_alg_qi",
"[",
"cpu",
"]",
"[",
"SHIFT_ASHIFT",
"]",
"[",
"count",
"]",
";",
"lr",
"=",
"shift_alg_qi",
"[",
"cpu",
"]",
"[",
"SHIFT_LSHIFTRT",
"]",
"[",
"count",
"]",
";",
"ar",
"=",
"shift_alg_qi",
"[",
"cpu",
"]",
"[",
"SHIFT_ASHIFTRT",
"]",
"[",
"count",
"]",
";",
"break",
";",
"case",
"E_HImode",
":",
"a",
"=",
"shift_alg_hi",
"[",
"cpu",
"]",
"[",
"SHIFT_ASHIFT",
"]",
"[",
"count",
"]",
";",
"lr",
"=",
"shift_alg_hi",
"[",
"cpu",
"]",
"[",
"SHIFT_LSHIFTRT",
"]",
"[",
"count",
"]",
";",
"ar",
"=",
"shift_alg_hi",
"[",
"cpu",
"]",
"[",
"SHIFT_ASHIFTRT",
"]",
"[",
"count",
"]",
";",
"break",
";",
"case",
"E_SImode",
":",
"a",
"=",
"shift_alg_si",
"[",
"cpu",
"]",
"[",
"SHIFT_ASHIFT",
"]",
"[",
"count",
"]",
";",
"lr",
"=",
"shift_alg_si",
"[",
"cpu",
"]",
"[",
"SHIFT_LSHIFTRT",
"]",
"[",
"count",
"]",
";",
"ar",
"=",
"shift_alg_si",
"[",
"cpu",
"]",
"[",
"SHIFT_ASHIFTRT",
"]",
"[",
"count",
"]",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"type",
"==",
"CLOBBER",
")",
"return",
"(",
"a",
"==",
"SHIFT_LOOP",
"||",
"lr",
"==",
"SHIFT_LOOP",
"||",
"ar",
"==",
"SHIFT_LOOP",
"||",
"(",
"TARGET_H8300H",
"&&",
"mode",
"==",
"SImode",
"&&",
"count",
"==",
"8",
")",
")",
";",
"else",
"if",
"(",
"type",
"==",
"ASHIFT",
")",
"return",
"(",
"a",
"==",
"SHIFT_LOOP",
"||",
"(",
"TARGET_H8300H",
"&&",
"mode",
"==",
"SImode",
"&&",
"count",
"==",
"8",
")",
")",
";",
"else",
"if",
"(",
"type",
"==",
"LSHIFTRT",
")",
"return",
"(",
"lr",
"==",
"SHIFT_LOOP",
"||",
"(",
"TARGET_H8300H",
"&&",
"mode",
"==",
"SImode",
"&&",
"count",
"==",
"8",
")",
")",
";",
"else",
"if",
"(",
"type",
"==",
"ASHIFTRT",
")",
"return",
"(",
"ar",
"==",
"SHIFT_LOOP",
"||",
"(",
"TARGET_H8300H",
"&&",
"mode",
"==",
"SImode",
"&&",
"count",
"==",
"8",
")",
")",
";",
"}",
"</s>"
] | [
"Given",
"COUNT",
"and",
"MODE",
"of",
"a",
"shift",
",",
"return",
"1",
"if",
"a",
"scratch",
"reg",
"may",
"be",
"needed",
"for",
"some",
"shift",
"with",
"COUNT",
"and",
"MODE",
".",
"Return",
"0",
"otherwise",
"."
] | [
"h8300",
"1",
"8",
"8",
"8",
"8"
] | h83001 | h8300_shift_needs_scratch_p | h8300 | MPU | GCC | 17,311 | 306 | 1 | [] |
[
"<s>",
"bool",
"SHUXIInstrInfo",
"::",
"isUnpredicatedTerminator",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
".",
"isTerminator",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
".",
"isBranch",
"(",
")",
"&&",
"!",
"MI",
".",
"isBarrier",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"MI",
".",
"isPredicable",
"(",
")",
")",
"return",
"true",
";",
"return",
"!",
"isPredicated",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"is",
"a",
"terminator",
"instruction",
"that",
"has",
"not",
"been",
"predicated",
"."
] | [
"SHUXI",
"SHUXI"
] | SHUXIInstrInfo | isUnpredicatedTerminator | SHUXI | CPU | LLVM | 17,312 | 62 | 1 | [] |
[
"<s>",
"bool",
"Thumb1FrameInfo",
"::",
"hasReservedCallFrame",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"FFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"unsigned",
"CFSize",
"=",
"FFI",
"->",
"getMaxCallFrameSize",
"(",
")",
";",
"if",
"(",
"CFSize",
">=",
"(",
"(",
"1",
"<<",
"8",
")",
"-",
"1",
")",
"*",
"4",
"/",
"2",
")",
"return",
"false",
";",
"return",
"!",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasReservedCallFrame",
"-",
"Under",
"normal",
"circumstances",
",",
"when",
"a",
"frame",
"pointer",
"is",
"not",
"required",
",",
"we",
"reserve",
"argument",
"space",
"for",
"call",
"sites",
"in",
"the",
"function",
"immediately",
"on",
"entry",
"to",
"the",
"current",
"function",
"."
] | [
"ARM",
"1",
"8",
"1",
"4",
"2"
] | Thumb1FrameInfo | hasReservedCallFrame | ARM | CPU | LLVM | 17,313 | 66 | 1 | [] |
[
"<s>",
"unsigned",
"MipsRegisterInfo",
"::",
"getFrameRegister",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"hasFP",
"(",
"MF",
")",
"?",
"Mips",
"::",
"FP",
":",
"Mips",
"::",
"SP",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"Mips",
"Mips",
"Mips::FP",
"Mips::SP"
] | MipsRegisterInfo18 | getFrameRegister | Mips | CPU | LLVM | 17,314 | 26 | 1 | [] |
[
"<s>",
"void",
"addExpr",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"MCExpr",
"*",
"Expr",
")",
"const",
"{",
"if",
"(",
"Expr",
"==",
"0",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"0",
")",
")",
";",
"else",
"if",
"(",
"const",
"MCConstantExpr",
"*",
"CE",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"Expr",
")",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"CE",
"->",
"getValue",
"(",
")",
")",
")",
";",
"else",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createExpr",
"(",
"Expr",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"new",
"MCExpr",
"operand",
"."
] | [
"P2",
"0",
"0"
] | P2AsmParser | addExpr | P2 | MPU | LLVM | 17,315 | 78 | 1 | [] |
[
"<s>",
"bool",
"aarch64_sve_scalar_inc_dec_immediate_p",
"(",
"rtx",
"x",
")",
"{",
"poly_int64",
"value",
";",
"return",
"(",
"poly_int_rtx_p",
"(",
"x",
",",
"&",
"value",
")",
"&&",
"(",
"aarch64_sve_cnt_immediate_p",
"(",
"value",
")",
"||",
"aarch64_sve_cnt_immediate_p",
"(",
"-",
"value",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"can",
"add",
"X",
"using",
"a",
"single",
"SVE",
"INC",
"or",
"DEC",
"instruction",
"."
] | [
"aarch64"
] | aarch64 | aarch64_sve_scalar_inc_dec_immediate_p | aarch64 | CPU | GCC | 17,316 | 35 | 1 | [] |
[
"<s>",
"static",
"void",
"avr_insert_attributes",
"(",
"tree",
"node",
",",
"tree",
"*",
"attributes",
")",
"{",
"avr_pgm_check_var_decl",
"(",
"node",
")",
";",
"if",
"(",
"TARGET_MAIN_IS_OS_TASK",
"&&",
"TREE_CODE",
"(",
"node",
")",
"==",
"FUNCTION_DECL",
"&&",
"MAIN_NAME_P",
"(",
"DECL_NAME",
"(",
"node",
")",
")",
"&&",
"INTEGRAL_TYPE_P",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"node",
")",
")",
")",
"&&",
"NULL",
"==",
"lookup_attribute",
"(",
"\"OS_task\"",
",",
"*",
"attributes",
")",
")",
"{",
"*",
"attributes",
"=",
"tree_cons",
"(",
"get_identifier",
"(",
"\"OS_task\"",
")",
",",
"NULL",
",",
"*",
"attributes",
")",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"node",
")",
"==",
"VAR_DECL",
"&&",
"(",
"TREE_STATIC",
"(",
"node",
")",
"||",
"DECL_EXTERNAL",
"(",
"node",
")",
")",
"&&",
"avr_progmem_p",
"(",
"node",
",",
"*",
"attributes",
")",
")",
"{",
"addr_space_t",
"as",
";",
"tree",
"node0",
"=",
"node",
";",
"do",
"node0",
"=",
"TREE_TYPE",
"(",
"node0",
")",
";",
"while",
"(",
"TREE_CODE",
"(",
"node0",
")",
"==",
"ARRAY_TYPE",
")",
";",
"if",
"(",
"error_mark_node",
"==",
"node0",
")",
"return",
";",
"as",
"=",
"TYPE_ADDR_SPACE",
"(",
"TREE_TYPE",
"(",
"node",
")",
")",
";",
"if",
"(",
"!",
"TYPE_READONLY",
"(",
"node0",
")",
"&&",
"!",
"TREE_READONLY",
"(",
"node",
")",
")",
"{",
"const",
"char",
"*",
"reason",
"=",
"\"__attribute__((progmem))\"",
";",
"if",
"(",
"!",
"ADDR_SPACE_GENERIC_P",
"(",
"as",
")",
")",
"reason",
"=",
"avr_addrspace",
"[",
"as",
"]",
".",
"name",
";",
"if",
"(",
"avr_log",
".",
"progmem",
")",
"avr_edump",
"(",
"\"\\n%?: %t\\n%t\\n\"",
",",
"node",
",",
"node0",
")",
";",
"error",
"(",
"\"variable %q+D must be const in order to be put into\"",
"\" read-only section by means of %qs\"",
",",
"node",
",",
"reason",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Add",
"the",
"section",
"attribute",
"if",
"the",
"variable",
"is",
"in",
"progmem",
"."
] | [
"avr",
"\"OS_task\"",
"\"OS_task\"",
"\"__attribute__((progmem))\"",
"\"\\n%?: %t\\n%t\\n\"",
"\"variable %q+D must be const in order to be put into\"",
"\" read-only section by means of %qs\""
] | avr | avr_insert_attributes | avr | MPU | GCC | 17,317 | 216 | 1 | [] |
[
"<s>",
"void",
"push",
"(",
"NestingType",
"NT",
")",
"{",
"NestingStack",
".",
"push_back",
"(",
"NT",
")",
";",
"}",
"</s>"
] | [
"Push",
"the",
"current",
"solver",
"state",
"."
] | [
"WebAssembly"
] | WebAssemblyAsmParser (2) | push | WebAssembly | Virtual ISA | LLVM | 17,318 | 15 | 1 | [] |
[
"<s>",
"static",
"void",
"aarch64_pop_regs",
"(",
"unsigned",
"regno1",
",",
"unsigned",
"regno2",
",",
"HOST_WIDE_INT",
"adjustment",
",",
"rtx",
"*",
"cfi_ops",
")",
"{",
"machine_mode",
"mode",
"=",
"(",
"regno1",
"<=",
"R30_REGNUM",
")",
"?",
"DImode",
":",
"DFmode",
";",
"rtx",
"reg1",
"=",
"gen_rtx_REG",
"(",
"mode",
",",
"regno1",
")",
";",
"*",
"cfi_ops",
"=",
"alloc_reg_note",
"(",
"REG_CFA_RESTORE",
",",
"reg1",
",",
"*",
"cfi_ops",
")",
";",
"if",
"(",
"regno2",
"==",
"INVALID_REGNUM",
")",
"{",
"rtx",
"mem",
"=",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"adjustment",
")",
";",
"mem",
"=",
"gen_rtx_POST_MODIFY",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"mem",
")",
";",
"emit_move_insn",
"(",
"reg1",
",",
"gen_rtx_MEM",
"(",
"mode",
",",
"mem",
")",
")",
";",
"}",
"else",
"{",
"rtx",
"reg2",
"=",
"gen_rtx_REG",
"(",
"mode",
",",
"regno2",
")",
";",
"*",
"cfi_ops",
"=",
"alloc_reg_note",
"(",
"REG_CFA_RESTORE",
",",
"reg2",
",",
"*",
"cfi_ops",
")",
";",
"emit_insn",
"(",
"aarch64_gen_loadwb_pair",
"(",
"mode",
",",
"stack_pointer_rtx",
",",
"reg1",
",",
"reg2",
",",
"adjustment",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Pop",
"the",
"two",
"registers",
"numbered",
"REGNO1",
",",
"REGNO2",
"from",
"the",
"stack",
",",
"adjusting",
"it",
"afterwards",
"by",
"ADJUSTMENT",
"and",
"writing",
"the",
"appropriate",
"REG_CFA_RESTORE",
"notes",
"into",
"CFI_OPS",
"."
] | [
"aarch64"
] | aarch644 | aarch64_pop_regs | aarch64 | CPU | GCC | 17,319 | 140 | 1 | [] |
[
"<s>",
"void",
"function_expander",
"::",
"add_mem_operand",
"(",
"machine_mode",
"mode",
",",
"rtx",
"addr",
")",
"{",
"gcc_assert",
"(",
"VECTOR_MODE_P",
"(",
"mode",
")",
"||",
"mode",
"==",
"OImode",
")",
";",
"rtx",
"mem",
"=",
"gen_rtx_MEM",
"(",
"mode",
",",
"memory_address",
"(",
"mode",
",",
"addr",
")",
")",
";",
"set_mem_align",
"(",
"mem",
",",
"GET_MODE_ALIGNMENT",
"(",
"GET_MODE_INNER",
"(",
"mode",
")",
")",
")",
";",
"add_fixed_operand",
"(",
"mem",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"memory",
"operand",
"with",
"mode",
"MODE",
"and",
"address",
"ADDR",
"."
] | [
"aarch64"
] | aarch64-sve-builtins | add_mem_operand | aarch64 | CPU | GCC | 17,320 | 58 | 1 | [] |
[
"<s>",
"AMDGPUSubtarget",
"&",
"AMDGPUSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"GPU",
",",
"StringRef",
"FS",
")",
"{",
"SmallString",
"<",
"256",
">",
"FullFS",
"(",
"\"+promote-alloca,+fp64-denormals,+load-store-opt,\"",
")",
";",
"if",
"(",
"isAmdHsaOS",
"(",
")",
")",
"FullFS",
"+=",
"\"+flat-for-global,+unaligned-buffer-access,\"",
";",
"FullFS",
"+=",
"FS",
";",
"ParseSubtargetFeatures",
"(",
"GPU",
",",
"FullFS",
")",
";",
"if",
"(",
"getGeneration",
"(",
")",
"<=",
"AMDGPUSubtarget",
"::",
"NORTHERN_ISLANDS",
")",
"{",
"FP32Denormals",
"=",
"false",
";",
"FP64Denormals",
"=",
"false",
";",
"}",
"if",
"(",
"MaxPrivateElementSize",
"==",
"0",
")",
"MaxPrivateElementSize",
"=",
"4",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"256",
"\"+promote-alloca,+fp64-denormals,+load-store-opt,\"",
"\"+flat-for-global,+unaligned-buffer-access,\"",
"AMDGPU",
"0",
"4"
] | AMDGPUSubtarget109 | initializeSubtargetDependencies | AMDGPU | GPU | LLVM | 17,321 | 83 | 1 | [] |
[
"<s>",
"bool",
"MBlazeTargetMachine",
"::",
"addInstSelector",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"PM",
".",
"add",
"(",
"createMBlazeISelDag",
"(",
"*",
"this",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"MBlaze",
"MBlaze",
"MBlaze"
] | MBlazeTargetMachine12 | addInstSelector | MBlaze | MPU | LLVM | 17,322 | 25 | 1 | [] |
[
"<s>",
"static",
"bool",
"spu_vector_mode_supported_p",
"(",
"machine_mode",
"mode",
")",
"{",
"switch",
"(",
"mode",
")",
"{",
"case",
"V16QImode",
":",
"case",
"V8HImode",
":",
"case",
"V4SImode",
":",
"case",
"V2DImode",
":",
"case",
"V4SFmode",
":",
"case",
"V2DFmode",
":",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"Similarly",
"for",
"vector",
"modes",
".",
"``",
"Supported",
"''",
"here",
"is",
"less",
"strict",
".",
"At",
"least",
"some",
"operations",
"are",
"supported",
";",
"need",
"to",
"check",
"optabs",
"or",
"builtins",
"for",
"further",
"details",
"."
] | [
"spu"
] | spu | spu_vector_mode_supported_p | spu | MPU | GCC | 17,323 | 41 | 1 | [] |
[
"<s>",
"void",
"PatmosSinglePathInfo",
"::",
"dump",
"(",
")",
"const",
"{",
"print",
"(",
"dbgs",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Dump",
"the",
"plan",
"to",
"stderr",
"(",
"for",
"debugging",
")",
"."
] | [
"Patmos",
"Patmos"
] | PatmosSinglePathInfo | dump | Patmos | VLIW | LLVM | 17,324 | 16 | 1 | [] |
[
"<s>",
"static",
"int",
"mcore_arg_partial_bytes",
"(",
"cumulative_args_t",
"cum",
",",
"machine_mode",
"mode",
",",
"tree",
"type",
",",
"bool",
"named",
")",
"{",
"int",
"reg",
"=",
"ROUND_REG",
"(",
"*",
"get_cumulative_args",
"(",
"cum",
")",
",",
"mode",
")",
";",
"if",
"(",
"named",
"==",
"0",
")",
"return",
"0",
";",
"if",
"(",
"targetm",
".",
"calls",
".",
"must_pass_in_stack",
"(",
"mode",
",",
"type",
")",
")",
"return",
"0",
";",
"if",
"(",
"reg",
">=",
"NPARM_REGS",
")",
"return",
"0",
";",
"if",
"(",
"reg",
"+",
"mcore_num_arg_regs",
"(",
"mode",
",",
"type",
")",
"<=",
"NPARM_REGS",
")",
"return",
"0",
";",
"reg",
"=",
"NPARM_REGS",
"-",
"reg",
";",
"return",
"reg",
"*",
"UNITS_PER_WORD",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"number",
"of",
"bytes",
"of",
"argument",
"registers",
"required",
"to",
"hold",
"*",
"part",
"*",
"of",
"a",
"parameter",
"of",
"machine",
"mode",
"MODE",
"and",
"type",
"TYPE",
"(",
"which",
"may",
"be",
"NULL",
"if",
"the",
"type",
"is",
"not",
"known",
")",
".",
"If",
"the",
"argument",
"fits",
"entirely",
"in",
"the",
"argument",
"registers",
",",
"or",
"entirely",
"on",
"the",
"stack",
",",
"then",
"0",
"is",
"returned",
".",
"CUM",
"is",
"the",
"number",
"of",
"argument",
"registers",
"already",
"used",
"by",
"earlier",
"parameters",
"to",
"the",
"function",
"."
] | [
"mcore",
"0",
"0",
"0",
"0",
"0"
] | mcore4 | mcore_arg_partial_bytes | mcore | MPU | GCC | 17,325 | 93 | 1 | [] |
[
"<s>",
"bool",
"FPMover",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"F",
")",
"{",
"if",
"(",
"TM",
".",
"getSubtarget",
"<",
"SparcSubtarget",
">",
"(",
")",
".",
"isV9",
"(",
")",
")",
"return",
"false",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"FI",
"=",
"F",
".",
"begin",
"(",
")",
",",
"FE",
"=",
"F",
".",
"end",
"(",
")",
";",
"FI",
"!=",
"FE",
";",
"++",
"FI",
")",
"Changed",
"|=",
"runOnMachineBasicBlock",
"(",
"*",
"FI",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Sparc",
"Sparc"
] | FPMover | runOnMachineFunction | Sparc | CPU | LLVM | 17,326 | 73 | 1 | [] |
[
"<s>",
"void",
"iq2000_expand_epilogue",
"(",
"void",
")",
"{",
"HOST_WIDE_INT",
"tsize",
"=",
"cfun",
"->",
"machine",
"->",
"total_size",
";",
"rtx",
"tsize_rtx",
"=",
"GEN_INT",
"(",
"tsize",
")",
";",
"rtx",
"tmp_rtx",
"=",
"(",
"rtx",
")",
"0",
";",
"if",
"(",
"iq2000_can_use_return_insn",
"(",
")",
")",
"{",
"emit_jump_insn",
"(",
"gen_return",
"(",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"tsize",
">",
"32767",
")",
"{",
"tmp_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"IQ2000_TEMP1_REGNUM",
")",
";",
"emit_move_insn",
"(",
"tmp_rtx",
",",
"tsize_rtx",
")",
";",
"tsize_rtx",
"=",
"tmp_rtx",
";",
"}",
"if",
"(",
"tsize",
">",
"0",
")",
"{",
"if",
"(",
"frame_pointer_needed",
")",
"{",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"stack_pointer_rtx",
",",
"hard_frame_pointer_rtx",
")",
")",
";",
"}",
"save_restore_insns",
"(",
"0",
")",
";",
"if",
"(",
"current_function_calls_eh_return",
")",
"{",
"rtx",
"eh_ofs",
"=",
"EH_RETURN_STACKADJ_RTX",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"eh_ofs",
",",
"eh_ofs",
",",
"tsize_rtx",
")",
")",
";",
"tsize_rtx",
"=",
"eh_ofs",
";",
"}",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"if",
"(",
"tsize",
"!=",
"0",
"||",
"current_function_calls_eh_return",
")",
"{",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"tsize_rtx",
")",
")",
";",
"}",
"}",
"if",
"(",
"current_function_calls_eh_return",
")",
"{",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"HARD_FRAME_POINTER_REGNUM",
")",
",",
"stack_pointer_rtx",
")",
";",
"emit_insn",
"(",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"HARD_FRAME_POINTER_REGNUM",
")",
")",
")",
";",
"emit_jump_insn",
"(",
"gen_eh_return_internal",
"(",
")",
")",
";",
"}",
"else",
"emit_jump_insn",
"(",
"gen_return_internal",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_REG_FIRST",
"+",
"31",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"epilogue",
"into",
"a",
"bunch",
"of",
"separate",
"insns",
"."
] | [
"iq2000",
"0",
"32767",
"0",
"0",
"0",
"31"
] | iq20002 | iq2000_expand_epilogue | iq2000 | CPU | GCC | 17,327 | 225 | 1 | [] |
[
"<s>",
"constexpr",
"u16",
"Index",
"(",
")",
"const",
"{",
"return",
"this",
"->",
"storage",
"+",
"offset",
";",
"}",
"</s>"
] | [
"Index",
"field",
",",
"for",
"use",
"by",
"the",
"object",
"file",
"implementation",
"."
] | [
"Teak"
] | operand | Index | Teak | DSP | LLVM | 17,328 | 15 | 1 | [] |
[
"<s>",
"void",
"microblaze_expand_epilogue",
"(",
"void",
")",
"{",
"HOST_WIDE_INT",
"fsiz",
"=",
"current_frame_info",
".",
"total_size",
";",
"rtx",
"fsiz_rtx",
"=",
"GEN_INT",
"(",
"fsiz",
")",
";",
"rtx",
"reg_rtx",
";",
"rtx",
"mem_rtx",
";",
"if",
"(",
"microblaze_can_use_return_insn",
"(",
")",
")",
"{",
"emit_jump_insn",
"(",
"gen_return_internal",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_REG_FIRST",
"+",
"MB_ABI_SUB_RETURN_ADDR_REGNUM",
")",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"fsiz",
">",
"0",
")",
"{",
"if",
"(",
"!",
"crtl",
"->",
"is_leaf",
"||",
"interrupt_handler",
")",
"{",
"mem_rtx",
"=",
"gen_rtx_MEM",
"(",
"SImode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"const0_rtx",
")",
")",
";",
"if",
"(",
"interrupt_handler",
")",
"MEM_VOLATILE_P",
"(",
"mem_rtx",
")",
"=",
"1",
";",
"reg_rtx",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"MB_ABI_SUB_RETURN_ADDR_REGNUM",
")",
";",
"emit_move_insn",
"(",
"reg_rtx",
",",
"mem_rtx",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"emit_insn",
"(",
"gen_movsi",
"(",
"stack_pointer_rtx",
",",
"hard_frame_pointer_rtx",
")",
")",
";",
"save_restore_insns",
"(",
"0",
")",
";",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"fsiz_rtx",
")",
")",
";",
"}",
"emit_jump_insn",
"(",
"gen_return_internal",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_REG_FIRST",
"+",
"MB_ABI_SUB_RETURN_ADDR_REGNUM",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"epilogue",
"into",
"a",
"bunch",
"of",
"separate",
"insns",
"."
] | [
"microblaze",
"0",
"1",
"0"
] | microblaze2 | microblaze_expand_epilogue | microblaze | MPU | GCC | 17,329 | 168 | 1 | [] |
[
"<s>",
"bool",
"ARCInstrInfo",
"::",
"getBaseAndOffsetPosition",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"&",
"BasePos",
",",
"unsigned",
"&",
"OffsetPos",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
".",
"mayLoad",
"(",
")",
"&&",
"!",
"MI",
".",
"mayStore",
"(",
")",
")",
"return",
"false",
";",
"BasePos",
"=",
"1",
";",
"OffsetPos",
"=",
"2",
";",
"if",
"(",
"isPostIncrement",
"(",
"MI",
")",
"||",
"isPreIncrement",
"(",
"MI",
")",
")",
"{",
"BasePos",
"++",
";",
"OffsetPos",
"++",
";",
"}",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"BasePos",
")",
".",
"isReg",
"(",
")",
"||",
"!",
"MI",
".",
"getOperand",
"(",
"OffsetPos",
")",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"instruction",
"contains",
"a",
"base",
"register",
"and",
"offset",
"."
] | [
"ARC",
"ARC",
"1",
"2"
] | ARCInstrInfo1 | getBaseAndOffsetPosition | ARC | MPU | LLVM | 17,330 | 100 | 1 | [] |
[
"<s>",
"virtual",
"BitVector",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"assert",
"(",
"!",
"\"Unimplemented\"",
")",
";",
"return",
"BitVector",
"(",
")",
";",
"}",
"</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",
"\"Unimplemented\""
] | AMDGPURegisterInfo1 | getReservedRegs | R600 | GPU | LLVM | 17,331 | 23 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"AARCH64_BR_RELAX_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AArch64"
] | AArch64BranchRelaxation | getPassName | AArch64 | CPU | LLVM | 17,332 | 13 | 1 | [] |
[
"<s>",
"static",
"bool",
"isLiveOut",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
",",
"unsigned",
"Reg",
")",
"{",
"for",
"(",
"MachineBasicBlock",
"*",
"Succ",
":",
"MBB",
".",
"successors",
"(",
")",
")",
"{",
"if",
"(",
"Succ",
"->",
"isLiveIn",
"(",
"Reg",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"isLiveOut",
"-",
"Determine",
"if",
"Reg",
"is",
"live",
"out",
"from",
"MBB",
",",
"when",
"not",
"considering",
"PHI",
"nodes",
"."
] | [
"AMDGPU"
] | SIOptimizeExecMasking | isLiveOut | AMDGPU | GPU | LLVM | 17,333 | 43 | 1 | [] |
[
"<s>",
"void",
"OR1KAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"I",
"=",
"MI",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"E",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"instr_end",
"(",
")",
";",
"do",
"{",
"customEmitInstruction",
"(",
"I",
"++",
")",
";",
"}",
"while",
"(",
"(",
"I",
"!=",
"E",
")",
"&&",
"I",
"->",
"isInsideBundle",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"OR1K",
"OR1K"
] | OR1KAsmPrinter | EmitInstruction | OR1K | CPU | LLVM | 17,334 | 58 | 1 | [] |
[
"<s>",
"bool",
"FalkorHWPFFix",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"auto",
"&",
"ST",
"=",
"static_cast",
"<",
"const",
"AArch64Subtarget",
"&",
">",
"(",
"Fn",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"ST",
".",
"getProcFamily",
"(",
")",
"!=",
"AArch64Subtarget",
"::",
"Falkor",
")",
"return",
"false",
";",
"if",
"(",
"skipFunction",
"(",
"Fn",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"AArch64InstrInfo",
"*",
">",
"(",
"ST",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"assert",
"(",
"TRI",
"->",
"trackLivenessAfterRegAlloc",
"(",
"Fn",
")",
"&&",
"\"Register liveness not available!\"",
")",
";",
"MachineLoopInfo",
"&",
"LI",
"=",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineLoop",
"*",
"I",
":",
"LI",
")",
"for",
"(",
"auto",
"L",
"=",
"df_begin",
"(",
"I",
")",
",",
"LE",
"=",
"df_end",
"(",
"I",
")",
";",
"L",
"!=",
"LE",
";",
"++",
"L",
")",
"if",
"(",
"L",
"->",
"empty",
"(",
")",
")",
"runOnLoop",
"(",
"*",
"*",
"L",
",",
"Fn",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"\"Register liveness not available!\""
] | AArch64FalkorHWPFFix | runOnMachineFunction | AArch64 | CPU | LLVM | 17,335 | 161 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"nds32_output_casesi_pc_relative",
"(",
"rtx",
"*",
"operands",
")",
"{",
"machine_mode",
"mode",
";",
"rtx",
"diff_vec",
";",
"diff_vec",
"=",
"PATTERN",
"(",
"NEXT_INSN",
"(",
"as_a",
"<",
"rtx_insn",
"*",
">",
"(",
"operands",
"[",
"1",
"]",
")",
")",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"diff_vec",
")",
"==",
"ADDR_DIFF_VEC",
")",
";",
"output_asm_insn",
"(",
"\"la\\t$ta, %l1\"",
",",
"operands",
")",
";",
"mode",
"=",
"GET_MODE",
"(",
"diff_vec",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_QImode",
":",
"output_asm_insn",
"(",
"\"lb\\t%2, [$ta + %0 << 0]\"",
",",
"operands",
")",
";",
"break",
";",
"case",
"E_HImode",
":",
"output_asm_insn",
"(",
"\"lh\\t%2, [$ta + %0 << 1]\"",
",",
"operands",
")",
";",
"break",
";",
"case",
"E_SImode",
":",
"output_asm_insn",
"(",
"\"lw\\t%2, [$ta + %0 << 2]\"",
",",
"operands",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"output_asm_insn",
"(",
"\"add\\t$ta, %2, $ta\"",
",",
"operands",
")",
";",
"if",
"(",
"TARGET_16_BIT",
")",
"return",
"\"jr5\\t$ta\"",
";",
"else",
"return",
"\"jr\\t$ta\"",
";",
"}",
"</s>"
] | [
"Function",
"to",
"generate",
"PC",
"relative",
"jump",
"table",
".",
"Refer",
"to",
"nds32.md",
"for",
"more",
"details",
".",
"The",
"following",
"is",
"the",
"sample",
"for",
"the",
"case",
"that",
"diff",
"value",
"can",
"be",
"presented",
"in",
"'.short",
"'",
"size",
".",
"addi",
"$",
"r1",
",",
"$",
"r1",
",",
"-",
"(",
"case_lower_bound",
")",
"slti",
"$",
"ta",
",",
"$",
"r1",
",",
"(",
"case_number",
")",
"beqz",
"$",
"ta",
",",
".L_skip_label",
"la",
"$",
"ta",
",",
".L35",
"!",
"get",
"jump",
"table",
"address",
"lh",
"$",
"r1",
",",
"[",
"$",
"ta",
"+",
"$",
"r1",
"<",
"<",
"1",
"]",
"!",
"load",
"symbol",
"diff",
"from",
"jump",
"table",
"entry",
"addi",
"$",
"ta",
",",
"$",
"r1",
",",
"$",
"ta",
"jr5",
"$",
"ta",
"!",
"jump",
"table",
"entry",
"L35",
":",
".short",
".L25-.L35",
".short",
".L26-.L35",
".short",
".L27-.L35",
".short",
".L28-.L35",
".short",
".L29-.L35",
".short",
".L30-.L35",
".short",
".L31-.L35",
".short",
".L32-.L35",
".short",
".L33-.L35",
".short",
".L34-.L35"
] | [
"nds32",
"1",
"\"la\\t$ta, %l1\"",
"\"lb\\t%2, [$ta + %0 << 0]\"",
"\"lh\\t%2, [$ta + %0 << 1]\"",
"\"lw\\t%2, [$ta + %0 << 2]\"",
"\"add\\t$ta, %2, $ta\"",
"\"jr5\\t$ta\"",
"\"jr\\t$ta\""
] | nds32-md-auxiliary5 | nds32_output_casesi_pc_relative | nds32 | CPU | GCC | 17,336 | 127 | 1 | [] |
[
"<s>",
"static",
"bool",
"c6x_callee_copies",
"(",
"cumulative_args_t",
"cum_v",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"const_tree",
"type",
"ATTRIBUTE_UNUSED",
",",
"bool",
"named",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CALLEE_COPIES",
"."
] | [
"c6x"
] | c6x2 | c6x_callee_copies | c6x | VLIW | GCC | 17,337 | 25 | 1 | [] |
[
"<s>",
"void",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"override",
"{",
"switch",
"(",
"Kind",
")",
"{",
"case",
"Immediate",
":",
"OS",
"<<",
"*",
"getImm",
"(",
")",
";",
"break",
";",
"case",
"Token",
":",
"OS",
"<<",
"\"'\"",
"<<",
"getToken",
"(",
")",
"<<",
"\"'\"",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"AGC",
"\"'\"",
"\"'\""
] | AGCAsmParser | print | AGC | MPU | LLVM | 17,338 | 44 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"SystemZSelectionDAGInfo",
"::",
"EmitTargetCodeForStrcpy",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"SDLoc",
"DL",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dest",
",",
"SDValue",
"Src",
",",
"MachinePointerInfo",
"DestPtrInfo",
",",
"MachinePointerInfo",
"SrcPtrInfo",
",",
"bool",
"isStpcpy",
")",
"const",
"{",
"SDVTList",
"VTs",
"=",
"DAG",
".",
"getVTList",
"(",
"Dest",
".",
"getValueType",
"(",
")",
",",
"MVT",
"::",
"Other",
")",
";",
"SDValue",
"EndDest",
"=",
"DAG",
".",
"getNode",
"(",
"SystemZISD",
"::",
"STPCPY",
",",
"DL",
",",
"VTs",
",",
"Chain",
",",
"Dest",
",",
"Src",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"isStpcpy",
"?",
"EndDest",
":",
"Dest",
",",
"EndDest",
".",
"getValue",
"(",
"1",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"strcpy",
"or",
"stpcpy",
",",
"in",
"cases",
"where",
"that",
"is",
"faster",
"than",
"a",
"libcall",
"."
] | [
"SystemZ",
"SystemZ",
"MVT::Other",
"SystemZISD::STPCPY",
"0",
"MVT::i32",
"1"
] | SystemZSelectionDAGInfo (2) | EmitTargetCodeForStrcpy | SystemZ | CPU | LLVM | 17,339 | 112 | 1 | [] |
[
"<s>",
"bool",
"DCPU16InstrInfo",
"::",
"isUnpredicatedTerminator",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
"->",
"isTerminator",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
"->",
"isBranch",
"(",
")",
"&&",
"!",
"MI",
"->",
"isBarrier",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"MI",
"->",
"isPredicable",
"(",
")",
")",
"return",
"true",
";",
"return",
"!",
"isPredicated",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"is",
"a",
"terminator",
"instruction",
"that",
"has",
"not",
"been",
"predicated",
"."
] | [
"Dcpu16",
"DCPU16"
] | Dcpu16InstrInfo | isUnpredicatedTerminator | Dcpu16 | CPU | LLVM | 17,340 | 62 | 1 | [] |
[
"<s>",
"bool",
"small_data_pattern",
"(",
"rtx",
"op",
",",
"machine_mode",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"SEQUENCE",
")",
"return",
"false",
";",
"subrtx_iterator",
"::",
"array_type",
"array",
";",
"FOR_EACH_SUBRTX",
"(",
"iter",
",",
"array",
",",
"op",
",",
"ALL",
")",
"{",
"const_rtx",
"x",
"=",
"*",
"iter",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"rtx_equal_p",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"pic_offset_table_rtx",
")",
")",
"iter",
".",
"skip_subrtxes",
"(",
")",
";",
"else",
"if",
"(",
"arc_rewrite_small_data_p",
"(",
"x",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"OP",
"refers",
"to",
"small",
"data",
"symbols",
"directly",
",",
"not",
"through",
"a",
"PLUS",
"."
] | [
"arc",
"0"
] | arc4 | small_data_pattern | arc | MPU | GCC | 17,341 | 86 | 1 | [] |
[
"<s>",
"void",
"assignValueToAddress",
"(",
"Register",
"ValVReg",
",",
"Register",
"Addr",
",",
"uint64_t",
"Size",
",",
"MachinePointerInfo",
"&",
"MPO",
",",
"CCValAssign",
"&",
"VA",
")",
"override",
"{",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"LocInfo",
"::",
"AExt",
")",
"{",
"Size",
"=",
"VA",
".",
"getLocVT",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"/",
"8",
";",
"ValVReg",
"=",
"MIRBuilder",
".",
"buildAnyExt",
"(",
"LLT",
"::",
"scalar",
"(",
"Size",
"*",
"8",
")",
",",
"ValVReg",
")",
".",
"getReg",
"(",
"0",
")",
";",
"}",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"auto",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MPO",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"Size",
",",
"inferAlignFromPtrInfo",
"(",
"MF",
",",
"MPO",
")",
")",
";",
"MIRBuilder",
".",
"buildStore",
"(",
"ValVReg",
",",
"Addr",
",",
"*",
"MMO",
")",
";",
"}",
"</s>"
] | [
"An",
"overload",
"which",
"takes",
"an",
"ArgInfo",
"if",
"additional",
"information",
"about",
"the",
"arg",
"is",
"needed",
"."
] | [
"AArch64",
"8",
"8",
"0"
] | AArch64CallLowering12 | assignValueToAddress | AArch64 | CPU | LLVM | 17,342 | 121 | 1 | [] |
[
"<s>",
"unsigned",
"char",
"X86Subtarget",
"::",
"classifyGlobalFunctionReference",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"const",
"Module",
"&",
"M",
")",
"const",
"{",
"if",
"(",
"TM",
".",
"shouldAssumeDSOLocal",
"(",
"M",
",",
"GV",
")",
")",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"if",
"(",
"isTargetCOFF",
"(",
")",
")",
"{",
"if",
"(",
"GV",
"->",
"hasDLLImportStorageClass",
"(",
")",
")",
"return",
"X86II",
"::",
"MO_DLLIMPORT",
";",
"return",
"X86II",
"::",
"MO_COFFSTUB",
";",
"}",
"const",
"Function",
"*",
"F",
"=",
"dyn_cast_or_null",
"<",
"Function",
">",
"(",
"GV",
")",
";",
"if",
"(",
"isTargetELF",
"(",
")",
")",
"{",
"if",
"(",
"is64Bit",
"(",
")",
"&&",
"F",
"&&",
"(",
"CallingConv",
"::",
"X86_RegCall",
"==",
"F",
"->",
"getCallingConv",
"(",
")",
")",
")",
"return",
"X86II",
"::",
"MO_GOTPCREL",
";",
"if",
"(",
"(",
"(",
"F",
"&&",
"F",
"->",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NonLazyBind",
")",
")",
"||",
"(",
"!",
"F",
"&&",
"M",
".",
"getRtLibUseGOT",
"(",
")",
")",
")",
"&&",
"is64Bit",
"(",
")",
")",
"return",
"X86II",
"::",
"MO_GOTPCREL",
";",
"return",
"X86II",
"::",
"MO_PLT",
";",
"}",
"if",
"(",
"is64Bit",
"(",
")",
")",
"{",
"if",
"(",
"F",
"&&",
"F",
"->",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NonLazyBind",
")",
")",
"return",
"X86II",
"::",
"MO_GOTPCREL",
";",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"}",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"}",
"</s>"
] | [
"Classify",
"a",
"global",
"function",
"reference",
"for",
"the",
"current",
"subtarget",
"."
] | [
"X86",
"X86",
"X86II::MO_NO_FLAG",
"X86II::MO_DLLIMPORT",
"X86II::MO_COFFSTUB",
"X86",
"X86II::MO_GOTPCREL",
"X86II::MO_GOTPCREL",
"X86II::MO_PLT",
"X86II::MO_GOTPCREL",
"X86II::MO_NO_FLAG",
"X86II::MO_NO_FLAG"
] | X86Subtarget (2)3 | classifyGlobalFunctionReference | X86 | CPU | LLVM | 17,343 | 185 | 1 | [] |
[
"<s>",
"int",
"avr_accumulate_outgoing_args",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"cfun",
")",
"return",
"TARGET_ACCUMULATE_OUTGOING_ARGS",
";",
"return",
"(",
"TARGET_ACCUMULATE_OUTGOING_ARGS",
"&&",
"!",
"(",
"cfun",
"->",
"calls_setjmp",
"||",
"cfun",
"->",
"has_nonlocal_label",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"`",
"ACCUMULATE_OUTGOING_ARGS",
"'",
"."
] | [
"avr"
] | avr | avr_accumulate_outgoing_args | avr | MPU | GCC | 17,344 | 31 | 1 | [] |
[
"<s>",
"int",
"mask_low_and_shift_len",
"(",
"machine_mode",
"mode",
",",
"rtx",
"mask",
",",
"rtx",
"shift",
")",
"{",
"HOST_WIDE_INT",
"shval",
";",
"shval",
"=",
"INTVAL",
"(",
"shift",
")",
"&",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"-",
"1",
")",
";",
"return",
"exact_log2",
"(",
"(",
"UINTVAL",
"(",
"mask",
")",
">>",
"shval",
")",
"+",
"1",
")",
";",
"}",
"</s>"
] | [
"The",
"canonical",
"form",
"of",
"a",
"mask-low-and-shift-left",
"operation",
"is",
"(",
"and",
"(",
"ashift",
"X",
"SHIFT",
")",
"MASK",
")",
"where",
"MASK",
"has",
"the",
"lower",
"SHIFT",
"number",
"of",
"bits",
"cleared",
".",
"Thus",
"we",
"need",
"to",
"shift",
"MASK",
"to",
"the",
"right",
"before",
"checking",
"if",
"it",
"is",
"a",
"valid",
"mask",
"value",
".",
"MODE",
"is",
"the",
"mode",
"of",
"the",
"operation",
".",
"If",
"true",
"return",
"the",
"length",
"of",
"the",
"mask",
",",
"otherwise",
"return",
"-1",
"."
] | [
"mips",
"1",
"1"
] | mips | mask_low_and_shift_len | mips | CPU | GCC | 17,345 | 48 | 1 | [] |
[
"<s>",
"static",
"void",
"release_options_strings",
"(",
"char",
"*",
"*",
"option_strings",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"IX86_FUNCTION_SPECIFIC_MAX",
";",
"i",
"++",
")",
"free",
"(",
"option_strings",
"[",
"i",
"]",
")",
";",
"}",
"</s>"
] | [
"Release",
"allocated",
"strings",
"."
] | [
"i386",
"0"
] | i386-options | release_options_strings | i386 | CPU | GCC | 17,346 | 33 | 1 | [] |
[
"<s>",
"BitVector",
"LEGRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"LEG",
"::",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"LEG",
"::",
"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",
"."
] | [
"LEG",
"LEG",
"LEG::SP",
"LEG::LR"
] | LEGRegisterInfo | getReservedRegs | LEG | CPU | LLVM | 17,347 | 42 | 1 | [] |
[
"<s>",
"void",
"RISCVFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"RISCVRegisterInfo",
"*",
"RI",
"=",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"auto",
"*",
"RVFI",
"=",
"MF",
".",
"getInfo",
"<",
"RISCVMachineFunctionInfo",
">",
"(",
")",
";",
"Register",
"FPReg",
"=",
"getFPReg",
"(",
"STI",
")",
";",
"Register",
"SPReg",
"=",
"getSPReg",
"(",
"STI",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"!",
"MBB",
".",
"empty",
"(",
")",
")",
"{",
"MBBI",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"if",
"(",
"MBBI",
"==",
"MBB",
".",
"end",
"(",
")",
")",
"MBBI",
"=",
"MBB",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"DL",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"!",
"MBBI",
"->",
"isTerminator",
"(",
")",
")",
"MBBI",
"=",
"std",
"::",
"next",
"(",
"MBBI",
")",
";",
"while",
"(",
"MBBI",
"!=",
"MBB",
".",
"begin",
"(",
")",
"&&",
"std",
"::",
"prev",
"(",
"MBBI",
")",
"->",
"getFlag",
"(",
"MachineInstr",
"::",
"FrameDestroy",
")",
")",
"--",
"MBBI",
";",
"}",
"const",
"auto",
"&",
"CSI",
"=",
"getNonLibcallCSI",
"(",
"MFI",
".",
"getCalleeSavedInfo",
"(",
")",
")",
";",
"auto",
"LastFrameDestroy",
"=",
"MBBI",
";",
"if",
"(",
"!",
"CSI",
".",
"empty",
"(",
")",
")",
"LastFrameDestroy",
"=",
"std",
"::",
"prev",
"(",
"MBBI",
",",
"CSI",
".",
"size",
"(",
")",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"uint64_t",
"RealStackSize",
"=",
"StackSize",
"+",
"RVFI",
"->",
"getLibCallStackSize",
"(",
")",
";",
"uint64_t",
"FPOffset",
"=",
"RealStackSize",
"-",
"RVFI",
"->",
"getVarArgsSaveSize",
"(",
")",
";",
"if",
"(",
"RI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
"||",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
"||",
"RVFI",
"->",
"hasSpillVRs",
"(",
")",
")",
"{",
"assert",
"(",
"hasFP",
"(",
"MF",
")",
"&&",
"\"frame pointer should not have been eliminated\"",
")",
";",
"adjustReg",
"(",
"MBB",
",",
"LastFrameDestroy",
",",
"DL",
",",
"SPReg",
",",
"FPReg",
",",
"-",
"FPOffset",
",",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"}",
"uint64_t",
"FirstSPAdjustAmount",
"=",
"getFirstSPAdjustAmount",
"(",
"MF",
")",
";",
"if",
"(",
"FirstSPAdjustAmount",
")",
"{",
"uint64_t",
"SecondSPAdjustAmount",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
"-",
"FirstSPAdjustAmount",
";",
"assert",
"(",
"SecondSPAdjustAmount",
">",
"0",
"&&",
"\"SecondSPAdjustAmount should be greater than zero\"",
")",
";",
"adjustReg",
"(",
"MBB",
",",
"LastFrameDestroy",
",",
"DL",
",",
"SPReg",
",",
"SPReg",
",",
"SecondSPAdjustAmount",
",",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"}",
"if",
"(",
"FirstSPAdjustAmount",
")",
"StackSize",
"=",
"FirstSPAdjustAmount",
";",
"adjustReg",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"SPReg",
",",
"SPReg",
",",
"StackSize",
",",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"\"frame pointer should not have been eliminated\"",
"0",
"\"SecondSPAdjustAmount should be greater than zero\""
] | RISCVFrameLowering20 | emitEpilogue | RISCV | CPU | LLVM | 17,348 | 377 | 1 | [] |
[
"<s>",
"void",
"x86_order_regs_for_local_alloc",
"(",
"void",
")",
"{",
"int",
"pos",
"=",
"0",
";",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
")",
"if",
"(",
"GENERAL_REGNO_P",
"(",
"i",
")",
"&&",
"call_used_regs",
"[",
"i",
"]",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
")",
"if",
"(",
"GENERAL_REGNO_P",
"(",
"i",
")",
"&&",
"!",
"call_used_regs",
"[",
"i",
"]",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"if",
"(",
"!",
"TARGET_SSE_MATH",
")",
"for",
"(",
"i",
"=",
"FIRST_STACK_REG",
";",
"i",
"<=",
"LAST_STACK_REG",
";",
"i",
"++",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"for",
"(",
"i",
"=",
"FIRST_SSE_REG",
";",
"i",
"<=",
"LAST_SSE_REG",
";",
"i",
"++",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"for",
"(",
"i",
"=",
"FIRST_REX_SSE_REG",
";",
"i",
"<=",
"LAST_REX_SSE_REG",
";",
"i",
"++",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"for",
"(",
"i",
"=",
"FIRST_EXT_REX_SSE_REG",
";",
"i",
"<=",
"LAST_EXT_REX_SSE_REG",
";",
"i",
"++",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"for",
"(",
"i",
"=",
"FIRST_MASK_REG",
";",
"i",
"<=",
"LAST_MASK_REG",
";",
"i",
"++",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"if",
"(",
"TARGET_SSE_MATH",
")",
"for",
"(",
"i",
"=",
"FIRST_STACK_REG",
";",
"i",
"<=",
"LAST_STACK_REG",
";",
"i",
"++",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"for",
"(",
"i",
"=",
"FIRST_MMX_REG",
";",
"i",
"<=",
"LAST_MMX_REG",
";",
"i",
"++",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"i",
";",
"while",
"(",
"pos",
"<",
"FIRST_PSEUDO_REGISTER",
")",
"reg_alloc_order",
"[",
"pos",
"++",
"]",
"=",
"0",
";",
"}",
"</s>"
] | [
"Order",
"the",
"registers",
"for",
"register",
"allocator",
"."
] | [
"i386",
"0",
"0",
"0",
"0"
] | i3868 | x86_order_regs_for_local_alloc | i386 | CPU | GCC | 17,349 | 252 | 1 | [] |
[
"<s>",
"bool",
"PPCCTRLoops",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"LI",
"=",
"&",
"getAnalysis",
"<",
"LoopInfo",
">",
"(",
")",
";",
"SE",
"=",
"&",
"getAnalysis",
"<",
"ScalarEvolution",
">",
"(",
")",
";",
"DT",
"=",
"&",
"getAnalysis",
"<",
"DominatorTreeWrapperPass",
">",
"(",
")",
".",
"getDomTree",
"(",
")",
";",
"DataLayoutPass",
"*",
"DLP",
"=",
"getAnalysisIfAvailable",
"<",
"DataLayoutPass",
">",
"(",
")",
";",
"DL",
"=",
"DLP",
"?",
"&",
"DLP",
"->",
"getDataLayout",
"(",
")",
":",
"0",
";",
"LibInfo",
"=",
"getAnalysisIfAvailable",
"<",
"TargetLibraryInfo",
">",
"(",
")",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"LoopInfo",
"::",
"iterator",
"I",
"=",
"LI",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"LI",
"->",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"Loop",
"*",
"L",
"=",
"*",
"I",
";",
"if",
"(",
"!",
"L",
"->",
"getParentLoop",
"(",
")",
")",
"MadeChange",
"|=",
"convertToCTRLoop",
"(",
"L",
")",
";",
"}",
"return",
"MadeChange",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"PowerPC",
"PPC",
"0"
] | PPCCTRLoops18 | runOnFunction | PowerPC | CPU | LLVM | 17,350 | 139 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_vector_duplicate_value",
"(",
"machine_mode",
"mode",
",",
"rtx",
"target",
",",
"rtx",
"val",
")",
"{",
"bool",
"ok",
";",
"rtx_insn",
"*",
"insn",
";",
"rtx",
"dup",
";",
"dup",
"=",
"gen_vec_duplicate",
"(",
"mode",
",",
"val",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"dup",
")",
")",
";",
"if",
"(",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"{",
"rtx_insn",
"*",
"seq",
";",
"machine_mode",
"innermode",
"=",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"rtx",
"reg",
";",
"start_sequence",
"(",
")",
";",
"reg",
"=",
"force_reg",
"(",
"innermode",
",",
"val",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"reg",
")",
"!=",
"innermode",
")",
"reg",
"=",
"gen_lowpart",
"(",
"innermode",
",",
"reg",
")",
";",
"SET_SRC",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"=",
"gen_vec_duplicate",
"(",
"mode",
",",
"reg",
")",
";",
"seq",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"if",
"(",
"seq",
")",
"emit_insn_before",
"(",
"seq",
",",
"insn",
")",
";",
"ok",
"=",
"recog_memoized",
"(",
"insn",
")",
">=",
"0",
";",
"gcc_assert",
"(",
"ok",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"ix86_expand_vector_init_duplicate",
".",
"Tries",
"to",
"fill",
"target",
"with",
"val",
"via",
"vec_duplicate",
"."
] | [
"i386",
"0",
"0"
] | i386-expand | ix86_vector_duplicate_value | i386 | CPU | GCC | 17,351 | 156 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_trampoline_init",
"(",
"rtx",
"m_tramp",
",",
"tree",
"fndecl",
",",
"rtx",
"cxt",
")",
"{",
"rtx",
"fnaddr",
"=",
"XEXP",
"(",
"DECL_RTL",
"(",
"fndecl",
")",
",",
"0",
")",
";",
"rtx",
"ctx_reg",
"=",
"force_reg",
"(",
"Pmode",
",",
"cxt",
")",
";",
"rtx",
"addr",
"=",
"force_reg",
"(",
"Pmode",
",",
"XEXP",
"(",
"m_tramp",
",",
"0",
")",
")",
";",
"emit_library_call",
"(",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"\"__trampoline_setup\"",
")",
",",
"LCT_NORMAL",
",",
"VOIDmode",
",",
"addr",
",",
"Pmode",
",",
"fnaddr",
",",
"Pmode",
",",
"ctx_reg",
",",
"Pmode",
")",
";",
"}",
"</s>"
] | [
"Emit",
"RTL",
"insns",
"to",
"initialize",
"the",
"variable",
"parts",
"of",
"a",
"trampoline",
".",
"FNADDR",
"is",
"an",
"RTX",
"for",
"the",
"address",
"of",
"the",
"function",
"'s",
"pure",
"code",
".",
"CXT",
"is",
"an",
"RTX",
"for",
"the",
"static",
"chain",
"value",
"for",
"the",
"function",
".",
"On",
"Nios",
"II",
",",
"we",
"handle",
"this",
"by",
"a",
"library",
"call",
"."
] | [
"nios2",
"0",
"0",
"\"__trampoline_setup\""
] | nios2 | nios2_trampoline_init | nios2 | MPU | GCC | 17,352 | 79 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"WebAssemblyFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"assert",
"(",
"!",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
"&&",
"(",
"hasFP",
"(",
"MF",
")",
"||",
"hasBP",
"(",
"MF",
")",
")",
"&&",
"\"Call frame pseudos should only be used for dynamic stack adjustment\"",
")",
";",
"const",
"auto",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"TII",
"->",
"getCallFrameDestroyOpcode",
"(",
")",
"&&",
"needsSPWriteback",
"(",
"MF",
")",
")",
"{",
"DebugLoc",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"writeSPToGlobal",
"(",
"WebAssembly",
"::",
"SP32",
",",
"MF",
",",
"MBB",
",",
"I",
",",
"DL",
")",
";",
"}",
"return",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"WebAssembly",
"WebAssembly",
"0",
"\"Call frame pseudos should only be used for dynamic stack adjustment\"",
"WebAssembly",
"WebAssembly::SP32"
] | WebAssemblyFrameLowering10 | eliminateCallFramePseudoInstr | WebAssembly | Virtual ISA | LLVM | 17,353 | 123 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"MipsRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"const",
"MipsSubtarget",
"&",
"Subtarget",
"=",
"MF",
"->",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
"->",
"getFunction",
"(",
")",
";",
"if",
"(",
"F",
"->",
"hasFnAttribute",
"(",
"\"interrupt\"",
")",
")",
"{",
"if",
"(",
"Subtarget",
".",
"hasMips64",
"(",
")",
")",
"return",
"Subtarget",
".",
"hasMips64r6",
"(",
")",
"?",
"CSR_Interrupt_64R6_SaveList",
":",
"CSR_Interrupt_64_SaveList",
";",
"else",
"return",
"Subtarget",
".",
"hasMips32r6",
"(",
")",
"?",
"CSR_Interrupt_32R6_SaveList",
":",
"CSR_Interrupt_32_SaveList",
";",
"}",
"if",
"(",
"Subtarget",
".",
"isSingleFloat",
"(",
")",
")",
"return",
"CSR_SingleFloatOnly_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isABI_N64",
"(",
")",
")",
"return",
"CSR_N64_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isABI_N32",
"(",
")",
")",
"return",
"CSR_N32_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isFP64bit",
"(",
")",
")",
"return",
"CSR_O32_FP64_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isFPXX",
"(",
")",
")",
"return",
"CSR_O32_FPXX_SaveList",
";",
"return",
"CSR_O32_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"\"interrupt\"",
"Mips",
"Mips",
"Mips"
] | MipsRegisterInfo (2)1 | getCalleeSavedRegs | Mips | CPU | LLVM | 17,354 | 140 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
"AllowModify",
")",
"const",
"{",
"TBB",
"=",
"nullptr",
";",
"FBB",
"=",
"nullptr",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"if",
"(",
"I",
"==",
"MBB",
".",
"begin",
"(",
")",
")",
"return",
"false",
";",
"--",
"I",
";",
"while",
"(",
"isPredicated",
"(",
"*",
"I",
")",
"||",
"I",
"->",
"isTerminator",
"(",
")",
"||",
"I",
"->",
"isDebugValue",
"(",
")",
")",
"{",
"bool",
"CantAnalyze",
"=",
"false",
";",
"while",
"(",
"I",
"->",
"isDebugValue",
"(",
")",
"||",
"!",
"I",
"->",
"isTerminator",
"(",
")",
")",
"{",
"if",
"(",
"I",
"==",
"MBB",
".",
"begin",
"(",
")",
")",
"return",
"false",
";",
"--",
"I",
";",
"}",
"if",
"(",
"isIndirectBranchOpcode",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"||",
"isJumpTableBranchOpcode",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
")",
"{",
"CantAnalyze",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"isUncondBranchOpcode",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
")",
"{",
"TBB",
"=",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"}",
"else",
"if",
"(",
"isCondBranchOpcode",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"Cond",
".",
"empty",
"(",
")",
")",
"return",
"true",
";",
"assert",
"(",
"!",
"FBB",
"&&",
"\"FBB should have been null.\"",
")",
";",
"FBB",
"=",
"TBB",
";",
"TBB",
"=",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"Cond",
".",
"push_back",
"(",
"I",
"->",
"getOperand",
"(",
"1",
")",
")",
";",
"Cond",
".",
"push_back",
"(",
"I",
"->",
"getOperand",
"(",
"2",
")",
")",
";",
"}",
"else",
"if",
"(",
"I",
"->",
"isReturn",
"(",
")",
")",
"{",
"CantAnalyze",
"=",
"!",
"isPredicated",
"(",
"*",
"I",
")",
";",
"}",
"else",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"isPredicated",
"(",
"*",
"I",
")",
"&&",
"(",
"isUncondBranchOpcode",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"||",
"isIndirectBranchOpcode",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"||",
"isJumpTableBranchOpcode",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"||",
"I",
"->",
"isReturn",
"(",
")",
")",
")",
"{",
"Cond",
".",
"clear",
"(",
")",
";",
"FBB",
"=",
"nullptr",
";",
"if",
"(",
"AllowModify",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"DI",
"=",
"std",
"::",
"next",
"(",
"I",
")",
";",
"while",
"(",
"DI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"MachineInstr",
"&",
"InstToDelete",
"=",
"*",
"DI",
";",
"++",
"DI",
";",
"InstToDelete",
".",
"eraseFromParent",
"(",
")",
";",
"}",
"}",
"}",
"if",
"(",
"CantAnalyze",
")",
"return",
"true",
";",
"if",
"(",
"I",
"==",
"MBB",
".",
"begin",
"(",
")",
")",
"return",
"false",
";",
"--",
"I",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"ARM",
"ARM",
"0",
"\"FBB should have been null.\"",
"0",
"1",
"2"
] | ARMBaseInstrInfo (2)2 | analyzeBranch | ARM | CPU | LLVM | 17,355 | 409 | 1 | [] |
[
"<s>",
"BitVector",
"NVPTXRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"for",
"(",
"unsigned",
"Reg",
"=",
"NVPTX",
"::",
"ENVREG0",
";",
"Reg",
"<=",
"NVPTX",
"::",
"ENVREG31",
";",
"++",
"Reg",
")",
"{",
"markSuperRegs",
"(",
"Reserved",
",",
"Reg",
")",
";",
"}",
"markSuperRegs",
"(",
"Reserved",
",",
"NVPTX",
"::",
"VRFrame32",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"NVPTX",
"::",
"VRFrameLocal32",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"NVPTX",
"::",
"VRFrame64",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"NVPTX",
"::",
"VRFrameLocal64",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"NVPTX",
"::",
"VRDepot",
")",
";",
"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",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX::ENVREG0",
"NVPTX::ENVREG31",
"NVPTX::VRFrame32",
"NVPTX::VRFrameLocal32",
"NVPTX::VRFrame64",
"NVPTX::VRFrameLocal64",
"NVPTX::VRDepot"
] | NVPTXRegisterInfo15 | getReservedRegs | NVPTX | GPU | LLVM | 17,356 | 96 | 1 | [] |
[
"<s>",
"MandarinTargetLowering",
"::",
"ConstraintType",
"MandarinTargetLowering",
"::",
"getConstraintType",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'r'",
":",
"return",
"C_RegisterClass",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getConstraintType",
"(",
"Constraint",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constraint",
"letter",
",",
"return",
"the",
"type",
"of",
"constraint",
"for",
"this",
"target",
"."
] | [
"Mandarin",
"1",
"0"
] | MandarinISelLowering | getConstraintType | Mandarin | CPU | LLVM | 17,357 | 56 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"BPFTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"BPFISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"BPFISD",
"::",
"FIRST_NUMBER",
":",
"break",
";",
"case",
"BPFISD",
"::",
"RET_FLAG",
":",
"return",
"\"BPFISD::RET_FLAG\"",
";",
"case",
"BPFISD",
"::",
"CALL",
":",
"return",
"\"BPFISD::CALL\"",
";",
"case",
"BPFISD",
"::",
"SELECT_CC",
":",
"return",
"\"BPFISD::SELECT_CC\"",
";",
"case",
"BPFISD",
"::",
"BR_CC",
":",
"return",
"\"BPFISD::BR_CC\"",
";",
"case",
"BPFISD",
"::",
"Wrapper",
":",
"return",
"\"BPFISD::Wrapper\"",
";",
"case",
"BPFISD",
"::",
"MEMCPY",
":",
"return",
"\"BPFISD::MEMCPY\"",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"BPF",
"BPF",
"BPFISD::NodeType",
"BPFISD::FIRST_NUMBER",
"BPFISD::RET_FLAG",
"\"BPFISD::RET_FLAG\"",
"BPFISD::CALL",
"\"BPFISD::CALL\"",
"BPFISD::SELECT_CC",
"\"BPFISD::SELECT_CC\"",
"BPFISD::BR_CC",
"\"BPFISD::BR_CC\"",
"BPFISD::Wrapper",
"\"BPFISD::Wrapper\"",
"BPFISD::MEMCPY",
"\"BPFISD::MEMCPY\""
] | BPFISelLowering | getTargetNodeName | BPF | Virtual ISA | LLVM | 17,358 | 82 | 1 | [] |
[
"<s>",
"void",
"X86DAGToDAGISel",
"::",
"PreprocessISelDAG",
"(",
")",
"{",
"OptForSize",
"=",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getFnAttributes",
"(",
")",
".",
"hasAttribute",
"(",
"Attributes",
"::",
"OptimizeForSize",
")",
";",
"for",
"(",
"SelectionDAG",
"::",
"allnodes_iterator",
"I",
"=",
"CurDAG",
"->",
"allnodes_begin",
"(",
")",
",",
"E",
"=",
"CurDAG",
"->",
"allnodes_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"SDNode",
"*",
"N",
"=",
"I",
"++",
";",
"if",
"(",
"OptLevel",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"CALL",
"||",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"TC_RETURN",
"&&",
"(",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"||",
"getTargetMachine",
"(",
")",
".",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"PIC_",
")",
")",
")",
")",
"{",
"bool",
"HasCallSeq",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"CALL",
";",
"SDValue",
"Chain",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"Load",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"!",
"isCalleeLoad",
"(",
"Load",
",",
"Chain",
",",
"HasCallSeq",
")",
")",
"continue",
";",
"MoveBelowOrigChain",
"(",
"CurDAG",
",",
"Load",
",",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"Chain",
")",
";",
"++",
"NumLoadMoved",
";",
"continue",
";",
"}",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"FP_ROUND",
"&&",
"N",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"FP_EXTEND",
")",
"continue",
";",
"EVT",
"SrcVT",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
".",
"getValueType",
"(",
")",
";",
"EVT",
"DstVT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"if",
"(",
"SrcVT",
".",
"isVector",
"(",
")",
"||",
"DstVT",
".",
"isVector",
"(",
")",
")",
"continue",
";",
"bool",
"SrcIsSSE",
"=",
"X86Lowering",
".",
"isScalarFPTypeInSSEReg",
"(",
"SrcVT",
")",
";",
"bool",
"DstIsSSE",
"=",
"X86Lowering",
".",
"isScalarFPTypeInSSEReg",
"(",
"DstVT",
")",
";",
"if",
"(",
"SrcIsSSE",
"&&",
"DstIsSSE",
")",
"continue",
";",
"if",
"(",
"!",
"SrcIsSSE",
"&&",
"!",
"DstIsSSE",
")",
"{",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"FP_EXTEND",
")",
"continue",
";",
"if",
"(",
"N",
"->",
"getConstantOperandVal",
"(",
"1",
")",
")",
"continue",
";",
"}",
"EVT",
"MemVT",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"FP_ROUND",
")",
"MemVT",
"=",
"DstVT",
";",
"else",
"MemVT",
"=",
"SrcIsSSE",
"?",
"SrcVT",
":",
"DstVT",
";",
"SDValue",
"MemTmp",
"=",
"CurDAG",
"->",
"CreateStackTemporary",
"(",
"MemVT",
")",
";",
"DebugLoc",
"dl",
"=",
"N",
"->",
"getDebugLoc",
"(",
")",
";",
"SDValue",
"Store",
"=",
"CurDAG",
"->",
"getTruncStore",
"(",
"CurDAG",
"->",
"getEntryNode",
"(",
")",
",",
"dl",
",",
"N",
"->",
"getOperand",
"(",
"0",
")",
",",
"MemTmp",
",",
"MachinePointerInfo",
"(",
")",
",",
"MemVT",
",",
"false",
",",
"false",
",",
"0",
")",
";",
"SDValue",
"Result",
"=",
"CurDAG",
"->",
"getExtLoad",
"(",
"ISD",
"::",
"EXTLOAD",
",",
"dl",
",",
"DstVT",
",",
"Store",
",",
"MemTmp",
",",
"MachinePointerInfo",
"(",
")",
",",
"MemVT",
",",
"false",
",",
"false",
",",
"0",
")",
";",
"--",
"I",
";",
"CurDAG",
"->",
"ReplaceAllUsesOfValueWith",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"Result",
")",
";",
"++",
"I",
";",
"CurDAG",
"->",
"DeleteNode",
"(",
"N",
")",
";",
"}",
"}",
"</s>"
] | [
"PreprocessISelDAG",
"-",
"This",
"hook",
"allows",
"targets",
"to",
"hack",
"on",
"the",
"graph",
"before",
"instruction",
"selection",
"starts",
"."
] | [
"X86",
"X86",
"X86ISD::CALL",
"X86ISD::TC_RETURN",
"X86ISD::CALL",
"0",
"1",
"0",
"ISD::FP_ROUND",
"ISD::FP_EXTEND",
"0",
"0",
"X86",
"X86",
"ISD::FP_EXTEND",
"1",
"ISD::FP_ROUND",
"0",
"0",
"ISD::EXTLOAD",
"0",
"0"
] | X86ISelDAGToDAG118 | PreprocessISelDAG | X86 | CPU | LLVM | 17,359 | 454 | 1 | [] |
[
"<s>",
"void",
"Z80Operand",
"::",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"Z80",
"Z80"
] | Z80Operand | print | Z80 | MPU | LLVM | 17,360 | 12 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"SITargetLowering",
"::",
"shouldExpandAtomicCmpXchgInIR",
"(",
"AtomicCmpXchgInst",
"*",
"CmpX",
")",
"const",
"{",
"return",
"CmpX",
"->",
"getPointerAddressSpace",
"(",
")",
"==",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
"?",
"AtomicExpansionKind",
"::",
"NotAtomic",
":",
"AtomicExpansionKind",
"::",
"None",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"given",
"atomic",
"cmpxchg",
"should",
"be",
"expanded",
"by",
"the",
"IR-level",
"AtomicExpand",
"pass",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU"
] | SIISelLowering62 | shouldExpandAtomicCmpXchgInIR | AMDGPU | GPU | LLVM | 17,361 | 33 | 1 | [] |
[
"<s>",
"static",
"bool",
"is_nonpipeline_insn",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"enum",
"attr_type",
"type",
";",
"if",
"(",
"!",
"insn",
"||",
"!",
"NONDEBUG_INSN_P",
"(",
"insn",
")",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"USE",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"CLOBBER",
")",
"return",
"false",
";",
"type",
"=",
"get_attr_type",
"(",
"insn",
")",
";",
"if",
"(",
"type",
"==",
"TYPE_MUL",
"||",
"type",
"==",
"TYPE_DIV",
"||",
"type",
"==",
"TYPE_SDIV",
"||",
"type",
"==",
"TYPE_DDIV",
"||",
"type",
"==",
"TYPE_SSQRT",
"||",
"type",
"==",
"TYPE_DSQRT",
"||",
"type",
"==",
"TYPE_MFCR",
"||",
"type",
"==",
"TYPE_MFCRF",
"||",
"type",
"==",
"TYPE_MFJMPR",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"instruction",
"is",
"nonpipelined",
"on",
"the",
"Cell",
"."
] | [
"rs6000"
] | rs6000 | is_nonpipeline_insn | rs6000 | CPU | GCC | 17,362 | 101 | 1 | [] |
[
"<s>",
"static",
"rtx",
"frv_dwarf_store",
"(",
"rtx",
"reg",
",",
"int",
"offset",
")",
"{",
"rtx",
"set",
"=",
"gen_rtx_SET",
"(",
"gen_rtx_MEM",
"(",
"GET_MODE",
"(",
"reg",
")",
",",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"offset",
")",
")",
",",
"reg",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"set",
")",
"=",
"1",
";",
"return",
"set",
";",
"}",
"</s>"
] | [
"Generate",
"a",
"frame-related",
"expression",
":",
"(",
"set",
"REG",
"(",
"mem",
"(",
"plus",
"(",
"sp",
")",
"(",
"const_int",
"OFFSET",
")",
")",
")",
")",
".",
"Such",
"expressions",
"are",
"used",
"in",
"FRAME_RELATED_EXPR",
"notes",
"for",
"more",
"complex",
"instructions",
".",
"Marking",
"the",
"expressions",
"as",
"frame-related",
"is",
"superfluous",
"if",
"the",
"note",
"contains",
"just",
"a",
"single",
"set",
".",
"But",
"if",
"the",
"note",
"contains",
"a",
"PARALLEL",
"or",
"SEQUENCE",
"that",
"has",
"several",
"sets",
",",
"each",
"set",
"must",
"be",
"individually",
"marked",
"as",
"frame-related",
"."
] | [
"frv",
"1"
] | frv | frv_dwarf_store | frv | VLIW | GCC | 17,363 | 47 | 1 | [] |
[
"<s>",
"static",
"void",
"do_isel",
"(",
"rtx",
"dest",
",",
"rtx",
"cmp",
",",
"rtx",
"src_t",
",",
"rtx",
"src_f",
",",
"rtx",
"cr",
")",
"{",
"if",
"(",
"GET_MODE",
"(",
"dest",
")",
"==",
"DImode",
")",
"emit_insn",
"(",
"gen_isel_cc_di",
"(",
"dest",
",",
"cmp",
",",
"src_t",
",",
"src_f",
",",
"cr",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_isel_cc_si",
"(",
"dest",
",",
"cmp",
",",
"src_t",
",",
"src_f",
",",
"cr",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"isel",
"of",
"the",
"proper",
"mode",
"for",
"DEST",
".",
"DEST",
"is",
"the",
"isel",
"destination",
"register",
".",
"SRC1",
"is",
"the",
"isel",
"source",
"if",
"CR",
"is",
"true",
".",
"SRC2",
"is",
"the",
"isel",
"source",
"if",
"CR",
"is",
"false",
".",
"CR",
"is",
"the",
"condition",
"for",
"the",
"isel",
"."
] | [
"rs6000"
] | rs6000-string1 | do_isel | rs6000 | CPU | GCC | 17,364 | 63 | 1 | [] |
[
"<s>",
"unsigned",
"PPCTTI",
"::",
"getIntImmCost",
"(",
"unsigned",
"Opcode",
",",
"unsigned",
"Idx",
",",
"const",
"APInt",
"&",
"Imm",
",",
"Type",
"*",
"Ty",
")",
"const",
"{",
"if",
"(",
"DisablePPCConstHoist",
")",
"return",
"TargetTransformInfo",
"::",
"getIntImmCost",
"(",
"Opcode",
",",
"Idx",
",",
"Imm",
",",
"Ty",
")",
";",
"assert",
"(",
"Ty",
"->",
"isIntegerTy",
"(",
")",
")",
";",
"unsigned",
"BitSize",
"=",
"Ty",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"BitSize",
"==",
"0",
")",
"return",
"~",
"0U",
";",
"unsigned",
"ImmIdx",
"=",
"~",
"0U",
";",
"bool",
"ShiftedFree",
"=",
"false",
",",
"RunFree",
"=",
"false",
",",
"UnsignedFree",
"=",
"false",
",",
"ZeroFree",
"=",
"false",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"TCC_Free",
";",
"case",
"Instruction",
"::",
"GetElementPtr",
":",
"if",
"(",
"Idx",
"==",
"0",
")",
"return",
"2",
"*",
"TCC_Basic",
";",
"return",
"TCC_Free",
";",
"case",
"Instruction",
"::",
"And",
":",
"RunFree",
"=",
"true",
";",
"case",
"Instruction",
"::",
"Add",
":",
"case",
"Instruction",
"::",
"Or",
":",
"case",
"Instruction",
"::",
"Xor",
":",
"ShiftedFree",
"=",
"true",
";",
"case",
"Instruction",
"::",
"Sub",
":",
"case",
"Instruction",
"::",
"Mul",
":",
"case",
"Instruction",
"::",
"Shl",
":",
"case",
"Instruction",
"::",
"LShr",
":",
"case",
"Instruction",
"::",
"AShr",
":",
"ImmIdx",
"=",
"1",
";",
"break",
";",
"case",
"Instruction",
"::",
"ICmp",
":",
"UnsignedFree",
"=",
"true",
";",
"ImmIdx",
"=",
"1",
";",
"case",
"Instruction",
"::",
"Select",
":",
"ZeroFree",
"=",
"true",
";",
"break",
";",
"case",
"Instruction",
"::",
"PHI",
":",
"case",
"Instruction",
"::",
"Call",
":",
"case",
"Instruction",
"::",
"Ret",
":",
"case",
"Instruction",
"::",
"Load",
":",
"case",
"Instruction",
"::",
"Store",
":",
"break",
";",
"}",
"if",
"(",
"ZeroFree",
"&&",
"Imm",
"==",
"0",
")",
"return",
"TCC_Free",
";",
"if",
"(",
"Idx",
"==",
"ImmIdx",
"&&",
"Imm",
".",
"getBitWidth",
"(",
")",
"<=",
"64",
")",
"{",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Imm",
".",
"getSExtValue",
"(",
")",
")",
")",
"return",
"TCC_Free",
";",
"if",
"(",
"RunFree",
")",
"{",
"if",
"(",
"Imm",
".",
"getBitWidth",
"(",
")",
"<=",
"32",
"&&",
"(",
"isShiftedMask_32",
"(",
"Imm",
".",
"getZExtValue",
"(",
")",
")",
"||",
"isShiftedMask_32",
"(",
"~",
"Imm",
".",
"getZExtValue",
"(",
")",
")",
")",
")",
"return",
"TCC_Free",
";",
"if",
"(",
"ST",
"->",
"isPPC64",
"(",
")",
"&&",
"(",
"isShiftedMask_64",
"(",
"Imm",
".",
"getZExtValue",
"(",
")",
")",
"||",
"isShiftedMask_64",
"(",
"~",
"Imm",
".",
"getZExtValue",
"(",
")",
")",
")",
")",
"return",
"TCC_Free",
";",
"}",
"if",
"(",
"UnsignedFree",
"&&",
"isUInt",
"<",
"16",
">",
"(",
"Imm",
".",
"getZExtValue",
"(",
")",
")",
")",
"return",
"TCC_Free",
";",
"if",
"(",
"ShiftedFree",
"&&",
"(",
"Imm",
".",
"getZExtValue",
"(",
")",
"&",
"0xFFFF",
")",
"==",
"0",
")",
"return",
"TCC_Free",
";",
"}",
"return",
"PPCTTI",
"::",
"getIntImmCost",
"(",
"Imm",
",",
"Ty",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"materializing",
"a",
"64-bit",
"value",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"0",
"0U",
"0U",
"0",
"2",
"1",
"1",
"0",
"64",
"16",
"32",
"PPC",
"16",
"0xFFFF",
"0",
"PPC"
] | PPCTargetTransformInfo26 | getIntImmCost | PowerPC | CPU | LLVM | 17,365 | 396 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"insertSSPDeclarations",
"(",
"Module",
"&",
"M",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
"->",
"getTargetTriple",
"(",
")",
".",
"isWindowsMSVCEnvironment",
"(",
")",
")",
"return",
"TargetLowering",
"::",
"insertSSPDeclarations",
"(",
"M",
")",
";",
"M",
".",
"getOrInsertGlobal",
"(",
"\"__security_cookie\"",
",",
"Type",
"::",
"getInt8PtrTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
")",
";",
"FunctionCallee",
"SecurityCheckCookie",
"=",
"M",
".",
"getOrInsertFunction",
"(",
"\"__security_check_cookie\"",
",",
"Type",
"::",
"getVoidTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
",",
"Type",
"::",
"getInt8PtrTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
")",
";",
"if",
"(",
"Function",
"*",
"F",
"=",
"dyn_cast",
"<",
"Function",
">",
"(",
"SecurityCheckCookie",
".",
"getCallee",
"(",
")",
")",
")",
"F",
"->",
"addAttribute",
"(",
"1",
",",
"Attribute",
"::",
"AttrKind",
"::",
"InReg",
")",
";",
"}",
"</s>"
] | [
"Inserts",
"necessary",
"declarations",
"for",
"SSP",
"(",
"stack",
"protection",
")",
"purpose",
"."
] | [
"ARM",
"ARM",
"\"__security_cookie\"",
"\"__security_check_cookie\"",
"1"
] | ARMISelLowering (2)6 | insertSSPDeclarations | ARM | CPU | LLVM | 17,366 | 114 | 1 | [] |
[
"<s>",
"std",
"::",
"unique_ptr",
"<",
"PBQPRAConstraint",
">",
"AArch64Subtarget",
"::",
"getCustomPBQPConstraints",
"(",
")",
"const",
"{",
"return",
"balanceFPOps",
"(",
")",
"?",
"std",
"::",
"make_unique",
"<",
"A57ChainingConstraint",
">",
"(",
")",
":",
"nullptr",
";",
"}",
"</s>"
] | [
"Return",
"PBQPConstraint",
"(",
"s",
")",
"for",
"the",
"target",
"."
] | [
"AArch64",
"AArch64"
] | AArch64Subtarget (2)1 | getCustomPBQPConstraints | AArch64 | CPU | LLVM | 17,367 | 30 | 1 | [] |
[
"<s>",
"void",
"MipsDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"== \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"Node",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
";",
"}",
"if",
"(",
"trySelect",
"(",
"Node",
")",
")",
"return",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ADD",
":",
"if",
"(",
"Node",
"->",
"getSimpleValueType",
"(",
"0",
")",
".",
"isVector",
"(",
")",
"&&",
"selectVecAddAsVecSubIfProfitable",
"(",
"Node",
")",
")",
"return",
";",
"break",
";",
"case",
"ISD",
"::",
"GLOBAL_OFFSET_TABLE",
":",
"ReplaceNode",
"(",
"Node",
",",
"getGlobalBaseReg",
"(",
"false",
")",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"case",
"ISD",
"::",
"STORE",
":",
"assert",
"(",
"(",
"Subtarget",
"->",
"systemSupportsUnalignedAccess",
"(",
"cast",
"<",
"MemSDNode",
">",
"(",
"Node",
")",
"->",
"getAddressSpace",
"(",
")",
")",
"||",
"(",
"cast",
"<",
"MemSDNode",
">",
"(",
"Node",
")",
"->",
"getMemoryVT",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"/",
"8",
")",
"<=",
"cast",
"<",
"MemSDNode",
">",
"(",
"Node",
")",
"->",
"getAlignment",
"(",
")",
")",
"&&",
"\"Unexpected unaligned loads/stores.\"",
")",
";",
"break",
";",
"}",
"SelectCode",
"(",
"Node",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Mips",
"Mips",
"\"== \"",
"\"\\n\"",
"1",
"ISD::ADD",
"0",
"ISD::GLOBAL_OFFSET_TABLE",
"ISD::LOAD",
"ISD::STORE",
"8",
"\"Unexpected unaligned loads/stores.\""
] | MipsISelDAGToDAG36 | Select | Mips | CPU | LLVM | 17,368 | 198 | 1 | [] |
[
"<s>",
"BitVector",
"Z80RegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"const",
"Z80FrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"Reserved",
".",
"set",
"(",
"Z80",
"::",
"SPS",
")",
";",
"Reserved",
".",
"set",
"(",
"Z80",
"::",
"PC",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"{",
"for",
"(",
"MCSubRegIterator",
"I",
"(",
"Z80",
"::",
"IX",
",",
"this",
",",
"true",
")",
";",
"I",
".",
"isValid",
"(",
")",
";",
"++",
"I",
")",
"{",
"Reserved",
".",
"set",
"(",
"*",
"I",
")",
";",
"}",
"}",
"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",
"."
] | [
"Z80",
"Z80",
"Z80",
"Z80::SPS",
"Z80::PC",
"Z80::IX"
] | Z80RegisterInfo1 | getReservedRegs | Z80 | MPU | LLVM | 17,369 | 96 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"canInsertSelect",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
",",
"Register",
"DstReg",
",",
"Register",
"TrueReg",
",",
"Register",
"FalseReg",
",",
"int",
"&",
"CondCycles",
",",
"int",
"&",
"TrueCycles",
",",
"int",
"&",
"FalseCycles",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"canUseCMOV",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Cond",
".",
"size",
"(",
")",
"!=",
"1",
")",
"return",
"false",
";",
"if",
"(",
"(",
"X86",
"::",
"CondCode",
")",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
">",
"X86",
"::",
"LAST_VALID_COND",
")",
"return",
"false",
";",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"RI",
".",
"getCommonSubClass",
"(",
"MRI",
".",
"getRegClass",
"(",
"TrueReg",
")",
",",
"MRI",
".",
"getRegClass",
"(",
"FalseReg",
")",
")",
";",
"if",
"(",
"!",
"RC",
")",
"return",
"false",
";",
"if",
"(",
"X86",
"::",
"GR16RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"||",
"X86",
"::",
"GR32RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"||",
"X86",
"::",
"GR64RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
")",
"{",
"CondCycles",
"=",
"2",
";",
"TrueCycles",
"=",
"2",
";",
"FalseCycles",
"=",
"2",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"possible",
"to",
"insert",
"a",
"select",
"instruction",
"that",
"chooses",
"between",
"TrueReg",
"and",
"FalseReg",
"based",
"on",
"the",
"condition",
"code",
"in",
"Cond",
"."
] | [
"X86",
"X86",
"1",
"X86::CondCode",
"0",
"X86::LAST_VALID_COND",
"X86::GR16RegClass",
"X86::GR32RegClass",
"X86::GR64RegClass",
"2",
"2",
"2"
] | X86InstrInfo64 | canInsertSelect | X86 | CPU | LLVM | 17,370 | 184 | 1 | [] |
[
"<s>",
"static",
"bool",
"is_load_insn1",
"(",
"rtx",
"pat",
",",
"rtx",
"*",
"load_mem",
")",
"{",
"if",
"(",
"!",
"pat",
"||",
"pat",
"==",
"NULL_RTX",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"SET",
")",
"{",
"if",
"(",
"REG_P",
"(",
"SET_DEST",
"(",
"pat",
")",
")",
")",
"return",
"find_mem_ref",
"(",
"SET_SRC",
"(",
"pat",
")",
",",
"load_mem",
")",
";",
"else",
"return",
"false",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"PARALLEL",
")",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"XVECLEN",
"(",
"pat",
",",
"0",
")",
";",
"i",
"++",
")",
"if",
"(",
"is_load_insn1",
"(",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"i",
")",
",",
"load_mem",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Determine",
"if",
"PAT",
"is",
"a",
"PATTERN",
"of",
"a",
"load",
"insn",
"."
] | [
"rs6000",
"0",
"0",
"0"
] | rs6000 | is_load_insn1 | rs6000 | CPU | GCC | 17,371 | 115 | 1 | [] |
[
"<s>",
"void",
"X86FrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedRegs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedRegs",
",",
"RS",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"X86MachineFunctionInfo",
"*",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"int64_t",
"TailCallReturnAddrDelta",
"=",
"X86FI",
"->",
"getTCReturnAddrDelta",
"(",
")",
";",
"if",
"(",
"TailCallReturnAddrDelta",
"<",
"0",
")",
"{",
"MFI",
".",
"CreateFixedObject",
"(",
"-",
"TailCallReturnAddrDelta",
",",
"TailCallReturnAddrDelta",
"-",
"SlotSize",
",",
"true",
")",
";",
"}",
"if",
"(",
"TRI",
"->",
"hasBasePointer",
"(",
"MF",
")",
")",
"{",
"SavedRegs",
".",
"set",
"(",
"TRI",
"->",
"getBaseRegister",
"(",
")",
")",
";",
"if",
"(",
"MF",
".",
"hasEHFunclets",
"(",
")",
")",
"{",
"int",
"FI",
"=",
"MFI",
".",
"CreateSpillStackObject",
"(",
"SlotSize",
",",
"SlotSize",
")",
";",
"X86FI",
"->",
"setHasSEHFramePtrSave",
"(",
"true",
")",
";",
"X86FI",
"->",
"setSEHFramePtrSaveIndex",
"(",
"FI",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"X86",
"X86"
] | X86FrameLowering (2)2 | determineCalleeSaves | X86 | CPU | LLVM | 17,372 | 143 | 1 | [] |
[
"<s>",
"void",
"R600TargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"AMDGPUTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"FP_TO_UINT",
":",
"Results",
".",
"push_back",
"(",
"LowerFPTOUINT",
"(",
"N",
"->",
"getOperand",
"(",
"0",
")",
",",
"DAG",
")",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"{",
"SDNode",
"*",
"Node",
"=",
"LowerLOAD",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
")",
".",
"getNode",
"(",
")",
";",
"Results",
".",
"push_back",
"(",
"SDValue",
"(",
"Node",
",",
"0",
")",
")",
";",
"Results",
".",
"push_back",
"(",
"SDValue",
"(",
"Node",
",",
"1",
")",
")",
";",
"DAG",
".",
"ReplaceAllUsesOfValueWith",
"(",
"SDValue",
"(",
"N",
",",
"1",
")",
",",
"SDValue",
"(",
"Node",
",",
"1",
")",
")",
";",
"return",
";",
"}",
"case",
"ISD",
"::",
"STORE",
":",
"SDNode",
"*",
"Node",
"=",
"LowerSTORE",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
")",
".",
"getNode",
"(",
")",
";",
"Results",
".",
"push_back",
"(",
"SDValue",
"(",
"Node",
",",
"0",
")",
")",
";",
"return",
";",
"}",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"R600",
"ISD::FP_TO_UINT",
"0",
"ISD::LOAD",
"0",
"0",
"1",
"1",
"1",
"ISD::STORE",
"0",
"0"
] | R600ISelLowering40 | ReplaceNodeResults | R600 | GPU | LLVM | 17,373 | 183 | 1 | [] |
[
"<s>",
"bool",
"gen_ldm_seq",
"(",
"rtx",
"*",
"operands",
",",
"int",
"nops",
",",
"bool",
"sort_regs",
")",
"{",
"int",
"regs",
"[",
"MAX_LDM_STM_OPS",
"]",
",",
"mem_order",
"[",
"MAX_LDM_STM_OPS",
"]",
";",
"rtx",
"mems",
"[",
"MAX_LDM_STM_OPS",
"]",
";",
"int",
"i",
",",
"j",
",",
"base_reg",
";",
"rtx",
"base_reg_rtx",
";",
"HOST_WIDE_INT",
"offset",
";",
"int",
"write_back",
"=",
"FALSE",
";",
"int",
"ldm_case",
";",
"rtx",
"addr",
";",
"ldm_case",
"=",
"load_multiple_sequence",
"(",
"operands",
",",
"nops",
",",
"regs",
",",
"mem_order",
",",
"&",
"base_reg",
",",
"&",
"offset",
",",
"!",
"sort_regs",
")",
";",
"if",
"(",
"ldm_case",
"==",
"0",
")",
"return",
"false",
";",
"if",
"(",
"sort_regs",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nops",
"-",
"1",
";",
"i",
"++",
")",
"for",
"(",
"j",
"=",
"i",
"+",
"1",
";",
"j",
"<",
"nops",
";",
"j",
"++",
")",
"if",
"(",
"regs",
"[",
"i",
"]",
">",
"regs",
"[",
"j",
"]",
")",
"{",
"int",
"t",
"=",
"regs",
"[",
"i",
"]",
";",
"regs",
"[",
"i",
"]",
"=",
"regs",
"[",
"j",
"]",
";",
"regs",
"[",
"j",
"]",
"=",
"t",
";",
"}",
"base_reg_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"base_reg",
")",
";",
"if",
"(",
"TARGET_THUMB1",
")",
"{",
"gcc_assert",
"(",
"ldm_case",
"==",
"1",
"||",
"ldm_case",
"==",
"5",
")",
";",
"write_back",
"=",
"true",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nops",
";",
"i",
"++",
")",
"if",
"(",
"base_reg",
"==",
"regs",
"[",
"i",
"]",
")",
"write_back",
"=",
"false",
";",
"if",
"(",
"write_back",
"&&",
"!",
"peep2_reg_dead_p",
"(",
"nops",
",",
"base_reg_rtx",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"ldm_case",
"==",
"5",
")",
"{",
"rtx",
"newbase",
"=",
"TARGET_THUMB1",
"?",
"base_reg_rtx",
":",
"gen_rtx_REG",
"(",
"SImode",
",",
"regs",
"[",
"0",
"]",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"newbase",
",",
"base_reg_rtx",
",",
"GEN_INT",
"(",
"offset",
")",
")",
")",
";",
"offset",
"=",
"0",
";",
"base_reg_rtx",
"=",
"newbase",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nops",
";",
"i",
"++",
")",
"{",
"addr",
"=",
"plus_constant",
"(",
"Pmode",
",",
"base_reg_rtx",
",",
"offset",
"+",
"i",
"*",
"4",
")",
";",
"mems",
"[",
"i",
"]",
"=",
"adjust_automodify_address_nv",
"(",
"operands",
"[",
"nops",
"+",
"mem_order",
"[",
"i",
"]",
"]",
",",
"SImode",
",",
"addr",
",",
"0",
")",
";",
"}",
"emit_insn",
"(",
"arm_gen_load_multiple_1",
"(",
"nops",
",",
"regs",
",",
"mems",
",",
"base_reg_rtx",
",",
"write_back",
"?",
"offset",
"+",
"i",
"*",
"4",
":",
"0",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Called",
"from",
"a",
"peephole2",
"expander",
"to",
"turn",
"a",
"sequence",
"of",
"loads",
"into",
"an",
"LDM",
"instruction",
".",
"OPERANDS",
"are",
"the",
"operands",
"found",
"by",
"the",
"peephole",
"matcher",
";",
"NOPS",
"indicates",
"how",
"many",
"separate",
"loads",
"we",
"are",
"trying",
"to",
"combine",
".",
"SORT_REGS",
"is",
"true",
"if",
"we",
"can",
"reorder",
"the",
"registers",
"because",
"they",
"are",
"used",
"commutatively",
"subsequently",
".",
"Returns",
"true",
"iff",
"we",
"could",
"generate",
"a",
"new",
"instruction",
"."
] | [
"arm",
"0",
"0",
"1",
"1",
"1",
"5",
"0",
"5",
"0",
"0",
"0",
"4",
"0",
"4",
"0"
] | arm | gen_ldm_seq | arm | CPU | GCC | 17,374 | 360 | 1 | [] |
[
"<s>",
"void",
"DLXInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"StringRef",
"Annotation",
",",
"const",
"MCSubtargetInfo",
"&",
")",
"{",
"if",
"(",
"!",
"printAlias",
"(",
"MI",
",",
"OS",
")",
"&&",
"!",
"printAliasInstr",
"(",
"MI",
",",
"OS",
")",
")",
"printInstruction",
"(",
"MI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annotation",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"DLX",
"DLX"
] | DLXInstPrinter | printInst | DLX | CPU | LLVM | 17,375 | 55 | 1 | [] |
[
"<s>",
"SDValue",
"Cpu0TargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"unsigned",
"Opc",
"=",
"N",
"->",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"SDIVREM",
":",
"case",
"ISD",
"::",
"UDIVREM",
":",
"return",
"performDivRemCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"Cpu0",
"Cpu0",
"ISD::SDIVREM",
"ISD::UDIVREM"
] | Cpu0ISelLowering | PerformDAGCombine | Cpu0 | CPU | LLVM | 17,376 | 70 | 1 | [] |
[
"<s>",
"bool",
"ARMConstantIslands",
"::",
"isBBInRange",
"(",
"MachineInstr",
"*",
"MI",
",",
"MachineBasicBlock",
"*",
"DestBB",
",",
"unsigned",
"MaxDisp",
")",
"{",
"unsigned",
"PCAdj",
"=",
"isThumb",
"?",
"4",
":",
"8",
";",
"unsigned",
"BrOffset",
"=",
"getOffsetOf",
"(",
"MI",
")",
"+",
"PCAdj",
";",
"unsigned",
"DestOffset",
"=",
"BBInfo",
"[",
"DestBB",
"->",
"getNumber",
"(",
")",
"]",
".",
"Offset",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Branch of destination BB#\"",
"<<",
"DestBB",
"->",
"getNumber",
"(",
")",
"<<",
"\" from BB#\"",
"<<",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getNumber",
"(",
")",
"<<",
"\" max delta=\"",
"<<",
"MaxDisp",
"<<",
"\" from \"",
"<<",
"getOffsetOf",
"(",
"MI",
")",
"<<",
"\" to \"",
"<<",
"DestOffset",
"<<",
"\" offset \"",
"<<",
"int",
"(",
"DestOffset",
"-",
"BrOffset",
")",
"<<",
"\"\\t\"",
"<<",
"*",
"MI",
")",
";",
"if",
"(",
"BrOffset",
"<=",
"DestOffset",
")",
"{",
"if",
"(",
"DestOffset",
"-",
"BrOffset",
"<=",
"MaxDisp",
")",
"return",
"true",
";",
"}",
"else",
"{",
"if",
"(",
"BrOffset",
"-",
"DestOffset",
"<=",
"MaxDisp",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"isBBInRange",
"-",
"Returns",
"true",
"if",
"the",
"distance",
"between",
"specific",
"MI",
"and",
"specific",
"BB",
"can",
"fit",
"in",
"MI",
"'s",
"displacement",
"field",
"."
] | [
"ARM",
"ARM",
"4",
"8",
"\"Branch of destination BB#\"",
"\" from BB#\"",
"\" max delta=\"",
"\" from \"",
"\" to \"",
"\" offset \"",
"\"\\t\""
] | ARMConstantIslandPass (2)1 | isBBInRange | ARM | CPU | LLVM | 17,377 | 143 | 1 | [] |
[
"<s>",
"static",
"bool",
"vr4130_swap_insns_p",
"(",
"rtx",
"insn1",
",",
"rtx",
"insn2",
")",
"{",
"rtx",
"dep",
";",
"for",
"(",
"dep",
"=",
"INSN_DEPEND",
"(",
"insn1",
")",
";",
"dep",
"!=",
"0",
";",
"dep",
"=",
"XEXP",
"(",
"dep",
",",
"1",
")",
")",
"if",
"(",
"REG_NOTE_KIND",
"(",
"dep",
")",
"==",
"REG_DEP_ANTI",
"&&",
"INSN_PRIORITY",
"(",
"XEXP",
"(",
"dep",
",",
"0",
")",
")",
">",
"INSN_PRIORITY",
"(",
"insn2",
")",
"&&",
"recog_memoized",
"(",
"XEXP",
"(",
"dep",
",",
"0",
")",
")",
">=",
"0",
"&&",
"get_attr_vr4130_class",
"(",
"XEXP",
"(",
"dep",
",",
"0",
")",
")",
"==",
"VR4130_CLASS_ALU",
")",
"return",
"false",
";",
"if",
"(",
"vr4130_last_insn",
"!=",
"0",
"&&",
"recog_memoized",
"(",
"insn1",
")",
">=",
"0",
"&&",
"recog_memoized",
"(",
"insn2",
")",
">=",
"0",
")",
"{",
"enum",
"attr_vr4130_class",
"class1",
"=",
"get_attr_vr4130_class",
"(",
"insn1",
")",
";",
"enum",
"attr_vr4130_class",
"class2",
"=",
"get_attr_vr4130_class",
"(",
"insn2",
")",
";",
"if",
"(",
"class1",
"!=",
"class2",
"||",
"class1",
"==",
"VR4130_CLASS_ALU",
")",
"{",
"bool",
"dep1",
"=",
"vr4130_true_reg_dependence_p",
"(",
"insn1",
")",
";",
"bool",
"dep2",
"=",
"vr4130_true_reg_dependence_p",
"(",
"insn2",
")",
";",
"if",
"(",
"dep1",
"!=",
"dep2",
")",
"return",
"dep1",
";",
"if",
"(",
"class1",
"!=",
"VR4130_CLASS_ALU",
"&&",
"recog_memoized",
"(",
"vr4130_last_insn",
")",
">=",
"0",
"&&",
"class1",
"==",
"get_attr_vr4130_class",
"(",
"vr4130_last_insn",
")",
")",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"A",
"TUNE_MIPS4130",
"helper",
"function",
".",
"Given",
"that",
"INSN1",
"is",
"at",
"the",
"head",
"of",
"the",
"ready",
"queue",
"and",
"that",
"INSN2",
"is",
"the",
"instruction",
"after",
"it",
",",
"return",
"true",
"if",
"it",
"is",
"worth",
"promoting",
"INSN2",
"ahead",
"of",
"INSN1",
".",
"Look",
"for",
"cases",
"in",
"which",
"INSN1",
"and",
"INSN2",
"can",
"probably",
"issue",
"in",
"parallel",
",",
"but",
"for",
"which",
"(",
"INSN2",
",",
"INSN1",
")",
"should",
"be",
"less",
"sensitive",
"to",
"instruction",
"alignment",
"than",
"(",
"INSN1",
",",
"INSN2",
")",
".",
"See",
"4130.md",
"for",
"more",
"details",
"."
] | [
"mips",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] | mips3 | vr4130_swap_insns_p | mips | CPU | GCC | 17,378 | 191 | 1 | [] |
[
"<s>",
"SDValue",
"ARMSelectionDAGInfo",
"::",
"EmitTargetCodeForMemset",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"SDLoc",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"unsigned",
"Align",
",",
"bool",
"isVolatile",
",",
"MachinePointerInfo",
"DstPtrInfo",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
"->",
"isAAPCS_ABI",
"(",
")",
"||",
"Subtarget",
"->",
"isTargetMachO",
"(",
")",
"||",
"Subtarget",
"->",
"isTargetWindows",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"const",
"ARMTargetLowering",
"&",
"TLI",
"=",
"*",
"static_cast",
"<",
"const",
"ARMTargetLowering",
"*",
">",
"(",
"DAG",
".",
"getTarget",
"(",
")",
".",
"getTargetLowering",
"(",
")",
")",
";",
"TargetLowering",
"::",
"ArgListTy",
"Args",
";",
"TargetLowering",
"::",
"ArgListEntry",
"Entry",
";",
"Type",
"*",
"IntPtrTy",
"=",
"TLI",
".",
"getDataLayout",
"(",
")",
"->",
"getIntPtrType",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"Entry",
".",
"Node",
"=",
"Dst",
";",
"Entry",
".",
"Ty",
"=",
"IntPtrTy",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"Entry",
".",
"Node",
"=",
"Size",
";",
"Entry",
".",
"Ty",
"=",
"IntPtrTy",
";",
"Entry",
".",
"isSExt",
"=",
"false",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"if",
"(",
"Src",
".",
"getValueType",
"(",
")",
".",
"bitsGT",
"(",
"MVT",
"::",
"i32",
")",
")",
"Src",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"Src",
")",
";",
"else",
"Src",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ZERO_EXTEND",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"Src",
")",
";",
"Entry",
".",
"Node",
"=",
"Src",
";",
"Entry",
".",
"Ty",
"=",
"Type",
"::",
"getInt32Ty",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"Entry",
".",
"isSExt",
"=",
"true",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"TargetLowering",
"::",
"CallLoweringInfo",
"CLI",
"(",
"DAG",
")",
";",
"CLI",
".",
"setDebugLoc",
"(",
"dl",
")",
".",
"setChain",
"(",
"Chain",
")",
".",
"setCallee",
"(",
"TLI",
".",
"getLibcallCallingConv",
"(",
"RTLIB",
"::",
"MEMSET",
")",
",",
"Type",
"::",
"getVoidTy",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
",",
"DAG",
".",
"getExternalSymbol",
"(",
"TLI",
".",
"getLibcallName",
"(",
"RTLIB",
"::",
"MEMSET",
")",
",",
"TLI",
".",
"getPointerTy",
"(",
")",
")",
",",
"&",
"Args",
",",
"0",
")",
".",
"setDiscardResult",
"(",
")",
";",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"CallResult",
"=",
"TLI",
".",
"LowerCallTo",
"(",
"CLI",
")",
";",
"return",
"CallResult",
".",
"second",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memset",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"MVT::i32",
"ISD::TRUNCATE",
"MVT::i32",
"ISD::ZERO_EXTEND",
"MVT::i32",
"0"
] | ARMSelectionDAGInfo22 | EmitTargetCodeForMemset | ARM | CPU | LLVM | 17,379 | 344 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"LIS",
"=",
"&",
"getAnalysis",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"MF",
".",
"end",
"(",
")",
";",
")",
"{",
"MachineBasicBlock",
"&",
"B",
"=",
"*",
"I",
"++",
";",
"if",
"(",
"processBlock",
"(",
"B",
")",
")",
"Changed",
"=",
"true",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"PowerPC",
"PPC"
] | PPCTLSDynamicCall | runOnMachineFunction | PowerPC | CPU | LLVM | 17,380 | 86 | 1 | [] |
[
"<s>",
"unsigned",
"NVPTXTTI",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"OperandValueKind",
"Opd1Info",
",",
"OperandValueKind",
"Opd2Info",
",",
"OperandValueProperties",
"Opd1PropInfo",
",",
"OperandValueProperties",
"Opd2PropInfo",
")",
"const",
"{",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"Ty",
")",
";",
"int",
"ISD",
"=",
"TLI",
"->",
"InstructionOpcodeToISD",
"(",
"Opcode",
")",
";",
"switch",
"(",
"ISD",
")",
"{",
"default",
":",
"return",
"TargetTransformInfo",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
")",
";",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"XOR",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"AND",
":",
"if",
"(",
"LT",
".",
"second",
".",
"SimpleTy",
"==",
"MVT",
"::",
"i64",
")",
"return",
"2",
"*",
"LT",
".",
"first",
";",
"return",
"TargetTransformInfo",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"NVPTX",
"NVPTX",
"ISD::ADD",
"ISD::MUL",
"ISD::XOR",
"ISD::OR",
"ISD::AND",
"MVT::i64",
"2"
] | NVPTXTargetTransformInfo21 | getArithmeticInstrCost | NVPTX | GPU | LLVM | 17,381 | 142 | 1 | [] |
[
"<s>",
"enum",
"m68k_function_kind",
"m68k_get_function_kind",
"(",
"tree",
"func",
")",
"{",
"tree",
"a",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"func",
")",
"==",
"FUNCTION_DECL",
")",
";",
"a",
"=",
"lookup_attribute",
"(",
"\"interrupt\"",
",",
"DECL_ATTRIBUTES",
"(",
"func",
")",
")",
";",
"if",
"(",
"a",
"!=",
"NULL_TREE",
")",
"return",
"m68k_fk_interrupt_handler",
";",
"a",
"=",
"lookup_attribute",
"(",
"\"interrupt_handler\"",
",",
"DECL_ATTRIBUTES",
"(",
"func",
")",
")",
";",
"if",
"(",
"a",
"!=",
"NULL_TREE",
")",
"return",
"m68k_fk_interrupt_handler",
";",
"a",
"=",
"lookup_attribute",
"(",
"\"interrupt_thread\"",
",",
"DECL_ATTRIBUTES",
"(",
"func",
")",
")",
";",
"if",
"(",
"a",
"!=",
"NULL_TREE",
")",
"return",
"m68k_fk_interrupt_thread",
";",
"return",
"m68k_fk_normal_function",
";",
"}",
"</s>"
] | [
"Return",
"m68k_fk_interrupt_handler",
"if",
"FUNC",
"has",
"an",
"``",
"interrupt",
"''",
"or",
"``",
"interrupt_handler",
"''",
"attribute",
"and",
"interrupt_thread",
"if",
"FUNC",
"has",
"an",
"``",
"interrupt_thread",
"''",
"attribute",
".",
"Otherwise",
",",
"return",
"m68k_fk_normal_function",
"."
] | [
"m68k",
"\"interrupt\"",
"\"interrupt_handler\"",
"\"interrupt_thread\""
] | m68k | m68k_get_function_kind | m68k | MPU | GCC | 17,382 | 88 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"*",
"RISCVTargetLowering",
"::",
"EmitInstrWithCustomInserter",
"(",
"MachineInstr",
"&",
"MI",
",",
"MachineBasicBlock",
"*",
"BB",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected instr type to insert\"",
")",
";",
"case",
"RISCV",
"::",
"ReadCycleWide",
":",
"assert",
"(",
"!",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"\"ReadCycleWrite is only to be used on riscv32\"",
")",
";",
"return",
"emitReadCycleWidePseudo",
"(",
"MI",
",",
"BB",
")",
";",
"case",
"RISCV",
"::",
"Select_GPR_Using_CC_GPR",
":",
"case",
"RISCV",
"::",
"Select_FPR16_Using_CC_GPR",
":",
"case",
"RISCV",
"::",
"Select_FPR32_Using_CC_GPR",
":",
"case",
"RISCV",
"::",
"Select_FPR64_Using_CC_GPR",
":",
"return",
"emitSelectPseudo",
"(",
"MI",
",",
"BB",
",",
"Subtarget",
")",
";",
"case",
"RISCV",
"::",
"BuildPairF64Pseudo",
":",
"return",
"emitBuildPairF64Pseudo",
"(",
"MI",
",",
"BB",
")",
";",
"case",
"RISCV",
"::",
"SplitF64Pseudo",
":",
"return",
"emitSplitF64Pseudo",
"(",
"MI",
",",
"BB",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"should",
"be",
"implemented",
"by",
"targets",
"that",
"mark",
"instructions",
"with",
"the",
"'usesCustomInserter",
"'",
"flag",
"."
] | [
"RISCV",
"RISCV",
"\"Unexpected instr type to insert\"",
"RISCV::ReadCycleWide",
"\"ReadCycleWrite is only to be used on riscv32\"",
"RISCV::Select_GPR_Using_CC_GPR",
"RISCV::Select_FPR16_Using_CC_GPR",
"RISCV::Select_FPR32_Using_CC_GPR",
"RISCV::Select_FPR64_Using_CC_GPR",
"RISCV::BuildPairF64Pseudo",
"RISCV::SplitF64Pseudo"
] | RISCVISelLowering1 | EmitInstrWithCustomInserter | RISCV | CPU | LLVM | 17,383 | 115 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"insertNoops",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"Quantity",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"while",
"(",
"Quantity",
">",
"0",
")",
"{",
"unsigned",
"Arg",
"=",
"std",
"::",
"min",
"(",
"Quantity",
",",
"8u",
")",
";",
"Quantity",
"-=",
"Arg",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"S_NOP",
")",
")",
".",
"addImm",
"(",
"Arg",
"-",
"1",
")",
";",
"}",
"}",
"</s>"
] | [
"Insert",
"noops",
"into",
"the",
"instruction",
"stream",
"at",
"the",
"specified",
"point",
"."
] | [
"AMDGPU",
"SI",
"0",
"8u",
"AMDGPU::S_NOP",
"1"
] | SIInstrInfo11 | insertNoops | AMDGPU | GPU | LLVM | 17,384 | 77 | 1 | [] |
[
"<s>",
"Register",
"CAHPRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"return",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"CAHP",
"::",
"X2",
":",
"CAHP",
"::",
"X1",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"CAHP",
"CAHP",
"CAHP::X2",
"CAHP::X1"
] | CAHPRegisterInfo | getFrameRegister | CAHP | CPU | LLVM | 17,385 | 39 | 1 | [] |
[
"<s>",
"rtx",
"arc_eh_return_address_location",
"(",
"void",
")",
"{",
"rtx",
"mem",
";",
"int",
"offset",
";",
"struct",
"arc_frame_info",
"*",
"afi",
";",
"arc_compute_frame_size",
"(",
")",
";",
"afi",
"=",
"&",
"cfun",
"->",
"machine",
"->",
"frame_info",
";",
"gcc_assert",
"(",
"crtl",
"->",
"calls_eh_return",
")",
";",
"gcc_assert",
"(",
"afi",
"->",
"save_return_addr",
")",
";",
"gcc_assert",
"(",
"afi",
"->",
"extra_size",
">=",
"4",
")",
";",
"offset",
"=",
"afi",
"->",
"reg_size",
"+",
"afi",
"->",
"extra_size",
"-",
"4",
";",
"mem",
"=",
"gen_frame_mem",
"(",
"Pmode",
",",
"plus_constant",
"(",
"Pmode",
",",
"frame_pointer_rtx",
",",
"offset",
")",
")",
";",
"MEM_VOLATILE_P",
"(",
"mem",
")",
"=",
"1",
";",
"return",
"mem",
";",
"}",
"</s>"
] | [
"Return",
"rtx",
"for",
"the",
"location",
"of",
"the",
"return",
"address",
"on",
"the",
"stack",
",",
"suitable",
"for",
"use",
"in",
"__builtin_eh_return",
".",
"The",
"new",
"return",
"address",
"will",
"be",
"written",
"to",
"this",
"location",
"in",
"order",
"to",
"redirect",
"the",
"return",
"to",
"the",
"exception",
"handler",
"."
] | [
"arc",
"4",
"4",
"1"
] | arc7 | arc_eh_return_address_location | arc | MPU | GCC | 17,386 | 92 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"msp430_get_linker_devices_include_path",
"(",
"int",
"argc",
"ATTRIBUTE_UNUSED",
",",
"const",
"char",
"*",
"*",
"argv",
"ATTRIBUTE_UNUSED",
")",
"{",
"char",
"*",
"devices_csv_path",
";",
"if",
"(",
"msp430_check_env_var_for_devices",
"(",
"&",
"devices_csv_path",
")",
")",
"return",
"NULL",
";",
"return",
"concat",
"(",
"\"-L\"",
",",
"msp430_dirname",
"(",
"devices_csv_path",
")",
",",
"NULL",
")",
";",
"}",
"</s>"
] | [
"Spec",
"function",
".",
"Used",
"to",
"place",
"the",
"path",
"to",
"the",
"MSP430-GCC",
"support",
"files",
"on",
"the",
"command",
"line",
",",
"prefixed",
"with",
"``",
"-L",
"''",
",",
"so",
"the",
"linker",
"finds",
"the",
"linker",
"scripts",
"in",
"that",
"directory",
"."
] | [
"msp430",
"\"-L\""
] | driver-msp430 | msp430_get_linker_devices_include_path | msp430 | MPU | GCC | 17,387 | 46 | 1 | [] |
[
"<s>",
"static",
"int",
"sequent_regs_live",
"(",
")",
"{",
"int",
"reg",
";",
"int",
"live_seq",
"=",
"0",
";",
"int",
"cur_seq",
"=",
"0",
";",
"for",
"(",
"reg",
"=",
"0",
";",
"reg",
"<",
"18",
";",
"++",
"reg",
")",
"{",
"if",
"(",
"!",
"call_used_regs",
"[",
"reg",
"]",
")",
"{",
"if",
"(",
"regs_ever_live",
"[",
"reg",
"]",
")",
"{",
"++",
"live_seq",
";",
"++",
"cur_seq",
";",
"}",
"else",
"cur_seq",
"=",
"0",
";",
"}",
"}",
"if",
"(",
"!",
"frame_pointer_needed",
")",
"{",
"if",
"(",
"regs_ever_live",
"[",
"REG_Y",
"]",
")",
"{",
"++",
"live_seq",
";",
"++",
"cur_seq",
";",
"}",
"else",
"cur_seq",
"=",
"0",
";",
"if",
"(",
"regs_ever_live",
"[",
"REG_Y",
"+",
"1",
"]",
")",
"{",
"++",
"live_seq",
";",
"++",
"cur_seq",
";",
"}",
"else",
"cur_seq",
"=",
"0",
";",
"}",
"else",
"{",
"cur_seq",
"+=",
"2",
";",
"live_seq",
"+=",
"2",
";",
"}",
"return",
"(",
"cur_seq",
"==",
"live_seq",
")",
"?",
"live_seq",
":",
"0",
";",
"}",
"</s>"
] | [
"This",
"function",
"checks",
"sequence",
"of",
"live",
"registers"
] | [
"avr",
"0",
"0",
"0",
"18",
"0",
"0",
"1",
"0",
"2",
"2",
"0"
] | avr2 | sequent_regs_live | avr | MPU | GCC | 17,388 | 136 | 1 | [] |
[
"<s>",
"unsigned",
"MipsAsmParser",
"::",
"checkEarlyTargetMatchPredicate",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"OperandVector",
"&",
"Operands",
")",
"{",
"switch",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"Match_Success",
";",
"case",
"Mips",
"::",
"DATI",
":",
"case",
"Mips",
"::",
"DAHI",
":",
"if",
"(",
"static_cast",
"<",
"MipsOperand",
"&",
">",
"(",
"*",
"Operands",
"[",
"1",
"]",
")",
".",
"isValidForTie",
"(",
"static_cast",
"<",
"MipsOperand",
"&",
">",
"(",
"*",
"Operands",
"[",
"2",
"]",
")",
")",
")",
"return",
"Match_Success",
";",
"return",
"Match_RequiresSameSrcAndDst",
";",
"}",
"}",
"</s>"
] | [
"Validate",
"the",
"instruction",
"match",
"against",
"any",
"complex",
"target",
"predicates",
"before",
"rendering",
"any",
"operands",
"to",
"it",
"."
] | [
"Mips",
"Mips",
"Mips::DATI",
"Mips::DAHI",
"Mips",
"1",
"Mips",
"2"
] | MipsAsmParser (2)4 | checkEarlyTargetMatchPredicate | Mips | CPU | LLVM | 17,389 | 78 | 1 | [] |
[
"<s>",
"static",
"bool",
"xstormy16_hard_regno_mode_ok",
"(",
"unsigned",
"int",
"regno",
",",
"machine_mode",
"mode",
")",
"{",
"return",
"regno",
"!=",
"16",
"||",
"mode",
"==",
"BImode",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_HARD_REGNO_MODE_OK",
"."
] | [
"stormy16",
"16"
] | stormy16 | xstormy16_hard_regno_mode_ok | stormy16 | CPU | GCC | 17,390 | 22 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"getMemOperandWithOffset",
"(",
"MachineInstr",
"&",
"MemOp",
",",
"MachineOperand",
"*",
"&",
"BaseOp",
",",
"int64_t",
"&",
"Offset",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MemOp",
".",
"getDesc",
"(",
")",
";",
"int",
"MemRefBegin",
"=",
"X86II",
"::",
"getMemoryOperandNo",
"(",
"Desc",
".",
"TSFlags",
")",
";",
"if",
"(",
"MemRefBegin",
"<",
"0",
")",
"return",
"false",
";",
"MemRefBegin",
"+=",
"X86II",
"::",
"getOperandBias",
"(",
"Desc",
")",
";",
"BaseOp",
"=",
"&",
"MemOp",
".",
"getOperand",
"(",
"MemRefBegin",
"+",
"X86",
"::",
"AddrBaseReg",
")",
";",
"if",
"(",
"!",
"BaseOp",
"->",
"isReg",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MemOp",
".",
"getOperand",
"(",
"MemRefBegin",
"+",
"X86",
"::",
"AddrScaleAmt",
")",
".",
"getImm",
"(",
")",
"!=",
"1",
")",
"return",
"false",
";",
"if",
"(",
"MemOp",
".",
"getOperand",
"(",
"MemRefBegin",
"+",
"X86",
"::",
"AddrIndexReg",
")",
".",
"getReg",
"(",
")",
"!=",
"X86",
"::",
"NoRegister",
")",
"return",
"false",
";",
"const",
"MachineOperand",
"&",
"DispMO",
"=",
"MemOp",
".",
"getOperand",
"(",
"MemRefBegin",
"+",
"X86",
"::",
"AddrDisp",
")",
";",
"if",
"(",
"!",
"DispMO",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"Offset",
"=",
"DispMO",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"BaseOp",
"->",
"isReg",
"(",
")",
"&&",
"\"getMemOperandWithOffset only supports base \"",
"\"operands of type register.\"",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Get",
"the",
"base",
"operand",
"and",
"byte",
"offset",
"of",
"an",
"instruction",
"that",
"reads/writes",
"memory",
"."
] | [
"X86",
"X86",
"X86II::getMemoryOperandNo",
"0",
"X86II::getOperandBias",
"X86::AddrBaseReg",
"X86::AddrScaleAmt",
"1",
"X86::AddrIndexReg",
"X86::NoRegister",
"X86::AddrDisp",
"\"getMemOperandWithOffset only supports base \"",
"\"operands of type register.\""
] | X86InstrInfo1 | getMemOperandWithOffset | X86 | CPU | LLVM | 17,391 | 190 | 1 | [] |
[
"<s>",
"void",
"AArch64RegisterInfo",
"::",
"materializeFrameBaseRegister",
"(",
"MachineBasicBlock",
"*",
"MBB",
",",
"unsigned",
"BaseReg",
",",
"int",
"FrameIdx",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"Ins",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"Ins",
"!=",
"MBB",
"->",
"end",
"(",
")",
")",
"DL",
"=",
"Ins",
"->",
"getDebugLoc",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"TII",
"->",
"get",
"(",
"AArch64",
"::",
"ADDXri",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
"->",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
"->",
"getParent",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"BaseReg",
",",
"TII",
"->",
"getRegClass",
"(",
"MCID",
",",
"0",
",",
"this",
",",
"MF",
")",
")",
";",
"unsigned",
"Shifter",
"=",
"AArch64_AM",
"::",
"getShifterImm",
"(",
"AArch64_AM",
"::",
"LSL",
",",
"0",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"Ins",
",",
"DL",
",",
"MCID",
",",
"BaseReg",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"Offset",
")",
".",
"addImm",
"(",
"Shifter",
")",
";",
"}",
"</s>"
] | [
"Insert",
"defining",
"instruction",
"(",
"s",
")",
"for",
"a",
"pointer",
"to",
"FrameIdx",
"before",
"insertion",
"point",
"I",
"."
] | [
"AArch64",
"AArch64",
"AArch64::ADDXri",
"0",
"AArch64_AM::getShifterImm",
"AArch64_AM::LSL",
"0"
] | AArch64RegisterInfo1 | materializeFrameBaseRegister | AArch64 | CPU | LLVM | 17,392 | 156 | 1 | [] |
[
"<s>",
"MCELFStreamer",
"&",
"SHUXITargetELFStreamer",
"::",
"getStreamer",
"(",
")",
"{",
"return",
"static_cast",
"<",
"MCELFStreamer",
"&",
">",
"(",
"Streamer",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"output",
"streamer",
"for",
"the",
"assembler",
"."
] | [
"SHUXI",
"SHUXI"
] | SHUXITargetStreamer | getStreamer | SHUXI | CPU | LLVM | 17,393 | 19 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"riscv_vector_alignment",
"(",
"const_tree",
"type",
")",
"{",
"if",
"(",
"GET_MODE_CLASS",
"(",
"TYPE_MODE",
"(",
"type",
")",
")",
"==",
"MODE_VECTOR_BOOL",
")",
"return",
"8",
";",
"widest_int",
"min_size",
"=",
"constant_lower_bound",
"(",
"wi",
"::",
"to_poly_widest",
"(",
"TYPE_SIZE",
"(",
"type",
")",
")",
")",
";",
"return",
"wi",
"::",
"umin",
"(",
"min_size",
",",
"128",
")",
".",
"to_uhwi",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_VECTOR_ALIGNMENT",
"."
] | [
"riscv",
"8",
"128"
] | riscv1 | riscv_vector_alignment | riscv | CPU | GCC | 17,394 | 54 | 1 | [] |
[
"<s>",
"unsigned",
"int",
"TMS320C64XRegisterInfo",
"::",
"getRARegister",
"(",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"Unimplemented function getRARegister\\n\"",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"return",
"the",
"register",
"where",
"the",
"return",
"address",
"can",
"be",
"found",
"."
] | [
"TMS320C64X",
"TMS320C64X",
"\"Unimplemented function getRARegister\\n\""
] | TMS320C64XRegisterInfo | getRARegister | TMS320C64X | VLIW | LLVM | 17,395 | 15 | 1 | [] |
[
"<s>",
"SDValue",
"R600TargetLowering",
"::",
"LowerFormalArguments",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"SDLoc",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"unsigned",
"ParamOffsetBytes",
"=",
"36",
";",
"Function",
"::",
"const_arg_iterator",
"FuncArg",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getFunction",
"(",
")",
"->",
"arg_begin",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"Ins",
".",
"size",
"(",
")",
";",
"i",
"<",
"e",
";",
"++",
"i",
",",
"++",
"FuncArg",
")",
"{",
"EVT",
"VT",
"=",
"Ins",
"[",
"i",
"]",
".",
"VT",
";",
"Type",
"*",
"ArgType",
"=",
"FuncArg",
"->",
"getType",
"(",
")",
";",
"unsigned",
"ArgSizeInBits",
"=",
"ArgType",
"->",
"isPointerTy",
"(",
")",
"?",
"32",
":",
"ArgType",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"unsigned",
"ArgBytes",
"=",
"ArgSizeInBits",
">>",
"3",
";",
"EVT",
"ArgVT",
";",
"if",
"(",
"ArgSizeInBits",
"<",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"ArgType",
"->",
"isFloatTy",
"(",
")",
"&&",
"\"Extending floating point arguments not supported yet\"",
")",
";",
"ArgVT",
"=",
"MVT",
"::",
"getIntegerVT",
"(",
"ArgSizeInBits",
")",
";",
"}",
"else",
"{",
"ArgVT",
"=",
"VT",
";",
"}",
"PointerType",
"*",
"PtrTy",
"=",
"PointerType",
"::",
"get",
"(",
"VT",
".",
"getTypeForEVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
",",
"AMDGPUAS",
"::",
"PARAM_I_ADDRESS",
")",
";",
"SDValue",
"Arg",
"=",
"DAG",
".",
"getExtLoad",
"(",
"ISD",
"::",
"ZEXTLOAD",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getRoot",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"ParamOffsetBytes",
",",
"MVT",
"::",
"i32",
")",
",",
"MachinePointerInfo",
"(",
"UndefValue",
"::",
"get",
"(",
"PtrTy",
")",
")",
",",
"ArgVT",
",",
"false",
",",
"false",
",",
"ArgBytes",
")",
";",
"InVals",
".",
"push_back",
"(",
"Arg",
")",
";",
"ParamOffsetBytes",
"+=",
"ArgBytes",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"the",
"Ins",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"R600",
"ISD::InputArg",
"36",
"0",
"32",
"3",
"\"Extending floating point arguments not supported yet\"",
"MVT::getIntegerVT",
"AMDGPUAS::PARAM_I_ADDRESS",
"ISD::ZEXTLOAD",
"MVT::i32"
] | R600ISelLowering1 | LowerFormalArguments | R600 | GPU | LLVM | 17,396 | 271 | 1 | [] |
[
"<s>",
"SUnit",
"*",
"TPCSchedStrategy",
"::",
"pickNodeBidrectional",
"(",
"bool",
"&",
"IsTopNode",
")",
"{",
"if",
"(",
"SUnit",
"*",
"SU",
"=",
"Bot",
".",
"pickOnlyChoice",
"(",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Picked only Bottom\\n\"",
")",
";",
"IsTopNode",
"=",
"false",
";",
"return",
"SU",
";",
"}",
"if",
"(",
"SUnit",
"*",
"SU",
"=",
"Top",
".",
"pickOnlyChoice",
"(",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Picked only Top\\n\"",
")",
";",
"IsTopNode",
"=",
"true",
";",
"return",
"SU",
";",
"}",
"SchedCandidate",
"BotCand",
";",
"CandResult",
"BotResult",
"=",
"pickNodeFromQueue",
"(",
"Bot",
".",
"Available",
",",
"DAG",
"->",
"getBotRPTracker",
"(",
")",
",",
"BotCand",
")",
";",
"assert",
"(",
"BotResult",
"!=",
"NoCand",
"&&",
"\"failed to find the first candidate\"",
")",
";",
"if",
"(",
"BotResult",
"==",
"SingleExcess",
"||",
"BotResult",
"==",
"SingleCritical",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Prefered Bottom Node\\n\"",
")",
";",
"IsTopNode",
"=",
"false",
";",
"return",
"BotCand",
".",
"SU",
";",
"}",
"SchedCandidate",
"TopCand",
";",
"CandResult",
"TopResult",
"=",
"pickNodeFromQueue",
"(",
"Top",
".",
"Available",
",",
"DAG",
"->",
"getTopRPTracker",
"(",
")",
",",
"TopCand",
")",
";",
"assert",
"(",
"TopResult",
"!=",
"NoCand",
"&&",
"\"failed to find the first candidate\"",
")",
";",
"if",
"(",
"TopResult",
"==",
"SingleExcess",
"||",
"TopResult",
"==",
"SingleCritical",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Prefered Top Node\\n\"",
")",
";",
"IsTopNode",
"=",
"true",
";",
"return",
"TopCand",
".",
"SU",
";",
"}",
"if",
"(",
"BotResult",
"==",
"SingleMax",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Prefered Bottom Node SingleMax\\n\"",
")",
";",
"IsTopNode",
"=",
"false",
";",
"return",
"BotCand",
".",
"SU",
";",
"}",
"if",
"(",
"TopResult",
"==",
"SingleMax",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Prefered Top Node SingleMax\\n\"",
")",
";",
"IsTopNode",
"=",
"true",
";",
"return",
"TopCand",
".",
"SU",
";",
"}",
"if",
"(",
"TopCand",
".",
"SCost",
">",
"BotCand",
".",
"SCost",
"||",
"BotCand",
".",
"SU",
"->",
"getInstr",
"(",
")",
"->",
"isPseudo",
"(",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Prefered Top Node Cost\\n\"",
")",
";",
"IsTopNode",
"=",
"true",
";",
"return",
"TopCand",
".",
"SU",
";",
"}",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Prefered Bottom in Node order\\n\"",
")",
";",
"IsTopNode",
"=",
"false",
";",
"return",
"BotCand",
".",
"SU",
";",
"}",
"</s>"
] | [
"Pick",
"the",
"best",
"candidate",
"node",
"from",
"either",
"the",
"top",
"or",
"bottom",
"queue",
"."
] | [
"TPC",
"TPC",
"\"Picked only Bottom\\n\"",
"\"Picked only Top\\n\"",
"\"failed to find the first candidate\"",
"\"Prefered Bottom Node\\n\"",
"\"failed to find the first candidate\"",
"\"Prefered Top Node\\n\"",
"\"Prefered Bottom Node SingleMax\\n\"",
"\"Prefered Top Node SingleMax\\n\"",
"\"Prefered Top Node Cost\\n\"",
"\"Prefered Bottom in Node order\\n\""
] | TPCMachineScheduler | pickNodeBidrectional | TPC | Virtual ISA | LLVM | 17,397 | 304 | 1 | [] |
[
"<s>",
"static",
"void",
"avr_option_override",
"(",
"void",
")",
"{",
"if",
"(",
"avr_strict_X",
")",
"flag_caller_saves",
"=",
"0",
";",
"maybe_set_param_value",
"(",
"PARAM_ALLOW_STORE_DATA_RACES",
",",
"1",
",",
"global_options",
".",
"x_param_values",
",",
"global_options_set",
".",
"x_param_values",
")",
";",
"if",
"(",
"(",
"flag_unwind_tables",
"||",
"flag_non_call_exceptions",
"||",
"flag_asynchronous_unwind_tables",
")",
"&&",
"!",
"ACCUMULATE_OUTGOING_ARGS",
")",
"{",
"flag_omit_frame_pointer",
"=",
"0",
";",
"}",
"if",
"(",
"flag_pic",
"==",
"1",
")",
"warning",
"(",
"OPT_fpic",
",",
"\"-fpic is not supported\"",
")",
";",
"if",
"(",
"flag_pic",
"==",
"2",
")",
"warning",
"(",
"OPT_fPIC",
",",
"\"-fPIC is not supported\"",
")",
";",
"if",
"(",
"flag_pie",
"==",
"1",
")",
"warning",
"(",
"OPT_fpie",
",",
"\"-fpie is not supported\"",
")",
";",
"if",
"(",
"flag_pie",
"==",
"2",
")",
"warning",
"(",
"OPT_fPIE",
",",
"\"-fPIE is not supported\"",
")",
";",
"avr_gasisr_prologues",
"=",
"0",
";",
"if",
"(",
"!",
"avr_set_core_architecture",
"(",
")",
")",
"return",
";",
"avr_addr",
".",
"sreg",
"=",
"0x3F",
"+",
"avr_arch",
"->",
"sfr_offset",
";",
"avr_addr",
".",
"rampz",
"=",
"0x3B",
"+",
"avr_arch",
"->",
"sfr_offset",
";",
"avr_addr",
".",
"rampy",
"=",
"0x3A",
"+",
"avr_arch",
"->",
"sfr_offset",
";",
"avr_addr",
".",
"rampx",
"=",
"0x39",
"+",
"avr_arch",
"->",
"sfr_offset",
";",
"avr_addr",
".",
"rampd",
"=",
"0x38",
"+",
"avr_arch",
"->",
"sfr_offset",
";",
"avr_addr",
".",
"ccp",
"=",
"(",
"AVR_TINY",
"?",
"0x3C",
":",
"0x34",
")",
"+",
"avr_arch",
"->",
"sfr_offset",
";",
"avr_addr",
".",
"sp_l",
"=",
"0x3D",
"+",
"avr_arch",
"->",
"sfr_offset",
";",
"avr_addr",
".",
"sp_h",
"=",
"avr_addr",
".",
"sp_l",
"+",
"1",
";",
"init_machine_status",
"=",
"avr_init_machine_status",
";",
"avr_log_set_avr_log",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"`",
"TARGET_OPTION_OVERRIDE",
"'",
"."
] | [
"avr",
"0",
"1",
"0",
"1",
"\"-fpic is not supported\"",
"2",
"\"-fPIC is not supported\"",
"1",
"\"-fpie is not supported\"",
"2",
"\"-fPIE is not supported\"",
"0",
"0x3F",
"0x3B",
"0x3A",
"0x39",
"0x38",
"0x3C",
"0x34",
"0x3D",
"1"
] | avr7 | avr_option_override | avr | MPU | GCC | 17,398 | 209 | 1 | [] |
[
"<s>",
"unsigned",
"getNumFixupKinds",
"(",
")",
"const",
"override",
"{",
"return",
"DLX",
"::",
"NumTargetFixupKinds",
";",
"}",
"</s>"
] | [
"Get",
"the",
"number",
"of",
"target",
"specific",
"fixup",
"kinds",
"."
] | [
"DLX",
"DLX::NumTargetFixupKinds"
] | DLXAsmBackend | getNumFixupKinds | DLX | CPU | LLVM | 17,399 | 13 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.