ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"static",
"void",
"get_pc_thunk_name",
"(",
"char",
"name",
"[",
"32",
"]",
",",
"unsigned",
"int",
"regno",
")",
"{",
"gcc_assert",
"(",
"!",
"TARGET_64BIT",
")",
";",
"if",
"(",
"USE_HIDDEN_LINKONCE",
")",
"sprintf",
"(",
"name",
",",
"\"__x86.get_pc_thunk.%s\"",
",",
"reg_names",
"[",
"regno",
"]",
")",
";",
"else",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"name",
",",
"\"LPR\"",
",",
"regno",
")",
";",
"}",
"</s>"
] | [
"Fills",
"in",
"the",
"label",
"name",
"that",
"should",
"be",
"used",
"for",
"a",
"pc",
"thunk",
"for",
"the",
"given",
"register",
"."
] | [
"i386",
"32",
"\"__x86.get_pc_thunk.%s\"",
"\"LPR\""
] | i386 | get_pc_thunk_name | i386 | CPU | GCC | 24,600 | 48 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"MipsRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"if",
"(",
"Subtarget",
".",
"isSingleFloat",
"(",
")",
")",
"return",
"CSR_SingleFloatOnly_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isFPXX",
"(",
")",
")",
"return",
"CSR_O32_FPXX_SaveList",
";",
"return",
"CSR_O32_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Mips",
"Mips"
] | MipsRegisterInfo30 | getCalleeSavedRegs | Mips | CPU | LLVM | 24,601 | 40 | 1 | [] |
[
"<s>",
"static",
"void",
"avr_asm_init_sections",
"(",
"void",
")",
"{",
"if",
"(",
"AVR_HAVE_JMP_CALL",
")",
"{",
"progmem_swtable_section",
"=",
"get_unnamed_section",
"(",
"0",
",",
"output_section_asm_op",
",",
"\"\\t.section\\t.progmem.gcc_sw_table\"",
"\",\\\"a\\\",@progbits\"",
")",
";",
"}",
"else",
"{",
"progmem_swtable_section",
"=",
"get_unnamed_section",
"(",
"SECTION_CODE",
",",
"output_section_asm_op",
",",
"\"\\t.section\\t.progmem.gcc_sw_table\"",
"\",\\\"ax\\\",@progbits\"",
")",
";",
"}",
"readonly_data_section",
"->",
"unnamed",
".",
"callback",
"=",
"avr_output_data_section_asm_op",
";",
"data_section",
"->",
"unnamed",
".",
"callback",
"=",
"avr_output_data_section_asm_op",
";",
"bss_section",
"->",
"unnamed",
".",
"callback",
"=",
"avr_output_bss_section_asm_op",
";",
"}",
"</s>"
] | [
"Implement",
"`",
"TARGET_ASM_INIT_SECTIONS",
"'",
"."
] | [
"avr",
"0",
"\"\\t.section\\t.progmem.gcc_sw_table\"",
"\",\\\"a\\\",@progbits\"",
"\"\\t.section\\t.progmem.gcc_sw_table\"",
"\",\\\"ax\\\",@progbits\""
] | avr4 | avr_asm_init_sections | avr | MPU | GCC | 24,602 | 65 | 1 | [] |
[
"<s>",
"EVT",
"X86TargetLowering",
"::",
"getSetCCResultType",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"LLVMContext",
"&",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"Subtarget",
"->",
"hasAVX512",
"(",
")",
"?",
"MVT",
"::",
"i1",
":",
"MVT",
"::",
"i8",
";",
"const",
"unsigned",
"NumElts",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"const",
"EVT",
"EltVT",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"if",
"(",
"VT",
".",
"is512BitVector",
"(",
")",
")",
"{",
"if",
"(",
"Subtarget",
"->",
"hasAVX512",
"(",
")",
")",
"if",
"(",
"EltVT",
"==",
"MVT",
"::",
"i32",
"||",
"EltVT",
"==",
"MVT",
"::",
"i64",
"||",
"EltVT",
"==",
"MVT",
"::",
"f32",
"||",
"EltVT",
"==",
"MVT",
"::",
"f64",
")",
"switch",
"(",
"NumElts",
")",
"{",
"case",
"8",
":",
"return",
"MVT",
"::",
"v8i1",
";",
"case",
"16",
":",
"return",
"MVT",
"::",
"v16i1",
";",
"}",
"if",
"(",
"Subtarget",
"->",
"hasBWI",
"(",
")",
")",
"if",
"(",
"EltVT",
"==",
"MVT",
"::",
"i8",
"||",
"EltVT",
"==",
"MVT",
"::",
"i16",
")",
"switch",
"(",
"NumElts",
")",
"{",
"case",
"32",
":",
"return",
"MVT",
"::",
"v32i1",
";",
"case",
"64",
":",
"return",
"MVT",
"::",
"v64i1",
";",
"}",
"}",
"if",
"(",
"VT",
".",
"is256BitVector",
"(",
")",
"||",
"VT",
".",
"is128BitVector",
"(",
")",
")",
"{",
"if",
"(",
"Subtarget",
"->",
"hasVLX",
"(",
")",
")",
"if",
"(",
"EltVT",
"==",
"MVT",
"::",
"i32",
"||",
"EltVT",
"==",
"MVT",
"::",
"i64",
"||",
"EltVT",
"==",
"MVT",
"::",
"f32",
"||",
"EltVT",
"==",
"MVT",
"::",
"f64",
")",
"switch",
"(",
"NumElts",
")",
"{",
"case",
"2",
":",
"return",
"MVT",
"::",
"v2i1",
";",
"case",
"4",
":",
"return",
"MVT",
"::",
"v4i1",
";",
"case",
"8",
":",
"return",
"MVT",
"::",
"v8i1",
";",
"}",
"if",
"(",
"Subtarget",
"->",
"hasBWI",
"(",
")",
"&&",
"Subtarget",
"->",
"hasVLX",
"(",
")",
")",
"if",
"(",
"EltVT",
"==",
"MVT",
"::",
"i8",
"||",
"EltVT",
"==",
"MVT",
"::",
"i16",
")",
"switch",
"(",
"NumElts",
")",
"{",
"case",
"8",
":",
"return",
"MVT",
"::",
"v8i1",
";",
"case",
"16",
":",
"return",
"MVT",
"::",
"v16i1",
";",
"case",
"32",
":",
"return",
"MVT",
"::",
"v32i1",
";",
"}",
"}",
"return",
"VT",
".",
"changeVectorElementTypeToInteger",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"X86",
"X86",
"MVT::i1",
"MVT::i8",
"MVT::i32",
"MVT::i64",
"MVT::f32",
"MVT::f64",
"8",
"MVT::v8i1",
"16",
"MVT::v16i1",
"MVT::i8",
"MVT::i16",
"32",
"MVT::v32i1",
"64",
"MVT::v64i1",
"MVT::i32",
"MVT::i64",
"MVT::f32",
"MVT::f64",
"2",
"MVT::v2i1",
"4",
"MVT::v4i1",
"8",
"MVT::v8i1",
"MVT::i8",
"MVT::i16",
"8",
"MVT::v8i1",
"16",
"MVT::v16i1",
"32",
"MVT::v32i1"
] | X86ISelLowering1 | getSetCCResultType | X86 | CPU | LLVM | 24,603 | 318 | 1 | [] |
[
"<s>",
"bool",
"ShouldShrinkFPConstant",
"(",
"EVT",
"VT",
")",
"const",
"{",
"return",
"VT",
"!=",
"MVT",
"::",
"f128",
";",
"}",
"</s>"
] | [
"If",
"true",
",",
"then",
"instruction",
"selection",
"should",
"seek",
"to",
"shrink",
"the",
"FP",
"constant",
"of",
"the",
"specified",
"type",
"to",
"a",
"smaller",
"type",
"in",
"order",
"to",
"save",
"space",
"and",
"/",
"or",
"reduce",
"runtime",
"."
] | [
"Sparc",
"MVT::f128"
] | SparcISelLowering2 | ShouldShrinkFPConstant | Sparc | CPU | LLVM | 24,604 | 16 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"shouldConvertConstantLoadToIntImm",
"(",
"const",
"APInt",
"&",
"Imm",
",",
"Type",
"*",
"Ty",
")",
"const",
"{",
"assert",
"(",
"Ty",
"->",
"isIntegerTy",
"(",
")",
")",
";",
"unsigned",
"BitSize",
"=",
"Ty",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"BitSize",
"==",
"0",
"||",
"BitSize",
">",
"64",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"it",
"is",
"beneficial",
"to",
"convert",
"a",
"load",
"of",
"a",
"constant",
"to",
"just",
"the",
"constant",
"itself",
"."
] | [
"X86",
"X86",
"0",
"64"
] | X86ISelLowering (2) | shouldConvertConstantLoadToIntImm | X86 | CPU | LLVM | 24,605 | 51 | 1 | [] |
[
"<s>",
"RegisterAggr",
"&",
"RegisterAggr",
"::",
"insert",
"(",
"RegisterRef",
"RR",
")",
"{",
"RegisterRef",
"NR",
"=",
"normalize",
"(",
"RR",
")",
";",
"auto",
"F",
"=",
"Masks",
".",
"find",
"(",
"NR",
".",
"Reg",
")",
";",
"if",
"(",
"F",
"==",
"Masks",
".",
"end",
"(",
")",
")",
"Masks",
".",
"insert",
"(",
"{",
"NR",
".",
"Reg",
",",
"NR",
".",
"Mask",
"}",
")",
";",
"else",
"F",
"->",
"second",
"|=",
"NR",
".",
"Mask",
";",
"const",
"TargetRegisterInfo",
"&",
"TRI",
"=",
"PRI",
".",
"getTRI",
"(",
")",
";",
"for",
"(",
"MCRegUnitIterator",
"U",
"(",
"RR",
".",
"Reg",
",",
"&",
"TRI",
")",
";",
"U",
".",
"isValid",
"(",
")",
";",
"++",
"U",
")",
"{",
"MCRegUnitRootIterator",
"R",
"(",
"*",
"U",
",",
"&",
"TRI",
")",
";",
"++",
"R",
";",
"if",
"(",
"!",
"R",
".",
"isValid",
"(",
")",
")",
"continue",
";",
"ExpAliasUnits",
".",
"set",
"(",
"*",
"U",
")",
";",
"CheckUnits",
"=",
"true",
";",
"}",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"insert",
"-",
"Append",
"entry",
"to",
"the",
"vector",
"if",
"it",
"does",
"n't",
"already",
"exist",
"."
] | [
"Hexagon"
] | RDFRegisters3 | insert | Hexagon | DSP | LLVM | 24,606 | 140 | 1 | [] |
[
"<s>",
"bool",
"IA64TargetMachine",
"::",
"addPreEmitPass",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"PM",
".",
"add",
"(",
"createIA64BundlingPass",
"(",
"*",
"this",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"IA64",
"IA64",
"IA64"
] | IA64TargetMachine | addPreEmitPass | IA64 | CPU | LLVM | 24,607 | 30 | 1 | [] |
[
"<s>",
"bool",
"X86LowerTileCopy",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"X86Subtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"const",
"X86InstrInfo",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"llvm",
"::",
"make_early_inc_range",
"(",
"MBB",
")",
")",
"{",
"if",
"(",
"!",
"MI",
".",
"isCopy",
"(",
")",
")",
"continue",
";",
"MachineOperand",
"&",
"DstMO",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"MachineOperand",
"&",
"SrcMO",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"Register",
"SrcReg",
"=",
"SrcMO",
".",
"getReg",
"(",
")",
";",
"Register",
"DstReg",
"=",
"DstMO",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"X86",
"::",
"TILERegClass",
".",
"contains",
"(",
"DstReg",
",",
"SrcReg",
")",
")",
"continue",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"Size",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"X86",
"::",
"TILERegClass",
")",
";",
"Align",
"Alignment",
"=",
"TRI",
"->",
"getSpillAlign",
"(",
"X86",
"::",
"TILERegClass",
")",
";",
"int",
"TileSS",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"CreateSpillStackObject",
"(",
"Size",
",",
"Alignment",
")",
";",
"Size",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"X86",
"::",
"GR64RegClass",
")",
";",
"Alignment",
"=",
"TRI",
"->",
"getSpillAlign",
"(",
"X86",
"::",
"GR64RegClass",
")",
";",
"int",
"StrideSS",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"CreateSpillStackObject",
"(",
"Size",
",",
"Alignment",
")",
";",
"Register",
"GR64Cand",
"=",
"X86",
"::",
"RAX",
";",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"IMPLICIT_DEF",
")",
",",
"GR64Cand",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"MOV64mr",
")",
")",
",",
"StrideSS",
")",
".",
"addReg",
"(",
"GR64Cand",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"MOV64ri",
")",
",",
"GR64Cand",
")",
".",
"addImm",
"(",
"64",
")",
";",
"unsigned",
"Opc",
"=",
"X86",
"::",
"TILESTORED",
";",
"MachineInstr",
"*",
"NewMI",
"=",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Opc",
")",
")",
",",
"TileSS",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"SrcMO",
".",
"isKill",
"(",
")",
")",
")",
";",
"MachineOperand",
"&",
"MO",
"=",
"NewMI",
"->",
"getOperand",
"(",
"2",
")",
";",
"MO",
".",
"setReg",
"(",
"GR64Cand",
")",
";",
"MO",
".",
"setIsKill",
"(",
"true",
")",
";",
"Opc",
"=",
"X86",
"::",
"TILELOADD",
";",
"NewMI",
"=",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Opc",
")",
",",
"DstReg",
")",
",",
"TileSS",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"MOV64rm",
")",
",",
"GR64Cand",
")",
",",
"StrideSS",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"1",
"X86::TILERegClass",
"X86::TILERegClass",
"X86::TILERegClass",
"X86::GR64RegClass",
"X86::GR64RegClass",
"X86::RAX",
"X86::IMPLICIT_DEF",
"X86::MOV64mr",
"X86::MOV64ri",
"64",
"X86::TILESTORED",
"2",
"X86::TILELOADD",
"X86::MOV64rm"
] | X86LowerTileCopy1 | runOnMachineFunction | X86 | CPU | LLVM | 24,608 | 453 | 1 | [] |
[
"<s>",
"bool",
"HexagonMCInstrInfo",
"::",
"isPredicated",
"(",
"MCInstrInfo",
"const",
"&",
"MCII",
",",
"MCInst",
"const",
"&",
"MCI",
")",
"{",
"const",
"uint64_t",
"F",
"=",
"HexagonMCInstrInfo",
"::",
"getDesc",
"(",
"MCII",
",",
"MCI",
")",
".",
"TSFlags",
";",
"return",
"(",
"(",
"F",
">>",
"HexagonII",
"::",
"PredicatedPos",
")",
"&",
"HexagonII",
"::",
"PredicatedMask",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"is",
"already",
"predicated",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"HexagonII::PredicatedPos",
"HexagonII::PredicatedMask"
] | HexagonMCInstrInfo (2)1 | isPredicated | Hexagon | DSP | LLVM | 24,609 | 47 | 1 | [] |
[
"<s>",
"static",
"struct",
"aarch64_arch_driver_info",
"*",
"get_arch_from_id",
"(",
"const",
"char",
"*",
"id",
")",
"{",
"unsigned",
"int",
"i",
"=",
"0",
";",
"for",
"(",
"i",
"=",
"0",
";",
"aarch64_arches",
"[",
"i",
"]",
".",
"id",
"!=",
"NULL",
";",
"i",
"++",
")",
"{",
"if",
"(",
"strcmp",
"(",
"id",
",",
"aarch64_arches",
"[",
"i",
"]",
".",
"id",
")",
"==",
"0",
")",
"return",
"&",
"aarch64_arches",
"[",
"i",
"]",
";",
"}",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Return",
"an",
"aarch64_arch_driver_info",
"for",
"the",
"architecture",
"described",
"by",
"ID",
",",
"or",
"NULL",
"if",
"ID",
"describes",
"something",
"we",
"do",
"n't",
"know",
"about",
"."
] | [
"aarch64",
"0",
"0",
"0"
] | driver-aarch64 | get_arch_from_id | aarch64 | CPU | GCC | 24,610 | 65 | 1 | [] |
[
"<s>",
"InstructionCost",
"AArch64TTIImpl",
"::",
"getMinMaxReductionCost",
"(",
"VectorType",
"*",
"Ty",
",",
"VectorType",
"*",
"CondTy",
",",
"bool",
"IsPairwise",
",",
"bool",
"IsUnsigned",
",",
"TTI",
"::",
"TargetCostKind",
"CostKind",
")",
"{",
"if",
"(",
"!",
"isa",
"<",
"ScalableVectorType",
">",
"(",
"Ty",
")",
")",
"return",
"BaseT",
"::",
"getMinMaxReductionCost",
"(",
"Ty",
",",
"CondTy",
",",
"IsPairwise",
",",
"IsUnsigned",
",",
"CostKind",
")",
";",
"assert",
"(",
"(",
"isa",
"<",
"ScalableVectorType",
">",
"(",
"Ty",
")",
"&&",
"isa",
"<",
"ScalableVectorType",
">",
"(",
"CondTy",
")",
")",
"&&",
"\"Both vector needs to be scalable\"",
")",
";",
"std",
"::",
"pair",
"<",
"InstructionCost",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"DL",
",",
"Ty",
")",
";",
"InstructionCost",
"LegalizationCost",
"=",
"0",
";",
"if",
"(",
"LT",
".",
"first",
">",
"1",
")",
"{",
"Type",
"*",
"LegalVTy",
"=",
"EVT",
"(",
"LT",
".",
"second",
")",
".",
"getTypeForEVT",
"(",
"Ty",
"->",
"getContext",
"(",
")",
")",
";",
"unsigned",
"CmpOpcode",
"=",
"Ty",
"->",
"isFPOrFPVectorTy",
"(",
")",
"?",
"Instruction",
"::",
"FCmp",
":",
"Instruction",
"::",
"ICmp",
";",
"LegalizationCost",
"=",
"getCmpSelInstrCost",
"(",
"CmpOpcode",
",",
"LegalVTy",
",",
"LegalVTy",
",",
"CmpInst",
"::",
"BAD_ICMP_PREDICATE",
",",
"CostKind",
")",
"+",
"getCmpSelInstrCost",
"(",
"Instruction",
"::",
"Select",
",",
"LegalVTy",
",",
"LegalVTy",
",",
"CmpInst",
"::",
"BAD_ICMP_PREDICATE",
",",
"CostKind",
")",
";",
"LegalizationCost",
"*=",
"LT",
".",
"first",
"-",
"1",
";",
"}",
"return",
"LegalizationCost",
"+",
"2",
";",
"}",
"</s>"
] | [
"Try",
"to",
"calculate",
"op",
"costs",
"for",
"min/max",
"reduction",
"operations",
"."
] | [
"AArch64",
"AArch64",
"\"Both vector needs to be scalable\"",
"0",
"1",
"1",
"2"
] | AArch64TargetTransformInfo27 | getMinMaxReductionCost | AArch64 | CPU | LLVM | 24,611 | 194 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"AArch64_MachoTargetObjectFile",
"::",
"getIndirectSymViaGOTPCRel",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"const",
"MCSymbol",
"*",
"Sym",
",",
"const",
"MCValue",
"&",
"MV",
",",
"int64_t",
"Offset",
",",
"MachineModuleInfo",
"*",
"MMI",
",",
"MCStreamer",
"&",
"Streamer",
")",
"const",
"{",
"assert",
"(",
"(",
"Offset",
"+",
"MV",
".",
"getConstant",
"(",
")",
"==",
"0",
")",
"&&",
"\"Arch64 does not support GOT PC rel with extra offset\"",
")",
";",
"const",
"MCExpr",
"*",
"Res",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"Sym",
",",
"MCSymbolRefExpr",
"::",
"VK_GOT",
",",
"getContext",
"(",
")",
")",
";",
"MCSymbol",
"*",
"PCSym",
"=",
"getContext",
"(",
")",
".",
"createTempSymbol",
"(",
")",
";",
"Streamer",
".",
"EmitLabel",
"(",
"PCSym",
")",
";",
"const",
"MCExpr",
"*",
"PC",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"PCSym",
",",
"getContext",
"(",
")",
")",
";",
"return",
"MCBinaryExpr",
"::",
"createSub",
"(",
"Res",
",",
"PC",
",",
"getContext",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"target",
"specific",
"PC",
"relative",
"GOT",
"entry",
"relocation",
"."
] | [
"AArch64",
"AArch64",
"0",
"\"Arch64 does not support GOT PC rel with extra offset\""
] | AArch64TargetObjectFile15 | getIndirectSymViaGOTPCRel | AArch64 | CPU | LLVM | 24,612 | 122 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_init_sched_context",
"(",
"void",
"*",
"_sc",
",",
"bool",
"clean_p",
")",
"{",
"rs6000_sched_context_t",
"sc",
"=",
"(",
"rs6000_sched_context_t",
")",
"_sc",
";",
"if",
"(",
"clean_p",
")",
"{",
"sc",
"->",
"cached_can_issue_more",
"=",
"0",
";",
"sc",
"->",
"last_scheduled_insn",
"=",
"NULL",
";",
"sc",
"->",
"load_store_pendulum",
"=",
"0",
";",
"sc",
"->",
"divide_cnt",
"=",
"0",
";",
"sc",
"->",
"vec_pairing",
"=",
"0",
";",
"}",
"else",
"{",
"sc",
"->",
"cached_can_issue_more",
"=",
"cached_can_issue_more",
";",
"sc",
"->",
"last_scheduled_insn",
"=",
"last_scheduled_insn",
";",
"sc",
"->",
"load_store_pendulum",
"=",
"load_store_pendulum",
";",
"sc",
"->",
"divide_cnt",
"=",
"divide_cnt",
";",
"sc",
"->",
"vec_pairing",
"=",
"vec_pairing",
";",
"}",
"}",
"</s>"
] | [
"If",
"CLEAN_P",
"is",
"true",
"then",
"initializes",
"_SC",
"with",
"clean",
"data",
",",
"and",
"from",
"the",
"global",
"context",
"otherwise",
"."
] | [
"rs6000",
"0",
"0",
"0",
"0"
] | rs6000 | rs6000_init_sched_context | rs6000 | CPU | GCC | 24,613 | 90 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_fp_comparison_cost",
"(",
"enum",
"rtx_code",
"code",
")",
"{",
"int",
"fcomi_cost",
",",
"sahf_cost",
",",
"arithmetics_cost",
"=",
"1024",
";",
"int",
"min",
";",
"fcomi_cost",
"=",
"ix86_fp_comparison_fcomi_cost",
"(",
"code",
")",
";",
"sahf_cost",
"=",
"ix86_fp_comparison_sahf_cost",
"(",
"code",
")",
";",
"min",
"=",
"arithmetics_cost",
"=",
"ix86_fp_comparison_arithmetics_cost",
"(",
"code",
")",
";",
"if",
"(",
"min",
">",
"sahf_cost",
")",
"min",
"=",
"sahf_cost",
";",
"if",
"(",
"min",
">",
"fcomi_cost",
")",
"min",
"=",
"fcomi_cost",
";",
"return",
"min",
";",
"}",
"</s>"
] | [
"Compute",
"cost",
"of",
"the",
"comparison",
"done",
"using",
"any",
"method",
".",
"See",
"ix86_fp_comparison_arithmetics_cost",
"for",
"the",
"metrics",
"."
] | [
"i386",
"1024"
] | i3863 | ix86_fp_comparison_cost | i386 | CPU | GCC | 24,614 | 68 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"{",
"assert",
"(",
"(",
"Kind",
"==",
"k_Register",
"||",
"Kind",
"==",
"k_WrappedRegister",
")",
"&&",
"\"Invalid access!\"",
")",
";",
"return",
"Reg",
".",
"RegNum",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"AArch64",
"\"Invalid access!\""
] | AArch64AsmParser13 | getReg | AArch64 | CPU | LLVM | 24,615 | 27 | 1 | [] |
[
"<s>",
"static",
"rtx",
"mips_call_tls_get_addr",
"(",
"rtx",
"sym",
",",
"enum",
"mips_symbol_type",
"type",
",",
"rtx",
"v0",
")",
"{",
"rtx",
"insn",
",",
"loc",
",",
"a0",
";",
"a0",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_ARG_FIRST",
")",
";",
"if",
"(",
"!",
"mips_tls_symbol",
")",
"mips_tls_symbol",
"=",
"init_one_libfunc",
"(",
"\"__tls_get_addr\"",
")",
";",
"loc",
"=",
"mips_unspec_address",
"(",
"sym",
",",
"type",
")",
";",
"start_sequence",
"(",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"Pmode",
",",
"a0",
",",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"pic_offset_table_rtx",
",",
"loc",
")",
")",
")",
";",
"insn",
"=",
"mips_expand_call",
"(",
"MIPS_CALL_NORMAL",
",",
"v0",
",",
"mips_tls_symbol",
",",
"const0_rtx",
",",
"NULL_RTX",
",",
"false",
")",
";",
"RTL_CONST_CALL_P",
"(",
"insn",
")",
"=",
"1",
";",
"use_reg",
"(",
"&",
"CALL_INSN_FUNCTION_USAGE",
"(",
"insn",
")",
",",
"a0",
")",
";",
"insn",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"return",
"insn",
";",
"}",
"</s>"
] | [
"Return",
"an",
"instruction",
"sequence",
"that",
"calls",
"__tls_get_addr",
".",
"SYM",
"is",
"the",
"TLS",
"symbol",
"we",
"are",
"referencing",
"and",
"TYPE",
"is",
"the",
"symbol",
"type",
"to",
"use",
"(",
"either",
"global",
"dynamic",
"or",
"local",
"dynamic",
")",
".",
"V0",
"is",
"an",
"RTX",
"for",
"the",
"return",
"value",
"location",
"."
] | [
"mips",
"\"__tls_get_addr\"",
"1"
] | mips4 | mips_call_tls_get_addr | mips | CPU | GCC | 24,616 | 124 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"host_detect_local_cpu",
"(",
"int",
"argc",
",",
"const",
"char",
"*",
"*",
"argv",
")",
"{",
"const",
"char",
"*",
"cpu",
"=",
"NULL",
";",
"char",
"*",
"buf",
"=",
"NULL",
";",
"kstat_ctl_t",
"*",
"kc",
";",
"kstat_t",
"*",
"ksp",
";",
"kstat_named_t",
"*",
"brand",
"=",
"NULL",
";",
"char",
"buf",
"[",
"128",
"]",
";",
"FILE",
"*",
"f",
";",
"int",
"i",
";",
"if",
"(",
"argc",
"<",
"1",
")",
"return",
"NULL",
";",
"if",
"(",
"strcmp",
"(",
"argv",
"[",
"0",
"]",
",",
"\"cpu\"",
")",
"&&",
"strcmp",
"(",
"argv",
"[",
"0",
"]",
",",
"\"tune\"",
")",
")",
"return",
"NULL",
";",
"kc",
"=",
"kstat_open",
"(",
")",
";",
"if",
"(",
"kc",
"!=",
"NULL",
")",
"{",
"ksp",
"=",
"kstat_lookup",
"(",
"kc",
",",
"CONST_CAST2",
"(",
"char",
"*",
",",
"const",
"char",
"*",
",",
"\"cpu_info\"",
")",
",",
"-",
"1",
",",
"NULL",
")",
";",
"if",
"(",
"ksp",
"!=",
"NULL",
"&&",
"kstat_read",
"(",
"kc",
",",
"ksp",
",",
"NULL",
")",
"!=",
"-",
"1",
"&&",
"ksp",
"->",
"ks_type",
"==",
"KSTAT_TYPE_NAMED",
")",
"brand",
"=",
"(",
"kstat_named_t",
"*",
")",
"kstat_data_lookup",
"(",
"ksp",
",",
"CONST_CAST2",
"(",
"char",
"*",
",",
"const",
"char",
"*",
",",
"\"brand\"",
")",
")",
";",
"if",
"(",
"brand",
"!=",
"NULL",
"&&",
"brand",
"->",
"data_type",
"==",
"KSTAT_DATA_STRING",
")",
"buf",
"=",
"KSTAT_NAMED_STR_PTR",
"(",
"brand",
")",
";",
"}",
"kstat_close",
"(",
"kc",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"cpu_names",
"[",
"i",
"]",
".",
"name",
"!=",
"NULL",
";",
"i",
"++",
")",
"if",
"(",
"strcmp",
"(",
"buf",
",",
"cpu_names",
"[",
"i",
"]",
".",
"name",
")",
"==",
"0",
")",
"cpu",
"=",
"cpu_names",
"[",
"i",
"]",
".",
"cpu",
";",
"f",
"=",
"fopen",
"(",
"\"/proc/cpuinfo\"",
",",
"\"r\"",
")",
";",
"if",
"(",
"f",
"==",
"NULL",
")",
"return",
"NULL",
";",
"while",
"(",
"fgets",
"(",
"buf",
",",
"sizeof",
"(",
"buf",
")",
",",
"f",
")",
"!=",
"NULL",
")",
"if",
"(",
"startswith",
"(",
"buf",
",",
"\"cpu\\t\\t:\"",
")",
")",
"{",
"for",
"(",
"i",
"=",
"0",
";",
"cpu_names",
"[",
"i",
"]",
".",
"name",
";",
"i",
"++",
")",
"if",
"(",
"strstr",
"(",
"buf",
",",
"cpu_names",
"[",
"i",
"]",
".",
"name",
")",
"!=",
"NULL",
")",
"{",
"cpu",
"=",
"cpu_names",
"[",
"i",
"]",
".",
"cpu",
";",
"break",
";",
"}",
"break",
";",
"}",
"fclose",
"(",
"f",
")",
";",
"if",
"(",
"cpu",
"==",
"NULL",
")",
"return",
"NULL",
";",
"return",
"concat",
"(",
"\"-m\"",
",",
"argv",
"[",
"0",
"]",
",",
"\"=\"",
",",
"cpu",
",",
"NULL",
")",
";",
"}",
"</s>"
] | [
"This",
"will",
"be",
"called",
"by",
"the",
"spec",
"parser",
"in",
"gcc.cc",
"when",
"it",
"sees",
"a",
"%",
":",
"local_cpu_detect",
"(",
"args",
")",
"construct",
".",
"Currently",
"it",
"will",
"be",
"called",
"with",
"either",
"``",
"cpu",
"''",
"or",
"``",
"tune",
"''",
"as",
"argument",
"depending",
"on",
"if",
"-mcpu=native",
"or",
"-mtune=native",
"is",
"to",
"be",
"substituted",
".",
"It",
"returns",
"a",
"string",
"containing",
"new",
"command",
"line",
"parameters",
"to",
"be",
"put",
"at",
"the",
"place",
"of",
"the",
"above",
"two",
"options",
",",
"depending",
"on",
"what",
"CPU",
"this",
"is",
"executed",
".",
"E.g",
".",
"``",
"-mcpu=ultrasparc3",
"''",
"on",
"an",
"UltraSPARC",
"III",
"for",
"-mcpu=native",
".",
"If",
"the",
"routine",
"ca",
"n't",
"detect",
"a",
"known",
"processor",
",",
"the",
"-mcpu",
"or",
"-mtune",
"option",
"is",
"discarded",
".",
"ARGC",
"and",
"ARGV",
"are",
"set",
"depending",
"on",
"the",
"actual",
"arguments",
"given",
"in",
"the",
"spec",
"."
] | [
"sparc",
"128",
"1",
"0",
"\"cpu\"",
"0",
"\"tune\"",
"\"cpu_info\"",
"1",
"1",
"\"brand\"",
"0",
"0",
"\"/proc/cpuinfo\"",
"\"r\"",
"\"cpu\\t\\t:\"",
"0",
"\"-m\"",
"0",
"\"=\""
] | driver-sparc | host_detect_local_cpu | sparc | CPU | GCC | 24,617 | 365 | 1 | [] |
[
"<s>",
"void",
"arm_asm_output_labelref",
"(",
"FILE",
"*",
"stream",
",",
"const",
"char",
"*",
"name",
")",
"{",
"int",
"skip",
";",
"int",
"verbatim",
"=",
"0",
";",
"while",
"(",
"(",
"skip",
"=",
"arm_get_strip_length",
"(",
"*",
"name",
")",
")",
")",
"{",
"verbatim",
"|=",
"(",
"*",
"name",
"==",
"'*'",
")",
";",
"name",
"+=",
"skip",
";",
"}",
"if",
"(",
"verbatim",
")",
"fputs",
"(",
"name",
",",
"stream",
")",
";",
"else",
"asm_fprintf",
"(",
"stream",
",",
"\"%U%s\"",
",",
"name",
")",
";",
"}",
"</s>"
] | [
"If",
"there",
"is",
"a",
"'",
"*",
"'",
"anywhere",
"in",
"the",
"name",
"'s",
"prefix",
",",
"then",
"emit",
"the",
"stripped",
"name",
"verbatim",
",",
"otherwise",
"prepend",
"an",
"underscore",
"if",
"leading",
"underscores",
"are",
"being",
"used",
"."
] | [
"arm",
"0",
"\"%U%s\""
] | arm | arm_asm_output_labelref | arm | CPU | GCC | 24,618 | 70 | 1 | [] |
[
"<s>",
"static",
"int",
"s390_sched_reorder",
"(",
"FILE",
"*",
"file",
",",
"int",
"verbose",
",",
"rtx_insn",
"*",
"*",
"ready",
",",
"int",
"*",
"nreadyp",
",",
"int",
"clock",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"s390_tune",
"==",
"PROCESSOR_2097_Z10",
")",
"if",
"(",
"reload_completed",
"&&",
"*",
"nreadyp",
">",
"1",
")",
"s390_z10_prevent_earlyload_conflicts",
"(",
"ready",
",",
"nreadyp",
")",
";",
"if",
"(",
"s390_tune",
"==",
"PROCESSOR_2827_ZEC12",
"&&",
"reload_completed",
"&&",
"*",
"nreadyp",
">",
"1",
")",
"{",
"int",
"i",
";",
"int",
"last_index",
"=",
"*",
"nreadyp",
"-",
"1",
";",
"int",
"max_index",
"=",
"-",
"1",
";",
"int",
"max_score",
"=",
"-",
"1",
";",
"rtx_insn",
"*",
"tmp",
";",
"for",
"(",
"i",
"=",
"last_index",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"int",
"score",
";",
"if",
"(",
"recog_memoized",
"(",
"ready",
"[",
"i",
"]",
")",
"<",
"0",
")",
"continue",
";",
"score",
"=",
"s390_sched_score",
"(",
"ready",
"[",
"i",
"]",
")",
";",
"if",
"(",
"score",
">",
"max_score",
")",
"{",
"max_score",
"=",
"score",
";",
"max_index",
"=",
"i",
";",
"}",
"}",
"if",
"(",
"max_index",
"!=",
"-",
"1",
")",
"{",
"if",
"(",
"max_index",
"!=",
"last_index",
")",
"{",
"tmp",
"=",
"ready",
"[",
"max_index",
"]",
";",
"ready",
"[",
"max_index",
"]",
"=",
"ready",
"[",
"last_index",
"]",
";",
"ready",
"[",
"last_index",
"]",
"=",
"tmp",
";",
"if",
"(",
"verbose",
">",
"5",
")",
"fprintf",
"(",
"file",
",",
"\"move insn %d to the top of list\\n\"",
",",
"INSN_UID",
"(",
"ready",
"[",
"last_index",
"]",
")",
")",
";",
"}",
"else",
"if",
"(",
"verbose",
">",
"5",
")",
"fprintf",
"(",
"file",
",",
"\"best insn %d already on top\\n\"",
",",
"INSN_UID",
"(",
"ready",
"[",
"last_index",
"]",
")",
")",
";",
"}",
"if",
"(",
"verbose",
">",
"5",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"ready list ooo attributes - sched state: %d\\n\"",
",",
"s390_sched_state",
")",
";",
"for",
"(",
"i",
"=",
"last_index",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"if",
"(",
"recog_memoized",
"(",
"ready",
"[",
"i",
"]",
")",
"<",
"0",
")",
"continue",
";",
"fprintf",
"(",
"file",
",",
"\"insn %d score: %d: \"",
",",
"INSN_UID",
"(",
"ready",
"[",
"i",
"]",
")",
",",
"s390_sched_score",
"(",
"ready",
"[",
"i",
"]",
")",
")",
";",
"PRINT_OOO_ATTR",
"(",
"ooo_cracked",
")",
";",
"PRINT_OOO_ATTR",
"(",
"ooo_expanded",
")",
";",
"PRINT_OOO_ATTR",
"(",
"ooo_endgroup",
")",
";",
"PRINT_OOO_ATTR",
"(",
"ooo_groupalone",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\n\"",
")",
";",
"}",
"}",
"}",
"return",
"s390_issue_rate",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"via",
"hook",
"TARGET_SCHED_REORDER",
"before",
"issuing",
"one",
"insn",
"from",
"list",
"READY",
"which",
"contains",
"*",
"NREADYP",
"entries",
".",
"For",
"target",
"z10",
"it",
"reorders",
"load",
"instructions",
"to",
"avoid",
"early",
"load",
"conflicts",
"in",
"the",
"floating",
"point",
"pipeline"
] | [
"s390",
"1",
"1",
"1",
"1",
"1",
"0",
"0",
"1",
"5",
"\"move insn %d to the top of list\\n\"",
"5",
"\"best insn %d already on top\\n\"",
"5",
"\"ready list ooo attributes - sched state: %d\\n\"",
"0",
"0",
"\"insn %d score: %d: \"",
"\"\\n\""
] | s3904 | s390_sched_reorder | s390 | MPU | GCC | 24,619 | 333 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"ReplaceNodeResults not implemented for this op for WebAssembly!\"",
")",
";",
"}",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"WebAssembly",
"WebAssembly",
"ISD::SIGN_EXTEND_INREG",
"\"ReplaceNodeResults not implemented for this op for WebAssembly!\""
] | WebAssemblyISelLowering (2)2 | ReplaceNodeResults | WebAssembly | Virtual ISA | LLVM | 24,620 | 47 | 1 | [] |
[
"<s>",
"void",
"expand_epilogue",
"(",
")",
"{",
"int",
"size",
";",
"register",
"int",
"regno",
";",
"int",
"return_size",
";",
"rtx",
"scratch",
";",
"if",
"(",
"reload_completed",
"!=",
"1",
")",
"abort",
"(",
")",
";",
"size",
"=",
"get_frame_size",
"(",
")",
";",
"if",
"(",
"current_function_return_rtx",
"==",
"0",
")",
"return_size",
"=",
"0",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"current_function_return_rtx",
")",
"==",
"MEM",
")",
"return_size",
"=",
"HARD_REG_SIZE",
";",
"else",
"return_size",
"=",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"current_function_return_rtx",
")",
")",
";",
"if",
"(",
"return_size",
">",
"HARD_REG_SIZE",
")",
"scratch",
"=",
"iy_reg",
";",
"else",
"scratch",
"=",
"ix_reg",
";",
"for",
"(",
"regno",
"=",
"SOFT_REG_LAST",
";",
"regno",
">=",
"SOFT_REG_FIRST",
";",
"regno",
"--",
")",
"{",
"if",
"(",
"regs_ever_live",
"[",
"regno",
"]",
"&&",
"!",
"call_used_regs",
"[",
"regno",
"]",
")",
"{",
"emit_move_after_reload",
"(",
"gen_rtx",
"(",
"REG",
",",
"HImode",
",",
"regno",
")",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"}",
"}",
"if",
"(",
"TARGET_M6812",
"&&",
"(",
"size",
">",
"4",
"||",
"size",
"==",
"3",
")",
")",
"{",
"emit_insn",
"(",
"gen_addhi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"size",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"size",
">",
"8",
")",
"{",
"rtx",
"insn",
";",
"insn",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"2",
",",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"stack_pointer_rtx",
",",
"gen_rtx_PLUS",
"(",
"HImode",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"size",
")",
")",
")",
",",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"scratch",
")",
")",
")",
";",
"emit_insn",
"(",
"insn",
")",
";",
"}",
"else",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"2",
";",
"i",
"<=",
"size",
";",
"i",
"+=",
"2",
")",
"emit_move_after_reload",
"(",
"scratch",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"if",
"(",
"size",
"&",
"1",
")",
"emit_insn",
"(",
"gen_addhi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"1",
")",
")",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"emit_move_after_reload",
"(",
"hard_frame_pointer_rtx",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"if",
"(",
"current_function_interrupt",
")",
"{",
"emit_move_after_reload",
"(",
"gen_rtx",
"(",
"REG",
",",
"HImode",
",",
"SOFT_SAVED_XY_REGNUM",
")",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"emit_move_after_reload",
"(",
"gen_rtx",
"(",
"REG",
",",
"HImode",
",",
"SOFT_Z_REGNUM",
")",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"emit_move_after_reload",
"(",
"m68hc11_soft_tmp_reg",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"}",
"else",
"if",
"(",
"current_function_trap",
"&&",
"return_size",
"!=",
"0",
")",
"{",
"rtx",
"addr_reg",
"=",
"stack_pointer_rtx",
";",
"if",
"(",
"!",
"TARGET_M6812",
")",
"{",
"emit_move_after_reload",
"(",
"scratch",
",",
"stack_pointer_rtx",
",",
"0",
")",
";",
"addr_reg",
"=",
"scratch",
";",
"}",
"emit_move_after_reload",
"(",
"gen_rtx",
"(",
"MEM",
",",
"HImode",
",",
"gen_rtx",
"(",
"PLUS",
",",
"HImode",
",",
"addr_reg",
",",
"GEN_INT",
"(",
"1",
")",
")",
")",
",",
"d_reg",
",",
"0",
")",
";",
"if",
"(",
"return_size",
">",
"HARD_REG_SIZE",
")",
"emit_move_after_reload",
"(",
"gen_rtx",
"(",
"MEM",
",",
"HImode",
",",
"gen_rtx",
"(",
"PLUS",
",",
"HImode",
",",
"addr_reg",
",",
"GEN_INT",
"(",
"3",
")",
")",
")",
",",
"ix_reg",
",",
"0",
")",
";",
"}",
"emit_jump_insn",
"(",
"gen_return",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"epilogue",
"into",
"RTL",
"."
] | [
"m68hc11",
"1",
"0",
"0",
"4",
"3",
"8",
"2",
"2",
"2",
"1",
"1",
"0",
"0",
"1",
"0",
"3",
"0"
] | m68hc11 | expand_epilogue | m68hc11 | MPU | GCC | 24,621 | 432 | 1 | [] |
[
"<s>",
"void",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"override",
"{",
"verifyInstructionPredicates",
"(",
"MI",
",",
"computeAvailableFeatures",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
")",
")",
";",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"Opcode",
")",
";",
"uint64_t",
"Bits",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"unsigned",
"Size",
"=",
"Desc",
".",
"getSize",
"(",
")",
";",
"switch",
"(",
"Size",
")",
"{",
"case",
"0",
":",
"break",
";",
"case",
"4",
":",
"if",
"(",
"IsLittleEndian",
")",
"{",
"support",
"::",
"endian",
"::",
"Writer",
"<",
"support",
"::",
"little",
">",
"(",
"OS",
")",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Bits",
")",
";",
"}",
"else",
"{",
"support",
"::",
"endian",
"::",
"Writer",
"<",
"support",
"::",
"big",
">",
"(",
"OS",
")",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Bits",
")",
";",
"}",
"break",
";",
"case",
"8",
":",
"if",
"(",
"IsLittleEndian",
")",
"{",
"uint64_t",
"Swapped",
"=",
"(",
"Bits",
"<<",
"32",
")",
"|",
"(",
"Bits",
">>",
"32",
")",
";",
"support",
"::",
"endian",
"::",
"Writer",
"<",
"support",
"::",
"little",
">",
"(",
"OS",
")",
".",
"write",
"<",
"uint64_t",
">",
"(",
"Swapped",
")",
";",
"}",
"else",
"{",
"support",
"::",
"endian",
"::",
"Writer",
"<",
"support",
"::",
"big",
">",
"(",
"OS",
")",
".",
"write",
"<",
"uint64_t",
">",
"(",
"Bits",
")",
";",
"}",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Invalid instruction size\"",
")",
";",
"}",
"++",
"MCNumEmitted",
";",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"PowerPC",
"0",
"4",
"support::endian",
"support::little",
"support::endian",
"support::big",
"8",
"32",
"32",
"support::endian",
"support::little",
"support::endian",
"support::big",
"\"Invalid instruction size\""
] | PPCMCCodeEmitter42 | encodeInstruction | PowerPC | CPU | LLVM | 24,622 | 236 | 1 | [] |
[
"<s>",
"void",
"mips_final_prescan_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"opvec",
",",
"int",
"noperands",
")",
"{",
"if",
"(",
"INSN_P",
"(",
"insn",
")",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"UNSPEC_VOLATILE",
"&&",
"XINT",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"1",
")",
"==",
"UNSPEC_CONSTTABLE",
")",
"mips_set_text_contents_type",
"(",
"asm_out_file",
",",
"\"__pool_\"",
",",
"XINT",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
",",
"0",
")",
",",
"0",
")",
",",
"FALSE",
")",
";",
"if",
"(",
"mips_need_noat_wrapper_p",
"(",
"insn",
",",
"opvec",
",",
"noperands",
")",
")",
"mips_push_asm_switch",
"(",
"&",
"mips_noat",
")",
";",
"}",
"</s>"
] | [
"Implement",
"FINAL_PRESCAN_INSN",
"."
] | [
"mips",
"1",
"\"__pool_\"",
"0",
"0",
"0"
] | mips6 | mips_final_prescan_insn | mips | CPU | GCC | 24,623 | 88 | 1 | [] |
[
"<s>",
"void",
"SITargetLowering",
"::",
"finalizeLowering",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"Info",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"Info",
"->",
"isEntryFunction",
"(",
")",
")",
"{",
"reservePrivateMemoryRegs",
"(",
"getTargetMachine",
"(",
")",
",",
"MF",
",",
"*",
"TRI",
",",
"*",
"Info",
")",
";",
"}",
"assert",
"(",
"!",
"TRI",
"->",
"isSubRegister",
"(",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
")",
";",
"if",
"(",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"SP_REG",
")",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"SP_REG",
",",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
";",
"if",
"(",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"PRIVATE_RSRC_REG",
")",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"PRIVATE_RSRC_REG",
",",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
")",
";",
"if",
"(",
"Info",
"->",
"getFrameOffsetReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"FP_REG",
")",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"FP_REG",
",",
"Info",
"->",
"getFrameOffsetReg",
"(",
")",
")",
";",
"if",
"(",
"Info",
"->",
"getScratchWaveOffsetReg",
"(",
")",
"!=",
"AMDGPU",
"::",
"SCRATCH_WAVE_OFFSET_REG",
")",
"{",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"SCRATCH_WAVE_OFFSET_REG",
",",
"Info",
"->",
"getScratchWaveOffsetReg",
"(",
")",
")",
";",
"}",
"Info",
"->",
"limitOccupancy",
"(",
"MF",
")",
";",
"TargetLoweringBase",
"::",
"finalizeLowering",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Execute",
"target",
"specific",
"actions",
"to",
"finalize",
"target",
"lowering",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"AMDGPU::SP_REG",
"AMDGPU::SP_REG",
"AMDGPU::PRIVATE_RSRC_REG",
"AMDGPU::PRIVATE_RSRC_REG",
"AMDGPU::FP_REG",
"AMDGPU::FP_REG",
"AMDGPU::SCRATCH_WAVE_OFFSET_REG",
"AMDGPU::SCRATCH_WAVE_OFFSET_REG"
] | SIISelLowering119 | finalizeLowering | AMDGPU | GPU | LLVM | 24,624 | 216 | 1 | [] |
[
"<s>",
"AArch64TargetMachine",
"::",
"AArch64TargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Optional",
"<",
"Reloc",
"::",
"Model",
">",
"RM",
",",
"Optional",
"<",
"CodeModel",
"::",
"Model",
">",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"JIT",
",",
"bool",
"LittleEndian",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"computeDataLayout",
"(",
"TT",
",",
"Options",
".",
"MCOptions",
",",
"LittleEndian",
")",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"getEffectiveRelocModel",
"(",
"TT",
",",
"RM",
")",
",",
"getEffectiveAArch64CodeModel",
"(",
"TT",
",",
"CM",
",",
"JIT",
")",
",",
"OL",
")",
",",
"TLOF",
"(",
"createTLOF",
"(",
"getTargetTriple",
"(",
")",
")",
")",
",",
"isLittle",
"(",
"LittleEndian",
")",
"{",
"initAsmInfo",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"{",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"this",
"->",
"Options",
".",
"NoTrapAfterNoreturn",
"=",
"true",
";",
"}",
"if",
"(",
"getMCAsmInfo",
"(",
")",
"->",
"usesWindowsCFI",
"(",
")",
")",
"{",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"}",
"if",
"(",
"getOptLevel",
"(",
")",
"<=",
"EnableGlobalISelAtO",
"&&",
"TT",
".",
"getArch",
"(",
")",
"!=",
"Triple",
"::",
"aarch64_32",
"&&",
"!",
"(",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Large",
"&&",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
")",
"{",
"setGlobalISel",
"(",
"true",
")",
";",
"setGlobalISelAbort",
"(",
"GlobalISelAbortMode",
"::",
"Disable",
")",
";",
"}",
"setMachineOutliner",
"(",
"true",
")",
";",
"setSupportsDefaultOutlining",
"(",
"true",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"AArch64",
"architecture",
"model",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine15 | AArch64TargetMachine | AArch64 | CPU | LLVM | 24,625 | 220 | 1 | [] |
[
"<s>",
"static",
"void",
"xstormy16_print_operand",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"x",
",",
"int",
"code",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"'B'",
":",
"{",
"static",
"int",
"bits_set",
"[",
"8",
"]",
"=",
"{",
"0",
",",
"1",
",",
"1",
",",
"2",
",",
"1",
",",
"2",
",",
"2",
",",
"3",
"}",
";",
"HOST_WIDE_INT",
"xx",
"=",
"1",
";",
"HOST_WIDE_INT",
"l",
";",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
")",
"xx",
"=",
"INTVAL",
"(",
"x",
")",
";",
"else",
"output_operand_lossage",
"(",
"\"'B' operand is not constant\"",
")",
";",
"if",
"(",
"bits_set",
"[",
"xx",
"&",
"7",
"]",
"<=",
"1",
")",
"{",
"if",
"(",
"(",
"~",
"xx",
"&",
"~",
"(",
"HOST_WIDE_INT",
")",
"0xff",
")",
"==",
"0",
")",
"xx",
"&=",
"0xff",
";",
"else",
"if",
"(",
"(",
"~",
"xx",
"&",
"~",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
")",
"==",
"0",
")",
"xx",
"&=",
"0xffff",
";",
"l",
"=",
"exact_log2",
"(",
"xx",
")",
";",
"}",
"else",
"{",
"if",
"(",
"(",
"xx",
"&",
"~",
"(",
"HOST_WIDE_INT",
")",
"0xff",
")",
"==",
"0",
")",
"xx",
"|=",
"~",
"(",
"HOST_WIDE_INT",
")",
"0xff",
";",
"else",
"if",
"(",
"(",
"xx",
"&",
"~",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
")",
"==",
"0",
")",
"xx",
"|=",
"~",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
";",
"l",
"=",
"exact_log2",
"(",
"~",
"xx",
")",
";",
"}",
"if",
"(",
"l",
"==",
"-",
"1",
")",
"output_operand_lossage",
"(",
"\"'B' operand has multiple bits set\"",
")",
";",
"fprintf",
"(",
"file",
",",
"IMMEDIATE_PREFIX",
"HOST_WIDE_INT_PRINT_DEC",
",",
"l",
")",
";",
"return",
";",
"}",
"case",
"'C'",
":",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
")",
"assemble_name",
"(",
"file",
",",
"XSTR",
"(",
"x",
",",
"0",
")",
")",
";",
"else",
"if",
"(",
"LABEL_P",
"(",
"x",
")",
")",
"output_asm_label",
"(",
"x",
")",
";",
"else",
"xstormy16_print_operand_address",
"(",
"file",
",",
"x",
")",
";",
"return",
";",
"case",
"'o'",
":",
"case",
"'O'",
":",
"{",
"HOST_WIDE_INT",
"xx",
"=",
"0",
";",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
")",
"xx",
"=",
"INTVAL",
"(",
"x",
")",
";",
"else",
"output_operand_lossage",
"(",
"\"'o' operand is not constant\"",
")",
";",
"if",
"(",
"code",
"==",
"'O'",
")",
"xx",
"=",
"-",
"xx",
";",
"fprintf",
"(",
"file",
",",
"IMMEDIATE_PREFIX",
"HOST_WIDE_INT_PRINT_DEC",
",",
"xx",
"-",
"1",
")",
";",
"return",
";",
"}",
"case",
"'b'",
":",
"{",
"HOST_WIDE_INT",
"xx",
"=",
"1",
";",
"HOST_WIDE_INT",
"l",
";",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
")",
"xx",
"=",
"INTVAL",
"(",
"x",
")",
";",
"else",
"output_operand_lossage",
"(",
"\"'B' operand is not constant\"",
")",
";",
"l",
"=",
"7",
"-",
"xx",
";",
"fputs",
"(",
"IMMEDIATE_PREFIX",
",",
"file",
")",
";",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
",",
"l",
")",
";",
"return",
";",
"}",
"case",
"0",
":",
"break",
";",
"default",
":",
"output_operand_lossage",
"(",
"\"xstormy16_print_operand: unknown code\"",
")",
";",
"return",
";",
"}",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"REG",
":",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"x",
")",
"]",
",",
"file",
")",
";",
"break",
";",
"case",
"MEM",
":",
"xstormy16_print_operand_address",
"(",
"file",
",",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"break",
";",
"default",
":",
"fputs",
"(",
"IMMEDIATE_PREFIX",
",",
"file",
")",
";",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"break",
";",
"}",
"return",
";",
"}",
"</s>"
] | [
"Print",
"an",
"operand",
"to",
"an",
"assembler",
"instruction",
"."
] | [
"stormy16",
"8",
"0",
"1",
"1",
"2",
"1",
"2",
"2",
"3",
"1",
"\"'B' operand is not constant\"",
"7",
"1",
"0xff",
"0",
"0xff",
"0xffff",
"0",
"0xffff",
"0xff",
"0",
"0xff",
"0xffff",
"0",
"0xffff",
"1",
"\"'B' operand has multiple bits set\"",
"0",
"0",
"\"'o' operand is not constant\"",
"1",
"1",
"\"'B' operand is not constant\"",
"7",
"0",
"\"xstormy16_print_operand: unknown code\"",
"0"
] | stormy164 | xstormy16_print_operand | stormy16 | CPU | GCC | 24,626 | 459 | 1 | [] |
[
"<s>",
"bool",
"M680x0ExpandPseudo",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"STI",
"=",
"&",
"static_cast",
"<",
"const",
"M680x0Subtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"STI",
"->",
"getRegisterInfo",
"(",
")",
";",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"M680x0MachineFunctionInfo",
">",
"(",
")",
";",
"FL",
"=",
"STI",
"->",
"getFrameLowering",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"Modified",
"|=",
"ExpandMBB",
"(",
"MBB",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"M680x0",
"M680x0",
"M680x0",
"M680x0"
] | M680x0ExpandPseudo | runOnMachineFunction | M680x0 | MPU | LLVM | 24,627 | 86 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isInlineConstant",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"uint8_t",
"OperandType",
")",
"const",
"{",
"if",
"(",
"!",
"MO",
".",
"isImm",
"(",
")",
"||",
"OperandType",
"<",
"AMDGPU",
"::",
"OPERAND_SRC_FIRST",
"||",
"OperandType",
">",
"AMDGPU",
"::",
"OPERAND_SRC_LAST",
")",
"return",
"false",
";",
"int64_t",
"Imm",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"switch",
"(",
"OperandType",
")",
"{",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_INT32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_FP32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_INT32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_FP32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_INT32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_FP32",
":",
"{",
"int32_t",
"Trunc",
"=",
"static_cast",
"<",
"int32_t",
">",
"(",
"Imm",
")",
";",
"return",
"AMDGPU",
"::",
"isInlinableLiteral32",
"(",
"Trunc",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"}",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_INT64",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_FP64",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_INT64",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_FP64",
":",
"return",
"AMDGPU",
"::",
"isInlinableLiteral64",
"(",
"MO",
".",
"getImm",
"(",
")",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_FP16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_FP16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_FP16",
":",
"{",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Imm",
")",
"||",
"isUInt",
"<",
"16",
">",
"(",
"Imm",
")",
")",
"{",
"int16_t",
"Trunc",
"=",
"static_cast",
"<",
"int16_t",
">",
"(",
"Imm",
")",
";",
"return",
"ST",
".",
"has16BitInsts",
"(",
")",
"&&",
"AMDGPU",
"::",
"isInlinableLiteral16",
"(",
"Trunc",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_V2INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_V2FP16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_V2INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_V2FP16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_V2INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_V2FP16",
":",
"{",
"uint32_t",
"Trunc",
"=",
"static_cast",
"<",
"uint32_t",
">",
"(",
"Imm",
")",
";",
"return",
"AMDGPU",
"::",
"isInlinableLiteralV216",
"(",
"Trunc",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"}",
"default",
":",
"llvm_unreachable",
"(",
"\"invalid bitwidth\"",
")",
";",
"}",
"}",
"</s>"
] | [
"returns",
"true",
"if",
"the",
"operand",
"OpIdx",
"in",
"MI",
"is",
"a",
"valid",
"inline",
"immediate",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::OPERAND_SRC_FIRST",
"AMDGPU::OPERAND_SRC_LAST",
"AMDGPU::OPERAND_REG_IMM_INT32",
"AMDGPU::OPERAND_REG_IMM_FP32",
"AMDGPU::OPERAND_REG_INLINE_C_INT32",
"AMDGPU::OPERAND_REG_INLINE_C_FP32",
"AMDGPU::OPERAND_REG_INLINE_AC_INT32",
"AMDGPU::OPERAND_REG_INLINE_AC_FP32",
"AMDGPU::isInlinableLiteral32",
"AMDGPU::OPERAND_REG_IMM_INT64",
"AMDGPU::OPERAND_REG_IMM_FP64",
"AMDGPU::OPERAND_REG_INLINE_C_INT64",
"AMDGPU::OPERAND_REG_INLINE_C_FP64",
"AMDGPU::isInlinableLiteral64",
"AMDGPU::OPERAND_REG_IMM_INT16",
"AMDGPU::OPERAND_REG_IMM_FP16",
"AMDGPU::OPERAND_REG_INLINE_C_INT16",
"AMDGPU::OPERAND_REG_INLINE_C_FP16",
"AMDGPU::OPERAND_REG_INLINE_AC_INT16",
"AMDGPU::OPERAND_REG_INLINE_AC_FP16",
"16",
"16",
"AMDGPU::isInlinableLiteral16",
"AMDGPU::OPERAND_REG_IMM_V2INT16",
"AMDGPU::OPERAND_REG_IMM_V2FP16",
"AMDGPU::OPERAND_REG_INLINE_C_V2INT16",
"AMDGPU::OPERAND_REG_INLINE_C_V2FP16",
"AMDGPU::OPERAND_REG_INLINE_AC_V2INT16",
"AMDGPU::OPERAND_REG_INLINE_AC_V2FP16",
"AMDGPU::isInlinableLiteralV216",
"\"invalid bitwidth\""
] | SIInstrInfo12 | isInlineConstant | AMDGPU | GPU | LLVM | 24,628 | 300 | 1 | [] |
[
"<s>",
"bool",
"XNCMTargetLowering",
"::",
"isTruncateFree",
"(",
"EVT",
"VT1",
",",
"EVT",
"VT2",
")",
"const",
"{",
"if",
"(",
"!",
"VT1",
".",
"isInteger",
"(",
")",
"||",
"!",
"VT2",
".",
"isInteger",
"(",
")",
")",
"return",
"false",
";",
"return",
"(",
"VT1",
".",
"getSizeInBits",
"(",
")",
">",
"VT2",
".",
"getSizeInBits",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"free",
"to",
"truncate",
"a",
"value",
"of",
"type",
"Ty1",
"to",
"type",
"Ty2",
"."
] | [
"XNCM",
"XNCM"
] | XNCMISelLowering | isTruncateFree | XNCM | CPU | LLVM | 24,629 | 48 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_optimize_register_info",
"(",
")",
"{",
"char",
"clobbered_regs",
"[",
"32",
"]",
";",
"int",
"i",
";",
"gcc_assert",
"(",
"epilogue_completed",
")",
";",
"gcc_assert",
"(",
"!",
"cfun",
"->",
"machine",
"->",
"split_branches_pending_p",
")",
";",
"s390_regs_ever_clobbered",
"(",
"clobbered_regs",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"32",
";",
"i",
"++",
")",
"clobbered_regs",
"[",
"i",
"]",
"=",
"clobbered_regs",
"[",
"i",
"]",
"&&",
"!",
"global_regs",
"[",
"i",
"]",
";",
"clobbered_regs",
"[",
"RETURN_REGNUM",
"]",
"|=",
"(",
"TARGET_TPF_PROFILING",
"||",
"cfun_frame_layout",
".",
"save_return_addr_p",
"||",
"crtl",
"->",
"calls_eh_return",
")",
";",
"memset",
"(",
"cfun_frame_layout",
".",
"gpr_save_slots",
",",
"SAVE_SLOT_NONE",
",",
"6",
")",
";",
"for",
"(",
"i",
"=",
"6",
";",
"i",
"<",
"16",
";",
"i",
"++",
")",
"if",
"(",
"!",
"clobbered_regs",
"[",
"i",
"]",
")",
"cfun_gpr_save_slot",
"(",
"i",
")",
"=",
"SAVE_SLOT_NONE",
";",
"s390_register_info_set_ranges",
"(",
")",
";",
"s390_register_info_stdarg_gpr",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"by",
"s390_optimize_prologue",
"in",
"order",
"to",
"get",
"rid",
"of",
"unnecessary",
"GPR",
"save/restore",
"instructions",
".",
"The",
"register",
"info",
"for",
"the",
"GPRs",
"is",
"re-computed",
"and",
"the",
"ranges",
"are",
"re-calculated",
"."
] | [
"s390",
"32",
"0",
"32",
"6",
"6",
"16"
] | s3905 | s390_optimize_register_info | s390 | MPU | GCC | 24,630 | 129 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_vector_mode_p",
"(",
"machine_mode",
"mode",
")",
"{",
"return",
"aarch64_vector_mode_supported_p",
"(",
"mode",
")",
"||",
"aarch64_vect_struct_mode_p",
"(",
"mode",
")",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"MODE",
"is",
"any",
"of",
"the",
"vector",
"modes",
"."
] | [
"aarch64"
] | aarch642 | aarch64_vector_mode_p | aarch64 | CPU | GCC | 24,631 | 20 | 1 | [] |
[
"<s>",
"void",
"LEGInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"LEG",
"LEG"
] | LEGInstPrinter1 | printInst | LEG | CPU | LLVM | 24,632 | 33 | 1 | [] |
[
"<s>",
"F2003fSubtarget",
"&",
"F2003fSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"std",
"::",
"string",
"CPUName",
"=",
"CPU",
";",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"CPUName",
"=",
"\"2003f\"",
";",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FS",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"F2003f",
"F2003f",
"F2003f",
"\"2003f\""
] | F2003fSubtarget | initializeSubtargetDependencies | F2003f | CPU | LLVM | 24,633 | 44 | 1 | [] |
[
"<s>",
"ARMSubtarget",
"::",
"ARMSubtarget",
"(",
"const",
"Triple",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"const",
"ARMBaseTargetMachine",
"&",
"TM",
",",
"bool",
"IsLittle",
")",
":",
"ARMGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"UseMulOps",
"(",
"UseFusedMulOps",
")",
",",
"CPUString",
"(",
"CPU",
")",
",",
"IsLittle",
"(",
"IsLittle",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"Options",
"(",
"TM",
".",
"Options",
")",
",",
"TM",
"(",
"TM",
")",
",",
"FrameLowering",
"(",
"initializeFrameLowering",
"(",
"CPU",
",",
"FS",
")",
")",
",",
"InstrInfo",
"(",
"isThumb1Only",
"(",
")",
"?",
"(",
"ARMBaseInstrInfo",
"*",
")",
"new",
"Thumb1InstrInfo",
"(",
"*",
"this",
")",
":",
"!",
"isThumb",
"(",
")",
"?",
"(",
"ARMBaseInstrInfo",
"*",
")",
"new",
"ARMInstrInfo",
"(",
"*",
"this",
")",
":",
"(",
"ARMBaseInstrInfo",
"*",
")",
"new",
"Thumb2InstrInfo",
"(",
"*",
"this",
")",
")",
",",
"TLInfo",
"(",
"TM",
",",
"*",
"this",
")",
"{",
"assert",
"(",
"(",
"isThumb",
"(",
")",
"||",
"hasARMOps",
"(",
")",
")",
"&&",
"\"Target must either be thumb or support ARM operations!\"",
")",
";",
"GISelAccessor",
"*",
"GISel",
"=",
"new",
"GISelAccessor",
"(",
")",
";",
"ARMGISelActualAccessor",
"*",
"GISel",
"=",
"new",
"ARMGISelActualAccessor",
"(",
")",
";",
"GISel",
"->",
"CallLoweringInfo",
".",
"reset",
"(",
"new",
"ARMCallLowering",
"(",
"*",
"getTargetLowering",
"(",
")",
")",
")",
";",
"GISel",
"->",
"Legalizer",
".",
"reset",
"(",
"new",
"ARMLegalizerInfo",
"(",
"*",
"this",
")",
")",
";",
"auto",
"*",
"RBI",
"=",
"new",
"ARMRegisterBankInfo",
"(",
"*",
"getRegisterInfo",
"(",
")",
")",
";",
"GISel",
"->",
"InstSelector",
".",
"reset",
"(",
"createARMInstructionSelector",
"(",
"*",
"static_cast",
"<",
"const",
"ARMBaseTargetMachine",
"*",
">",
"(",
"&",
"TM",
")",
",",
"*",
"this",
",",
"*",
"RBI",
")",
")",
";",
"GISel",
"->",
"RegBankInfo",
".",
"reset",
"(",
"RBI",
")",
";",
"setGISelAccessor",
"(",
"*",
"GISel",
")",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"\"Target must either be thumb or support ARM operations!\"",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMSubtarget51 | ARMSubtarget | ARM | CPU | LLVM | 24,634 | 256 | 1 | [] |
[
"<s>",
"bool",
"ARMPassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"addPass",
"(",
"createARMISelDag",
"(",
"getARMTargetMachine",
"(",
")",
",",
"getOptLevel",
"(",
")",
")",
")",
";",
"const",
"ARMSubtarget",
"*",
"Subtarget",
"=",
"&",
"getARMSubtarget",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetELF",
"(",
")",
"&&",
"!",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
"&&",
"TM",
"->",
"Options",
".",
"EnableFastISel",
")",
"addPass",
"(",
"createARMGlobalBaseRegPass",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine100 | addInstSelector | ARM | CPU | LLVM | 24,635 | 63 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_avx_u128_mode_after",
"(",
"int",
"mode",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"vzeroupper_pattern",
"(",
"pat",
",",
"VOIDmode",
")",
"||",
"vzeroall_pattern",
"(",
"pat",
",",
"VOIDmode",
")",
")",
"return",
"AVX_U128_CLEAN",
";",
"if",
"(",
"CALL_P",
"(",
"insn",
")",
")",
"{",
"bool",
"avx_upper_reg_found",
"=",
"false",
";",
"note_stores",
"(",
"insn",
",",
"ix86_check_avx_upper_stores",
",",
"&",
"avx_upper_reg_found",
")",
";",
"return",
"avx_upper_reg_found",
"?",
"AVX_U128_DIRTY",
":",
"AVX_U128_CLEAN",
";",
"}",
"return",
"mode",
";",
"}",
"</s>"
] | [
"Calculate",
"mode",
"of",
"upper",
"128bit",
"AVX",
"registers",
"after",
"the",
"insn",
"."
] | [
"i386"
] | i386 | ix86_avx_u128_mode_after | i386 | CPU | GCC | 24,636 | 74 | 1 | [] |
[
"<s>",
"int",
"h8300_ldm_stm_parallel",
"(",
"rtvec",
"vec",
",",
"int",
"load_p",
",",
"int",
"first",
")",
"{",
"rtx",
"last",
";",
"int",
"nregs",
",",
"i",
",",
"regno",
",",
"adjust",
";",
"if",
"(",
"GET_NUM_ELEM",
"(",
"vec",
")",
"<",
"3",
")",
"return",
"false",
";",
"nregs",
"=",
"GET_NUM_ELEM",
"(",
"vec",
")",
"-",
"first",
"-",
"1",
";",
"regno",
"=",
"h8300_ldm_stm_regno",
"(",
"RTVEC_ELT",
"(",
"vec",
",",
"first",
")",
",",
"load_p",
",",
"0",
",",
"nregs",
")",
";",
"if",
"(",
"regno",
"<",
"0",
"||",
"regno",
"+",
"nregs",
">",
"8",
")",
"return",
"false",
";",
"if",
"(",
"!",
"TARGET_H8300SX",
")",
"{",
"if",
"(",
"(",
"regno",
"&",
"1",
")",
"!=",
"0",
")",
"return",
"false",
";",
"if",
"(",
"nregs",
">",
"2",
"&&",
"(",
"regno",
"&",
"3",
")",
"!=",
"0",
")",
"return",
"false",
";",
"}",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"nregs",
";",
"i",
"++",
")",
"if",
"(",
"h8300_ldm_stm_regno",
"(",
"RTVEC_ELT",
"(",
"vec",
",",
"first",
"+",
"i",
")",
",",
"load_p",
",",
"i",
",",
"nregs",
")",
"!=",
"regno",
"+",
"i",
")",
"return",
"false",
";",
"last",
"=",
"RTVEC_ELT",
"(",
"vec",
",",
"first",
"+",
"nregs",
")",
";",
"adjust",
"=",
"(",
"load_p",
"?",
"nregs",
":",
"-",
"nregs",
")",
"*",
"4",
";",
"return",
"(",
"GET_CODE",
"(",
"last",
")",
"==",
"SET",
"&&",
"SET_DEST",
"(",
"last",
")",
"==",
"stack_pointer_rtx",
"&&",
"h8300_stack_offset_p",
"(",
"SET_SRC",
"(",
"last",
")",
",",
"adjust",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"elements",
"of",
"VEC",
"starting",
"at",
"FIRST",
"describe",
"an",
"ldm",
"or",
"stm",
"instruction",
"(",
"LOAD_P",
"says",
"which",
")",
"."
] | [
"h8300",
"3",
"1",
"0",
"0",
"8",
"1",
"0",
"2",
"3",
"0",
"1",
"4"
] | h8300 | h8300_ldm_stm_parallel | h8300 | MPU | GCC | 24,637 | 210 | 1 | [] |
[
"<s>",
"bool",
"mergeStoresAfterLegalization",
"(",
"EVT",
"MemVT",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Do",
"not",
"merge",
"vector",
"stores",
"after",
"legalization",
"because",
"that",
"may",
"conflict",
"with",
"x86-specific",
"store",
"splitting",
"optimizations",
"."
] | [
"TPC"
] | TPCISelLowering | mergeStoresAfterLegalization | TPC | Virtual ISA | LLVM | 24,638 | 13 | 1 | [] |
[
"<s>",
"rtx",
"s390_emit_call",
"(",
"rtx",
"addr_location",
",",
"rtx",
"tls_call",
",",
"rtx",
"result_reg",
",",
"rtx",
"retaddr_reg",
")",
"{",
"bool",
"plt_call",
"=",
"false",
";",
"rtx",
"insn",
";",
"rtx",
"call",
";",
"rtx",
"clobber",
";",
"rtvec",
"vec",
";",
"if",
"(",
"GET_CODE",
"(",
"addr_location",
")",
"==",
"SYMBOL_REF",
")",
"{",
"if",
"(",
"flag_pic",
"&&",
"!",
"SYMBOL_REF_LOCAL_P",
"(",
"addr_location",
")",
")",
"{",
"addr_location",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"addr_location",
")",
",",
"UNSPEC_PLT",
")",
";",
"addr_location",
"=",
"gen_rtx_CONST",
"(",
"Pmode",
",",
"addr_location",
")",
";",
"plt_call",
"=",
"true",
";",
"}",
"if",
"(",
"!",
"TARGET_SMALL_EXEC",
"&&",
"!",
"TARGET_CPU_ZARCH",
")",
"{",
"if",
"(",
"flag_pic",
")",
"addr_location",
"=",
"legitimize_pic_address",
"(",
"addr_location",
",",
"0",
")",
";",
"else",
"addr_location",
"=",
"force_reg",
"(",
"Pmode",
",",
"addr_location",
")",
";",
"}",
"}",
"if",
"(",
"retaddr_reg",
"==",
"NULL_RTX",
"&&",
"GET_CODE",
"(",
"addr_location",
")",
"!=",
"SYMBOL_REF",
"&&",
"!",
"plt_call",
")",
"{",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"SIBCALL_REGNUM",
")",
",",
"addr_location",
")",
";",
"addr_location",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"SIBCALL_REGNUM",
")",
";",
"}",
"addr_location",
"=",
"gen_rtx_MEM",
"(",
"QImode",
",",
"addr_location",
")",
";",
"call",
"=",
"gen_rtx_CALL",
"(",
"VOIDmode",
",",
"addr_location",
",",
"const0_rtx",
")",
";",
"if",
"(",
"result_reg",
"!=",
"NULL_RTX",
")",
"call",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"result_reg",
",",
"call",
")",
";",
"if",
"(",
"retaddr_reg",
"!=",
"NULL_RTX",
")",
"{",
"clobber",
"=",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"retaddr_reg",
")",
";",
"if",
"(",
"tls_call",
"!=",
"NULL_RTX",
")",
"vec",
"=",
"gen_rtvec",
"(",
"3",
",",
"call",
",",
"clobber",
",",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"tls_call",
")",
")",
";",
"else",
"vec",
"=",
"gen_rtvec",
"(",
"2",
",",
"call",
",",
"clobber",
")",
";",
"call",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"vec",
")",
";",
"}",
"insn",
"=",
"emit_call_insn",
"(",
"call",
")",
";",
"if",
"(",
"(",
"!",
"TARGET_64BIT",
"&&",
"plt_call",
")",
"||",
"tls_call",
"!=",
"NULL_RTX",
")",
"{",
"gcc_assert",
"(",
"retaddr_reg",
"!=",
"NULL_RTX",
")",
";",
"use_reg",
"(",
"&",
"CALL_INSN_FUNCTION_USAGE",
"(",
"insn",
")",
",",
"pic_offset_table_rtx",
")",
";",
"}",
"return",
"insn",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"used",
"by",
"the",
"call",
"expanders",
"of",
"the",
"machine",
"description",
".",
"It",
"emits",
"the",
"call",
"insn",
"itself",
"together",
"with",
"the",
"necessary",
"operations",
"to",
"adjust",
"the",
"target",
"address",
"and",
"returns",
"the",
"emitted",
"insn",
".",
"ADDR_LOCATION",
"is",
"the",
"target",
"address",
"rtx",
"TLS_CALL",
"the",
"location",
"of",
"the",
"thread-local",
"symbol",
"RESULT_REG",
"the",
"register",
"where",
"the",
"result",
"of",
"the",
"call",
"should",
"be",
"stored",
"RETADDR_REG",
"the",
"register",
"where",
"the",
"return",
"address",
"should",
"be",
"stored",
"If",
"this",
"parameter",
"is",
"NULL_RTX",
"the",
"call",
"is",
"considered",
"to",
"be",
"a",
"sibling",
"call",
"."
] | [
"s390",
"1",
"0",
"3",
"2"
] | s3903 | s390_emit_call | s390 | MPU | GCC | 24,639 | 300 | 1 | [] |
[
"<s>",
"static",
"rtx",
"aarch64_expand_builtin_memtag",
"(",
"int",
"fcode",
",",
"tree",
"exp",
",",
"rtx",
"target",
")",
"{",
"if",
"(",
"TARGET_ILP32",
")",
"{",
"error",
"(",
"\"Memory Tagging Extension does not support %<-mabi=ilp32%>\"",
")",
";",
"return",
"const0_rtx",
";",
"}",
"rtx",
"pat",
"=",
"NULL",
";",
"enum",
"insn_code",
"icode",
"=",
"aarch64_memtag_builtin_data",
"[",
"fcode",
"-",
"AARCH64_MEMTAG_BUILTIN_START",
"-",
"1",
"]",
".",
"icode",
";",
"rtx",
"op0",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"0",
")",
")",
";",
"machine_mode",
"mode0",
"=",
"GET_MODE",
"(",
"op0",
")",
";",
"op0",
"=",
"force_reg",
"(",
"mode0",
"==",
"VOIDmode",
"?",
"DImode",
":",
"mode0",
",",
"op0",
")",
";",
"op0",
"=",
"convert_to_mode",
"(",
"DImode",
",",
"op0",
",",
"true",
")",
";",
"switch",
"(",
"fcode",
")",
"{",
"case",
"AARCH64_MEMTAG_BUILTIN_IRG",
":",
"case",
"AARCH64_MEMTAG_BUILTIN_GMI",
":",
"case",
"AARCH64_MEMTAG_BUILTIN_SUBP",
":",
"case",
"AARCH64_MEMTAG_BUILTIN_INC_TAG",
":",
"{",
"if",
"(",
"!",
"target",
"||",
"GET_MODE",
"(",
"target",
")",
"!=",
"DImode",
"||",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"predicate",
")",
"(",
"target",
",",
"DImode",
")",
")",
"target",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"if",
"(",
"fcode",
"==",
"AARCH64_MEMTAG_BUILTIN_INC_TAG",
")",
"{",
"rtx",
"op1",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"1",
")",
")",
";",
"if",
"(",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"3",
"]",
".",
"predicate",
")",
"(",
"op1",
",",
"QImode",
")",
")",
"{",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"const0_rtx",
",",
"op1",
")",
";",
"break",
";",
"}",
"error_at",
"(",
"EXPR_LOCATION",
"(",
"exp",
")",
",",
"\"argument %d must be a constant immediate \"",
"\"in range [0,15]\"",
",",
"2",
")",
";",
"return",
"const0_rtx",
";",
"}",
"else",
"{",
"rtx",
"op1",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"1",
")",
")",
";",
"machine_mode",
"mode1",
"=",
"GET_MODE",
"(",
"op1",
")",
";",
"op1",
"=",
"force_reg",
"(",
"mode1",
"==",
"VOIDmode",
"?",
"DImode",
":",
"mode1",
",",
"op1",
")",
";",
"op1",
"=",
"convert_to_mode",
"(",
"DImode",
",",
"op1",
",",
"true",
")",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"op1",
")",
";",
"}",
"break",
";",
"}",
"case",
"AARCH64_MEMTAG_BUILTIN_GET_TAG",
":",
"target",
"=",
"op0",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"const0_rtx",
")",
";",
"break",
";",
"case",
"AARCH64_MEMTAG_BUILTIN_SET_TAG",
":",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"op0",
",",
"op0",
",",
"const0_rtx",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"!",
"pat",
")",
"return",
"NULL_RTX",
";",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"expression",
"EXP",
"that",
"calls",
"a",
"MEMTAG",
"built-in",
"FCODE",
"with",
"result",
"going",
"to",
"TARGET",
"."
] | [
"aarch64",
"\"Memory Tagging Extension does not support %<-mabi=ilp32%>\"",
"1",
"0",
"0",
"1",
"3",
"\"argument %d must be a constant immediate \"",
"\"in range [0,15]\"",
"2",
"1"
] | aarch64-builtins | aarch64_expand_builtin_memtag | aarch64 | CPU | GCC | 24,640 | 365 | 1 | [] |
[
"<s>",
"static",
"rtx",
"nvptx_expand_builtin",
"(",
"tree",
"exp",
",",
"rtx",
"target",
",",
"rtx",
"ARG_UNUSED",
"(",
"subtarget",
")",
",",
"machine_mode",
"mode",
",",
"int",
"ignore",
")",
"{",
"tree",
"fndecl",
"=",
"TREE_OPERAND",
"(",
"CALL_EXPR_FN",
"(",
"exp",
")",
",",
"0",
")",
";",
"switch",
"(",
"DECL_MD_FUNCTION_CODE",
"(",
"fndecl",
")",
")",
"{",
"case",
"NVPTX_BUILTIN_SHUFFLE",
":",
"case",
"NVPTX_BUILTIN_SHUFFLELL",
":",
"return",
"nvptx_expand_shuffle",
"(",
"exp",
",",
"target",
",",
"mode",
",",
"ignore",
")",
";",
"case",
"NVPTX_BUILTIN_WORKER_ADDR",
":",
"return",
"nvptx_expand_shared_addr",
"(",
"exp",
",",
"target",
",",
"mode",
",",
"ignore",
",",
"false",
")",
";",
"case",
"NVPTX_BUILTIN_VECTOR_ADDR",
":",
"return",
"nvptx_expand_shared_addr",
"(",
"exp",
",",
"target",
",",
"mode",
",",
"ignore",
",",
"true",
")",
";",
"case",
"NVPTX_BUILTIN_CMP_SWAP",
":",
"case",
"NVPTX_BUILTIN_CMP_SWAPLL",
":",
"return",
"nvptx_expand_cmp_swap",
"(",
"exp",
",",
"target",
",",
"mode",
",",
"ignore",
")",
";",
"case",
"NVPTX_BUILTIN_MEMBAR_GL",
":",
"emit_insn",
"(",
"gen_nvptx_membar_gl",
"(",
")",
")",
";",
"return",
"NULL_RTX",
";",
"case",
"NVPTX_BUILTIN_MEMBAR_CTA",
":",
"emit_insn",
"(",
"gen_nvptx_membar_cta",
"(",
")",
")",
";",
"return",
"NULL_RTX",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Expand",
"an",
"expression",
"EXP",
"that",
"calls",
"a",
"built-in",
"function",
",",
"with",
"result",
"going",
"to",
"TARGET",
"if",
"that",
"'s",
"convenient",
"(",
"and",
"in",
"mode",
"MODE",
"if",
"that",
"'s",
"convenient",
")",
".",
"SUBTARGET",
"may",
"be",
"used",
"as",
"the",
"target",
"for",
"computing",
"one",
"of",
"EXP",
"'s",
"operands",
".",
"IGNORE",
"is",
"nonzero",
"if",
"the",
"value",
"is",
"to",
"be",
"ignored",
"."
] | [
"nvptx",
"0"
] | nvptx | nvptx_expand_builtin | nvptx | GPU | GCC | 24,641 | 148 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"MVE VPT block insertion pass\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM",
"\"MVE VPT block insertion pass\""
] | MVEVPTBlockPass (2) | getPassName | ARM | CPU | LLVM | 24,642 | 11 | 1 | [] |
[
"<s>",
"bool",
"GCNUpwardRPTracker",
"::",
"isValid",
"(",
")",
"const",
"{",
"const",
"auto",
"&",
"SI",
"=",
"LIS",
".",
"getInstructionIndex",
"(",
"*",
"LastTrackedMI",
")",
".",
"getBaseIndex",
"(",
")",
";",
"const",
"auto",
"LISLR",
"=",
"llvm",
"::",
"getLiveRegs",
"(",
"SI",
",",
"LIS",
",",
"*",
"MRI",
")",
";",
"const",
"auto",
"TrackedLR",
"=",
"stripEmpty",
"(",
"LiveRegs",
")",
";",
"if",
"(",
"!",
"isEqual",
"(",
"LISLR",
",",
"TrackedLR",
")",
")",
"{",
"dbgs",
"(",
")",
"<<",
"\"\\nGCNUpwardRPTracker error: Tracked and\"",
"\" LIS reported livesets mismatch:\\n\"",
";",
"printLivesAt",
"(",
"SI",
",",
"LIS",
",",
"*",
"MRI",
")",
";",
"reportMismatch",
"(",
"LISLR",
",",
"TrackedLR",
",",
"MRI",
"->",
"getTargetRegisterInfo",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"auto",
"LISPressure",
"=",
"getRegPressure",
"(",
"*",
"MRI",
",",
"LISLR",
")",
";",
"if",
"(",
"LISPressure",
"!=",
"CurPressure",
")",
"{",
"dbgs",
"(",
")",
"<<",
"\"GCNUpwardRPTracker error: Pressure sets different\\nTracked: \"",
";",
"CurPressure",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"LIS rpt: \"",
";",
"LISPressure",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"this",
"iterator",
"is",
"still",
"pointing",
"at",
"a",
"valid",
"entry",
"."
] | [
"AMDGPU",
"SI",
"SI",
"\"\\nGCNUpwardRPTracker error: Tracked and\"",
"\" LIS reported livesets mismatch:\\n\"",
"SI",
"\"GCNUpwardRPTracker error: Pressure sets different\\nTracked: \"",
"\"LIS rpt: \""
] | GCNRegPressure22 | isValid | AMDGPU | GPU | LLVM | 24,643 | 151 | 1 | [] |
[
"<s>",
"bool",
"ARMPassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createARMLoadStoreOptimizationPass",
"(",
"true",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"getARMSubtarget",
"(",
")",
".",
"isCortexA9",
"(",
")",
")",
"addPass",
"(",
"createMLxExpansionPass",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"getARMSubtarget",
"(",
")",
".",
"isCortexA15",
"(",
")",
"&&",
"getARMSubtarget",
"(",
")",
".",
"hasNEON",
"(",
")",
"&&",
"!",
"DisableA15SDOptimization",
")",
"{",
"addPass",
"(",
"createA15SDOptimizerPass",
"(",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine35 | addPreRegAlloc | ARM | CPU | LLVM | 24,644 | 92 | 1 | [] |
[
"<s>",
"const",
"SNESInstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"SNES",
"SNES"
] | SNESSubtarget | getInstrInfo | SNES | DSP | LLVM | 24,645 | 14 | 1 | [] |
[
"<s>",
"const",
"ARMSubtarget",
"*",
"getSubtargetImpl",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"ARM",
"ARM"
] | ARMTargetMachine12 | getSubtargetImpl | ARM | CPU | LLVM | 24,646 | 14 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"if",
"(",
"TM",
"->",
"Options",
".",
"ThreadModel",
"==",
"ThreadModel",
"::",
"Single",
")",
"addPass",
"(",
"createLowerAtomicPass",
"(",
")",
")",
";",
"else",
"addPass",
"(",
"createAtomicExpandPass",
"(",
"TM",
")",
")",
";",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"WebAssembly",
"WebAssembly"
] | WebAssemblyTargetMachine2 | addIRPasses | WebAssembly | Virtual ISA | LLVM | 24,647 | 42 | 1 | [] |
[
"<s>",
"void",
"IA64RegisterInfo",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"unsigned",
"Amount",
"=",
"Old",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"Old",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"unsigned",
"Align",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"(",
"Amount",
"+",
"Align",
"-",
"1",
")",
"/",
"Align",
"*",
"Align",
";",
"if",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"IA64",
"::",
"ADJUSTCALLSTACKDOWN",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"IA64",
"::",
"ADDIMM22",
")",
",",
"IA64",
"::",
"r12",
")",
".",
"addReg",
"(",
"IA64",
"::",
"r12",
")",
".",
"addImm",
"(",
"-",
"Amount",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"IA64",
"::",
"ADJUSTCALLSTACKUP",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"IA64",
"::",
"ADDIMM22",
")",
",",
"IA64",
"::",
"r12",
")",
".",
"addReg",
"(",
"IA64",
"::",
"r12",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"}",
"}",
"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",
")",
"."
] | [
"IA64",
"IA64",
"0",
"0",
"1",
"IA64::ADJUSTCALLSTACKDOWN",
"IA64::ADDIMM22",
"IA64::r12",
"IA64::r12",
"IA64::ADJUSTCALLSTACKUP",
"IA64::ADDIMM22",
"IA64::r12",
"IA64::r12"
] | IA64RegisterInfo | eliminateCallFramePseudoInstr | IA64 | CPU | LLVM | 24,648 | 204 | 1 | [] |
[
"<s>",
"int",
"ix86_attr_length_immediate_default",
"(",
"rtx",
"insn",
",",
"int",
"shortform",
")",
"{",
"int",
"len",
"=",
"0",
";",
"int",
"i",
";",
"extract_insn_cached",
"(",
"insn",
")",
";",
"for",
"(",
"i",
"=",
"recog_data",
".",
"n_operands",
"-",
"1",
";",
"i",
">=",
"0",
";",
"--",
"i",
")",
"if",
"(",
"CONSTANT_P",
"(",
"recog_data",
".",
"operand",
"[",
"i",
"]",
")",
")",
"{",
"gcc_assert",
"(",
"!",
"len",
")",
";",
"if",
"(",
"shortform",
"&&",
"GET_CODE",
"(",
"recog_data",
".",
"operand",
"[",
"i",
"]",
")",
"==",
"CONST_INT",
"&&",
"CONST_OK_FOR_LETTER_P",
"(",
"INTVAL",
"(",
"recog_data",
".",
"operand",
"[",
"i",
"]",
")",
",",
"'K'",
")",
")",
"len",
"=",
"1",
";",
"else",
"{",
"switch",
"(",
"get_attr_mode",
"(",
"insn",
")",
")",
"{",
"case",
"MODE_QI",
":",
"len",
"+=",
"1",
";",
"break",
";",
"case",
"MODE_HI",
":",
"len",
"+=",
"2",
";",
"break",
";",
"case",
"MODE_SI",
":",
"len",
"+=",
"4",
";",
"break",
";",
"case",
"MODE_DI",
":",
"len",
"+=",
"4",
";",
"break",
";",
"default",
":",
"fatal_insn",
"(",
"\"unknown insn mode\"",
",",
"insn",
")",
";",
"}",
"}",
"}",
"return",
"len",
";",
"}",
"</s>"
] | [
"Compute",
"default",
"value",
"for",
"``",
"length_immediate",
"''",
"attribute",
".",
"When",
"SHORTFORM",
"is",
"set",
"expect",
"that",
"insn",
"have",
"8bit",
"immediate",
"alternative",
"."
] | [
"i386",
"0",
"1",
"0",
"1",
"1",
"2",
"4",
"4",
"\"unknown insn mode\""
] | i3863 | ix86_attr_length_immediate_default | i386 | CPU | GCC | 24,649 | 156 | 1 | [] |
[
"<s>",
"bool",
"X86RegisterInfo",
"::",
"isArgumentRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"MCRegister",
"Reg",
")",
"const",
"{",
"const",
"X86Subtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"&",
"TRI",
"=",
"*",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"auto",
"IsSubReg",
"=",
"[",
"&",
"]",
"(",
"MCRegister",
"RegA",
",",
"MCRegister",
"RegB",
")",
"{",
"return",
"TRI",
".",
"isSuperOrSubRegisterEq",
"(",
"RegA",
",",
"RegB",
")",
";",
"}",
";",
"if",
"(",
"!",
"ST",
".",
"is64Bit",
"(",
")",
")",
"return",
"llvm",
"::",
"any_of",
"(",
"SmallVector",
"<",
"MCRegister",
">",
"{",
"X86",
"::",
"EAX",
",",
"X86",
"::",
"ECX",
",",
"X86",
"::",
"EDX",
"}",
",",
"[",
"&",
"]",
"(",
"MCRegister",
"&",
"RegA",
")",
"{",
"return",
"IsSubReg",
"(",
"RegA",
",",
"Reg",
")",
";",
"}",
")",
"||",
"(",
"ST",
".",
"hasMMX",
"(",
")",
"&&",
"X86",
"::",
"VR64RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
";",
"CallingConv",
"::",
"ID",
"CC",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"X86_64_SysV",
"&&",
"IsSubReg",
"(",
"X86",
"::",
"RAX",
",",
"Reg",
")",
")",
"return",
"true",
";",
"if",
"(",
"llvm",
"::",
"any_of",
"(",
"SmallVector",
"<",
"MCRegister",
">",
"{",
"X86",
"::",
"RDX",
",",
"X86",
"::",
"RCX",
",",
"X86",
"::",
"R8",
",",
"X86",
"::",
"R9",
"}",
",",
"[",
"&",
"]",
"(",
"MCRegister",
"&",
"RegA",
")",
"{",
"return",
"IsSubReg",
"(",
"RegA",
",",
"Reg",
")",
";",
"}",
")",
")",
"return",
"true",
";",
"if",
"(",
"CC",
"!=",
"CallingConv",
"::",
"Win64",
"&&",
"llvm",
"::",
"any_of",
"(",
"SmallVector",
"<",
"MCRegister",
">",
"{",
"X86",
"::",
"RDI",
",",
"X86",
"::",
"RSI",
"}",
",",
"[",
"&",
"]",
"(",
"MCRegister",
"&",
"RegA",
")",
"{",
"return",
"IsSubReg",
"(",
"RegA",
",",
"Reg",
")",
";",
"}",
")",
")",
"return",
"true",
";",
"if",
"(",
"ST",
".",
"hasSSE1",
"(",
")",
"&&",
"llvm",
"::",
"any_of",
"(",
"SmallVector",
"<",
"MCRegister",
">",
"{",
"X86",
"::",
"XMM0",
",",
"X86",
"::",
"XMM1",
",",
"X86",
"::",
"XMM2",
",",
"X86",
"::",
"XMM3",
",",
"X86",
"::",
"XMM4",
",",
"X86",
"::",
"XMM5",
",",
"X86",
"::",
"XMM6",
",",
"X86",
"::",
"XMM7",
"}",
",",
"[",
"&",
"]",
"(",
"MCRegister",
"&",
"RegA",
")",
"{",
"return",
"IsSubReg",
"(",
"RegA",
",",
"Reg",
")",
";",
"}",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"isArgumentReg",
"-",
"Returns",
"true",
"if",
"Reg",
"can",
"be",
"used",
"as",
"an",
"argument",
"to",
"a",
"function",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86::EAX",
"X86::ECX",
"X86::EDX",
"X86::VR64RegClass",
"X86",
"X86::RAX",
"X86::RDX",
"X86::RCX",
"X86::R8",
"X86::R9",
"X86::RDI",
"X86::RSI",
"X86::XMM0",
"X86::XMM1",
"X86::XMM2",
"X86::XMM3",
"X86::XMM4",
"X86::XMM5",
"X86::XMM6",
"X86::XMM7"
] | X86RegisterInfo47 | isArgumentRegister | X86 | CPU | LLVM | 24,650 | 348 | 1 | [] |
[
"<s>",
"void",
"output_profile_hook",
"(",
"int",
"labelno",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"TARGET_PROFILE_KERNEL",
")",
"return",
";",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
"||",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
")",
"{",
"if",
"(",
"NO_PROFILE_COUNTERS",
")",
"emit_library_call",
"(",
"init_one_libfunc",
"(",
"RS6000_MCOUNT",
")",
",",
"LCT_NORMAL",
",",
"VOIDmode",
")",
";",
"else",
"{",
"char",
"buf",
"[",
"30",
"]",
";",
"const",
"char",
"*",
"label_name",
";",
"rtx",
"fun",
";",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"buf",
",",
"\"LP\"",
",",
"labelno",
")",
";",
"label_name",
"=",
"ggc_strdup",
"(",
"(",
"*",
"targetm",
".",
"strip_name_encoding",
")",
"(",
"buf",
")",
")",
";",
"fun",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"label_name",
")",
";",
"emit_library_call",
"(",
"init_one_libfunc",
"(",
"RS6000_MCOUNT",
")",
",",
"LCT_NORMAL",
",",
"VOIDmode",
",",
"fun",
",",
"Pmode",
")",
";",
"}",
"}",
"else",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_DARWIN",
")",
"{",
"const",
"char",
"*",
"mcount_name",
"=",
"RS6000_MCOUNT",
";",
"int",
"caller_addr_regno",
"=",
"LR_REGNO",
";",
"crtl",
"->",
"uses_pic_offset_table",
"=",
"1",
";",
"if",
"(",
"MACHOPIC_INDIRECT",
"&&",
"crtl",
"->",
"uses_pic_offset_table",
")",
"caller_addr_regno",
"=",
"0",
";",
"emit_library_call",
"(",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"mcount_name",
")",
",",
"LCT_NORMAL",
",",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"caller_addr_regno",
")",
",",
"Pmode",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"profile",
"function",
"."
] | [
"rs6000",
"30",
"\"LP\"",
"1",
"0"
] | rs6000 | output_profile_hook | rs6000 | CPU | GCC | 24,651 | 171 | 1 | [] |
[
"<s>",
"void",
"rs6000_emit_sCOND",
"(",
"machine_mode",
"mode",
",",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"condition_rtx",
"=",
"rs6000_generate_compare",
"(",
"operands",
"[",
"1",
"]",
",",
"mode",
")",
";",
"rtx_code",
"cond_code",
"=",
"GET_CODE",
"(",
"condition_rtx",
")",
";",
"if",
"(",
"FLOAT_MODE_P",
"(",
"mode",
")",
"&&",
"HONOR_NANS",
"(",
"mode",
")",
"&&",
"!",
"(",
"FLOAT128_VECTOR_P",
"(",
"mode",
")",
"&&",
"!",
"TARGET_FLOAT128_HW",
")",
")",
";",
"else",
"if",
"(",
"cond_code",
"==",
"NE",
"||",
"cond_code",
"==",
"GE",
"||",
"cond_code",
"==",
"LE",
"||",
"cond_code",
"==",
"GEU",
"||",
"cond_code",
"==",
"LEU",
"||",
"cond_code",
"==",
"ORDERED",
"||",
"cond_code",
"==",
"UNGE",
"||",
"cond_code",
"==",
"UNLE",
")",
"{",
"rtx",
"not_result",
"=",
"gen_reg_rtx",
"(",
"CCEQmode",
")",
";",
"rtx",
"not_op",
",",
"rev_cond_rtx",
";",
"machine_mode",
"cc_mode",
";",
"cc_mode",
"=",
"GET_MODE",
"(",
"XEXP",
"(",
"condition_rtx",
",",
"0",
")",
")",
";",
"rev_cond_rtx",
"=",
"gen_rtx_fmt_ee",
"(",
"rs6000_reverse_condition",
"(",
"cc_mode",
",",
"cond_code",
")",
",",
"SImode",
",",
"XEXP",
"(",
"condition_rtx",
",",
"0",
")",
",",
"const0_rtx",
")",
";",
"not_op",
"=",
"gen_rtx_COMPARE",
"(",
"CCEQmode",
",",
"rev_cond_rtx",
",",
"const0_rtx",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"not_result",
",",
"not_op",
")",
")",
";",
"condition_rtx",
"=",
"gen_rtx_EQ",
"(",
"VOIDmode",
",",
"not_result",
",",
"const0_rtx",
")",
";",
"}",
"machine_mode",
"op_mode",
"=",
"GET_MODE",
"(",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"0",
")",
")",
";",
"if",
"(",
"op_mode",
"==",
"VOIDmode",
")",
"op_mode",
"=",
"GET_MODE",
"(",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"1",
")",
")",
";",
"if",
"(",
"TARGET_POWERPC64",
"&&",
"(",
"op_mode",
"==",
"DImode",
"||",
"FLOAT_MODE_P",
"(",
"mode",
")",
")",
")",
"{",
"PUT_MODE",
"(",
"condition_rtx",
",",
"DImode",
")",
";",
"convert_move",
"(",
"operands",
"[",
"0",
"]",
",",
"condition_rtx",
",",
"0",
")",
";",
"}",
"else",
"{",
"PUT_MODE",
"(",
"condition_rtx",
",",
"SImode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operands",
"[",
"0",
"]",
",",
"condition_rtx",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"the",
"RTL",
"for",
"an",
"sCOND",
"pattern",
"."
] | [
"rs6000",
"1",
"0",
"0",
"1",
"0",
"1",
"1",
"0",
"0",
"0"
] | rs6000 | rs6000_emit_sCOND | rs6000 | CPU | GCC | 24,652 | 274 | 1 | [] |
[
"<s>",
"void",
"Thumb1InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"assert",
"(",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"tGPRRegClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"&&",
"\"Unknown regclass!\"",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"tGPRRegClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tLDRspi",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::tGPRRegClass",
"ARM",
"\"Unknown regclass!\"",
"ARM::tGPRRegClass",
"ARM",
"ARM::tLDRspi",
"0"
] | Thumb1InstrInfo | loadRegFromStackSlot | ARM | CPU | LLVM | 24,653 | 199 | 1 | [] |
[
"<s>",
"static",
"uint32_t",
"negate",
"(",
"uint32_t",
"Cmp",
")",
"{",
"if",
"(",
"Cmp",
"==",
"EQ",
")",
"return",
"NE",
";",
"if",
"(",
"Cmp",
"==",
"NE",
")",
"return",
"EQ",
";",
"assert",
"(",
"(",
"Cmp",
"&",
"(",
"L",
"|",
"G",
")",
")",
"!=",
"(",
"L",
"|",
"G",
")",
")",
";",
"return",
"Cmp",
"^",
"(",
"L",
"|",
"G",
")",
";",
"}",
"</s>"
] | [
"Negate",
"this",
"APInt",
"in",
"place",
"."
] | [
"Hexagon"
] | HexagonConstPropagation | negate | Hexagon | DSP | LLVM | 24,654 | 55 | 1 | [] |
[
"<s>",
"static",
"rtx",
"gen_stack_pointer_inc",
"(",
"rtx",
"increment",
")",
"{",
"return",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"stack_pointer_rtx",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"increment",
")",
")",
";",
"}",
"</s>"
] | [
"Generate",
"an",
"increment",
"for",
"the",
"stack",
"pointer",
"."
] | [
"sparc"
] | sparc3 | gen_stack_pointer_inc | sparc | CPU | GCC | 24,655 | 26 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"X86FrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"bool",
"reserveCallFrame",
"=",
"hasReservedCallFrame",
"(",
"MF",
")",
";",
"unsigned",
"Opcode",
"=",
"I",
"->",
"getOpcode",
"(",
")",
";",
"bool",
"isDestroy",
"=",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"uint64_t",
"Amount",
"=",
"!",
"reserveCallFrame",
"?",
"TII",
".",
"getFrameSize",
"(",
"*",
"I",
")",
":",
"0",
";",
"uint64_t",
"InternalAmt",
"=",
"(",
"isDestroy",
"||",
"Amount",
")",
"?",
"TII",
".",
"getFrameAdjustment",
"(",
"*",
"I",
")",
":",
"0",
";",
"I",
"=",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"auto",
"InsertPos",
"=",
"skipDebugInstructionsForward",
"(",
"I",
",",
"MBB",
".",
"end",
"(",
")",
")",
";",
"if",
"(",
"!",
"reserveCallFrame",
")",
"{",
"unsigned",
"StackAlign",
"=",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"alignTo",
"(",
"Amount",
",",
"StackAlign",
")",
";",
"MachineModuleInfo",
"&",
"MMI",
"=",
"MF",
".",
"getMMI",
"(",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"bool",
"WindowsCFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
"->",
"usesWindowsCFI",
"(",
")",
";",
"bool",
"DwarfCFI",
"=",
"!",
"WindowsCFI",
"&&",
"(",
"MMI",
".",
"hasDebugInfo",
"(",
")",
"||",
"F",
".",
"needsUnwindTableEntry",
"(",
")",
")",
";",
"bool",
"HasDwarfEHHandlers",
"=",
"!",
"WindowsCFI",
"&&",
"!",
"MF",
".",
"getLandingPads",
"(",
")",
".",
"empty",
"(",
")",
";",
"if",
"(",
"HasDwarfEHHandlers",
"&&",
"!",
"isDestroy",
"&&",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
"->",
"getHasPushSequences",
"(",
")",
")",
"BuildCFI",
"(",
"MBB",
",",
"InsertPos",
",",
"DL",
",",
"MCCFIInstruction",
"::",
"createGnuArgsSize",
"(",
"nullptr",
",",
"Amount",
")",
")",
";",
"if",
"(",
"Amount",
"==",
"0",
")",
"return",
"I",
";",
"Amount",
"-=",
"InternalAmt",
";",
"if",
"(",
"isDestroy",
"&&",
"InternalAmt",
"&&",
"DwarfCFI",
"&&",
"!",
"hasFP",
"(",
"MF",
")",
")",
"BuildCFI",
"(",
"MBB",
",",
"InsertPos",
",",
"DL",
",",
"MCCFIInstruction",
"::",
"createAdjustCfaOffset",
"(",
"nullptr",
",",
"-",
"InternalAmt",
")",
")",
";",
"int64_t",
"StackAdjustment",
"=",
"isDestroy",
"?",
"Amount",
":",
"-",
"Amount",
";",
"if",
"(",
"StackAdjustment",
")",
"{",
"StackAdjustment",
"+=",
"mergeSPUpdates",
"(",
"MBB",
",",
"InsertPos",
",",
"true",
")",
";",
"StackAdjustment",
"+=",
"mergeSPUpdates",
"(",
"MBB",
",",
"InsertPos",
",",
"false",
")",
";",
"if",
"(",
"StackAdjustment",
")",
"{",
"if",
"(",
"!",
"(",
"F",
".",
"optForMinSize",
"(",
")",
"&&",
"adjustStackWithPops",
"(",
"MBB",
",",
"InsertPos",
",",
"DL",
",",
"StackAdjustment",
")",
")",
")",
"BuildStackAdjustment",
"(",
"MBB",
",",
"InsertPos",
",",
"DL",
",",
"StackAdjustment",
",",
"false",
")",
";",
"}",
"}",
"if",
"(",
"DwarfCFI",
"&&",
"!",
"hasFP",
"(",
"MF",
")",
")",
"{",
"int64_t",
"CfaAdjustment",
"=",
"-",
"StackAdjustment",
";",
"if",
"(",
"CfaAdjustment",
")",
"{",
"BuildCFI",
"(",
"MBB",
",",
"InsertPos",
",",
"DL",
",",
"MCCFIInstruction",
"::",
"createAdjustCfaOffset",
"(",
"nullptr",
",",
"CfaAdjustment",
")",
")",
";",
"}",
"}",
"return",
"I",
";",
"}",
"if",
"(",
"isDestroy",
"&&",
"InternalAmt",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"CI",
"=",
"I",
";",
"MachineBasicBlock",
"::",
"iterator",
"B",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"while",
"(",
"CI",
"!=",
"B",
"&&",
"!",
"std",
"::",
"prev",
"(",
"CI",
")",
"->",
"isCall",
"(",
")",
")",
"--",
"CI",
";",
"BuildStackAdjustment",
"(",
"MBB",
",",
"CI",
",",
"DL",
",",
"-",
"InternalAmt",
",",
"false",
")",
";",
"}",
"return",
"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",
")",
"."
] | [
"X86",
"X86",
"0",
"0",
"X86",
"0"
] | X86FrameLowering105 | eliminateCallFramePseudoInstr | X86 | CPU | LLVM | 24,656 | 488 | 1 | [] |
[
"<s>",
"int",
"rs6000_register_move_cost",
"(",
"enum",
"machine_mode",
"mode",
",",
"enum",
"reg_class",
"from",
",",
"enum",
"reg_class",
"to",
")",
"{",
"if",
"(",
"reg_classes_intersect_p",
"(",
"to",
",",
"GENERAL_REGS",
")",
"||",
"reg_classes_intersect_p",
"(",
"from",
",",
"GENERAL_REGS",
")",
")",
"{",
"if",
"(",
"!",
"reg_classes_intersect_p",
"(",
"to",
",",
"GENERAL_REGS",
")",
")",
"from",
"=",
"to",
";",
"if",
"(",
"from",
"==",
"FLOAT_REGS",
"||",
"from",
"==",
"ALTIVEC_REGS",
")",
"return",
"(",
"rs6000_memory_move_cost",
"(",
"mode",
",",
"from",
",",
"0",
")",
"+",
"rs6000_memory_move_cost",
"(",
"mode",
",",
"GENERAL_REGS",
",",
"0",
")",
")",
";",
"else",
"if",
"(",
"from",
"==",
"CR_REGS",
")",
"return",
"4",
";",
"else",
"return",
"2",
"*",
"hard_regno_nregs",
"[",
"0",
"]",
"[",
"mode",
"]",
";",
"}",
"else",
"if",
"(",
"reg_classes_intersect_p",
"(",
"to",
",",
"from",
")",
")",
"return",
"mode",
"==",
"TFmode",
"?",
"4",
":",
"2",
";",
"else",
"return",
"(",
"rs6000_register_move_cost",
"(",
"mode",
",",
"GENERAL_REGS",
",",
"to",
")",
"+",
"rs6000_register_move_cost",
"(",
"mode",
",",
"from",
",",
"GENERAL_REGS",
")",
")",
";",
"}",
"</s>"
] | [
"A",
"C",
"expression",
"returning",
"the",
"cost",
"of",
"moving",
"data",
"from",
"a",
"register",
"of",
"class",
"CLASS1",
"to",
"one",
"of",
"CLASS2",
"."
] | [
"rs6000",
"0",
"0",
"4",
"2",
"0",
"4",
"2"
] | rs60003 | rs6000_register_move_cost | rs6000 | CPU | GCC | 24,657 | 143 | 1 | [] |
[
"<s>",
"RISCVSubtarget",
"&",
"RISCVSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"TuneCPU",
",",
"StringRef",
"FS",
",",
"StringRef",
"ABIName",
")",
"{",
"bool",
"Is64Bit",
"=",
"TT",
".",
"isArch64Bit",
"(",
")",
";",
"if",
"(",
"CPU",
".",
"empty",
"(",
")",
"||",
"CPU",
"==",
"\"generic\"",
")",
"CPU",
"=",
"Is64Bit",
"?",
"\"generic-rv64\"",
":",
"\"generic-rv32\"",
";",
"if",
"(",
"TuneCPU",
".",
"empty",
"(",
")",
")",
"TuneCPU",
"=",
"CPU",
";",
"ParseSubtargetFeatures",
"(",
"CPU",
",",
"TuneCPU",
",",
"FS",
")",
";",
"if",
"(",
"Is64Bit",
")",
"{",
"XLenVT",
"=",
"MVT",
"::",
"i64",
";",
"XLen",
"=",
"64",
";",
"}",
"TargetABI",
"=",
"RISCVABI",
"::",
"computeTargetABI",
"(",
"TT",
",",
"getFeatureBits",
"(",
")",
",",
"ABIName",
")",
";",
"RISCVFeatures",
"::",
"validate",
"(",
"TT",
",",
"getFeatureBits",
"(",
")",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"\"generic\"",
"\"generic-rv64\"",
"\"generic-rv32\"",
"MVT::i64",
"64",
"RISCVABI::computeTargetABI",
"RISCVFeatures::validate"
] | RISCVSubtarget10 | initializeSubtargetDependencies | RISCV | CPU | LLVM | 24,658 | 121 | 1 | [] |
[
"<s>",
"SDValue",
"P2TargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MachineFrameInfo",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"LLVM_DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"=== Lower Return: \"",
";",
"MF",
".",
"dump",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_P2",
")",
";",
"SDValue",
"Flag",
";",
"SmallVector",
"<",
"SDValue",
",",
"4",
">",
"RetOps",
"(",
"1",
",",
"Chain",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"SDValue",
"Val",
"=",
"OutVals",
"[",
"i",
"]",
";",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"if",
"(",
"!",
"VA",
".",
"isRegLoc",
"(",
")",
")",
"continue",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
"!=",
"RVLocs",
"[",
"i",
"]",
".",
"getLocVT",
"(",
")",
")",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocVT",
"(",
")",
",",
"Val",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasStructRetAttr",
"(",
")",
")",
"{",
"P2FunctionInfo",
"*",
"P2FI",
"=",
"MF",
".",
"getInfo",
"<",
"P2FunctionInfo",
">",
"(",
")",
";",
"unsigned",
"reg",
"=",
"P2FI",
"->",
"getSRetReturnReg",
"(",
")",
";",
"if",
"(",
"!",
"reg",
")",
"llvm_unreachable",
"(",
"\"sret virtual register not created in entry block\"",
")",
";",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"reg",
",",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
")",
";",
"unsigned",
"R15",
"=",
"P2",
"::",
"R15",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"R15",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"R15",
",",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
")",
")",
";",
"}",
"RetOps",
"[",
"0",
"]",
"=",
"Chain",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"RetOps",
".",
"push_back",
"(",
"Flag",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"P2ISD",
"::",
"RET",
",",
"DL",
",",
"MVT",
"::",
"Other",
",",
"RetOps",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"P2",
"P2",
"ISD::OutputArg",
"16",
"\"=== Lower Return: \"",
"P2",
"4",
"1",
"0",
"\"Can only return in registers!\"",
"ISD::BITCAST",
"1",
"P2",
"P2",
"P2",
"P2",
"\"sret virtual register not created in entry block\"",
"P2::R15",
"1",
"0",
"P2ISD::RET",
"MVT::Other"
] | P2ISelLowering | LowerReturn | P2 | MPU | LLVM | 24,659 | 450 | 1 | [] |
[
"<s>",
"void",
"X86RegisterInfo",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"if",
"(",
"!",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"uint64_t",
"Amount",
"=",
"Old",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"Amount",
"=",
"(",
"Amount",
"+",
"StackAlign",
"-",
"1",
")",
"/",
"StackAlign",
"*",
"StackAlign",
";",
"MachineInstr",
"*",
"New",
"=",
"0",
";",
"if",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"getCallFrameSetupOpcode",
"(",
")",
")",
"{",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Is64Bit",
"?",
"X86",
"::",
"SUB64ri32",
":",
"X86",
"::",
"SUB32ri",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"getCallFrameDestroyOpcode",
"(",
")",
")",
";",
"uint64_t",
"CalleeAmt",
"=",
"Old",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"Amount",
"-=",
"CalleeAmt",
";",
"if",
"(",
"Amount",
")",
"{",
"unsigned",
"Opc",
"=",
"(",
"Amount",
"<",
"128",
")",
"?",
"(",
"Is64Bit",
"?",
"X86",
"::",
"ADD64ri8",
":",
"X86",
"::",
"ADD32ri8",
")",
":",
"(",
"Is64Bit",
"?",
"X86",
"::",
"ADD64ri32",
":",
"X86",
"::",
"ADD32ri",
")",
";",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"}",
"if",
"(",
"New",
")",
"{",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"getCallFrameDestroyOpcode",
"(",
")",
")",
"{",
"if",
"(",
"uint64_t",
"CalleeAmt",
"=",
"I",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
")",
"{",
"unsigned",
"Opc",
"=",
"(",
"CalleeAmt",
"<",
"128",
")",
"?",
"(",
"Is64Bit",
"?",
"X86",
"::",
"SUB64ri8",
":",
"X86",
"::",
"SUB32ri8",
")",
":",
"(",
"Is64Bit",
"?",
"X86",
"::",
"SUB64ri32",
":",
"X86",
"::",
"SUB32ri",
")",
";",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"MachineInstr",
"*",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"CalleeAmt",
")",
";",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"}",
"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",
")",
"."
] | [
"X86",
"X86",
"0",
"0",
"1",
"0",
"X86::SUB64ri32",
"X86::SUB32ri",
"1",
"128",
"X86::ADD64ri8",
"X86::ADD32ri8",
"X86::ADD64ri32",
"X86::ADD32ri",
"3",
"1",
"128",
"X86::SUB64ri8",
"X86::SUB32ri8",
"X86::SUB64ri32",
"X86::SUB32ri",
"3"
] | X86RegisterInfo11 | eliminateCallFramePseudoInstr | X86 | CPU | LLVM | 24,660 | 397 | 1 | [] |
[
"<s>",
"void",
"A57ChainingConstraint",
"::",
"apply",
"(",
"PBQPRAGraph",
"&",
"G",
")",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"G",
".",
"getMetadata",
"(",
")",
".",
"MF",
";",
"LiveIntervals",
"&",
"LIs",
"=",
"G",
".",
"getMetadata",
"(",
")",
".",
"LIS",
";",
"TRI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"LLVM_DEBUG",
"(",
"MF",
".",
"dump",
"(",
")",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"MBB",
":",
"MF",
")",
"{",
"Chains",
".",
"clear",
"(",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"MI",
":",
"MBB",
")",
"{",
"for",
"(",
"auto",
"r",
":",
"Chains",
")",
"{",
"SmallVector",
"<",
"unsigned",
",",
"8",
">",
"toDel",
";",
"if",
"(",
"regJustKilledBefore",
"(",
"LIs",
",",
"r",
",",
"MI",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Killing chain \"",
"<<",
"printReg",
"(",
"r",
",",
"TRI",
")",
"<<",
"\" at \"",
";",
"MI",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
";",
")",
";",
"toDel",
".",
"push_back",
"(",
"r",
")",
";",
"}",
"while",
"(",
"!",
"toDel",
".",
"empty",
"(",
")",
")",
"{",
"Chains",
".",
"remove",
"(",
"toDel",
".",
"back",
"(",
")",
")",
";",
"toDel",
".",
"pop_back",
"(",
")",
";",
"}",
"}",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AArch64",
"::",
"FMSUBSrrr",
":",
"case",
"AArch64",
"::",
"FMADDSrrr",
":",
"case",
"AArch64",
"::",
"FNMSUBSrrr",
":",
"case",
"AArch64",
"::",
"FNMADDSrrr",
":",
"case",
"AArch64",
"::",
"FMSUBDrrr",
":",
"case",
"AArch64",
"::",
"FMADDDrrr",
":",
"case",
"AArch64",
"::",
"FNMSUBDrrr",
":",
"case",
"AArch64",
"::",
"FNMADDDrrr",
":",
"{",
"unsigned",
"Rd",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"Ra",
"=",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"addIntraChainConstraint",
"(",
"G",
",",
"Rd",
",",
"Ra",
")",
")",
"addInterChainConstraint",
"(",
"G",
",",
"Rd",
",",
"Ra",
")",
";",
"break",
";",
"}",
"case",
"AArch64",
"::",
"FMLAv2f32",
":",
"case",
"AArch64",
"::",
"FMLSv2f32",
":",
"{",
"unsigned",
"Rd",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"addInterChainConstraint",
"(",
"G",
",",
"Rd",
",",
"Rd",
")",
";",
"break",
";",
"}",
"default",
":",
"break",
";",
"}",
"}",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"profile",
"inference",
"algorithm",
"for",
"a",
"given",
"function",
"."
] | [
"AArch64",
"8",
"\"Killing chain \"",
"\" at \"",
"AArch64::FMSUBSrrr",
"AArch64::FMADDSrrr",
"AArch64::FNMSUBSrrr",
"AArch64::FNMADDSrrr",
"AArch64::FMSUBDrrr",
"AArch64::FMADDDrrr",
"AArch64::FNMSUBDrrr",
"AArch64::FNMADDDrrr",
"0",
"3",
"AArch64::FMLAv2f32",
"AArch64::FMLSv2f32",
"0"
] | AArch64PBQPRegAlloc14 | apply | AArch64 | CPU | LLVM | 24,661 | 321 | 1 | [] |
[
"<s>",
"static",
"rtx",
"restore_fpr",
"(",
"rtx",
"base",
",",
"int",
"offset",
",",
"int",
"regnum",
")",
"{",
"rtx",
"addr",
";",
"addr",
"=",
"gen_rtx_MEM",
"(",
"DFmode",
",",
"plus_constant",
"(",
"base",
",",
"offset",
")",
")",
";",
"set_mem_alias_set",
"(",
"addr",
",",
"get_frame_alias_set",
"(",
")",
")",
";",
"return",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"DFmode",
",",
"regnum",
")",
",",
"addr",
")",
";",
"}",
"</s>"
] | [
"Emit",
"insn",
"to",
"restore",
"fpr",
"REGNUM",
"from",
"offset",
"OFFSET",
"relative",
"to",
"register",
"BASE",
".",
"Return",
"generated",
"insn",
"."
] | [
"s390"
] | s3903 | restore_fpr | s390 | MPU | GCC | 24,662 | 54 | 1 | [] |
[
"<s>",
"SDValue",
"SITargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"EVT",
"VT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"AMDGPUTargetLowering",
"::",
"PerformDAGCombine",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"{",
"ConstantSDNode",
"*",
"True",
",",
"*",
"False",
";",
"if",
"(",
"(",
"True",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
"->",
"getOperand",
"(",
"2",
")",
")",
")",
"&&",
"(",
"False",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
"->",
"getOperand",
"(",
"3",
")",
")",
")",
"&&",
"True",
"->",
"isAllOnesValue",
"(",
")",
"&&",
"False",
"->",
"isNullValue",
"(",
")",
"&&",
"VT",
"==",
"MVT",
"::",
"i1",
")",
"{",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SETCC",
",",
"DL",
",",
"VT",
",",
"N",
"->",
"getOperand",
"(",
"0",
")",
",",
"N",
"->",
"getOperand",
"(",
"1",
")",
",",
"N",
"->",
"getOperand",
"(",
"4",
")",
")",
";",
"}",
"break",
";",
"}",
"case",
"ISD",
"::",
"SETCC",
":",
"{",
"SDValue",
"Arg0",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"Arg1",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"SDValue",
"CC",
"=",
"N",
"->",
"getOperand",
"(",
"2",
")",
";",
"ConstantSDNode",
"*",
"C",
"=",
"nullptr",
";",
"ISD",
"::",
"CondCode",
"CCOp",
"=",
"dyn_cast",
"<",
"CondCodeSDNode",
">",
"(",
"CC",
")",
"->",
"get",
"(",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i1",
"&&",
"Arg0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SIGN_EXTEND",
"&&",
"Arg0",
".",
"getOperand",
"(",
"0",
")",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"i1",
"&&",
"(",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Arg1",
")",
")",
"&&",
"C",
"->",
"isNullValue",
"(",
")",
"&&",
"CCOp",
"==",
"ISD",
"::",
"SETNE",
")",
"{",
"return",
"SimplifySetCC",
"(",
"VT",
",",
"Arg0",
".",
"getOperand",
"(",
"0",
")",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"MVT",
"::",
"i1",
")",
",",
"CCOp",
",",
"true",
",",
"DCI",
",",
"DL",
")",
";",
"}",
"break",
";",
"}",
"}",
"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",
"."
] | [
"R600",
"SI",
"0",
"ISD::SELECT_CC",
"2",
"3",
"MVT::i1",
"ISD::SETCC",
"0",
"1",
"4",
"ISD::SETCC",
"0",
"1",
"2",
"ISD::CondCode",
"MVT::i1",
"ISD::SIGN_EXTEND",
"0",
"MVT::i1",
"ISD::SETNE",
"0",
"0",
"MVT::i1"
] | SIISelLowering102 | PerformDAGCombine | R600 | GPU | LLVM | 24,663 | 327 | 1 | [] |
[
"<s>",
"MCRegister",
"ARMElfTargetObjectFile",
"::",
"getStaticBase",
"(",
")",
"const",
"{",
"return",
"ARM",
"::",
"R9",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"used",
"as",
"static",
"base",
"in",
"RWPI",
"variants",
"."
] | [
"ARM",
"ARM",
"ARM::R9"
] | ARMTargetObjectFile11 | getStaticBase | ARM | CPU | LLVM | 24,664 | 14 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"isCoalescableExtInstr",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"&",
"SrcReg",
",",
"unsigned",
"&",
"DstReg",
",",
"unsigned",
"&",
"SubIdx",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"AArch64",
"::",
"SBFMXri",
":",
"case",
"AArch64",
"::",
"UBFMXri",
":",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"!=",
"0",
"||",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
"!=",
"31",
")",
"return",
"false",
";",
"SrcReg",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"DstReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"SubIdx",
"=",
"AArch64",
"::",
"sub_32",
";",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"isCoalescableExtInstr",
"-",
"Return",
"true",
"if",
"the",
"instruction",
"is",
"a",
"``",
"coalescable",
"''",
"extension",
"instruction",
"."
] | [
"AArch64",
"AArch64",
"AArch64::SBFMXri",
"AArch64::UBFMXri",
"2",
"0",
"3",
"31",
"1",
"0",
"AArch64::sub_32"
] | AArch64InstrInfo (2) | isCoalescableExtInstr | AArch64 | CPU | LLVM | 24,665 | 116 | 1 | [] |
[
"<s>",
"void",
"HexagonFrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"bool",
"HasAlloca",
"=",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
";",
"bool",
"NeedsAlign",
"=",
"(",
"MFI",
".",
"getMaxAlign",
"(",
")",
">",
"getStackAlign",
"(",
")",
")",
";",
"if",
"(",
"!",
"HasAlloca",
"||",
"!",
"NeedsAlign",
")",
"return",
";",
"SmallSet",
"<",
"int",
",",
"4",
">",
"DealignSlots",
";",
"unsigned",
"LFS",
"=",
"MFI",
".",
"getLocalFrameSize",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"e",
"=",
"MFI",
".",
"getObjectIndexEnd",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"!",
"MFI",
".",
"isSpillSlotObjectIndex",
"(",
"i",
")",
"||",
"MFI",
".",
"isDeadObjectIndex",
"(",
"i",
")",
")",
"continue",
";",
"unsigned",
"S",
"=",
"MFI",
".",
"getObjectSize",
"(",
"i",
")",
";",
"unsigned",
"A",
"=",
"std",
"::",
"max",
"(",
"MFI",
".",
"getObjectAlignment",
"(",
"i",
")",
",",
"8U",
")",
";",
"MFI",
".",
"setObjectAlignment",
"(",
"i",
",",
"8",
")",
";",
"LFS",
"=",
"alignTo",
"(",
"LFS",
"+",
"S",
",",
"A",
")",
";",
"MFI",
".",
"mapLocalFrameObject",
"(",
"i",
",",
"-",
"static_cast",
"<",
"int64_t",
">",
"(",
"LFS",
")",
")",
";",
"DealignSlots",
".",
"insert",
"(",
"i",
")",
";",
"}",
"MFI",
".",
"setLocalFrameSize",
"(",
"LFS",
")",
";",
"Align",
"A",
"=",
"MFI",
".",
"getLocalFrameMaxAlign",
"(",
")",
";",
"assert",
"(",
"A",
"<=",
"8",
"&&",
"\"Unexpected local frame alignment\"",
")",
";",
"if",
"(",
"A",
"==",
"1",
")",
"MFI",
".",
"setLocalFrameMaxAlign",
"(",
"Align",
"(",
"8",
")",
")",
";",
"MFI",
".",
"setUseLocalStackAllocationBlock",
"(",
"true",
")",
";",
"if",
"(",
"!",
"DealignSlots",
".",
"empty",
"(",
")",
")",
"{",
"for",
"(",
"MachineBasicBlock",
"&",
"BB",
":",
"MF",
")",
"{",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"BB",
")",
"{",
"bool",
"KeepOld",
"=",
"true",
";",
"ArrayRef",
"<",
"MachineMemOperand",
"*",
">",
"memops",
"=",
"MI",
".",
"memoperands",
"(",
")",
";",
"SmallVector",
"<",
"MachineMemOperand",
"*",
",",
"1",
">",
"new_memops",
";",
"for",
"(",
"MachineMemOperand",
"*",
"MMO",
":",
"memops",
")",
"{",
"auto",
"*",
"PV",
"=",
"MMO",
"->",
"getPseudoValue",
"(",
")",
";",
"if",
"(",
"auto",
"*",
"FS",
"=",
"dyn_cast_or_null",
"<",
"FixedStackPseudoSourceValue",
">",
"(",
"PV",
")",
")",
"{",
"int",
"FI",
"=",
"FS",
"->",
"getFrameIndex",
"(",
")",
";",
"if",
"(",
"DealignSlots",
".",
"count",
"(",
"FI",
")",
")",
"{",
"unsigned",
"A",
"=",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
";",
"auto",
"*",
"NewMMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MMO",
"->",
"getPointerInfo",
"(",
")",
",",
"MMO",
"->",
"getFlags",
"(",
")",
",",
"MMO",
"->",
"getSize",
"(",
")",
",",
"A",
",",
"MMO",
"->",
"getAAInfo",
"(",
")",
",",
"MMO",
"->",
"getRanges",
"(",
")",
",",
"MMO",
"->",
"getSyncScopeID",
"(",
")",
",",
"MMO",
"->",
"getOrdering",
"(",
")",
",",
"MMO",
"->",
"getFailureOrdering",
"(",
")",
")",
";",
"new_memops",
".",
"push_back",
"(",
"NewMMO",
")",
";",
"KeepOld",
"=",
"false",
";",
"continue",
";",
"}",
"}",
"new_memops",
".",
"push_back",
"(",
"MMO",
")",
";",
"}",
"if",
"(",
"!",
"KeepOld",
")",
"MI",
".",
"setMemRefs",
"(",
"MF",
",",
"new_memops",
")",
";",
"}",
"}",
"}",
"unsigned",
"AP",
"=",
"0",
";",
"if",
"(",
"const",
"MachineInstr",
"*",
"AI",
"=",
"getAlignaInstr",
"(",
"MF",
")",
")",
"AP",
"=",
"AI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"auto",
"&",
"HMFI",
"=",
"*",
"MF",
".",
"getInfo",
"<",
"HexagonMachineFunctionInfo",
">",
"(",
")",
";",
"HMFI",
".",
"setStackAlignBasePhysReg",
"(",
"AP",
")",
";",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"Hexagon",
"Hexagon",
"4",
"0",
"8U",
"8",
"8",
"\"Unexpected local frame alignment\"",
"1",
"8",
"1",
"0",
"0",
"Hexagon"
] | HexagonFrameLowering38 | processFunctionBeforeFrameFinalized | Hexagon | DSP | LLVM | 24,666 | 506 | 1 | [] |
[
"<s>",
"bool",
"EvexToVexInstPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"X86Subtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"if",
"(",
"!",
"ST",
".",
"hasAVX512",
"(",
")",
")",
"return",
"false",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"MBB",
")",
"Changed",
"|=",
"CompressEvexToVexImpl",
"(",
"MI",
")",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86"
] | X86EvexToVex | runOnMachineFunction | X86 | CPU | LLVM | 24,667 | 85 | 1 | [] |
[
"<s>",
"DecodeStatus",
"MOSDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"Instr",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"CStream",
")",
"const",
"{",
"Size",
"=",
"0",
";",
"if",
"(",
"Has65816",
")",
"{",
"if",
"(",
"(",
"MLow",
"||",
"XLow",
")",
"&&",
"Bytes",
".",
"size",
"(",
")",
">=",
"3",
")",
"{",
"uint32_t",
"Insn",
"=",
"0",
";",
"DecodeStatus",
"Result",
"=",
"MCDisassembler",
"::",
"Fail",
";",
"for",
"(",
"size_t",
"Byte",
":",
"seq",
"(",
"0",
",",
"3",
")",
")",
"{",
"Insn",
"|=",
"Bytes",
"[",
"Byte",
"]",
"<<",
"(",
"8",
"*",
"Byte",
")",
";",
"}",
"if",
"(",
"MLow",
")",
"{",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTableMOSMLow24",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"}",
"if",
"(",
"Result",
"==",
"MCDisassembler",
"::",
"Fail",
"&&",
"XLow",
")",
"{",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTableMOSXLow24",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"}",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"{",
"MCOperand",
"&",
"Op",
"=",
"Instr",
".",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"(",
"uint64_t",
")",
"Op",
".",
"getImm",
"(",
")",
"<=",
"UCHAR_MAX",
")",
"{",
"Op",
"=",
"MCOperand",
"::",
"createExpr",
"(",
"MOSMCExpr",
"::",
"create",
"(",
"MOSMCExpr",
"::",
"VK_MOS_IMM16",
",",
"MCConstantExpr",
"::",
"create",
"(",
"Op",
".",
"getImm",
"(",
")",
",",
"getContext",
"(",
")",
")",
",",
"false",
",",
"getContext",
"(",
")",
")",
")",
";",
"}",
"Size",
"=",
"3",
";",
"return",
"Result",
";",
"}",
"}",
"}",
"for",
"(",
"size_t",
"InsnSize",
":",
"seq_inclusive",
"(",
"1",
",",
"4",
")",
")",
"{",
"uint32_t",
"Insn",
"=",
"0",
";",
"DecodeStatus",
"Result",
";",
"if",
"(",
"Bytes",
".",
"size",
"(",
")",
"<",
"InsnSize",
")",
"{",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"for",
"(",
"size_t",
"Byte",
":",
"seq",
"(",
"(",
"size_t",
")",
"0",
",",
"InsnSize",
")",
")",
"{",
"Insn",
"|=",
"Bytes",
"[",
"Byte",
"]",
"<<",
"(",
"8",
"*",
"Byte",
")",
";",
"}",
"Result",
"=",
"decodeInstruction",
"(",
"getDecoderTable",
"(",
"InsnSize",
")",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"{",
"Size",
"=",
"InsnSize",
";",
"return",
"Result",
";",
"}",
"}",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"MOS",
"MOS",
"0",
"3",
"0",
"0",
"3",
"8",
"MOS",
"MOS",
"0",
"MOS",
"MOS",
"MOS",
"3",
"1",
"4",
"0",
"0",
"8"
] | MOSDisassembler | getInstruction | MOS | MPU | LLVM | 24,668 | 339 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"cris_hard_regno_nregs",
"(",
"unsigned",
"int",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"return",
"1",
";",
"return",
"CEIL",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
",",
"UNITS_PER_WORD",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_HARD_REGNO_NREGS",
".",
"The",
"VOIDmode",
"test",
"is",
"so",
"we",
"can",
"omit",
"mode",
"on",
"anonymous",
"insns",
".",
"FIXME",
":",
"Still",
"needed",
"in",
"2.9x",
",",
"at",
"least",
"for",
"Axis-20000319",
"."
] | [
"cris",
"1"
] | cris | cris_hard_regno_nregs | cris | MPU | GCC | 24,669 | 33 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"VETargetLowering",
"::",
"shouldExpandAtomicRMWInIR",
"(",
"AtomicRMWInst",
"*",
"AI",
")",
"const",
"{",
"if",
"(",
"AI",
"->",
"getOperation",
"(",
")",
"==",
"AtomicRMWInst",
"::",
"Xchg",
")",
"{",
"return",
"AtomicExpansionKind",
"::",
"None",
";",
"}",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"IR-level",
"AtomicExpand",
"pass",
"should",
"expand",
"the",
"given",
"AtomicRMW",
",",
"if",
"at",
"all",
"."
] | [
"VE",
"VE"
] | VEISelLowering11 | shouldExpandAtomicRMWInIR | VE | CPU | LLVM | 24,670 | 38 | 1 | [] |
[
"<s>",
"void",
"ix86_emit_i387_cosh",
"(",
"rtx",
"op0",
",",
"rtx",
"op1",
")",
"{",
"rtx",
"e1",
"=",
"gen_reg_rtx",
"(",
"XFmode",
")",
";",
"rtx",
"e2",
"=",
"gen_reg_rtx",
"(",
"XFmode",
")",
";",
"rtx",
"half",
"=",
"const_double_from_real_value",
"(",
"dconsthalf",
",",
"XFmode",
")",
";",
"rtx",
"cst1",
";",
"emit_insn",
"(",
"gen_expxf2",
"(",
"e1",
",",
"op1",
")",
")",
";",
"cst1",
"=",
"force_reg",
"(",
"XFmode",
",",
"CONST1_RTX",
"(",
"XFmode",
")",
")",
";",
"emit_insn",
"(",
"gen_divxf3",
"(",
"e2",
",",
"cst1",
",",
"e1",
")",
")",
";",
"emit_insn",
"(",
"gen_addxf3",
"(",
"e2",
",",
"e1",
",",
"e2",
")",
")",
";",
"half",
"=",
"force_reg",
"(",
"XFmode",
",",
"half",
")",
";",
"emit_insn",
"(",
"gen_mulxf3",
"(",
"op0",
",",
"e2",
",",
"half",
")",
")",
";",
"}",
"</s>"
] | [
"Output",
"code",
"to",
"perform",
"an",
"cosh",
"XFmode",
"calculation",
"."
] | [
"i386"
] | i386-expand | ix86_emit_i387_cosh | i386 | CPU | GCC | 24,671 | 107 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_movw_imm",
"(",
"HOST_WIDE_INT",
"val",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
">",
"4",
")",
"{",
"if",
"(",
"(",
"val",
"&",
"(",
"(",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
")",
"<<",
"32",
")",
")",
"==",
"val",
"||",
"(",
"val",
"&",
"(",
"(",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
")",
"<<",
"48",
")",
")",
"==",
"val",
")",
"return",
"1",
";",
"}",
"else",
"{",
"val",
"&=",
"(",
"HOST_WIDE_INT",
")",
"0xffffffff",
";",
"}",
"return",
"(",
"(",
"val",
"&",
"(",
"(",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
")",
"<<",
"0",
")",
")",
"==",
"val",
"||",
"(",
"val",
"&",
"(",
"(",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
")",
"<<",
"16",
")",
")",
"==",
"val",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"val",
"is",
"an",
"immediate",
"that",
"can",
"be",
"loaded",
"into",
"a",
"register",
"by",
"a",
"MOVZ",
"instruction",
"."
] | [
"aarch64",
"4",
"0xffff",
"32",
"0xffff",
"48",
"1",
"0xffffffff",
"0xffff",
"0",
"0xffff",
"16"
] | aarch642 | aarch64_movw_imm | aarch64 | CPU | GCC | 24,672 | 109 | 1 | [] |
[
"<s>",
"void",
"TVMAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"EmitInstruction: \"",
"<<",
"*",
"MI",
"<<",
"'\\n'",
")",
";",
"if",
"(",
"isVerbose",
"(",
")",
")",
"for",
"(",
"auto",
"Comment",
":",
"MFI",
"->",
"getStackModelComments",
"(",
"MI",
")",
")",
"{",
"OutStreamer",
"->",
"AddComment",
"(",
"Comment",
")",
";",
"}",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"TVM",
"::",
"ARGUMENT",
":",
"case",
"TVM",
"::",
"ARGUMENT_SLICE",
":",
"case",
"TVM",
"::",
"ARGUMENT_BUILDER",
":",
"case",
"TVM",
"::",
"ARGUMENT_CELL",
":",
"case",
"TVM",
"::",
"ARGUMENT_TUPLE",
":",
"llvm_unreachable",
"(",
"\"CG only instruction mustn't reach ASM printer\"",
")",
";",
"break",
";",
"case",
"TVM",
"::",
"REG_TO_REG_COPY_S",
":",
"case",
"TVM",
"::",
"TO_TUPLE_COPY_S",
":",
"case",
"TVM",
"::",
"TO_SLICE_COPY_S",
":",
"case",
"TVM",
"::",
"TO_BUILDER_COPY_S",
":",
"case",
"TVM",
"::",
"TO_CELL_COPY_S",
":",
"case",
"TVM",
"::",
"FROM_TUPLE_COPY_S",
":",
"case",
"TVM",
"::",
"FROM_SLICE_COPY_S",
":",
"case",
"TVM",
"::",
"FROM_BUILDER_COPY_S",
":",
"case",
"TVM",
"::",
"FROM_CELL_COPY_S",
":",
"break",
";",
"case",
"TVM",
"::",
"FALLTHROUGH_RETURN",
":",
"if",
"(",
"isVerbose",
"(",
")",
")",
"{",
"OutStreamer",
"->",
"AddComment",
"(",
"\"fallthrough return\"",
")",
";",
"OutStreamer",
"->",
"AddBlankLine",
"(",
")",
";",
"}",
"break",
";",
"default",
":",
"TVMMCInstLower",
"MCInstLowering",
"(",
"OutContext",
",",
"*",
"this",
")",
";",
"MCInst",
"TmpInst",
";",
"MCInstLowering",
".",
"lower",
"(",
"MI",
",",
"TmpInst",
")",
";",
"OutStreamer",
"->",
"GetOS",
"(",
")",
"<<",
"\"\\t\"",
";",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"TmpInst",
")",
";",
"if",
"(",
"TmpInst",
".",
"getOpcode",
"(",
")",
"==",
"TVM",
"::",
"PUSHCONT_MBB_S",
")",
"{",
"EmitSubBlockForPushcont",
"(",
"MCInstLowering",
",",
"TmpInst",
",",
"0",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"TVM",
"TVM",
"\"EmitInstruction: \"",
"TVM::ARGUMENT",
"TVM::ARGUMENT_SLICE",
"TVM::ARGUMENT_BUILDER",
"TVM::ARGUMENT_CELL",
"TVM::ARGUMENT_TUPLE",
"\"CG only instruction mustn't reach ASM printer\"",
"TVM::REG_TO_REG_COPY_S",
"TVM::TO_TUPLE_COPY_S",
"TVM::TO_SLICE_COPY_S",
"TVM::TO_BUILDER_COPY_S",
"TVM::TO_CELL_COPY_S",
"TVM::FROM_TUPLE_COPY_S",
"TVM::FROM_SLICE_COPY_S",
"TVM::FROM_BUILDER_COPY_S",
"TVM::FROM_CELL_COPY_S",
"TVM::FALLTHROUGH_RETURN",
"\"fallthrough return\"",
"TVM",
"\"\\t\"",
"TVM::PUSHCONT_MBB_S",
"0"
] | TVMAsmPrinter | EmitInstruction | TVM | Virtual ISA | LLVM | 24,673 | 232 | 1 | [] |
[
"<s>",
"static",
"int",
"scavenge_reg",
"(",
"HARD_REG_SET",
"*",
"s",
")",
"{",
"for",
"(",
"int",
"r",
"=",
"FIRST_GENERAL_REG",
";",
"r",
"<=",
"LAST_GENERAL_REG",
";",
"r",
"++",
")",
"if",
"(",
"TEST_HARD_REG_BIT",
"(",
"*",
"s",
",",
"r",
")",
")",
"return",
"r",
";",
"return",
"-",
"1",
";",
"}",
"</s>"
] | [
"Find",
"the",
"number",
"of",
"a",
"general",
"purpose",
"register",
"in",
"S",
"."
] | [
"sh",
"1"
] | sh | scavenge_reg | sh | CPU | GCC | 24,674 | 41 | 1 | [] |
[
"<s>",
"BitVector",
"SystemZRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R11D",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R14D",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R15D",
")",
";",
"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",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ::R11D",
"SystemZ::R14D",
"SystemZ::R15D"
] | SystemZRegisterInfo13 | getReservedRegs | SystemZ | CPU | LLVM | 24,675 | 58 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"getPointerRegClass",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"unsigned",
"Kind",
"=",
"0",
")",
"const",
"override",
"{",
"return",
"&",
"LoongArch",
"::",
"GPRRegClass",
";",
"}",
"</s>"
] | [
"getPointerRegClass",
"-",
"Returns",
"a",
"TargetRegisterClass",
"used",
"for",
"pointer",
"values",
"."
] | [
"LoongArch",
"0",
"LoongArch::GPRRegClass"
] | LoongArchRegisterInfo | getPointerRegClass | LoongArch | CPU | LLVM | 24,676 | 25 | 1 | [] |
[
"<s>",
"static",
"int",
"ia64_speculate_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"ds_t",
"ts",
",",
"rtx",
"*",
"new_pat",
")",
"{",
"int",
"mode_no",
";",
"int",
"res",
";",
"gcc_assert",
"(",
"!",
"(",
"ts",
"&",
"~",
"SPECULATIVE",
")",
")",
";",
"if",
"(",
"ia64_spec_check_p",
"(",
"insn",
")",
")",
"return",
"-",
"1",
";",
"if",
"(",
"(",
"ts",
"&",
"BE_IN_SPEC",
")",
"&&",
"!",
"insn_can_be_in_speculative_p",
"(",
"insn",
",",
"ts",
")",
")",
"return",
"-",
"1",
";",
"mode_no",
"=",
"get_mode_no_for_insn",
"(",
"insn",
")",
";",
"if",
"(",
"mode_no",
"!=",
"SPEC_MODE_INVALID",
")",
"{",
"if",
"(",
"ia64_get_insn_spec_ds",
"(",
"insn",
")",
"==",
"ds_get_speculation_types",
"(",
"ts",
")",
")",
"res",
"=",
"0",
";",
"else",
"{",
"res",
"=",
"1",
";",
"*",
"new_pat",
"=",
"ia64_gen_spec_load",
"(",
"insn",
",",
"ts",
",",
"mode_no",
")",
";",
"}",
"}",
"else",
"res",
"=",
"-",
"1",
";",
"return",
"res",
";",
"}",
"</s>"
] | [
"Implement",
"targetm.sched.speculate_insn",
"hook",
".",
"Check",
"if",
"the",
"INSN",
"can",
"be",
"TS",
"speculative",
".",
"If",
"'no",
"'",
"-",
"return",
"-1",
".",
"If",
"'yes",
"'",
"-",
"generate",
"speculative",
"pattern",
"in",
"the",
"NEW_PAT",
"and",
"return",
"1",
".",
"If",
"current",
"pattern",
"of",
"the",
"INSN",
"already",
"provides",
"TS",
"speculation",
",",
"return",
"0",
"."
] | [
"ia64",
"1",
"1",
"0",
"1",
"1"
] | ia64 | ia64_speculate_insn | ia64 | CPU | GCC | 24,677 | 124 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"MSP430 Branch Selector\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"MSP430",
"\"MSP430 Branch Selector\""
] | MSP430BranchSelector12 | getPassName | MSP430 | MPU | LLVM | 24,678 | 13 | 1 | [] |
[
"<s>",
"static",
"void",
"const_double_split",
"(",
"rtx",
"x",
",",
"HOST_WIDE_INT",
"*",
"p_high",
",",
"HOST_WIDE_INT",
"*",
"p_low",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_DOUBLE",
")",
"{",
"long",
"t",
"[",
"2",
"]",
";",
"REAL_VALUE_TYPE",
"rv",
";",
"switch",
"(",
"GET_MODE",
"(",
"x",
")",
")",
"{",
"case",
"DFmode",
":",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"rv",
",",
"x",
")",
";",
"REAL_VALUE_TO_TARGET_DOUBLE",
"(",
"rv",
",",
"t",
")",
";",
"*",
"p_high",
"=",
"t",
"[",
"1",
"]",
";",
"*",
"p_low",
"=",
"t",
"[",
"0",
"]",
";",
"return",
";",
"case",
"SFmode",
":",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"rv",
",",
"x",
")",
";",
"REAL_VALUE_TO_TARGET_SINGLE",
"(",
"rv",
",",
"*",
"p_high",
")",
";",
"*",
"p_low",
"=",
"0",
";",
"return",
";",
"case",
"VOIDmode",
":",
"case",
"DImode",
":",
"*",
"p_high",
"=",
"CONST_DOUBLE_HIGH",
"(",
"x",
")",
";",
"*",
"p_low",
"=",
"CONST_DOUBLE_LOW",
"(",
"x",
")",
";",
"return",
";",
"default",
":",
"break",
";",
"}",
"}",
"fatal_insn",
"(",
"\"const_double_split got a bad insn:\"",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"high",
"and",
"low",
"words",
"of",
"a",
"CONST_DOUBLE"
] | [
"v850",
"2",
"1",
"0",
"0",
"\"const_double_split got a bad insn:\""
] | v8503 | const_double_split | v850 | MPU | GCC | 24,679 | 141 | 1 | [] |
[
"<s>",
"bool",
"PIC16TargetMachine",
"::",
"addPreEmitPass",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"PM",
".",
"add",
"(",
"createPIC16MemSelOptimizerPass",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"PIC16",
"PIC16",
"PIC16"
] | PIC16TargetMachine | addPreEmitPass | PIC16 | MPU | LLVM | 24,680 | 28 | 1 | [] |
[
"<s>",
"bool",
"MSP430RegisterInfo",
"::",
"hasReservedCallFrame",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"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",
"."
] | [
"MSP430",
"MSP430"
] | MSP430RegisterInfo10 | hasReservedCallFrame | MSP430 | MPU | LLVM | 24,681 | 25 | 1 | [] |
[
"<s>",
"static",
"void",
"expand_set_cint32",
"(",
"rtx",
"dest_reg",
",",
"rtx",
"src_val",
")",
"{",
"HOST_WIDE_INT",
"val",
";",
"int",
"leading_zeroes",
",",
"trailing_zeroes",
";",
"int",
"lower",
",",
"upper",
";",
"int",
"three_wide_only",
";",
"rtx",
"temp",
";",
"gcc_assert",
"(",
"CONST_INT_P",
"(",
"src_val",
")",
")",
";",
"val",
"=",
"trunc_int_for_mode",
"(",
"INTVAL",
"(",
"src_val",
")",
",",
"SImode",
")",
";",
"if",
"(",
"expand_set_cint32_one_inst",
"(",
"dest_reg",
",",
"val",
",",
"false",
")",
")",
"return",
";",
"temp",
"=",
"create_temp_reg_if_possible",
"(",
"SImode",
",",
"dest_reg",
")",
";",
"leading_zeroes",
"=",
"31",
"-",
"floor_log2",
"(",
"val",
"&",
"0xFFFFFFFF",
")",
";",
"trailing_zeroes",
"=",
"exact_log2",
"(",
"val",
"&",
"-",
"val",
")",
";",
"lower",
"=",
"trunc_int_for_mode",
"(",
"val",
",",
"HImode",
")",
";",
"upper",
"=",
"trunc_int_for_mode",
"(",
"(",
"val",
"-",
"lower",
")",
">>",
"16",
",",
"HImode",
")",
";",
"for",
"(",
"three_wide_only",
"=",
"1",
";",
"three_wide_only",
">=",
"0",
";",
"three_wide_only",
"--",
")",
"{",
"int",
"count",
";",
"if",
"(",
"expand_set_cint32_one_inst",
"(",
"temp",
",",
"val",
">>",
"trailing_zeroes",
",",
"three_wide_only",
")",
")",
"{",
"emit_move_insn",
"(",
"dest_reg",
",",
"gen_rtx_ASHIFT",
"(",
"SImode",
",",
"temp",
",",
"GEN_INT",
"(",
"trailing_zeroes",
")",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"expand_set_cint32_one_inst",
"(",
"temp",
",",
"val",
"<<",
"leading_zeroes",
",",
"three_wide_only",
")",
")",
"{",
"emit_move_insn",
"(",
"dest_reg",
",",
"gen_rtx_LSHIFTRT",
"(",
"SImode",
",",
"temp",
",",
"GEN_INT",
"(",
"leading_zeroes",
")",
")",
")",
";",
"return",
";",
"}",
"for",
"(",
"count",
"=",
"1",
";",
"count",
"<",
"32",
";",
"count",
"++",
")",
"{",
"HOST_WIDE_INT",
"r",
"=",
"rotate_right",
"(",
"val",
",",
"count",
")",
";",
"if",
"(",
"expand_set_cint32_one_inst",
"(",
"temp",
",",
"r",
",",
"three_wide_only",
")",
")",
"{",
"emit_move_insn",
"(",
"dest_reg",
",",
"gen_rtx_ROTATE",
"(",
"SImode",
",",
"temp",
",",
"GEN_INT",
"(",
"count",
")",
")",
")",
";",
"return",
";",
"}",
"}",
"if",
"(",
"lower",
"==",
"trunc_int_for_mode",
"(",
"lower",
",",
"QImode",
")",
")",
"{",
"break",
";",
"}",
"}",
"emit_move_insn",
"(",
"temp",
",",
"GEN_INT",
"(",
"upper",
"<<",
"16",
")",
")",
";",
"emit_move_insn",
"(",
"dest_reg",
",",
"(",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"temp",
",",
"GEN_INT",
"(",
"lower",
")",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Create",
"code",
"to",
"move",
"the",
"CONST_INT",
"value",
"in",
"src_val",
"to",
"dest_reg",
"."
] | [
"tilepro",
"31",
"0xFFFFFFFF",
"16",
"1",
"0",
"1",
"32",
"16"
] | tilepro | expand_set_cint32 | tilepro | VLIW | GCC | 24,682 | 307 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_vector_duplicate_value",
"(",
"machine_mode",
"mode",
",",
"rtx",
"target",
",",
"rtx",
"val",
")",
"{",
"bool",
"ok",
";",
"rtx_insn",
"*",
"insn",
";",
"rtx",
"dup",
";",
"dup",
"=",
"gen_rtx_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",
")",
";",
"XEXP",
"(",
"dup",
",",
"0",
")",
"=",
"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",
"0"
] | i3866 | ix86_vector_duplicate_value | i386 | CPU | GCC | 24,683 | 150 | 1 | [] |
[
"<s>",
"static",
"bool",
"loongarch_cannot_force_const_mem",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
")",
"{",
"enum",
"loongarch_symbol_type",
"type",
";",
"rtx",
"base",
",",
"offset",
";",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
"&&",
"loongarch_legitimate_constant_p",
"(",
"mode",
",",
"x",
")",
")",
"return",
"true",
";",
"split_const",
"(",
"x",
",",
"&",
"base",
",",
"&",
"offset",
")",
";",
"if",
"(",
"loongarch_symbolic_constant_p",
"(",
"base",
",",
"&",
"type",
")",
")",
"{",
"if",
"(",
"IMM12_INT",
"(",
"offset",
")",
"&&",
"loongarch_symbol_insns",
"(",
"type",
",",
"MAX_MACHINE_MODE",
")",
">",
"0",
")",
"return",
"true",
";",
"}",
"if",
"(",
"tls_referenced_p",
"(",
"x",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CANNOT_FORCE_CONST_MEM",
"."
] | [
"loongarch",
"0"
] | loongarch | loongarch_cannot_force_const_mem | loongarch | CPU | GCC | 24,684 | 93 | 1 | [] |
[
"<s>",
"bool",
"SIRegisterInfo",
"::",
"isConstantPhysReg",
"(",
"MCRegister",
"PhysReg",
")",
"const",
"{",
"switch",
"(",
"PhysReg",
")",
"{",
"case",
"AMDGPU",
"::",
"SGPR_NULL",
":",
"case",
"AMDGPU",
"::",
"SRC_SHARED_BASE",
":",
"case",
"AMDGPU",
"::",
"SRC_PRIVATE_BASE",
":",
"case",
"AMDGPU",
"::",
"SRC_SHARED_LIMIT",
":",
"case",
"AMDGPU",
"::",
"SRC_PRIVATE_LIMIT",
":",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"PhysReg",
"is",
"unallocatable",
"and",
"constant",
"throughout",
"the",
"function",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::SGPR_NULL",
"AMDGPU::SRC_SHARED_BASE",
"AMDGPU::SRC_PRIVATE_BASE",
"AMDGPU::SRC_SHARED_LIMIT",
"AMDGPU::SRC_PRIVATE_LIMIT"
] | SIRegisterInfo (3) | isConstantPhysReg | AMDGPU | GPU | LLVM | 24,685 | 50 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"buildOutlinedFrame",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineFunction",
"&",
"MF",
",",
"const",
"outliner",
"::",
"OutlinedFunction",
"&",
"OF",
")",
"const",
"{",
"if",
"(",
"OF",
".",
"FrameConstructionID",
"==",
"MachineOutlinerTailCall",
")",
"return",
";",
"MachineInstr",
"*",
"retq",
"=",
"BuildMI",
"(",
"MF",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"RETQ",
")",
")",
";",
"MBB",
".",
"insert",
"(",
"MBB",
".",
"end",
"(",
")",
",",
"retq",
")",
";",
"}",
"</s>"
] | [
"Insert",
"a",
"custom",
"frame",
"for",
"outlined",
"functions",
"."
] | [
"X86",
"X86",
"X86::RETQ"
] | X86InstrInfo (2)3 | buildOutlinedFrame | X86 | CPU | LLVM | 24,686 | 66 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"PPCRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"if",
"(",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"AnyReg",
")",
"{",
"if",
"(",
"Subtarget",
".",
"hasVSX",
"(",
")",
")",
"return",
"CSR_64_AllRegs_VSX_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
")",
"return",
"CSR_64_AllRegs_Altivec_SaveList",
";",
"return",
"CSR_64_AllRegs_SaveList",
";",
"}",
"if",
"(",
"Subtarget",
".",
"isDarwinABI",
"(",
")",
")",
"return",
"Subtarget",
".",
"isPPC64",
"(",
")",
"?",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"CSR_Darwin64_Altivec_SaveList",
":",
"CSR_Darwin64_SaveList",
")",
":",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"CSR_Darwin32_Altivec_SaveList",
":",
"CSR_Darwin32_SaveList",
")",
";",
"bool",
"SaveR2",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
".",
"isAllocatable",
"(",
"PPC",
"::",
"X2",
")",
";",
"return",
"Subtarget",
".",
"isPPC64",
"(",
")",
"?",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"(",
"SaveR2",
"?",
"CSR_SVR464_R2_Altivec_SaveList",
":",
"CSR_SVR464_Altivec_SaveList",
")",
":",
"(",
"SaveR2",
"?",
"CSR_SVR464_R2_SaveList",
":",
"CSR_SVR464_SaveList",
")",
")",
":",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"CSR_SVR432_Altivec_SaveList",
":",
"CSR_SVR432_SaveList",
")",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC::X2",
"PPC"
] | PPCRegisterInfo22 | getCalleeSavedRegs | PowerPC | CPU | LLVM | 24,687 | 156 | 1 | [] |
[
"<s>",
"bool",
"rs6000_gimple_fold_builtin",
"(",
"gimple_stmt_iterator",
"*",
"gsi",
")",
"{",
"gimple",
"*",
"stmt",
"=",
"gsi_stmt",
"(",
"*",
"gsi",
")",
";",
"tree",
"fndecl",
"=",
"gimple_call_fndecl",
"(",
"stmt",
")",
";",
"gcc_checking_assert",
"(",
"fndecl",
"&&",
"DECL_BUILT_IN_CLASS",
"(",
"fndecl",
")",
"==",
"BUILT_IN_MD",
")",
";",
"enum",
"rs6000_builtins",
"fn_code",
"=",
"(",
"enum",
"rs6000_builtins",
")",
"DECL_FUNCTION_CODE",
"(",
"fndecl",
")",
";",
"tree",
"arg0",
",",
"arg1",
",",
"lhs",
";",
"switch",
"(",
"fn_code",
")",
"{",
"case",
"ALTIVEC_BUILTIN_VADDUBM",
":",
"case",
"ALTIVEC_BUILTIN_VADDUHM",
":",
"case",
"ALTIVEC_BUILTIN_VADDUWM",
":",
"case",
"P8V_BUILTIN_VADDUDM",
":",
"case",
"ALTIVEC_BUILTIN_VADDFP",
":",
"case",
"VSX_BUILTIN_XVADDDP",
":",
"{",
"arg0",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"0",
")",
";",
"arg1",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"1",
")",
";",
"lhs",
"=",
"gimple_call_lhs",
"(",
"stmt",
")",
";",
"gimple",
"*",
"g",
"=",
"gimple_build_assign",
"(",
"lhs",
",",
"PLUS_EXPR",
",",
"arg0",
",",
"arg1",
")",
";",
"gimple_set_location",
"(",
"g",
",",
"gimple_location",
"(",
"stmt",
")",
")",
";",
"gsi_replace",
"(",
"gsi",
",",
"g",
",",
"true",
")",
";",
"return",
"true",
";",
"}",
"case",
"ALTIVEC_BUILTIN_VSUBUBM",
":",
"case",
"ALTIVEC_BUILTIN_VSUBUHM",
":",
"case",
"ALTIVEC_BUILTIN_VSUBUWM",
":",
"case",
"P8V_BUILTIN_VSUBUDM",
":",
"case",
"ALTIVEC_BUILTIN_VSUBFP",
":",
"case",
"VSX_BUILTIN_XVSUBDP",
":",
"{",
"arg0",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"0",
")",
";",
"arg1",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"1",
")",
";",
"lhs",
"=",
"gimple_call_lhs",
"(",
"stmt",
")",
";",
"gimple",
"*",
"g",
"=",
"gimple_build_assign",
"(",
"lhs",
",",
"MINUS_EXPR",
",",
"arg0",
",",
"arg1",
")",
";",
"gimple_set_location",
"(",
"g",
",",
"gimple_location",
"(",
"stmt",
")",
")",
";",
"gsi_replace",
"(",
"gsi",
",",
"g",
",",
"true",
")",
";",
"return",
"true",
";",
"}",
"case",
"ALTIVEC_BUILTIN_VMULESB",
":",
"case",
"ALTIVEC_BUILTIN_VMULESH",
":",
"case",
"ALTIVEC_BUILTIN_VMULEUB",
":",
"case",
"ALTIVEC_BUILTIN_VMULEUH",
":",
"{",
"arg0",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"0",
")",
";",
"arg1",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"1",
")",
";",
"lhs",
"=",
"gimple_call_lhs",
"(",
"stmt",
")",
";",
"gimple",
"*",
"g",
"=",
"gimple_build_assign",
"(",
"lhs",
",",
"VEC_WIDEN_MULT_EVEN_EXPR",
",",
"arg0",
",",
"arg1",
")",
";",
"gimple_set_location",
"(",
"g",
",",
"gimple_location",
"(",
"stmt",
")",
")",
";",
"gsi_replace",
"(",
"gsi",
",",
"g",
",",
"true",
")",
";",
"return",
"true",
";",
"}",
"case",
"ALTIVEC_BUILTIN_VMULOSB",
":",
"case",
"ALTIVEC_BUILTIN_VMULOSH",
":",
"case",
"ALTIVEC_BUILTIN_VMULOUB",
":",
"case",
"ALTIVEC_BUILTIN_VMULOUH",
":",
"{",
"arg0",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"0",
")",
";",
"arg1",
"=",
"gimple_call_arg",
"(",
"stmt",
",",
"1",
")",
";",
"lhs",
"=",
"gimple_call_lhs",
"(",
"stmt",
")",
";",
"gimple",
"*",
"g",
"=",
"gimple_build_assign",
"(",
"lhs",
",",
"VEC_WIDEN_MULT_ODD_EXPR",
",",
"arg0",
",",
"arg1",
")",
";",
"gimple_set_location",
"(",
"g",
",",
"gimple_location",
"(",
"stmt",
")",
")",
";",
"gsi_replace",
"(",
"gsi",
",",
"g",
",",
"true",
")",
";",
"return",
"true",
";",
"}",
"default",
":",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Fold",
"a",
"machine-dependent",
"built-in",
"in",
"GIMPLE",
".",
"(",
"For",
"folding",
"into",
"a",
"constant",
",",
"use",
"rs6000_fold_builtin",
".",
")"
] | [
"rs6000",
"0",
"1",
"0",
"1",
"0",
"1",
"0",
"1"
] | rs60006 | rs6000_gimple_fold_builtin | rs6000 | CPU | GCC | 24,688 | 388 | 1 | [] |
[
"<s>",
"static",
"bool",
"isNot",
"(",
"const",
"MachineRegisterInfo",
"&",
"MRI",
",",
"const",
"MachineInstr",
"&",
"MI",
")",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"!=",
"TargetOpcode",
"::",
"G_XOR",
")",
"return",
"false",
";",
"auto",
"ConstVal",
"=",
"getIConstantVRegSExtVal",
"(",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
";",
"return",
"ConstVal",
"&&",
"*",
"ConstVal",
"==",
"-",
"1",
";",
"}",
"</s>"
] | [
"Check",
"if",
"the",
"current",
"token",
"has",
"kind",
"K",
"."
] | [
"AMDGPU",
"2",
"1"
] | AMDGPULegalizerInfo1 | isNot | AMDGPU | GPU | LLVM | 24,689 | 59 | 1 | [] |
[
"<s>",
"static",
"rtx",
"alpha_emit_set_long_const",
"(",
"rtx",
"target",
",",
"HOST_WIDE_INT",
"c1",
")",
"{",
"HOST_WIDE_INT",
"d1",
",",
"d2",
",",
"d3",
",",
"d4",
";",
"d1",
"=",
"(",
"(",
"c1",
"&",
"0xffff",
")",
"^",
"0x8000",
")",
"-",
"0x8000",
";",
"c1",
"-=",
"d1",
";",
"d2",
"=",
"(",
"(",
"c1",
"&",
"0xffffffff",
")",
"^",
"0x80000000",
")",
"-",
"0x80000000",
";",
"c1",
"=",
"(",
"c1",
"-",
"d2",
")",
">>",
"32",
";",
"d3",
"=",
"(",
"(",
"c1",
"&",
"0xffff",
")",
"^",
"0x8000",
")",
"-",
"0x8000",
";",
"c1",
"-=",
"d3",
";",
"d4",
"=",
"(",
"(",
"c1",
"&",
"0xffffffff",
")",
"^",
"0x80000000",
")",
"-",
"0x80000000",
";",
"gcc_assert",
"(",
"c1",
"==",
"d4",
")",
";",
"if",
"(",
"d4",
")",
"{",
"emit_move_insn",
"(",
"target",
",",
"GEN_INT",
"(",
"d4",
")",
")",
";",
"if",
"(",
"d3",
")",
"emit_move_insn",
"(",
"target",
",",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"target",
",",
"GEN_INT",
"(",
"d3",
")",
")",
")",
";",
"}",
"else",
"emit_move_insn",
"(",
"target",
",",
"GEN_INT",
"(",
"d3",
")",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"gen_rtx_ASHIFT",
"(",
"DImode",
",",
"target",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
";",
"if",
"(",
"d2",
")",
"emit_move_insn",
"(",
"target",
",",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"target",
",",
"GEN_INT",
"(",
"d2",
")",
")",
")",
";",
"if",
"(",
"d1",
")",
"emit_move_insn",
"(",
"target",
",",
"gen_rtx_PLUS",
"(",
"DImode",
",",
"target",
",",
"GEN_INT",
"(",
"d1",
")",
")",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Having",
"failed",
"to",
"find",
"a",
"3",
"insn",
"sequence",
"in",
"alpha_emit_set_const",
",",
"fall",
"back",
"to",
"a",
"straight",
"forward",
"decomposition",
".",
"We",
"do",
"this",
"to",
"avoid",
"exponential",
"run",
"times",
"encountered",
"when",
"looking",
"for",
"longer",
"sequences",
"with",
"alpha_emit_set_const",
"."
] | [
"alpha",
"0xffff",
"0x8000",
"0x8000",
"0xffffffff",
"0x80000000",
"0x80000000",
"32",
"0xffff",
"0x8000",
"0x8000",
"0xffffffff",
"0x80000000",
"0x80000000",
"32"
] | alpha | alpha_emit_set_long_const | alpha | MPU | GCC | 24,690 | 212 | 1 | [] |
[
"<s>",
"bool",
"ARMPreAllocLoadStoreOpt",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"if",
"(",
"AssumeMisalignedLoadStores",
"||",
"skipFunction",
"(",
"Fn",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"TD",
"=",
"&",
"Fn",
".",
"getDataLayout",
"(",
")",
";",
"STI",
"=",
"&",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"Fn",
".",
"getSubtarget",
"(",
")",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"STI",
"->",
"getRegisterInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"Fn",
".",
"getRegInfo",
"(",
")",
";",
"MF",
"=",
"&",
"Fn",
";",
"AA",
"=",
"&",
"getAnalysis",
"<",
"AAResultsWrapperPass",
">",
"(",
")",
".",
"getAAResults",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MFI",
":",
"Fn",
")",
"Modified",
"|=",
"RescheduleLoadStoreInstrs",
"(",
"&",
"MFI",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMLoadStoreOptimizer10 | runOnMachineFunction | ARM | CPU | LLVM | 24,691 | 121 | 1 | [] |
[
"<s>",
"static",
"void",
"sparc_asm_function_epilogue",
"(",
"FILE",
"*",
"file",
")",
"{",
"rtx_insn",
"*",
"insn",
"=",
"get_last_insn",
"(",
")",
";",
"rtx",
"last_real_insn",
"=",
"prev_real_insn",
"(",
"insn",
")",
";",
"if",
"(",
"last_real_insn",
"&&",
"NONJUMP_INSN_P",
"(",
"last_real_insn",
")",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"last_real_insn",
")",
")",
"==",
"SEQUENCE",
")",
"last_real_insn",
"=",
"XVECEXP",
"(",
"PATTERN",
"(",
"last_real_insn",
")",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"last_real_insn",
"&&",
"CALL_P",
"(",
"last_real_insn",
")",
"&&",
"!",
"SIBLING_CALL_P",
"(",
"last_real_insn",
")",
")",
"fputs",
"(",
"\"\\tnop\\n\"",
",",
"file",
")",
";",
"sparc_output_deferred_case_vectors",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"generates",
"the",
"assembly",
"code",
"for",
"function",
"exit",
"."
] | [
"sparc",
"0",
"0",
"\"\\tnop\\n\""
] | sparc | sparc_asm_function_epilogue | sparc | CPU | GCC | 24,692 | 85 | 1 | [] |
[
"<s>",
"bool",
"rs6000_is_valid_mask",
"(",
"rtx",
"mask",
",",
"int",
"*",
"b",
",",
"int",
"*",
"e",
",",
"machine_mode",
"mode",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"val",
"=",
"INTVAL",
"(",
"mask",
")",
";",
"unsigned",
"HOST_WIDE_INT",
"bit",
";",
"int",
"nb",
",",
"ne",
";",
"int",
"n",
"=",
"GET_MODE_PRECISION",
"(",
"mode",
")",
";",
"if",
"(",
"mode",
"!=",
"DImode",
"&&",
"mode",
"!=",
"SImode",
")",
"return",
"false",
";",
"if",
"(",
"INTVAL",
"(",
"mask",
")",
">=",
"0",
")",
"{",
"bit",
"=",
"val",
"&",
"-",
"val",
";",
"ne",
"=",
"exact_log2",
"(",
"bit",
")",
";",
"nb",
"=",
"exact_log2",
"(",
"val",
"+",
"bit",
")",
";",
"}",
"else",
"if",
"(",
"val",
"+",
"1",
"==",
"0",
")",
"{",
"nb",
"=",
"n",
";",
"ne",
"=",
"0",
";",
"}",
"else",
"if",
"(",
"val",
"&",
"1",
")",
"{",
"val",
"=",
"~",
"val",
";",
"bit",
"=",
"val",
"&",
"-",
"val",
";",
"nb",
"=",
"exact_log2",
"(",
"bit",
")",
";",
"ne",
"=",
"exact_log2",
"(",
"val",
"+",
"bit",
")",
";",
"}",
"else",
"{",
"bit",
"=",
"val",
"&",
"-",
"val",
";",
"ne",
"=",
"exact_log2",
"(",
"bit",
")",
";",
"if",
"(",
"val",
"+",
"bit",
"==",
"0",
")",
"nb",
"=",
"n",
";",
"else",
"nb",
"=",
"0",
";",
"}",
"nb",
"--",
";",
"if",
"(",
"nb",
"<",
"0",
"||",
"ne",
"<",
"0",
"||",
"nb",
">=",
"n",
"||",
"ne",
">=",
"n",
")",
"return",
"false",
";",
"if",
"(",
"b",
")",
"*",
"b",
"=",
"nb",
";",
"if",
"(",
"e",
")",
"*",
"e",
"=",
"ne",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"whether",
"MASK",
"(",
"a",
"CONST_INT",
")",
"is",
"a",
"valid",
"mask",
"for",
"any",
"rlwinm",
",",
"rldicl",
",",
"rldicr",
",",
"or",
"rldic",
"instruction",
"in",
"mode",
"MODE",
".",
"If",
"so",
",",
"if",
"E",
"is",
"not",
"zero",
",",
"store",
"there",
"the",
"bit",
"offset",
"(",
"counted",
"from",
"the",
"right",
")",
"where",
"the",
"single",
"stretch",
"of",
"1",
"bits",
"begins",
";",
"and",
"similarly",
"for",
"B",
",",
"the",
"bit",
"offset",
"where",
"it",
"ends",
"."
] | [
"rs6000",
"0",
"1",
"0",
"0",
"1",
"0",
"0",
"0",
"0"
] | rs6000 | rs6000_is_valid_mask | rs6000 | CPU | GCC | 24,693 | 227 | 1 | [] |
[
"<s>",
"void",
"initializePass",
"(",
")",
"override",
"{",
"pushTTIStack",
"(",
"this",
")",
";",
"}",
"</s>"
] | [
"initializePass",
"-",
"This",
"method",
"may",
"be",
"overriden",
"by",
"immutable",
"passes",
"to",
"allow",
"them",
"to",
"perform",
"various",
"initialization",
"actions",
"they",
"require",
"."
] | [
"X86"
] | X86TargetTransformInfo112 | initializePass | X86 | CPU | LLVM | 24,694 | 12 | 1 | [] |
[
"<s>",
"static",
"rtx",
"aarch64_strip_extend",
"(",
"rtx",
"x",
",",
"bool",
"strip_shift",
")",
"{",
"scalar_int_mode",
"mode",
";",
"rtx",
"op",
"=",
"x",
";",
"if",
"(",
"!",
"is_a",
"<",
"scalar_int_mode",
">",
"(",
"GET_MODE",
"(",
"op",
")",
",",
"&",
"mode",
")",
")",
"return",
"op",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"AND",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
"==",
"MULT",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"1",
")",
")",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
"&&",
"aarch64_uxt_size",
"(",
"exact_log2",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"1",
")",
")",
")",
",",
"INTVAL",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
")",
"!=",
"0",
")",
"return",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"0",
")",
";",
"if",
"(",
"strip_shift",
"&&",
"GET_CODE",
"(",
"op",
")",
"==",
"ASHIFT",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
"&&",
"(",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"INTVAL",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
")",
"<=",
"4",
")",
"op",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"ZERO_EXTEND",
"||",
"GET_CODE",
"(",
"op",
")",
"==",
"SIGN_EXTEND",
")",
"op",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"if",
"(",
"op",
"!=",
"x",
")",
"return",
"op",
";",
"return",
"x",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"for",
"rtx",
"cost",
"calculation",
".",
"Strip",
"an",
"extend",
"expression",
"from",
"X",
".",
"Returns",
"the",
"inner",
"operand",
"if",
"successful",
",",
"or",
"the",
"original",
"expression",
"on",
"failure",
".",
"We",
"deal",
"with",
"a",
"number",
"of",
"possible",
"canonicalization",
"variations",
"here",
"."
] | [
"aarch64",
"0",
"0",
"1",
"1",
"0",
"1",
"1",
"0",
"0",
"0",
"1",
"1",
"4",
"0",
"0"
] | aarch641 | aarch64_strip_extend | aarch64 | CPU | GCC | 24,695 | 217 | 1 | [] |
[
"<s>",
"bool",
"ARMFrameInfo",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"bool",
"isVarArg",
"=",
"AFI",
"->",
"getVarArgsRegSaveSize",
"(",
")",
">",
"0",
";",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"PopOpc",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
"?",
"ARM",
"::",
"t2LDMIA_UPD",
":",
"ARM",
"::",
"LDMIA_UPD",
";",
"unsigned",
"LdrOpc",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
"?",
"ARM",
"::",
"t2LDR_POST",
":",
"ARM",
"::",
"LDR_POST",
";",
"unsigned",
"FltOpc",
"=",
"ARM",
"::",
"VLDMDIA_UPD",
";",
"emitPopInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"FltOpc",
",",
"0",
",",
"isVarArg",
",",
"true",
",",
"&",
"isARMArea3Register",
")",
";",
"emitPopInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"PopOpc",
",",
"LdrOpc",
",",
"isVarArg",
",",
"false",
",",
"&",
"isARMArea2Register",
")",
";",
"emitPopInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"PopOpc",
",",
"LdrOpc",
",",
"isVarArg",
",",
"false",
",",
"&",
"isARMArea1Register",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"0",
"ARM::t2LDMIA_UPD",
"ARM::LDMIA_UPD",
"ARM::t2LDR_POST",
"ARM::LDR_POST",
"ARM::VLDMDIA_UPD",
"0",
"ARM",
"ARM",
"ARM"
] | ARMFrameInfo | restoreCalleeSavedRegisters | ARM | CPU | LLVM | 24,696 | 191 | 1 | [] |
[
"<s>",
"static",
"inline",
"ChildIteratorType",
"child_begin",
"(",
"NodeType",
"*",
"N",
")",
"{",
"return",
"N",
"->",
"G",
"->",
"Edges",
".",
"lower_bound",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"nodes_iterator/begin/end",
"-",
"Allow",
"iteration",
"over",
"all",
"nodes",
"in",
"the",
"graph"
] | [
"Patmos"
] | PatmosFunctionSplitter | child_begin | Patmos | VLIW | LLVM | 24,697 | 23 | 1 | [] |
[
"<s>",
"static",
"void",
"loongarch_trampoline_init",
"(",
"rtx",
"m_tramp",
",",
"tree",
"fndecl",
",",
"rtx",
"chain_value",
")",
"{",
"rtx",
"addr",
",",
"end_addr",
",",
"mem",
";",
"rtx",
"trampoline",
"[",
"8",
"]",
";",
"unsigned",
"int",
"i",
",",
"j",
";",
"HOST_WIDE_INT",
"end_addr_offset",
",",
"static_chain_offset",
",",
"target_function_offset",
";",
"end_addr_offset",
"=",
"TRAMPOLINE_CODE_SIZE",
";",
"static_chain_offset",
"=",
"end_addr_offset",
";",
"target_function_offset",
"=",
"static_chain_offset",
"+",
"GET_MODE_SIZE",
"(",
"ptr_mode",
")",
";",
"addr",
"=",
"force_reg",
"(",
"Pmode",
",",
"XEXP",
"(",
"m_tramp",
",",
"0",
")",
")",
";",
"end_addr",
"=",
"loongarch_force_binary",
"(",
"Pmode",
",",
"PLUS",
",",
"addr",
",",
"GEN_INT",
"(",
"end_addr_offset",
")",
")",
";",
"i",
"=",
"0",
";",
"trampoline",
"[",
"i",
"++",
"]",
"=",
"OP",
"(",
"0x18000000",
"|",
"(",
"STATIC_CHAIN_REGNUM",
"-",
"GP_REG_FIRST",
")",
")",
";",
"trampoline",
"[",
"i",
"++",
"]",
"=",
"OP",
"(",
"(",
"ptr_mode",
"==",
"DImode",
"?",
"0x28c00000",
":",
"0x28800000",
")",
"|",
"19",
"|",
"(",
"(",
"STATIC_CHAIN_REGNUM",
"-",
"GP_REG_FIRST",
")",
"<<",
"5",
")",
"|",
"(",
"(",
"target_function_offset",
"&",
"0xfff",
")",
"<<",
"10",
")",
")",
";",
"trampoline",
"[",
"i",
"++",
"]",
"=",
"OP",
"(",
"(",
"ptr_mode",
"==",
"DImode",
"?",
"0x28c00000",
":",
"0x28800000",
")",
"|",
"(",
"STATIC_CHAIN_REGNUM",
"-",
"GP_REG_FIRST",
")",
"|",
"(",
"(",
"STATIC_CHAIN_REGNUM",
"-",
"GP_REG_FIRST",
")",
"<<",
"5",
")",
"|",
"(",
"(",
"static_chain_offset",
"&",
"0xfff",
")",
"<<",
"10",
")",
")",
";",
"trampoline",
"[",
"i",
"++",
"]",
"=",
"OP",
"(",
"0x4c000000",
"|",
"(",
"19",
"<<",
"5",
")",
")",
";",
"for",
"(",
"j",
"=",
"0",
";",
"j",
"<",
"i",
";",
"j",
"++",
")",
"{",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"SImode",
",",
"j",
"*",
"GET_MODE_SIZE",
"(",
"SImode",
")",
")",
";",
"loongarch_emit_move",
"(",
"mem",
",",
"trampoline",
"[",
"j",
"]",
")",
";",
"}",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"ptr_mode",
",",
"static_chain_offset",
")",
";",
"loongarch_emit_move",
"(",
"mem",
",",
"chain_value",
")",
";",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"ptr_mode",
",",
"target_function_offset",
")",
";",
"loongarch_emit_move",
"(",
"mem",
",",
"XEXP",
"(",
"DECL_RTL",
"(",
"fndecl",
")",
",",
"0",
")",
")",
";",
"emit_insn",
"(",
"gen_add3_insn",
"(",
"end_addr",
",",
"addr",
",",
"GEN_INT",
"(",
"TRAMPOLINE_SIZE",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_clear_cache",
"(",
"addr",
",",
"end_addr",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_TRAMPOLINE_INIT",
"."
] | [
"loongarch",
"8",
"0",
"0",
"0x18000000",
"0x28c00000",
"0x28800000",
"19",
"5",
"0xfff",
"10",
"0x28c00000",
"0x28800000",
"5",
"0xfff",
"10",
"0x4c000000",
"19",
"5",
"0",
"0"
] | loongarch | loongarch_trampoline_init | loongarch | CPU | GCC | 24,698 | 322 | 1 | [] |
[
"<s>",
"MVT",
"MipsTargetLowering",
"::",
"getRegisterTypeForCallingConv",
"(",
"LLVMContext",
"&",
"Context",
",",
"CallingConv",
"::",
"ID",
"CC",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"getRegisterType",
"(",
"Context",
",",
"VT",
")",
";",
"return",
"Subtarget",
".",
"isABI_O32",
"(",
")",
"||",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"32",
"?",
"MVT",
"::",
"i32",
":",
"MVT",
"::",
"i64",
";",
"}",
"</s>"
] | [
"Certain",
"combinations",
"of",
"ABIs",
",",
"Targets",
"and",
"features",
"require",
"that",
"types",
"are",
"legal",
"for",
"some",
"operations",
"and",
"not",
"for",
"other",
"operations",
"."
] | [
"Mips",
"Mips",
"32",
"MVT::i32",
"MVT::i64"
] | MipsISelLowering (2)4 | getRegisterTypeForCallingConv | Mips | CPU | LLVM | 24,699 | 60 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.