ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"void",
"RISCVInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"SrcReg",
",",
"bool",
"IsKill",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"RISCV",
"::",
"GPRRegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"RISCV",
"::",
"SW",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"IsKill",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Can't store this register to stack slot\"",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"RISCV",
"RISCV",
"RISCV::GPRRegClass",
"RISCV::SW",
"0",
"\"Can't store this register to stack slot\""
] | RISCVInstrInfo17 | storeRegToStackSlot | RISCV | CPU | LLVM | 16,400 | 110 | 1 | [] |
[
"<s>",
"void",
"TriCoreFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"computeStackSize",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"StackSize",
")",
"{",
"return",
";",
"}",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"MachineFunction",
"::",
"iterator",
"I",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"TriCore",
"::",
"MOVAAsrr",
")",
",",
"TriCore",
"::",
"A14",
")",
".",
"addReg",
"(",
"TriCore",
"::",
"A10",
")",
";",
"for",
"(",
"I",
"=",
"std",
"::",
"next",
"(",
"MF",
".",
"begin",
"(",
")",
")",
";",
"I",
"!=",
"MF",
".",
"end",
"(",
")",
";",
"++",
"I",
")",
"I",
"->",
"addLiveIn",
"(",
"TriCore",
"::",
"A14",
")",
";",
"}",
"unsigned",
"StackReg",
"=",
"TriCore",
"::",
"A10",
";",
"unsigned",
"OffsetReg",
"=",
"materializeOffset",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"(",
"unsigned",
")",
"StackSize",
")",
";",
"if",
"(",
"OffsetReg",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"TriCore",
"::",
"SUBArr",
")",
",",
"StackReg",
")",
".",
"addReg",
"(",
"StackReg",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"TriCore",
"::",
"SUBAsc",
")",
")",
".",
"addImm",
"(",
"StackSize",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"TriCore",
"TriCore",
"TriCore::MOVAAsrr",
"TriCore::A14",
"TriCore::A10",
"TriCore::A14",
"TriCore::A10",
"TriCore::SUBArr",
"TriCore::SUBAsc"
] | TriCoreFrameLowering (2) | emitPrologue | TriCore | MPU | LLVM | 16,401 | 259 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"riscv_pass_mode_in_fpr_p",
"(",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"GET_MODE_UNIT_SIZE",
"(",
"mode",
")",
"<=",
"UNITS_PER_FP_ARG",
")",
"{",
"if",
"(",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_FLOAT",
")",
"return",
"1",
";",
"if",
"(",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_COMPLEX_FLOAT",
")",
"return",
"2",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"If",
"MODE",
"represents",
"an",
"argument",
"that",
"can",
"be",
"passed",
"or",
"returned",
"in",
"floating-point",
"registers",
",",
"return",
"the",
"number",
"of",
"registers",
",",
"else",
"0",
"."
] | [
"riscv",
"1",
"2",
"0"
] | riscv | riscv_pass_mode_in_fpr_p | riscv | CPU | GCC | 16,402 | 47 | 1 | [] |
[
"<s>",
"static",
"void",
"sparc_dwarf_handle_frame_unspec",
"(",
"const",
"char",
"*",
"label",
",",
"rtx",
"pattern",
"ATTRIBUTE_UNUSED",
",",
"int",
"index",
"ATTRIBUTE_UNUSED",
")",
"{",
"gcc_assert",
"(",
"index",
"==",
"UNSPECV_SAVEW",
")",
";",
"dwarf2out_window_save",
"(",
"label",
")",
";",
"}",
"</s>"
] | [
"Handle",
"the",
"TARGET_DWARF_HANDLE_FRAME_UNSPEC",
"hook",
".",
"This",
"is",
"called",
"from",
"dwarf2out.c",
"to",
"emit",
"call",
"frame",
"instructions",
"for",
"frame-related",
"insns",
"containing",
"UNSPECs",
"and",
"UNSPEC_VOLATILEs",
"."
] | [
"sparc"
] | sparc3 | sparc_dwarf_handle_frame_unspec | sparc | CPU | GCC | 16,403 | 31 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"TVM peephole optimizer\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"TVM",
"\"TVM peephole optimizer\""
] | TVMPeephole | getPassName | TVM | Virtual ISA | LLVM | 16,404 | 11 | 1 | [] |
[
"<s>",
"void",
"SIScheduleBlockScheduler",
"::",
"addLiveRegs",
"(",
"std",
"::",
"set",
"<",
"unsigned",
">",
"&",
"Regs",
")",
"{",
"for",
"(",
"unsigned",
"Reg",
":",
"Regs",
")",
"{",
"if",
"(",
"!",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"Reg",
")",
")",
"continue",
";",
"(",
"void",
")",
"LiveRegs",
".",
"insert",
"(",
"Reg",
")",
";",
"}",
"}",
"</s>"
] | [
"Force",
"liveness",
"of",
"virtual",
"registers",
"or",
"physical",
"register",
"units",
"."
] | [
"AMDGPU",
"SI"
] | SIMachineScheduler | addLiveRegs | AMDGPU | GPU | LLVM | 16,405 | 47 | 1 | [] |
[
"<s>",
"void",
"addExpr",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"MCExpr",
"*",
"Expr",
")",
"const",
"{",
"if",
"(",
"Expr",
"==",
"0",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"0",
")",
")",
";",
"else",
"if",
"(",
"const",
"MCConstantExpr",
"*",
"CE",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"Expr",
")",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"CE",
"->",
"getValue",
"(",
")",
")",
")",
";",
"else",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createExpr",
"(",
"Expr",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"new",
"MCExpr",
"operand",
"."
] | [
"Cpu0",
"0",
"0"
] | Cpu0AsmParser | addExpr | Cpu0 | CPU | LLVM | 16,406 | 78 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"J2RegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"return",
"CSR_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"J2",
"J2"
] | J2RegisterInfo | getCalleeSavedRegs | J2 | MPU | LLVM | 16,407 | 18 | 1 | [] |
[
"<s>",
"void",
"X86FuchsiaTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"InitializeELF",
"(",
"TM",
".",
"Options",
".",
"UseInitArray",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"X86",
"X86"
] | X86TargetObjectFile17 | Initialize | X86 | CPU | LLVM | 16,408 | 34 | 1 | [] |
[
"<s>",
"SDValue",
"SITargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"LowerBRCOND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"LowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"{",
"unsigned",
"IntrinsicID",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
")",
"->",
"getZExtValue",
"(",
")",
";",
"EVT",
"VT",
"=",
"Op",
".",
"getValueType",
"(",
")",
";",
"switch",
"(",
"IntrinsicID",
")",
"{",
"case",
"AMDGPUIntrinsic",
"::",
"SI_vs_load_buffer_index",
":",
"return",
"CreateLiveInRegister",
"(",
"DAG",
",",
"&",
"AMDGPU",
"::",
"VReg_32RegClass",
",",
"AMDGPU",
"::",
"VGPR0",
",",
"VT",
")",
";",
"default",
":",
"return",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"break",
";",
"}",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"R600",
"SI",
"ISD::BRCOND",
"ISD::LOAD",
"ISD::SELECT_CC",
"ISD::INTRINSIC_WO_CHAIN",
"0",
"AMDGPUIntrinsic::SI_vs_load_buffer_index"
] | SIISelLowering34 | LowerOperation | R600 | GPU | LLVM | 16,409 | 159 | 1 | [] |
[
"<s>",
"void",
"h8300_swap_into_er6",
"(",
"rtx",
"addr",
")",
"{",
"push",
"(",
"HARD_FRAME_POINTER_REGNUM",
")",
";",
"emit_move_insn",
"(",
"hard_frame_pointer_rtx",
",",
"addr",
")",
";",
"if",
"(",
"REGNO",
"(",
"addr",
")",
"==",
"SP_REG",
")",
"emit_move_insn",
"(",
"hard_frame_pointer_rtx",
",",
"plus_constant",
"(",
"hard_frame_pointer_rtx",
",",
"GET_MODE_SIZE",
"(",
"word_mode",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Move",
"ADDR",
"into",
"er6",
"after",
"pushing",
"its",
"old",
"value",
"onto",
"the",
"stack",
"."
] | [
"h8300"
] | h83003 | h8300_swap_into_er6 | h8300 | MPU | GCC | 16,410 | 44 | 1 | [] |
[
"<s>",
"bool",
"X86ATTAsmParser",
"::",
"ParseInstruction",
"(",
"const",
"StringRef",
"&",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"SmallVectorImpl",
"<",
"MCParsedAsmOperand",
"*",
">",
"&",
"Operands",
")",
"{",
"StringRef",
"PatchedName",
"=",
"StringSwitch",
"<",
"StringRef",
">",
"(",
"Name",
")",
".",
"Case",
"(",
"\"sal\"",
",",
"\"shl\"",
")",
".",
"Case",
"(",
"\"salb\"",
",",
"\"shlb\"",
")",
".",
"Case",
"(",
"\"sall\"",
",",
"\"shll\"",
")",
".",
"Case",
"(",
"\"salq\"",
",",
"\"shlq\"",
")",
".",
"Case",
"(",
"\"salw\"",
",",
"\"shlw\"",
")",
".",
"Case",
"(",
"\"repe\"",
",",
"\"rep\"",
")",
".",
"Case",
"(",
"\"repz\"",
",",
"\"rep\"",
")",
".",
"Case",
"(",
"\"repnz\"",
",",
"\"repne\"",
")",
".",
"Default",
"(",
"Name",
")",
";",
"Operands",
".",
"push_back",
"(",
"X86Operand",
"::",
"CreateToken",
"(",
"PatchedName",
",",
"NameLoc",
")",
")",
";",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"if",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Star",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Operands",
".",
"push_back",
"(",
"X86Operand",
"::",
"CreateToken",
"(",
"\"*\"",
",",
"Loc",
")",
")",
";",
"Parser",
".",
"Lex",
"(",
")",
";",
"}",
"if",
"(",
"X86Operand",
"*",
"Op",
"=",
"ParseOperand",
"(",
")",
")",
"Operands",
".",
"push_back",
"(",
"Op",
")",
";",
"else",
"return",
"true",
";",
"while",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"X86Operand",
"*",
"Op",
"=",
"ParseOperand",
"(",
")",
")",
"Operands",
".",
"push_back",
"(",
"Op",
")",
";",
"else",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"X86",
"X86",
"\"sal\"",
"\"shl\"",
"\"salb\"",
"\"shlb\"",
"\"sall\"",
"\"shll\"",
"\"salq\"",
"\"shlq\"",
"\"salw\"",
"\"shlw\"",
"\"repe\"",
"\"rep\"",
"\"repz\"",
"\"rep\"",
"\"repnz\"",
"\"repne\"",
"X86Operand::CreateToken",
"X86Operand::CreateToken",
"\"*\"",
"X86",
"X86"
] | X86AsmParser68 | ParseInstruction | X86 | CPU | LLVM | 16,411 | 238 | 1 | [] |
[
"<s>",
"bool",
"FPGATTIImpl",
"::",
"isTruncateFree",
"(",
"Type",
"*",
"Ty1",
",",
"Type",
"*",
"Ty2",
")",
"{",
"if",
"(",
"!",
"Ty1",
"->",
"isIntegerTy",
"(",
")",
"||",
"!",
"Ty2",
"->",
"isIntegerTy",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"NumBits1",
"=",
"Ty1",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"unsigned",
"NumBits2",
"=",
"Ty2",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"return",
"NumBits1",
">",
"NumBits2",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"free",
"to",
"truncate",
"a",
"value",
"of",
"type",
"Ty1",
"to",
"type",
"Ty2",
"."
] | [
"FPGA",
"FPGA"
] | FPGATargetTransformInfo | isTruncateFree | FPGA | CPU | LLVM | 16,412 | 57 | 1 | [] |
[
"<s>",
"bool",
"SystemZAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"O",
"<<",
"\"\\n\\n\"",
";",
"EmitConstantPool",
"(",
"MF",
".",
"getConstantPool",
"(",
")",
")",
";",
"emitFunctionHeader",
"(",
"MF",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"const_iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"!",
"VerboseAsm",
"&&",
"(",
"I",
"->",
"pred_empty",
"(",
")",
"||",
"I",
"->",
"isOnlyReachableByFallthrough",
"(",
")",
")",
")",
"{",
"}",
"else",
"{",
"printBasicBlockLabel",
"(",
"I",
",",
"true",
",",
"true",
",",
"VerboseAsm",
")",
";",
"O",
"<<",
"'\\n'",
";",
"}",
"for",
"(",
"MachineBasicBlock",
"::",
"const_iterator",
"II",
"=",
"I",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"I",
"->",
"end",
"(",
")",
";",
"II",
"!=",
"E",
";",
"++",
"II",
")",
"printMachineInstruction",
"(",
"II",
")",
";",
"}",
"if",
"(",
"TAI",
"->",
"hasDotTypeDotSizeDirective",
"(",
")",
")",
"O",
"<<",
"\"\\t.size\\t\"",
"<<",
"CurrentFnName",
"<<",
"\", .-\"",
"<<",
"CurrentFnName",
"<<",
"'\\n'",
";",
"EmitJumpTableInfo",
"(",
"MF",
".",
"getJumpTableInfo",
"(",
")",
",",
"MF",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"SystemZ",
"SystemZ",
"\"\\n\\n\"",
"\"\\t.size\\t\"",
"\", .-\""
] | SystemZAsmPrinter30 | runOnMachineFunction | SystemZ | CPU | LLVM | 16,413 | 170 | 1 | [] |
[
"<s>",
"StringRef",
"AArch64MCExpr",
"::",
"getVariantKindName",
"(",
")",
"const",
"{",
"switch",
"(",
"static_cast",
"<",
"uint32_t",
">",
"(",
"getKind",
"(",
")",
")",
")",
"{",
"case",
"VK_CALL",
":",
"return",
"\"\"",
";",
"case",
"VK_LO12",
":",
"return",
"\":lo12:\"",
";",
"case",
"VK_ABS_G3",
":",
"return",
"\":abs_g3:\"",
";",
"case",
"VK_ABS_G2",
":",
"return",
"\":abs_g2:\"",
";",
"case",
"VK_ABS_G2_S",
":",
"return",
"\":abs_g2_s:\"",
";",
"case",
"VK_ABS_G2_NC",
":",
"return",
"\":abs_g2_nc:\"",
";",
"case",
"VK_ABS_G1",
":",
"return",
"\":abs_g1:\"",
";",
"case",
"VK_ABS_G1_S",
":",
"return",
"\":abs_g1_s:\"",
";",
"case",
"VK_ABS_G1_NC",
":",
"return",
"\":abs_g1_nc:\"",
";",
"case",
"VK_ABS_G0",
":",
"return",
"\":abs_g0:\"",
";",
"case",
"VK_ABS_G0_S",
":",
"return",
"\":abs_g0_s:\"",
";",
"case",
"VK_ABS_G0_NC",
":",
"return",
"\":abs_g0_nc:\"",
";",
"case",
"VK_DTPREL_G2",
":",
"return",
"\":dtprel_g2:\"",
";",
"case",
"VK_DTPREL_G1",
":",
"return",
"\":dtprel_g1:\"",
";",
"case",
"VK_DTPREL_G1_NC",
":",
"return",
"\":dtprel_g1_nc:\"",
";",
"case",
"VK_DTPREL_G0",
":",
"return",
"\":dtprel_g0:\"",
";",
"case",
"VK_DTPREL_G0_NC",
":",
"return",
"\":dtprel_g0_nc:\"",
";",
"case",
"VK_DTPREL_HI12",
":",
"return",
"\":dtprel_hi12:\"",
";",
"case",
"VK_DTPREL_LO12",
":",
"return",
"\":dtprel_lo12:\"",
";",
"case",
"VK_DTPREL_LO12_NC",
":",
"return",
"\":dtprel_lo12_nc:\"",
";",
"case",
"VK_TPREL_G2",
":",
"return",
"\":tprel_g2:\"",
";",
"case",
"VK_TPREL_G1",
":",
"return",
"\":tprel_g1:\"",
";",
"case",
"VK_TPREL_G1_NC",
":",
"return",
"\":tprel_g1_nc:\"",
";",
"case",
"VK_TPREL_G0",
":",
"return",
"\":tprel_g0:\"",
";",
"case",
"VK_TPREL_G0_NC",
":",
"return",
"\":tprel_g0_nc:\"",
";",
"case",
"VK_TPREL_HI12",
":",
"return",
"\":tprel_hi12:\"",
";",
"case",
"VK_TPREL_LO12",
":",
"return",
"\":tprel_lo12:\"",
";",
"case",
"VK_TPREL_LO12_NC",
":",
"return",
"\":tprel_lo12_nc:\"",
";",
"case",
"VK_TLSDESC_LO12",
":",
"return",
"\":tlsdesc_lo12:\"",
";",
"case",
"VK_ABS_PAGE",
":",
"return",
"\"\"",
";",
"case",
"VK_ABS_PAGE_NC",
":",
"return",
"\":pg_hi21_nc:\"",
";",
"case",
"VK_GOT_PAGE",
":",
"return",
"\":got:\"",
";",
"case",
"VK_GOT_LO12",
":",
"return",
"\":got_lo12:\"",
";",
"case",
"VK_GOTTPREL_PAGE",
":",
"return",
"\":gottprel:\"",
";",
"case",
"VK_GOTTPREL_LO12_NC",
":",
"return",
"\":gottprel_lo12:\"",
";",
"case",
"VK_GOTTPREL_G1",
":",
"return",
"\":gottprel_g1:\"",
";",
"case",
"VK_GOTTPREL_G0_NC",
":",
"return",
"\":gottprel_g0_nc:\"",
";",
"case",
"VK_TLSDESC",
":",
"return",
"\"\"",
";",
"case",
"VK_TLSDESC_PAGE",
":",
"return",
"\":tlsdesc:\"",
";",
"case",
"VK_SECREL_LO12",
":",
"return",
"\":secrel_lo12:\"",
";",
"case",
"VK_SECREL_HI12",
":",
"return",
"\":secrel_hi12:\"",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Invalid ELF symbol kind\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Convert",
"the",
"variant",
"kind",
"into",
"an",
"ELF-appropriate",
"modifier",
"(",
"e.g",
"."
] | [
"AArch64",
"AArch64",
"\"\"",
"\":lo12:\"",
"\":abs_g3:\"",
"\":abs_g2:\"",
"\":abs_g2_s:\"",
"\":abs_g2_nc:\"",
"\":abs_g1:\"",
"\":abs_g1_s:\"",
"\":abs_g1_nc:\"",
"\":abs_g0:\"",
"\":abs_g0_s:\"",
"\":abs_g0_nc:\"",
"\":dtprel_g2:\"",
"\":dtprel_g1:\"",
"\":dtprel_g1_nc:\"",
"\":dtprel_g0:\"",
"\":dtprel_g0_nc:\"",
"\":dtprel_hi12:\"",
"\":dtprel_lo12:\"",
"\":dtprel_lo12_nc:\"",
"\":tprel_g2:\"",
"\":tprel_g1:\"",
"\":tprel_g1_nc:\"",
"\":tprel_g0:\"",
"\":tprel_g0_nc:\"",
"\":tprel_hi12:\"",
"\":tprel_lo12:\"",
"\":tprel_lo12_nc:\"",
"\":tlsdesc_lo12:\"",
"\"\"",
"\":pg_hi21_nc:\"",
"\":got:\"",
"\":got_lo12:\"",
"\":gottprel:\"",
"\":gottprel_lo12:\"",
"\":gottprel_g1:\"",
"\":gottprel_g0_nc:\"",
"\"\"",
"\":tlsdesc:\"",
"\":secrel_lo12:\"",
"\":secrel_hi12:\"",
"\"Invalid ELF symbol kind\""
] | AArch64MCExpr12 | getVariantKindName | AArch64 | CPU | LLVM | 16,414 | 276 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmPrinter",
"::",
"lowerOperand",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"MCOperand",
"&",
"MCOp",
")",
"{",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"unknown operand type\"",
")",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"if",
"(",
"MO",
".",
"isImplicit",
"(",
")",
"&&",
"MO",
".",
"getReg",
"(",
")",
"!=",
"ARM",
"::",
"CPSR",
")",
"return",
"false",
";",
"assert",
"(",
"!",
"MO",
".",
"getSubReg",
"(",
")",
"&&",
"\"Subregs should be eliminated!\"",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateReg",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateImm",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_MachineBasicBlock",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateExpr",
"(",
"MCSymbolRefExpr",
"::",
"Create",
"(",
"MO",
".",
"getMBB",
"(",
")",
"->",
"getSymbol",
"(",
")",
",",
"OutContext",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"getSymbol",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetJTISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetCPISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_BlockAddress",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetBlockAddressSymbol",
"(",
"MO",
".",
"getBlockAddress",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_FPImmediate",
":",
"{",
"APFloat",
"Val",
"=",
"MO",
".",
"getFPImm",
"(",
")",
"->",
"getValueAPF",
"(",
")",
";",
"bool",
"ignored",
";",
"Val",
".",
"convert",
"(",
"APFloat",
"::",
"IEEEdouble",
",",
"APFloat",
"::",
"rmTowardZero",
",",
"&",
"ignored",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateFPImm",
"(",
"Val",
".",
"convertToDouble",
"(",
")",
")",
";",
"break",
";",
"}",
"case",
"MachineOperand",
"::",
"MO_RegisterMask",
":",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Wrapper",
"for",
"MCInstLowering.lowerOperand",
"(",
")",
"for",
"the",
"tblgen'erated",
"pseudo",
"lowering",
"."
] | [
"ARM",
"ARM",
"\"unknown operand type\"",
"ARM::CPSR",
"\"Subregs should be eliminated!\""
] | ARMMCInstLower37 | lowerOperand | ARM | CPU | LLVM | 16,415 | 317 | 1 | [] |
[
"<s>",
"BitVector",
"SIRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"EXEC_LO",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"EXEC_HI",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"INDIRECT_BASE_ADDR",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"FLAT_SCR",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"FLAT_SCR_LO",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"FLAT_SCR_HI",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"VGPR255",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"VGPR254",
")",
";",
"if",
"(",
"ST",
".",
"hasSGPRInitBug",
"(",
")",
")",
"{",
"unsigned",
"NumSGPRs",
"=",
"AMDGPU",
"::",
"SGPR_32RegClass",
".",
"getNumRegs",
"(",
")",
";",
"unsigned",
"Limit",
"=",
"AMDGPUSubtarget",
"::",
"FIXED_SGPR_COUNT_FOR_INIT_BUG",
"-",
"4",
";",
"for",
"(",
"unsigned",
"i",
"=",
"Limit",
";",
"i",
"<",
"NumSGPRs",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"AMDGPU",
"::",
"SGPR_32RegClass",
".",
"getRegister",
"(",
"i",
")",
";",
"MCRegAliasIterator",
"R",
"=",
"MCRegAliasIterator",
"(",
"Reg",
",",
"this",
",",
"true",
")",
";",
"for",
"(",
";",
"R",
".",
"isValid",
"(",
")",
";",
"++",
"R",
")",
"Reserved",
".",
"set",
"(",
"*",
"R",
")",
";",
"}",
"}",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"R600",
"SI",
"4"
] | SIRegisterInfo100 | getReservedRegs | R600 | GPU | LLVM | 16,416 | 195 | 1 | [] |
[
"<s>",
"void",
"SIRegisterInfo",
"::",
"materializeFrameBaseRegister",
"(",
"MachineBasicBlock",
"*",
"MBB",
",",
"unsigned",
"BaseReg",
",",
"int",
"FrameIdx",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"Ins",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"Ins",
"!=",
"MBB",
"->",
"end",
"(",
")",
")",
"DL",
"=",
"Ins",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
"->",
"getParent",
"(",
")",
";",
"const",
"AMDGPUSubtarget",
"&",
"Subtarget",
"=",
"MF",
"->",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"assert",
"(",
"isUInt",
"<",
"27",
">",
"(",
"Offset",
")",
"&&",
"\"Private offset should never exceed maximum private size\"",
")",
";",
"if",
"(",
"Offset",
"==",
"0",
")",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"Ins",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"V_MOV_B32_e32",
")",
",",
"BaseReg",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
";",
"return",
";",
"}",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"unsigned",
"UnusedCarry",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_64RegClass",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"Ins",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"V_ADD_I32_e64",
")",
",",
"BaseReg",
")",
".",
"addReg",
"(",
"UnusedCarry",
",",
"RegState",
"::",
"Define",
"|",
"RegState",
"::",
"Dead",
")",
".",
"addImm",
"(",
"Offset",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
";",
"}",
"</s>"
] | [
"Insert",
"defining",
"instruction",
"(",
"s",
")",
"for",
"a",
"pointer",
"to",
"FrameIdx",
"before",
"insertion",
"point",
"I",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU",
"27",
"\"Private offset should never exceed maximum private size\"",
"0",
"AMDGPU::V_MOV_B32_e32",
"AMDGPU::SReg_64RegClass",
"AMDGPU::V_ADD_I32_e64"
] | SIRegisterInfo69 | materializeFrameBaseRegister | AMDGPU | GPU | LLVM | 16,417 | 204 | 1 | [] |
[
"<s>",
"bool",
"IA64RegisterInfo",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"NoFramePointerElim",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"IA64",
"IA64"
] | IA64RegisterInfo | hasFP | IA64 | CPU | LLVM | 16,418 | 33 | 1 | [] |
[
"<s>",
"unsigned",
"X86TTI",
"::",
"getNumberOfRegisters",
"(",
"bool",
"Vector",
")",
"const",
"{",
"if",
"(",
"Vector",
"&&",
"!",
"ST",
"->",
"hasSSE1",
"(",
")",
")",
"return",
"0",
";",
"if",
"(",
"ST",
"->",
"is64Bit",
"(",
")",
")",
"return",
"16",
";",
"return",
"8",
";",
"}",
"</s>"
] | [
"�",
"?",
"Vector",
"TTI",
"begin",
"�",
"?"
] | [
"X86",
"X86",
"0",
"16",
"8"
] | X86TargetTransformInfo113 | getNumberOfRegisters | X86 | CPU | LLVM | 16,419 | 39 | 1 | [] |
[
"<s>",
"const_iterator",
"end",
"(",
")",
"const",
"{",
"return",
"Blocks",
".",
"end",
"(",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"const_iterator",
"to",
"the",
"end",
"of",
"the",
"symbol",
"table",
"."
] | [
"Hexagon"
] | HexagonVectorCombine | end | Hexagon | DSP | LLVM | 16,420 | 14 | 1 | [] |
[
"<s>",
"bool",
"X86TargetMachine",
"::",
"addPreRegAlloc",
"(",
"PassManagerBase",
"&",
"PM",
",",
"bool",
"Fast",
")",
"{",
"PM",
".",
"add",
"(",
"createX86MaxStackAlignmentCalculatorPass",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"X86",
"X86",
"X86"
] | X86TargetMachine92 | addPreRegAlloc | X86 | CPU | LLVM | 16,421 | 26 | 1 | [] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"BuildSDIVPow2",
"(",
"SDNode",
"*",
"N",
",",
"const",
"APInt",
"&",
"Divisor",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDNode",
"*",
">",
"&",
"Created",
")",
"const",
"{",
"EVT",
"VT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i64",
"&&",
"!",
"Subtarget",
".",
"isPPC64",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"(",
"VT",
"!=",
"MVT",
"::",
"i32",
"&&",
"VT",
"!=",
"MVT",
"::",
"i64",
")",
"||",
"!",
"(",
"Divisor",
".",
"isPowerOf2",
"(",
")",
"||",
"(",
"-",
"Divisor",
")",
".",
"isPowerOf2",
"(",
")",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"SDValue",
"N0",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"bool",
"IsNegPow2",
"=",
"(",
"-",
"Divisor",
")",
".",
"isPowerOf2",
"(",
")",
";",
"unsigned",
"Lg2",
"=",
"(",
"IsNegPow2",
"?",
"-",
"Divisor",
":",
"Divisor",
")",
".",
"countTrailingZeros",
"(",
")",
";",
"SDValue",
"ShiftAmt",
"=",
"DAG",
".",
"getConstant",
"(",
"Lg2",
",",
"DL",
",",
"VT",
")",
";",
"SDValue",
"Op",
"=",
"DAG",
".",
"getNode",
"(",
"PPCISD",
"::",
"SRA_ADDZE",
",",
"DL",
",",
"VT",
",",
"N0",
",",
"ShiftAmt",
")",
";",
"Created",
".",
"push_back",
"(",
"Op",
".",
"getNode",
"(",
")",
")",
";",
"if",
"(",
"IsNegPow2",
")",
"{",
"Op",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SUB",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"VT",
")",
",",
"Op",
")",
";",
"Created",
".",
"push_back",
"(",
"Op",
".",
"getNode",
"(",
")",
")",
";",
"}",
"return",
"Op",
";",
"}",
"</s>"
] | [
"Targets",
"may",
"override",
"this",
"function",
"to",
"provide",
"custom",
"SDIV",
"lowering",
"for",
"power-of-2",
"denominators",
"."
] | [
"PowerPC",
"PPC",
"0",
"MVT::i64",
"PPC",
"MVT::i32",
"MVT::i64",
"0",
"PPCISD::SRA_ADDZE",
"ISD::SUB",
"0"
] | PPCISelLowering (2)7 | BuildSDIVPow2 | PowerPC | CPU | LLVM | 16,422 | 235 | 1 | [] |
[
"<s>",
"static",
"void",
"ia64_sched_finish",
"(",
"FILE",
"*",
"dump",
",",
"int",
"sched_verbose",
")",
"{",
"if",
"(",
"sched_verbose",
")",
"fprintf",
"(",
"dump",
",",
"\"// Finishing schedule.\\n\"",
")",
";",
"if",
"(",
"!",
"reload_completed",
")",
"return",
";",
"if",
"(",
"reload_completed",
")",
"{",
"final_emit_insn_group_barriers",
"(",
"dump",
")",
";",
"bundling",
"(",
"dump",
",",
"sched_verbose",
",",
"current_sched_info",
"->",
"prev_head",
",",
"current_sched_info",
"->",
"next_tail",
")",
";",
"if",
"(",
"sched_verbose",
"&&",
"dump",
")",
"fprintf",
"(",
"dump",
",",
"\"// finishing %d-%d\\n\"",
",",
"INSN_UID",
"(",
"NEXT_INSN",
"(",
"current_sched_info",
"->",
"prev_head",
")",
")",
",",
"INSN_UID",
"(",
"PREV_INSN",
"(",
"current_sched_info",
"->",
"next_tail",
")",
")",
")",
";",
"return",
";",
"}",
"}",
"</s>"
] | [
"Free",
"data",
"allocated",
"by",
"ia64_sched_init",
"."
] | [
"ia64",
"\"// Finishing schedule.\\n\"",
"\"// finishing %d-%d\\n\""
] | ia64 | ia64_sched_finish | ia64 | CPU | GCC | 16,423 | 92 | 1 | [] |
[
"<s>",
"const",
"ArrayRef",
"<",
"MCPhysReg",
">",
"MipsABIInfo",
"::",
"GetVarArgRegs",
"(",
")",
"const",
"{",
"if",
"(",
"IsO32",
"(",
")",
")",
"return",
"makeArrayRef",
"(",
"O32IntRegs",
")",
";",
"if",
"(",
"IsN32",
"(",
")",
"||",
"IsN64",
"(",
")",
")",
"return",
"makeArrayRef",
"(",
"Mips64IntRegs",
")",
";",
"llvm_unreachable",
"(",
"\"Unhandled ABI\"",
")",
";",
"}",
"</s>"
] | [
"The",
"registers",
"to",
"use",
"for",
"the",
"variable",
"argument",
"list",
"."
] | [
"Mips",
"Mips",
"Mips",
"\"Unhandled ABI\""
] | MipsABIInfo15 | GetVarArgRegs | Mips | CPU | LLVM | 16,424 | 46 | 1 | [] |
[
"<s>",
"int",
"expand_block_clear",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"orig_dest",
"=",
"operands",
"[",
"0",
"]",
";",
"rtx",
"bytes_rtx",
"=",
"operands",
"[",
"1",
"]",
";",
"rtx",
"align_rtx",
"=",
"operands",
"[",
"3",
"]",
";",
"bool",
"constp",
"=",
"(",
"GET_CODE",
"(",
"bytes_rtx",
")",
"==",
"CONST_INT",
")",
";",
"HOST_WIDE_INT",
"align",
";",
"HOST_WIDE_INT",
"bytes",
";",
"int",
"offset",
";",
"int",
"clear_bytes",
";",
"int",
"clear_step",
";",
"if",
"(",
"!",
"constp",
")",
"return",
"0",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"align_rtx",
")",
"==",
"CONST_INT",
")",
";",
"align",
"=",
"INTVAL",
"(",
"align_rtx",
")",
"*",
"BITS_PER_UNIT",
";",
"bytes",
"=",
"INTVAL",
"(",
"bytes_rtx",
")",
";",
"if",
"(",
"bytes",
"<=",
"0",
")",
"return",
"1",
";",
"if",
"(",
"TARGET_ALTIVEC",
"&&",
"(",
"align",
">=",
"128",
"||",
"TARGET_EFFICIENT_UNALIGNED_VSX",
")",
")",
"clear_step",
"=",
"16",
";",
"else",
"if",
"(",
"TARGET_POWERPC64",
"&&",
"(",
"align",
">=",
"64",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"clear_step",
"=",
"8",
";",
"else",
"clear_step",
"=",
"4",
";",
"if",
"(",
"optimize_size",
"&&",
"bytes",
">",
"3",
"*",
"clear_step",
")",
"return",
"0",
";",
"if",
"(",
"!",
"optimize_size",
"&&",
"bytes",
">",
"8",
"*",
"clear_step",
")",
"return",
"0",
";",
"for",
"(",
"offset",
"=",
"0",
";",
"bytes",
">",
"0",
";",
"offset",
"+=",
"clear_bytes",
",",
"bytes",
"-=",
"clear_bytes",
")",
"{",
"machine_mode",
"mode",
"=",
"BLKmode",
";",
"rtx",
"dest",
";",
"if",
"(",
"bytes",
">=",
"16",
"&&",
"TARGET_ALTIVEC",
"&&",
"(",
"align",
">=",
"128",
"||",
"TARGET_EFFICIENT_UNALIGNED_VSX",
")",
")",
"{",
"clear_bytes",
"=",
"16",
";",
"mode",
"=",
"V4SImode",
";",
"}",
"else",
"if",
"(",
"bytes",
">=",
"8",
"&&",
"TARGET_POWERPC64",
"&&",
"(",
"align",
">=",
"64",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"{",
"clear_bytes",
"=",
"8",
";",
"mode",
"=",
"DImode",
";",
"if",
"(",
"offset",
"==",
"0",
"&&",
"align",
"<",
"64",
")",
"{",
"rtx",
"addr",
";",
"addr",
"=",
"XEXP",
"(",
"orig_dest",
",",
"0",
")",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"PLUS",
"||",
"GET_CODE",
"(",
"addr",
")",
"==",
"LO_SUM",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"&",
"3",
")",
"!=",
"0",
")",
"{",
"addr",
"=",
"copy_addr_to_reg",
"(",
"addr",
")",
";",
"orig_dest",
"=",
"replace_equiv_address",
"(",
"orig_dest",
",",
"addr",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"bytes",
">=",
"4",
"&&",
"(",
"align",
">=",
"32",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"{",
"clear_bytes",
"=",
"4",
";",
"mode",
"=",
"SImode",
";",
"}",
"else",
"if",
"(",
"bytes",
">=",
"2",
"&&",
"(",
"align",
">=",
"16",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"{",
"clear_bytes",
"=",
"2",
";",
"mode",
"=",
"HImode",
";",
"}",
"else",
"{",
"clear_bytes",
"=",
"1",
";",
"mode",
"=",
"QImode",
";",
"}",
"dest",
"=",
"adjust_address",
"(",
"orig_dest",
",",
"mode",
",",
"offset",
")",
";",
"emit_move_insn",
"(",
"dest",
",",
"CONST0_RTX",
"(",
"mode",
")",
")",
";",
"}",
"return",
"1",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"block",
"clear",
"operation",
",",
"and",
"return",
"1",
"if",
"successful",
".",
"Return",
"0",
"if",
"we",
"should",
"let",
"the",
"compiler",
"generate",
"normal",
"code",
".",
"operands",
"[",
"0",
"]",
"is",
"the",
"destination",
"operands",
"[",
"1",
"]",
"is",
"the",
"length",
"operands",
"[",
"3",
"]",
"is",
"the",
"alignment"
] | [
"rs6000",
"0",
"1",
"3",
"0",
"0",
"1",
"128",
"16",
"64",
"8",
"4",
"3",
"0",
"8",
"0",
"0",
"0",
"16",
"128",
"16",
"8",
"64",
"8",
"0",
"64",
"0",
"1",
"1",
"3",
"0",
"4",
"32",
"4",
"2",
"16",
"2",
"1",
"1"
] | rs6000-string2 | expand_block_clear | rs6000 | CPU | GCC | 16,425 | 427 | 1 | [] |
[
"<s>",
"unsigned",
"AlphaInstrInfo",
"::",
"getGlobalBaseReg",
"(",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"AlphaMachineFunctionInfo",
"*",
"AlphaFI",
"=",
"MF",
"->",
"getInfo",
"<",
"AlphaMachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"GlobalBaseReg",
"=",
"AlphaFI",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"if",
"(",
"GlobalBaseReg",
"!=",
"0",
")",
"return",
"GlobalBaseReg",
";",
"MachineBasicBlock",
"&",
"FirstMBB",
"=",
"MF",
"->",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"FirstMBB",
".",
"begin",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RegInfo",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"GlobalBaseReg",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"&",
"Alpha",
"::",
"GPRCRegClass",
")",
";",
"bool",
"Ok",
"=",
"TII",
"->",
"copyRegToReg",
"(",
"FirstMBB",
",",
"MBBI",
",",
"GlobalBaseReg",
",",
"Alpha",
"::",
"R29",
",",
"&",
"Alpha",
"::",
"GPRCRegClass",
",",
"&",
"Alpha",
"::",
"GPRCRegClass",
")",
";",
"assert",
"(",
"Ok",
"&&",
"\"Couldn't assign to global base register!\"",
")",
";",
"Ok",
"=",
"Ok",
";",
"RegInfo",
".",
"addLiveIn",
"(",
"Alpha",
"::",
"R29",
")",
";",
"AlphaFI",
"->",
"setGlobalBaseReg",
"(",
"GlobalBaseReg",
")",
";",
"return",
"GlobalBaseReg",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"Alpha",
"Alpha",
"Alpha",
"Alpha",
"Alpha",
"Alpha",
"0",
"Alpha::GPRCRegClass",
"Alpha::R29",
"Alpha::GPRCRegClass",
"Alpha::GPRCRegClass",
"\"Couldn't assign to global base register!\"",
"Alpha::R29",
"Alpha"
] | AlphaInstrInfo1 | getGlobalBaseReg | Alpha | MPU | LLVM | 16,426 | 159 | 1 | [] |
[
"<s>",
"static",
"bool",
"sparc_frame_pointer_required",
"(",
"void",
")",
"{",
"if",
"(",
"cfun",
"->",
"calls_alloca",
")",
"return",
"true",
";",
"if",
"(",
"cfun",
"->",
"has_nonlocal_label",
")",
"return",
"true",
";",
"if",
"(",
"TARGET_FLAT",
")",
"return",
"false",
";",
"return",
"!",
"(",
"optimize",
">",
"0",
"&&",
"crtl",
"->",
"is_leaf",
"&&",
"only_leaf_regs_used",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FRAME_POINTER_REQUIRED",
"."
] | [
"sparc",
"0"
] | sparc | sparc_frame_pointer_required | sparc | CPU | GCC | 16,427 | 49 | 1 | [] |
[
"<s>",
"static",
"void",
"build_sv_uint_offset",
"(",
"function_builder",
"&",
"b",
",",
"const",
"char",
"*",
"signature",
",",
"const",
"function_group_info",
"&",
"group",
")",
"{",
"build_32_64",
"(",
"b",
",",
"signature",
",",
"group",
",",
"MODE_none",
",",
"MODE_s64offset",
")",
";",
"build_32_64",
"(",
"b",
",",
"signature",
",",
"group",
",",
"MODE_u32offset",
",",
"MODE_u64offset",
")",
";",
"}",
"</s>"
] | [
"Like",
"build_sv_offset",
",",
"but",
"exclude",
"offsets",
"that",
"must",
"be",
"interpreted",
"as",
"signed",
"(",
"i.e",
".",
"s32offset",
")",
"."
] | [
"aarch64"
] | aarch64-sve-builtins-shapes | build_sv_uint_offset | aarch64 | CPU | GCC | 16,428 | 46 | 1 | [] |
[
"<s>",
"static",
"rtx",
"expand_set_or_cpymem_prologue",
"(",
"rtx",
"destmem",
",",
"rtx",
"srcmem",
",",
"rtx",
"destptr",
",",
"rtx",
"srcptr",
",",
"rtx",
"value",
",",
"rtx",
"vec_value",
",",
"rtx",
"count",
",",
"int",
"align",
",",
"int",
"desired_alignment",
",",
"bool",
"issetmem",
")",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"desired_alignment",
";",
"i",
"<<=",
"1",
")",
"{",
"if",
"(",
"align",
"<=",
"i",
")",
"{",
"rtx_code_label",
"*",
"label",
"=",
"ix86_expand_aligntest",
"(",
"destptr",
",",
"i",
",",
"false",
")",
";",
"if",
"(",
"issetmem",
")",
"{",
"if",
"(",
"vec_value",
"&&",
"i",
">",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"value",
")",
")",
")",
"destmem",
"=",
"emit_memset",
"(",
"destmem",
",",
"destptr",
",",
"vec_value",
",",
"i",
")",
";",
"else",
"destmem",
"=",
"emit_memset",
"(",
"destmem",
",",
"destptr",
",",
"value",
",",
"i",
")",
";",
"}",
"else",
"destmem",
"=",
"emit_memmov",
"(",
"destmem",
",",
"&",
"srcmem",
",",
"destptr",
",",
"srcptr",
",",
"i",
")",
";",
"ix86_adjust_counter",
"(",
"count",
",",
"i",
")",
";",
"emit_label",
"(",
"label",
")",
";",
"LABEL_NUSES",
"(",
"label",
")",
"=",
"1",
";",
"set_mem_align",
"(",
"destmem",
",",
"i",
"*",
"2",
"*",
"BITS_PER_UNIT",
")",
";",
"}",
"}",
"return",
"destmem",
";",
"}",
"</s>"
] | [
"Depending",
"on",
"ISSETMEM",
",",
"copy",
"enough",
"from",
"SRCMEM",
"to",
"DESTMEM",
"or",
"set",
"enough",
"to",
"DESTMEM",
"to",
"align",
"it",
"to",
"DESIRED_ALIGNMENT",
".",
"Original",
"alignment",
"is",
"ALIGN",
".",
"Depending",
"on",
"ISSETMEM",
",",
"either",
"arguments",
"SRCMEM/SRCPTR",
"or",
"VALUE/VEC_VALUE",
"are",
"ignored",
".",
"Return",
"value",
"is",
"updated",
"DESTMEM",
"."
] | [
"i386",
"1",
"1",
"1",
"2"
] | i386-expand | expand_set_or_cpymem_prologue | i386 | CPU | GCC | 16,429 | 173 | 1 | [] |
[
"<s>",
"void",
"MOSPassConfig",
"::",
"addMachineSSAOptimization",
"(",
")",
"{",
"TargetPassConfig",
"::",
"addMachineSSAOptimization",
"(",
")",
";",
"addPass",
"(",
"createMOSInsertCopiesPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Methods",
"with",
"trivial",
"inline",
"returns",
"are",
"convenient",
"points",
"in",
"the",
"common",
"codegen",
"pass",
"pipeline",
"where",
"targets",
"may",
"insert",
"passes",
"."
] | [
"MOS",
"MOS",
"MOS"
] | MOSTargetMachine | addMachineSSAOptimization | MOS | MPU | LLVM | 16,430 | 21 | 1 | [] |
[
"<s>",
"virtual",
"uint32_t",
"generateCompactUnwindEncoding",
"(",
"ArrayRef",
"<",
"MCCFIInstruction",
">",
"Instrs",
")",
"const",
"{",
"return",
"SupportsCU",
"?",
"generateCompactUnwindEncodingImpl",
"(",
"Instrs",
")",
":",
"0",
";",
"}",
"</s>"
] | [
"Generate",
"compact",
"unwind",
"encoding",
"for",
"the",
"function",
"based",
"on",
"the",
"CFI",
"instructions",
"."
] | [
"X86",
"0"
] | X86AsmBackend27 | generateCompactUnwindEncoding | X86 | CPU | LLVM | 16,431 | 23 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"hfa_element_mode",
"(",
"const_tree",
"type",
",",
"bool",
"nested",
")",
"{",
"machine_mode",
"element_mode",
"=",
"VOIDmode",
";",
"machine_mode",
"mode",
";",
"enum",
"tree_code",
"code",
"=",
"TREE_CODE",
"(",
"type",
")",
";",
"int",
"know_element_mode",
"=",
"0",
";",
"tree",
"t",
";",
"if",
"(",
"!",
"nested",
"&&",
"(",
"!",
"TYPE_SIZE",
"(",
"type",
")",
"||",
"integer_zerop",
"(",
"TYPE_SIZE",
"(",
"type",
")",
")",
")",
")",
"return",
"VOIDmode",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"VOID_TYPE",
":",
"case",
"INTEGER_TYPE",
":",
"case",
"ENUMERAL_TYPE",
":",
"case",
"BOOLEAN_TYPE",
":",
"case",
"POINTER_TYPE",
":",
"case",
"OFFSET_TYPE",
":",
"case",
"REFERENCE_TYPE",
":",
"case",
"METHOD_TYPE",
":",
"case",
"LANG_TYPE",
":",
"case",
"FUNCTION_TYPE",
":",
"return",
"VOIDmode",
";",
"case",
"COMPLEX_TYPE",
":",
"if",
"(",
"GET_MODE_CLASS",
"(",
"TYPE_MODE",
"(",
"type",
")",
")",
"==",
"MODE_COMPLEX_FLOAT",
"&&",
"TYPE_MODE",
"(",
"type",
")",
"!=",
"TCmode",
")",
"return",
"GET_MODE_INNER",
"(",
"TYPE_MODE",
"(",
"type",
")",
")",
";",
"else",
"return",
"VOIDmode",
";",
"case",
"REAL_TYPE",
":",
"if",
"(",
"nested",
"&&",
"TYPE_MODE",
"(",
"type",
")",
"!=",
"TFmode",
")",
"return",
"TYPE_MODE",
"(",
"type",
")",
";",
"else",
"return",
"VOIDmode",
";",
"case",
"ARRAY_TYPE",
":",
"return",
"hfa_element_mode",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"1",
")",
";",
"case",
"RECORD_TYPE",
":",
"case",
"UNION_TYPE",
":",
"case",
"QUAL_UNION_TYPE",
":",
"for",
"(",
"t",
"=",
"TYPE_FIELDS",
"(",
"type",
")",
";",
"t",
";",
"t",
"=",
"DECL_CHAIN",
"(",
"t",
")",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"t",
")",
"!=",
"FIELD_DECL",
"||",
"DECL_FIELD_ABI_IGNORED",
"(",
"t",
")",
")",
"continue",
";",
"mode",
"=",
"hfa_element_mode",
"(",
"TREE_TYPE",
"(",
"t",
")",
",",
"1",
")",
";",
"if",
"(",
"know_element_mode",
")",
"{",
"if",
"(",
"mode",
"!=",
"element_mode",
")",
"return",
"VOIDmode",
";",
"}",
"else",
"if",
"(",
"GET_MODE_CLASS",
"(",
"mode",
")",
"!=",
"MODE_FLOAT",
")",
"return",
"VOIDmode",
";",
"else",
"{",
"know_element_mode",
"=",
"1",
";",
"element_mode",
"=",
"mode",
";",
"}",
"}",
"return",
"element_mode",
";",
"default",
":",
"return",
"VOIDmode",
";",
"}",
"return",
"VOIDmode",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"TYPE",
"is",
"a",
"homogeneous",
"floating",
"point",
"aggregate",
".",
"If",
"it",
"is",
",",
"return",
"the",
"mode",
"of",
"the",
"floating",
"point",
"type",
"that",
"appears",
"in",
"all",
"leafs",
".",
"If",
"it",
"is",
"not",
",",
"return",
"VOIDmode",
".",
"An",
"aggregate",
"is",
"a",
"homogeneous",
"floating",
"point",
"aggregate",
"is",
"if",
"all",
"fields/elements",
"in",
"it",
"have",
"the",
"same",
"floating",
"point",
"type",
"(",
"e.g",
",",
"SFmode",
")",
".",
"128-bit",
"quad-precision",
"floats",
"are",
"excluded",
"."
] | [
"ia64",
"0",
"1",
"1",
"1"
] | ia64 | hfa_element_mode | ia64 | CPU | GCC | 16,432 | 280 | 1 | [] |
[
"<s>",
"static",
"rtx",
"ix86_expand_sse_cmp",
"(",
"rtx",
"dest",
",",
"enum",
"rtx_code",
"code",
",",
"rtx",
"cmp_op0",
",",
"rtx",
"cmp_op1",
",",
"rtx",
"op_true",
",",
"rtx",
"op_false",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"dest",
")",
";",
"machine_mode",
"cmp_ops_mode",
"=",
"GET_MODE",
"(",
"cmp_op0",
")",
";",
"machine_mode",
"cmp_mode",
";",
"bool",
"maskcmp",
"=",
"false",
";",
"rtx",
"x",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"cmp_ops_mode",
")",
"==",
"64",
")",
"{",
"unsigned",
"int",
"nbits",
"=",
"GET_MODE_NUNITS",
"(",
"cmp_ops_mode",
")",
";",
"cmp_mode",
"=",
"int_mode_for_size",
"(",
"nbits",
",",
"0",
")",
".",
"require",
"(",
")",
";",
"maskcmp",
"=",
"true",
";",
"}",
"else",
"cmp_mode",
"=",
"cmp_ops_mode",
";",
"cmp_op0",
"=",
"force_reg",
"(",
"cmp_ops_mode",
",",
"cmp_op0",
")",
";",
"if",
"(",
"!",
"nonimmediate_operand",
"(",
"cmp_op1",
",",
"cmp_ops_mode",
")",
")",
"cmp_op1",
"=",
"force_reg",
"(",
"cmp_ops_mode",
",",
"cmp_op1",
")",
";",
"if",
"(",
"optimize",
"||",
"(",
"maskcmp",
"&&",
"cmp_mode",
"!=",
"mode",
")",
"||",
"(",
"op_true",
"&&",
"reg_overlap_mentioned_p",
"(",
"dest",
",",
"op_true",
")",
")",
"||",
"(",
"op_false",
"&&",
"reg_overlap_mentioned_p",
"(",
"dest",
",",
"op_false",
")",
")",
")",
"dest",
"=",
"gen_reg_rtx",
"(",
"maskcmp",
"?",
"cmp_mode",
":",
"mode",
")",
";",
"if",
"(",
"maskcmp",
"&&",
"(",
"code",
"==",
"GT",
"||",
"code",
"==",
"EQ",
")",
")",
"{",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"switch",
"(",
"cmp_ops_mode",
")",
"{",
"case",
"E_V64QImode",
":",
"gcc_assert",
"(",
"TARGET_AVX512BW",
")",
";",
"gen",
"=",
"code",
"==",
"GT",
"?",
"gen_avx512bw_gtv64qi3",
":",
"gen_avx512bw_eqv64qi3_1",
";",
"break",
";",
"case",
"E_V32HImode",
":",
"gcc_assert",
"(",
"TARGET_AVX512BW",
")",
";",
"gen",
"=",
"code",
"==",
"GT",
"?",
"gen_avx512bw_gtv32hi3",
":",
"gen_avx512bw_eqv32hi3_1",
";",
"break",
";",
"case",
"E_V16SImode",
":",
"gen",
"=",
"code",
"==",
"GT",
"?",
"gen_avx512f_gtv16si3",
":",
"gen_avx512f_eqv16si3_1",
";",
"break",
";",
"case",
"E_V8DImode",
":",
"gen",
"=",
"code",
"==",
"GT",
"?",
"gen_avx512f_gtv8di3",
":",
"gen_avx512f_eqv8di3_1",
";",
"break",
";",
"default",
":",
"gen",
"=",
"NULL",
";",
"}",
"if",
"(",
"gen",
")",
"{",
"emit_insn",
"(",
"gen",
"(",
"dest",
",",
"cmp_op0",
",",
"cmp_op1",
")",
")",
";",
"return",
"dest",
";",
"}",
"}",
"x",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"cmp_mode",
",",
"cmp_op0",
",",
"cmp_op1",
")",
";",
"if",
"(",
"cmp_mode",
"!=",
"mode",
"&&",
"!",
"maskcmp",
")",
"{",
"x",
"=",
"force_reg",
"(",
"cmp_ops_mode",
",",
"x",
")",
";",
"convert_move",
"(",
"dest",
",",
"x",
",",
"false",
")",
";",
"}",
"else",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dest",
",",
"x",
")",
")",
";",
"return",
"dest",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"sse",
"vector",
"comparison",
".",
"Return",
"the",
"register",
"with",
"the",
"result",
"."
] | [
"i386",
"64",
"0"
] | i3867 | ix86_expand_sse_cmp | i386 | CPU | GCC | 16,433 | 355 | 1 | [] |
[
"<s>",
"unsigned",
"ARMBaseInstrInfo",
"::",
"getInstrLatency",
"(",
"const",
"InstrItineraryData",
"*",
"ItinData",
",",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"*",
"PredCost",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"isCopyLike",
"(",
")",
"||",
"MI",
"->",
"isInsertSubreg",
"(",
")",
"||",
"MI",
"->",
"isRegSequence",
"(",
")",
"||",
"MI",
"->",
"isImplicitDef",
"(",
")",
")",
"return",
"1",
";",
"if",
"(",
"MI",
"->",
"isBundle",
"(",
")",
")",
"{",
"unsigned",
"Latency",
"=",
"0",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"I",
"=",
"MI",
"->",
"getIterator",
"(",
")",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"E",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"instr_end",
"(",
")",
";",
"while",
"(",
"++",
"I",
"!=",
"E",
"&&",
"I",
"->",
"isInsideBundle",
"(",
")",
")",
"{",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"!=",
"ARM",
"::",
"t2IT",
")",
"Latency",
"+=",
"getInstrLatency",
"(",
"ItinData",
",",
"&",
"*",
"I",
",",
"PredCost",
")",
";",
"}",
"return",
"Latency",
";",
"}",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"if",
"(",
"PredCost",
"&&",
"(",
"MCID",
".",
"isCall",
"(",
")",
"||",
"MCID",
".",
"hasImplicitDefOfPhysReg",
"(",
"ARM",
"::",
"CPSR",
")",
")",
")",
"{",
"*",
"PredCost",
"=",
"1",
";",
"}",
"if",
"(",
"!",
"ItinData",
")",
"return",
"MI",
"->",
"mayLoad",
"(",
")",
"?",
"3",
":",
"1",
";",
"unsigned",
"Class",
"=",
"MCID",
".",
"getSchedClass",
"(",
")",
";",
"if",
"(",
"!",
"ItinData",
"->",
"isEmpty",
"(",
")",
"&&",
"ItinData",
"->",
"getNumMicroOps",
"(",
"Class",
")",
"<",
"0",
")",
"return",
"getNumMicroOps",
"(",
"ItinData",
",",
"MI",
")",
";",
"unsigned",
"Latency",
"=",
"ItinData",
"->",
"getStageLatency",
"(",
"Class",
")",
";",
"unsigned",
"DefAlign",
"=",
"MI",
"->",
"hasOneMemOperand",
"(",
")",
"?",
"(",
"*",
"MI",
"->",
"memoperands_begin",
"(",
")",
")",
"->",
"getAlignment",
"(",
")",
":",
"0",
";",
"int",
"Adj",
"=",
"adjustDefLatency",
"(",
"Subtarget",
",",
"MI",
",",
"&",
"MCID",
",",
"DefAlign",
")",
";",
"if",
"(",
"Adj",
">=",
"0",
"||",
"(",
"int",
")",
"Latency",
">",
"-",
"Adj",
")",
"{",
"return",
"Latency",
"+",
"Adj",
";",
"}",
"return",
"Latency",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"instruction",
"latency",
"of",
"a",
"given",
"instruction",
"."
] | [
"ARM",
"ARM",
"1",
"0",
"ARM::t2IT",
"ARM::CPSR",
"1",
"3",
"1",
"0",
"0",
"0"
] | ARMBaseInstrInfo (2)3 | getInstrLatency | ARM | CPU | LLVM | 16,434 | 298 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SystemZ Comparison Elimination\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"SystemZ",
"\"SystemZ Comparison Elimination\""
] | SystemZElimCompare (2) | getPassName | SystemZ | CPU | LLVM | 16,435 | 13 | 1 | [] |
[
"<s>",
"unsigned",
"SISubtarget",
"::",
"getOccupancyWithNumSGPRs",
"(",
"unsigned",
"SGPRs",
")",
"const",
"{",
"if",
"(",
"getGeneration",
"(",
")",
">=",
"SISubtarget",
"::",
"VOLCANIC_ISLANDS",
")",
"{",
"if",
"(",
"SGPRs",
"<=",
"80",
")",
"return",
"10",
";",
"if",
"(",
"SGPRs",
"<=",
"88",
")",
"return",
"9",
";",
"if",
"(",
"SGPRs",
"<=",
"100",
")",
"return",
"8",
";",
"return",
"7",
";",
"}",
"if",
"(",
"SGPRs",
"<=",
"48",
")",
"return",
"10",
";",
"if",
"(",
"SGPRs",
"<=",
"56",
")",
"return",
"9",
";",
"if",
"(",
"SGPRs",
"<=",
"64",
")",
"return",
"8",
";",
"if",
"(",
"SGPRs",
"<=",
"72",
")",
"return",
"7",
";",
"if",
"(",
"SGPRs",
"<=",
"80",
")",
"return",
"6",
";",
"return",
"5",
";",
"}",
"</s>"
] | [
"Return",
"the",
"maximum",
"number",
"of",
"waves",
"per",
"SIMD",
"for",
"kernels",
"using",
"SGPRs",
"SGPRs",
"."
] | [
"AMDGPU",
"SI",
"SI",
"80",
"10",
"88",
"9",
"100",
"8",
"7",
"48",
"10",
"56",
"9",
"64",
"8",
"72",
"7",
"80",
"6",
"5"
] | AMDGPUSubtarget10 | getOccupancyWithNumSGPRs | AMDGPU | GPU | LLVM | 16,436 | 101 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"Mandarin Assembly Printer\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Mandarin",
"\"Mandarin Assembly Printer\""
] | MandarinAsmPrinter | getPassName | Mandarin | CPU | LLVM | 16,437 | 13 | 1 | [] |
[
"<s>",
"bool",
"M68kFrameLowering",
"::",
"assignCalleeSavedSpillSlots",
"(",
"MachineFunction",
"&",
"MF",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
")",
"const",
"{",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"M68kMachineFunctionInfo",
"*",
"M68kFI",
"=",
"MF",
".",
"getInfo",
"<",
"M68kMachineFunctionInfo",
">",
"(",
")",
";",
"int",
"SpillSlotOffset",
"=",
"getOffsetOfLocalArea",
"(",
")",
"+",
"M68kFI",
"->",
"getTCReturnAddrDelta",
"(",
")",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"SpillSlotOffset",
"-=",
"SlotSize",
";",
"MFI",
".",
"CreateFixedSpillStackObject",
"(",
"SlotSize",
",",
"SpillSlotOffset",
")",
";",
"unsigned",
"FPReg",
"=",
"TRI",
"->",
"getFrameRegister",
"(",
"MF",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"TRI",
"->",
"regsOverlap",
"(",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
",",
"FPReg",
")",
")",
"{",
"CSI",
".",
"erase",
"(",
"CSI",
".",
"begin",
"(",
")",
"+",
"i",
")",
";",
"break",
";",
"}",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"function",
"will",
"assign",
"callee",
"saved",
"gprs",
"to",
"volatile",
"vector",
"registers",
"for",
"prologue",
"spills",
"when",
"applicable",
"."
] | [
"M68k",
"M68k",
"M68k",
"M68k",
"M68k",
"M68k",
"0"
] | M68kFrameLowering | assignCalleeSavedSpillSlots | M68k | MPU | LLVM | 16,438 | 156 | 1 | [] |
[
"<s>",
"rtx",
"legitimize_pic_address",
"(",
"rtx",
"orig",
",",
"rtx",
"reg",
",",
"rtx",
"picreg",
")",
"{",
"rtx",
"addr",
"=",
"orig",
";",
"rtx",
"new",
"=",
"orig",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"addr",
")",
"==",
"LABEL_REF",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"SYMBOL_REF",
"&&",
"CONSTANT_POOL_ADDRESS_P",
"(",
"addr",
")",
")",
"reg",
"=",
"new",
"=",
"orig",
";",
"else",
"{",
"if",
"(",
"reg",
"==",
"0",
")",
"{",
"gcc_assert",
"(",
"!",
"no_new_pseudos",
")",
";",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"}",
"if",
"(",
"flag_pic",
"==",
"2",
")",
"{",
"emit_insn",
"(",
"gen_movsi_high_pic",
"(",
"reg",
",",
"addr",
")",
")",
";",
"emit_insn",
"(",
"gen_movsi_low_pic",
"(",
"reg",
",",
"reg",
",",
"addr",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"reg",
",",
"reg",
",",
"picreg",
")",
")",
";",
"new",
"=",
"gen_const_mem",
"(",
"Pmode",
",",
"reg",
")",
";",
"}",
"else",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"addr",
")",
",",
"UNSPEC_MOVE_PIC",
")",
";",
"new",
"=",
"gen_const_mem",
"(",
"Pmode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"picreg",
",",
"tmp",
")",
")",
";",
"}",
"emit_move_insn",
"(",
"reg",
",",
"new",
")",
";",
"}",
"if",
"(",
"picreg",
"==",
"pic_offset_table_rtx",
")",
"current_function_uses_pic_offset_table",
"=",
"1",
";",
"return",
"reg",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST",
"||",
"GET_CODE",
"(",
"addr",
")",
"==",
"PLUS",
")",
"{",
"rtx",
"base",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST",
")",
"{",
"addr",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"PLUS",
")",
";",
"}",
"if",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
"==",
"picreg",
")",
"return",
"orig",
";",
"if",
"(",
"reg",
"==",
"0",
")",
"{",
"gcc_assert",
"(",
"!",
"no_new_pseudos",
")",
";",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"}",
"base",
"=",
"legitimize_pic_address",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"reg",
",",
"picreg",
")",
";",
"addr",
"=",
"legitimize_pic_address",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
",",
"base",
"==",
"reg",
"?",
"NULL_RTX",
":",
"reg",
",",
"picreg",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST_INT",
")",
"{",
"gcc_assert",
"(",
"!",
"reload_in_progress",
"&&",
"!",
"reload_completed",
")",
";",
"addr",
"=",
"force_reg",
"(",
"Pmode",
",",
"addr",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"PLUS",
"&&",
"CONSTANT_P",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
")",
"{",
"base",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"base",
",",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
";",
"addr",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"}",
"return",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"base",
",",
"addr",
")",
";",
"}",
"return",
"new",
";",
"}",
"</s>"
] | [
"Legitimize",
"PIC",
"addresses",
".",
"If",
"the",
"address",
"is",
"already",
"position-independent",
",",
"we",
"return",
"ORIG",
".",
"Newly",
"generated",
"position-independent",
"addresses",
"go",
"into",
"a",
"reg",
".",
"This",
"is",
"REG",
"if",
"nonzero",
",",
"otherwise",
"we",
"allocate",
"register",
"(",
"s",
")",
"as",
"necessary",
"."
] | [
"bfin",
"0",
"2",
"1",
"1",
"0",
"0",
"0",
"0",
"1",
"1",
"0",
"1"
] | bfin2 | legitimize_pic_address | bfin | DSP | GCC | 16,439 | 406 | 1 | [] |
[
"<s>",
"void",
"SIScheduleBlock",
"::",
"releaseSucc",
"(",
"SUnit",
"*",
"SU",
",",
"SDep",
"*",
"SuccEdge",
")",
"{",
"SUnit",
"*",
"SuccSU",
"=",
"SuccEdge",
"->",
"getSUnit",
"(",
")",
";",
"if",
"(",
"SuccEdge",
"->",
"isWeak",
"(",
")",
")",
"{",
"--",
"SuccSU",
"->",
"WeakPredsLeft",
";",
"return",
";",
"}",
"if",
"(",
"SuccSU",
"->",
"NumPredsLeft",
"==",
"0",
")",
"{",
"dbgs",
"(",
")",
"<<",
"\"*** Scheduling failed! ***\\n\"",
";",
"DAG",
"->",
"dumpNode",
"(",
"*",
"SuccSU",
")",
";",
"dbgs",
"(",
")",
"<<",
"\" has been released too many times!\\n\"",
";",
"llvm_unreachable",
"(",
"nullptr",
")",
";",
"}",
"--",
"SuccSU",
"->",
"NumPredsLeft",
";",
"}",
"</s>"
] | [
"ReleaseSucc",
"-",
"Decrement",
"the",
"NumPredsLeft",
"count",
"of",
"a",
"successor",
"."
] | [
"AMDGPU",
"SI",
"0",
"\"*** Scheduling failed! ***\\n\"",
"\" has been released too many times!\\n\""
] | SIMachineScheduler (2) | releaseSucc | AMDGPU | GPU | LLVM | 16,440 | 82 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"Register",
"DestReg",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"unsigned",
"Align",
"=",
"FrameInfo",
".",
"getObjectAlignment",
"(",
"FrameIndex",
")",
";",
"unsigned",
"Size",
"=",
"FrameInfo",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
";",
"unsigned",
"SpillSize",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FrameIndex",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"Size",
",",
"Align",
")",
";",
"if",
"(",
"RI",
".",
"isSGPRClass",
"(",
"RC",
")",
")",
"{",
"MFI",
"->",
"setHasSpilledSGPRs",
"(",
")",
";",
"assert",
"(",
"DestReg",
"!=",
"AMDGPU",
"::",
"M0",
"&&",
"\"m0 should not be reloaded into\"",
")",
";",
"const",
"MCInstrDesc",
"&",
"OpDesc",
"=",
"get",
"(",
"getSGPRSpillRestoreOpcode",
"(",
"SpillSize",
")",
")",
";",
"if",
"(",
"Register",
"::",
"isVirtualRegister",
"(",
"DestReg",
")",
"&&",
"SpillSize",
"==",
"4",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"DestReg",
",",
"&",
"AMDGPU",
"::",
"SReg_32_XM0RegClass",
")",
";",
"}",
"if",
"(",
"RI",
".",
"spillSGPRToVGPR",
"(",
")",
")",
"FrameInfo",
".",
"setStackID",
"(",
"FrameIndex",
",",
"TargetStackID",
"::",
"SGPRSpill",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"OpDesc",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getStackPtrOffsetReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
";",
"}",
"unsigned",
"Opcode",
"=",
"RI",
".",
"hasAGPRs",
"(",
"RC",
")",
"?",
"getAGPRSpillRestoreOpcode",
"(",
"SpillSize",
")",
":",
"getVGPRSpillRestoreOpcode",
"(",
"SpillSize",
")",
";",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
",",
"DestReg",
")",
";",
"if",
"(",
"RI",
".",
"hasAGPRs",
"(",
"RC",
")",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"Register",
"Tmp",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"MIB",
".",
"addReg",
"(",
"Tmp",
",",
"RegState",
"::",
"Define",
")",
";",
"}",
"MIB",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU::M0",
"\"m0 should not be reloaded into\"",
"4",
"AMDGPU::SReg_32_XM0RegClass",
"AMDGPU::VGPR_32RegClass",
"0"
] | SIInstrInfo72 | loadRegFromStackSlot | AMDGPU | GPU | LLVM | 16,441 | 408 | 1 | [] |
[
"<s>",
"static",
"int",
"getMinValue",
"(",
"uint64_t",
"TSFlags",
")",
"{",
"unsigned",
"isSigned",
"=",
"(",
"TSFlags",
">>",
"HexagonII",
"::",
"ExtentSignedPos",
")",
"&",
"HexagonII",
"::",
"ExtentSignedMask",
";",
"unsigned",
"bits",
"=",
"(",
"TSFlags",
">>",
"HexagonII",
"::",
"ExtentBitsPos",
")",
"&",
"HexagonII",
"::",
"ExtentBitsMask",
";",
"if",
"(",
"isSigned",
")",
"return",
"-",
"1U",
"<<",
"(",
"bits",
"-",
"1",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"the",
"minimal",
"unsigned",
"value",
"possible",
"given",
"these",
"KnownBits",
"."
] | [
"Hexagon",
"HexagonII::ExtentSignedPos",
"HexagonII::ExtentSignedMask",
"HexagonII::ExtentBitsPos",
"HexagonII::ExtentBitsMask",
"1U",
"1",
"0"
] | HexagonInstPrinter11 | getMinValue | Hexagon | DSP | LLVM | 16,442 | 56 | 1 | [] |
[
"<s>",
"unsigned",
"PatmosRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"TM",
".",
"getFrameLowering",
"(",
")",
";",
"return",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"Patmos",
"::",
"RFP",
":",
"Patmos",
"::",
"RSP",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"Patmos",
"Patmos",
"Patmos::RFP",
"Patmos::RSP"
] | PatmosRegisterInfo | getFrameRegister | Patmos | VLIW | LLVM | 16,443 | 40 | 1 | [] |
[
"<s>",
"static",
"bool",
"r10k_safe_mem_expr_p",
"(",
"tree",
"expr",
",",
"unsigned",
"HOST_WIDE_INT",
"offset",
")",
"{",
"HOST_WIDE_INT",
"bitoffset",
",",
"bitsize",
";",
"tree",
"inner",
",",
"var_offset",
";",
"machine_mode",
"mode",
";",
"int",
"unsigned_p",
",",
"reverse_p",
",",
"volatile_p",
";",
"inner",
"=",
"get_inner_reference",
"(",
"expr",
",",
"&",
"bitsize",
",",
"&",
"bitoffset",
",",
"&",
"var_offset",
",",
"&",
"mode",
",",
"&",
"unsigned_p",
",",
"&",
"reverse_p",
",",
"&",
"volatile_p",
")",
";",
"if",
"(",
"!",
"DECL_P",
"(",
"inner",
")",
"||",
"!",
"DECL_SIZE_UNIT",
"(",
"inner",
")",
"||",
"var_offset",
")",
"return",
"false",
";",
"offset",
"+=",
"bitoffset",
"/",
"BITS_PER_UNIT",
";",
"return",
"offset",
"<",
"tree_to_uhwi",
"(",
"DECL_SIZE_UNIT",
"(",
"inner",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"a",
"MEM",
"with",
"MEM_EXPR",
"EXPR",
"and",
"MEM_OFFSET",
"OFFSET",
"is",
"an",
"in-range",
"access",
"to",
"an",
"automatic",
"variable",
",",
"or",
"to",
"an",
"object",
"with",
"a",
"link-time-constant",
"address",
"."
] | [
"mips"
] | mips6 | r10k_safe_mem_expr_p | mips | CPU | GCC | 16,444 | 97 | 1 | [] |
[
"<s>",
"bool",
"LEGInstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"LEG",
"::",
"MOVi32",
":",
"{",
"DebugLoc",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"const",
"unsigned",
"DstReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"const",
"bool",
"DstIsDead",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isDead",
"(",
")",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"auto",
"LO16",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"LEG",
"::",
"MOVLOi16",
")",
",",
"DstReg",
")",
";",
"auto",
"HI16",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"LEG",
"::",
"MOVHIi16",
")",
")",
".",
"addReg",
"(",
"DstReg",
",",
"RegState",
"::",
"Define",
"|",
"getDeadRegState",
"(",
"DstIsDead",
")",
")",
".",
"addReg",
"(",
"DstReg",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"const",
"unsigned",
"Imm",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"const",
"unsigned",
"Lo16",
"=",
"Imm",
"&",
"0xffff",
";",
"const",
"unsigned",
"Hi16",
"=",
"(",
"Imm",
">>",
"16",
")",
"&",
"0xffff",
";",
"LO16",
"=",
"LO16",
".",
"addImm",
"(",
"Lo16",
")",
";",
"HI16",
"=",
"HI16",
".",
"addImm",
"(",
"Hi16",
")",
";",
"}",
"else",
"{",
"const",
"GlobalValue",
"*",
"GV",
"=",
"MO",
".",
"getGlobal",
"(",
")",
";",
"const",
"unsigned",
"TF",
"=",
"MO",
".",
"getTargetFlags",
"(",
")",
";",
"LO16",
"=",
"LO16",
".",
"addGlobalAddress",
"(",
"GV",
",",
"MO",
".",
"getOffset",
"(",
")",
",",
"TF",
"|",
"LEGII",
"::",
"MO_LO16",
")",
";",
"HI16",
"=",
"HI16",
".",
"addGlobalAddress",
"(",
"GV",
",",
"MO",
".",
"getOffset",
"(",
")",
",",
"TF",
"|",
"LEGII",
"::",
"MO_HI16",
")",
";",
"}",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"return",
"true",
";",
"}",
"}",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
] | [
"LEG",
"LEG",
"LEG::MOVi32",
"0",
"0",
"1",
"LEG::MOVLOi16",
"LEG::MOVHIi16",
"0xffff",
"16",
"0xffff",
"LEGII::MO_LO16",
"LEGII::MO_HI16"
] | LEGInstrInfo | expandPostRAPseudo | LEG | CPU | LLVM | 16,445 | 289 | 1 | [] |
[
"<s>",
"static",
"bool",
"mt_legitimate_simple_address_p",
"(",
"enum",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"xinsn",
",",
"int",
"strict",
")",
"{",
"if",
"(",
"TARGET_DEBUG",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"\\n========== GO_IF_LEGITIMATE_ADDRESS, %sstrict\\n\"",
",",
"strict",
"?",
"\"\"",
":",
"\"not \"",
")",
";",
"debug_rtx",
"(",
"xinsn",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"xinsn",
")",
"==",
"REG",
"&&",
"mt_reg_ok_for_base_p",
"(",
"xinsn",
",",
"strict",
")",
")",
"return",
"true",
";",
"if",
"(",
"GET_CODE",
"(",
"xinsn",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"xinsn",
",",
"0",
")",
")",
"==",
"REG",
"&&",
"mt_reg_ok_for_base_p",
"(",
"XEXP",
"(",
"xinsn",
",",
"0",
")",
",",
"strict",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"xinsn",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"SMALL_INT",
"(",
"XEXP",
"(",
"xinsn",
",",
"1",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"of",
"mt_legitimate_address_p",
".",
"Return",
"true",
"if",
"XINSN",
"is",
"a",
"simple",
"address",
",",
"otherwise",
"false",
"."
] | [
"mt",
"\"\\n========== GO_IF_LEGITIMATE_ADDRESS, %sstrict\\n\"",
"\"\"",
"\"not \"",
"0",
"0",
"1",
"1"
] | mt | mt_legitimate_simple_address_p | mt | CPU | GCC | 16,446 | 121 | 1 | [] |
[
"<s>",
"bool",
"MOSTargetLowering",
"::",
"isTruncateFree",
"(",
"Type",
"*",
"SrcTy",
",",
"Type",
"*",
"DstTy",
")",
"const",
"{",
"if",
"(",
"!",
"SrcTy",
"->",
"isIntegerTy",
"(",
")",
"||",
"!",
"DstTy",
"->",
"isIntegerTy",
"(",
")",
")",
"return",
"false",
";",
"return",
"SrcTy",
"->",
"getPrimitiveSizeInBits",
"(",
")",
">",
"DstTy",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"free",
"to",
"truncate",
"a",
"value",
"of",
"type",
"Ty1",
"to",
"type",
"Ty2",
"."
] | [
"MOS",
"MOS"
] | MOSISelLowering | isTruncateFree | MOS | MPU | LLVM | 16,447 | 48 | 1 | [] |
[
"<s>",
"static",
"void",
"emit_save_or_restore_local_in_regs",
"(",
"rtx",
"base",
",",
"int",
"offset",
",",
"sorr_act_t",
"action",
")",
"{",
"if",
"(",
"offset",
"<",
"-",
"4096",
"||",
"offset",
"+",
"16",
"*",
"UNITS_PER_WORD",
">",
"4095",
")",
"{",
"base",
"=",
"emit_adjust_base_to_offset",
"(",
"base",
",",
"offset",
")",
";",
"offset",
"=",
"0",
";",
"}",
"emit_save_or_restore_regs",
"(",
"16",
",",
"32",
",",
"base",
",",
"offset",
",",
"sparc_leaf_function_p",
",",
"save_local_or_in_reg_p",
",",
"action",
",",
"SORR_ADVANCE",
")",
";",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"save/restore",
"call-saved",
"local",
"and",
"in",
"registers",
"."
] | [
"sparc",
"4096",
"16",
"4095",
"0",
"16",
"32"
] | sparc | emit_save_or_restore_local_in_regs | sparc | CPU | GCC | 16,448 | 64 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"SparcDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"N",
")",
"{",
"SDLoc",
"dl",
"(",
"N",
")",
";",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"N",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
"nullptr",
";",
"}",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"SPISD",
"::",
"GLOBAL_BASE_REG",
":",
"return",
"getGlobalBaseReg",
"(",
")",
";",
"case",
"ISD",
"::",
"SDIV",
":",
"case",
"ISD",
"::",
"UDIV",
":",
"{",
"if",
"(",
"N",
"->",
"getValueType",
"(",
"0",
")",
"==",
"MVT",
"::",
"i64",
")",
"break",
";",
"SDValue",
"DivLHS",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"DivRHS",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"SDValue",
"TopPart",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
")",
"{",
"TopPart",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"SP",
"::",
"SRAri",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"DivLHS",
",",
"CurDAG",
"->",
"getTargetConstant",
"(",
"31",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"0",
")",
";",
"}",
"else",
"{",
"TopPart",
"=",
"CurDAG",
"->",
"getRegister",
"(",
"SP",
"::",
"G0",
",",
"MVT",
"::",
"i32",
")",
";",
"}",
"TopPart",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"SP",
"::",
"WRYrr",
",",
"dl",
",",
"MVT",
"::",
"Glue",
",",
"TopPart",
",",
"CurDAG",
"->",
"getRegister",
"(",
"SP",
"::",
"G0",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"0",
")",
";",
"unsigned",
"Opcode",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
"?",
"SP",
"::",
"SDIVrr",
":",
"SP",
"::",
"UDIVrr",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"Opcode",
",",
"MVT",
"::",
"i32",
",",
"DivLHS",
",",
"DivRHS",
",",
"TopPart",
")",
";",
"}",
"case",
"ISD",
"::",
"MULHU",
":",
"case",
"ISD",
"::",
"MULHS",
":",
"{",
"SDValue",
"MulLHS",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"MulRHS",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"unsigned",
"Opcode",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"MULHU",
"?",
"SP",
"::",
"UMULrr",
":",
"SP",
"::",
"SMULrr",
";",
"SDNode",
"*",
"Mul",
"=",
"CurDAG",
"->",
"getMachineNode",
"(",
"Opcode",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Glue",
",",
"MulLHS",
",",
"MulRHS",
")",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"SP",
"::",
"RDY",
",",
"MVT",
"::",
"i32",
",",
"SDValue",
"(",
"Mul",
",",
"1",
")",
")",
";",
"}",
"}",
"return",
"SelectCode",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Sparc",
"Sparc",
"1",
"SPISD::GLOBAL_BASE_REG",
"ISD::SDIV",
"ISD::UDIV",
"0",
"MVT::i64",
"0",
"1",
"ISD::SDIV",
"SP::SRAri",
"MVT::i32",
"31",
"MVT::i32",
"0",
"SP::G0",
"MVT::i32",
"SP::WRYrr",
"MVT::Glue",
"SP::G0",
"MVT::i32",
"0",
"ISD::SDIV",
"SP::SDIVrr",
"SP::UDIVrr",
"MVT::i32",
"ISD::MULHU",
"ISD::MULHS",
"0",
"1",
"ISD::MULHU",
"SP::UMULrr",
"SP::SMULrr",
"MVT::i32",
"MVT::Glue",
"SP::RDY",
"MVT::i32",
"1"
] | SparcISelDAGToDAG | Select | Sparc | CPU | LLVM | 16,449 | 365 | 1 | [] |
[
"<s>",
"static",
"bool",
"is_store_insn1",
"(",
"rtx",
"pat",
",",
"rtx",
"*",
"str_mem",
")",
"{",
"if",
"(",
"!",
"pat",
"||",
"pat",
"==",
"NULL_RTX",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"SET",
")",
"return",
"find_mem_ref",
"(",
"SET_DEST",
"(",
"pat",
")",
",",
"str_mem",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"PARALLEL",
")",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"XVECLEN",
"(",
"pat",
",",
"0",
")",
";",
"i",
"++",
")",
"if",
"(",
"is_store_insn1",
"(",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"i",
")",
",",
"str_mem",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Determine",
"if",
"PAT",
"is",
"a",
"PATTERN",
"of",
"a",
"store",
"insn",
"."
] | [
"powerpcspe",
"0",
"0",
"0"
] | powerpcspe | is_store_insn1 | powerpcspe | CPU | GCC | 16,450 | 99 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUTargetLowering",
"::",
"isFAbsFree",
"(",
"EVT",
"VT",
")",
"const",
"{",
"assert",
"(",
"VT",
".",
"isFloatingPoint",
"(",
")",
")",
";",
"return",
"VT",
"==",
"MVT",
"::",
"f32",
"||",
"VT",
"==",
"MVT",
"::",
"f64",
"||",
"(",
"Subtarget",
"->",
"has16BitInsts",
"(",
")",
"&&",
"VT",
"==",
"MVT",
"::",
"f16",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"an",
"fabs",
"operation",
"is",
"free",
"to",
"the",
"point",
"where",
"it",
"is",
"never",
"worthwhile",
"to",
"replace",
"it",
"with",
"a",
"bitwise",
"operation",
"."
] | [
"AMDGPU",
"AMDGPU",
"MVT::f32",
"MVT::f64",
"MVT::f16"
] | AMDGPUISelLowering (2)1 | isFAbsFree | AMDGPU | GPU | LLVM | 16,451 | 47 | 1 | [] |
[
"<s>",
"bool",
"isVolatile",
"(",
"const",
"Instruction",
"*",
"Inst",
")",
"{",
"if",
"(",
"auto",
"*",
"LI",
"=",
"dyn_cast",
"<",
"LoadInst",
">",
"(",
"Inst",
")",
")",
"return",
"LI",
"->",
"isVolatile",
"(",
")",
";",
"else",
"if",
"(",
"auto",
"*",
"SI",
"=",
"dyn_cast",
"<",
"StoreInst",
">",
"(",
"Inst",
")",
")",
"return",
"SI",
"->",
"isVolatile",
"(",
")",
";",
"else",
"if",
"(",
"auto",
"*",
"AI",
"=",
"dyn_cast",
"<",
"AtomicCmpXchgInst",
">",
"(",
"Inst",
")",
")",
"return",
"AI",
"->",
"isVolatile",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"is",
"a",
"store",
"to",
"a",
"volatile",
"memory",
"location",
"."
] | [
"TPC"
] | TPCTools | isVolatile | TPC | Virtual ISA | LLVM | 16,452 | 78 | 1 | [] |
[
"<s>",
"bool",
"mep_legitimate_address",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"int",
"strict",
")",
"{",
"int",
"the_tag",
";",
"fprintf",
"(",
"stderr",
",",
"\"legit: mode %s strict %d \"",
",",
"mode_name",
"[",
"mode",
"]",
",",
"strict",
")",
";",
"debug_rtx",
"(",
"x",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"LO_SUM",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"REG",
"&&",
"GEN_REG",
"(",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
",",
"strict",
")",
"&&",
"CONSTANT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"{",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
">",
"4",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\" - nope, %%lo(sym)[reg] not splittable\\n\"",
")",
";",
"return",
"false",
";",
"}",
"fprintf",
"(",
"stderr",
",",
"\" - yup, %%lo(sym)[reg]\\n\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"REG",
"&&",
"GEN_REG",
"(",
"REGNO",
"(",
"x",
")",
",",
"strict",
")",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\" - yup, [reg]\\n\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"REG",
"&&",
"GEN_REG",
"(",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
",",
"strict",
")",
"&&",
"const_in_range",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"-",
"32768",
",",
"32767",
")",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\" - yup, [reg+const]\\n\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"REG",
"&&",
"GEN_REG",
"(",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
",",
"strict",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"CONST",
"&&",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"0",
")",
")",
"==",
"UNSPEC",
"||",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"UNSPEC",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"0",
")",
",",
"1",
")",
")",
"==",
"CONST_INT",
")",
")",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\" - yup, [reg+unspec]\\n\"",
")",
";",
"return",
"true",
";",
"}",
"the_tag",
"=",
"mep_section_tag",
"(",
"x",
")",
";",
"if",
"(",
"the_tag",
"==",
"'f'",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\" - nope, [far]\\n\"",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"mode",
"==",
"VOIDmode",
"&&",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\" - yup, call [symbol]\\n\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"(",
"mode",
"==",
"SImode",
"||",
"mode",
"==",
"SFmode",
")",
"&&",
"CONSTANT_P",
"(",
"x",
")",
"&&",
"mep_legitimate_constant_p",
"(",
"mode",
",",
"x",
")",
"&&",
"the_tag",
"!=",
"'t'",
"&&",
"the_tag",
"!=",
"'b'",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"!=",
"CONST_INT",
"||",
"(",
"INTVAL",
"(",
"x",
")",
"<=",
"0xfffff",
"&&",
"INTVAL",
"(",
"x",
")",
">=",
"0",
"&&",
"(",
"INTVAL",
"(",
"x",
")",
"%",
"4",
")",
"==",
"0",
")",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\" - yup, [const]\\n\"",
")",
";",
"return",
"true",
";",
"}",
"}",
"fprintf",
"(",
"stderr",
",",
"\" - nope.\\n\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Be",
"careful",
"not",
"to",
"use",
"macros",
"that",
"need",
"to",
"be",
"compiled",
"one",
"way",
"for",
"strict",
",",
"and",
"another",
"way",
"for",
"not-strict",
",",
"like",
"REG_OK_FOR_BASE_P",
"."
] | [
"mep",
"\"legit: mode %s strict %d \"",
"0",
"0",
"1",
"4",
"\" - nope, %%lo(sym)[reg] not splittable\\n\"",
"\" - yup, %%lo(sym)[reg]\\n\"",
"\" - yup, [reg]\\n\"",
"0",
"0",
"1",
"32768",
"32767",
"\" - yup, [reg+const]\\n\"",
"0",
"0",
"1",
"1",
"0",
"1",
"0",
"1",
"0",
"0",
"1",
"0",
"1",
"\" - yup, [reg+unspec]\\n\"",
"\" - nope, [far]\\n\"",
"\" - yup, call [symbol]\\n\"",
"0xfffff",
"0",
"4",
"0",
"\" - yup, [const]\\n\"",
"\" - nope.\\n\""
] | mep | mep_legitimate_address | mep | CPU | GCC | 16,453 | 493 | 1 | [] |
[
"<s>",
"bool",
"AArch64AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
";",
"if",
"(",
"!",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNum",
",",
"AsmVariant",
",",
"ExtraCode",
",",
"O",
")",
")",
"return",
"false",
";",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"1",
"]",
"!=",
"0",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"default",
":",
"return",
"true",
";",
"case",
"'w'",
":",
"case",
"'x'",
":",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"printAsmMRegister",
"(",
"MO",
",",
"ExtraCode",
"[",
"0",
"]",
",",
"O",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
"&&",
"MO",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"unsigned",
"Reg",
"=",
"ExtraCode",
"[",
"0",
"]",
"==",
"'w'",
"?",
"AArch64",
"::",
"WZR",
":",
"AArch64",
"::",
"XZR",
";",
"O",
"<<",
"AArch64InstPrinter",
"::",
"getRegisterName",
"(",
"Reg",
")",
";",
"return",
"false",
";",
"}",
"printOperand",
"(",
"MI",
",",
"OpNum",
",",
"O",
")",
";",
"return",
"false",
";",
"case",
"'b'",
":",
"case",
"'h'",
":",
"case",
"'s'",
":",
"case",
"'d'",
":",
"case",
"'q'",
":",
"case",
"'z'",
":",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"RC",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"case",
"'b'",
":",
"RC",
"=",
"&",
"AArch64",
"::",
"FPR8RegClass",
";",
"break",
";",
"case",
"'h'",
":",
"RC",
"=",
"&",
"AArch64",
"::",
"FPR16RegClass",
";",
"break",
";",
"case",
"'s'",
":",
"RC",
"=",
"&",
"AArch64",
"::",
"FPR32RegClass",
";",
"break",
";",
"case",
"'d'",
":",
"RC",
"=",
"&",
"AArch64",
"::",
"FPR64RegClass",
";",
"break",
";",
"case",
"'q'",
":",
"RC",
"=",
"&",
"AArch64",
"::",
"FPR128RegClass",
";",
"break",
";",
"case",
"'z'",
":",
"RC",
"=",
"&",
"AArch64",
"::",
"ZPRRegClass",
";",
"break",
";",
"default",
":",
"return",
"true",
";",
"}",
"return",
"printAsmRegInClass",
"(",
"MO",
",",
"RC",
",",
"false",
",",
"O",
")",
";",
"}",
"printOperand",
"(",
"MI",
",",
"OpNum",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"AArch64",
"::",
"GPR32allRegClass",
".",
"contains",
"(",
"Reg",
")",
"||",
"AArch64",
"::",
"GPR64allRegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"return",
"printAsmMRegister",
"(",
"MO",
",",
"'x'",
",",
"O",
")",
";",
"bool",
"hasAltName",
";",
"const",
"TargetRegisterClass",
"*",
"RegClass",
";",
"if",
"(",
"AArch64",
"::",
"ZPRRegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"RegClass",
"=",
"&",
"AArch64",
"::",
"ZPRRegClass",
";",
"hasAltName",
"=",
"false",
";",
"}",
"else",
"if",
"(",
"AArch64",
"::",
"PPRRegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"RegClass",
"=",
"&",
"AArch64",
"::",
"PPRRegClass",
";",
"hasAltName",
"=",
"false",
";",
"}",
"else",
"{",
"RegClass",
"=",
"&",
"AArch64",
"::",
"FPR128RegClass",
";",
"hasAltName",
"=",
"true",
";",
"}",
"return",
"printAsmRegInClass",
"(",
"MO",
",",
"RegClass",
",",
"hasAltName",
",",
"O",
")",
";",
"}",
"printOperand",
"(",
"MI",
",",
"OpNum",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"AArch64",
"AArch64",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"AArch64::WZR",
"AArch64::XZR",
"AArch64",
"0",
"AArch64::FPR8RegClass",
"AArch64::FPR16RegClass",
"AArch64::FPR32RegClass",
"AArch64::FPR64RegClass",
"AArch64::FPR128RegClass",
"AArch64::ZPRRegClass",
"AArch64::GPR32allRegClass",
"AArch64::GPR64allRegClass",
"AArch64::ZPRRegClass",
"AArch64::ZPRRegClass",
"AArch64::PPRRegClass",
"AArch64::PPRRegClass",
"AArch64::FPR128RegClass"
] | AArch64AsmPrinter47 | PrintAsmOperand | AArch64 | CPU | LLVM | 16,454 | 471 | 1 | [] |
[
"<s>",
"bool",
"RISCVFrameLowering",
"::",
"canUseAsPrologue",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"*",
"TmpMBB",
"=",
"const_cast",
"<",
"MachineBasicBlock",
"*",
">",
"(",
"&",
"MBB",
")",
";",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"auto",
"*",
"RVFI",
"=",
"MF",
"->",
"getInfo",
"<",
"RISCVMachineFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"!",
"RVFI",
"->",
"useSaveRestoreLibCalls",
"(",
"*",
"MF",
")",
")",
"return",
"true",
";",
"RegScavenger",
"RS",
";",
"RS",
".",
"enterBasicBlock",
"(",
"*",
"TmpMBB",
")",
";",
"return",
"!",
"RS",
".",
"isRegUsed",
"(",
"RISCV",
"::",
"X5",
")",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"or",
"not",
"the",
"given",
"MBB",
"can",
"be",
"used",
"as",
"a",
"prologue",
"for",
"the",
"target",
"."
] | [
"RI5CY",
"RISCV",
"RISCV",
"RISCV::X5"
] | RISCVFrameLowering | canUseAsPrologue | RI5CY | CPU | LLVM | 16,455 | 88 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_function_value_regno_p",
"(",
"const",
"unsigned",
"int",
"regno",
")",
"{",
"switch",
"(",
"regno",
")",
"{",
"case",
"AX_REG",
":",
"return",
"true",
";",
"case",
"DX_REG",
":",
"return",
"(",
"!",
"TARGET_64BIT",
"||",
"ix86_cfun_abi",
"(",
")",
"!=",
"MS_ABI",
")",
";",
"case",
"DI_REG",
":",
"case",
"SI_REG",
":",
"return",
"TARGET_64BIT",
"&&",
"ix86_cfun_abi",
"(",
")",
"!=",
"MS_ABI",
";",
"case",
"BND0_REG",
":",
"case",
"BND1_REG",
":",
"return",
"chkp_function_instrumented_p",
"(",
"current_function_decl",
")",
";",
"case",
"ST0_REG",
":",
"case",
"ST1_REG",
":",
"if",
"(",
"TARGET_64BIT",
"&&",
"ix86_cfun_abi",
"(",
")",
"==",
"MS_ABI",
")",
"return",
"false",
";",
"return",
"TARGET_FLOAT_RETURNS_IN_80387",
";",
"case",
"XMM0_REG",
":",
"case",
"XMM1_REG",
":",
"return",
"TARGET_SSE",
";",
"case",
"MM0_REG",
":",
"if",
"(",
"TARGET_MACHO",
"||",
"TARGET_64BIT",
")",
"return",
"false",
";",
"return",
"TARGET_MMX",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"N",
"is",
"a",
"possible",
"register",
"number",
"of",
"function",
"value",
"."
] | [
"i386"
] | i3865 | ix86_function_value_regno_p | i386 | CPU | GCC | 16,456 | 114 | 1 | [] |
[
"<s>",
"bool",
"Emitter",
"<",
"CodeEmitter",
">",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"MCE",
".",
"setModuleInfo",
"(",
"&",
"getAnalysis",
"<",
"MachineModuleInfo",
">",
"(",
")",
")",
";",
"II",
"=",
"TM",
".",
"getInstrInfo",
"(",
")",
";",
"TD",
"=",
"TM",
".",
"getTargetData",
"(",
")",
";",
"Is64BitMode",
"=",
"TM",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
".",
"is64Bit",
"(",
")",
";",
"IsPIC",
"=",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
";",
"do",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"JITTing function '\"",
"<<",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getName",
"(",
")",
"<<",
"\"'\\n\"",
")",
";",
"MCE",
".",
"startFunction",
"(",
"MF",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"E",
";",
"++",
"MBB",
")",
"{",
"MCE",
".",
"StartMachineBasicBlock",
"(",
"MBB",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"const_iterator",
"I",
"=",
"MBB",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"const",
"TargetInstrDesc",
"&",
"Desc",
"=",
"I",
"->",
"getDesc",
"(",
")",
";",
"emitInstruction",
"(",
"*",
"I",
",",
"&",
"Desc",
")",
";",
"if",
"(",
"Desc",
".",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"MOVPC32r",
")",
"emitInstruction",
"(",
"*",
"I",
",",
"&",
"II",
"->",
"get",
"(",
"X86",
"::",
"POP32r",
")",
")",
";",
"NumEmitted",
"++",
";",
"}",
"}",
"}",
"while",
"(",
"MCE",
".",
"finishFunction",
"(",
"MF",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"\"JITTing function '\"",
"\"'\\n\"",
"X86::MOVPC32r",
"X86::POP32r"
] | X86CodeEmitter20 | runOnMachineFunction | X86 | CPU | LLVM | 16,457 | 232 | 1 | [] |
[
"<s>",
"int",
"arc_delay_slots_for_epilogue",
"(",
")",
"{",
"if",
"(",
"arc_compute_function_type",
"(",
"current_function_decl",
")",
"!=",
"ARC_FUNCTION_NORMAL",
")",
"return",
"0",
";",
"if",
"(",
"!",
"current_frame_info",
".",
"initialized",
")",
"(",
"void",
")",
"arc_compute_frame_size",
"(",
"get_frame_size",
"(",
")",
")",
";",
"if",
"(",
"current_frame_info",
".",
"total_size",
"==",
"0",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Define",
"the",
"number",
"of",
"delay",
"slots",
"needed",
"for",
"the",
"function",
"epilogue",
".",
"Interrupt",
"handlers",
"ca",
"n't",
"have",
"any",
"epilogue",
"delay",
"slots",
"(",
"it",
"'s",
"always",
"needed",
"for",
"something",
"else",
",",
"I",
"think",
")",
".",
"For",
"normal",
"functions",
",",
"we",
"have",
"to",
"worry",
"about",
"using",
"call-saved",
"regs",
"as",
"they",
"'ll",
"be",
"restored",
"before",
"the",
"delay",
"slot",
"insn",
".",
"Functions",
"with",
"non-empty",
"frames",
"already",
"have",
"enough",
"choices",
"for",
"the",
"epilogue",
"delay",
"slot",
"so",
"for",
"now",
"we",
"only",
"consider",
"functions",
"with",
"empty",
"frames",
"."
] | [
"arc",
"0",
"0",
"1",
"0"
] | arc2 | arc_delay_slots_for_epilogue | arc | MPU | GCC | 16,458 | 49 | 1 | [] |
[
"<s>",
"bool",
"trackLivenessAfterRegAlloc",
"(",
"const",
"MachineFunction",
"&",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"live-ins",
"should",
"be",
"tracked",
"after",
"register",
"allocation",
"."
] | [
"CAHP"
] | CAHPRegisterInfo | trackLivenessAfterRegAlloc | CAHP | CPU | LLVM | 16,459 | 14 | 1 | [] |
[
"<s>",
"unsigned",
"ARMTargetLowering",
"::",
"getRegPressureLimit",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameInfo",
"*",
"TFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"switch",
"(",
"RC",
"->",
"getID",
"(",
")",
")",
"{",
"default",
":",
"return",
"0",
";",
"case",
"ARM",
"::",
"tGPRRegClassID",
":",
"return",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"4",
":",
"5",
";",
"case",
"ARM",
"::",
"GPRRegClassID",
":",
"{",
"unsigned",
"FP",
"=",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"1",
":",
"0",
";",
"return",
"10",
"-",
"FP",
"-",
"(",
"Subtarget",
"->",
"isR9Reserved",
"(",
")",
"?",
"1",
":",
"0",
")",
";",
"}",
"case",
"ARM",
"::",
"SPRRegClassID",
":",
"case",
"ARM",
"::",
"DPRRegClassID",
":",
"return",
"32",
"-",
"10",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"pressure",
"``",
"high",
"water",
"mark",
"''",
"for",
"the",
"specific",
"register",
"class",
"."
] | [
"ARM",
"ARM",
"0",
"ARM::tGPRRegClassID",
"4",
"5",
"ARM::GPRRegClassID",
"1",
"0",
"10",
"1",
"0",
"ARM::SPRRegClassID",
"ARM::DPRRegClassID",
"32",
"10"
] | ARMISelLowering71 | getRegPressureLimit | ARM | CPU | LLVM | 16,460 | 117 | 1 | [] |
[
"<s>",
"bool",
"cris_base_p",
"(",
"const_rtx",
"x",
",",
"bool",
"strict",
")",
"{",
"return",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"reg_ok_for_base_p",
"(",
"x",
",",
"strict",
")",
")",
";",
"}",
"</s>"
] | [
"True",
"if",
"X",
"is",
"a",
"valid",
"base",
"register",
"."
] | [
"cris"
] | cris | cris_base_p | cris | MPU | GCC | 16,461 | 26 | 1 | [] |
[
"<s>",
"unsigned",
"bfin_local_alignment",
"(",
"tree",
"type",
",",
"unsigned",
"align",
")",
"{",
"if",
"(",
"TYPE_SIZE",
"(",
"type",
")",
"&&",
"TREE_CODE",
"(",
"TYPE_SIZE",
"(",
"type",
")",
")",
"==",
"INTEGER_CST",
"&&",
"wi",
"::",
"gtu_p",
"(",
"wi",
"::",
"to_wide",
"(",
"TYPE_SIZE",
"(",
"type",
")",
")",
",",
"8",
")",
"&&",
"align",
"<",
"32",
")",
"return",
"32",
";",
"return",
"align",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"alignment",
"for",
"a",
"local",
"variable",
".",
"TYPE",
"is",
"the",
"data",
"type",
",",
"and",
"ALIGN",
"is",
"the",
"alignment",
"that",
"the",
"object",
"would",
"ordinarily",
"have",
".",
"The",
"value",
"of",
"this",
"macro",
"is",
"used",
"instead",
"of",
"that",
"alignment",
"to",
"align",
"the",
"object",
"."
] | [
"bfin",
"8",
"32",
"32"
] | bfin | bfin_local_alignment | bfin | DSP | GCC | 16,462 | 55 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"CAHP"
] | CAHPTargetMachine | getObjFileLowering | CAHP | CPU | LLVM | 16,463 | 16 | 1 | [] |
[
"<s>",
"bool",
"MipsAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"SmallVectorImpl",
"<",
"MCParsedAsmOperand",
"*",
">",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
")",
"{",
"MCInst",
"Inst",
";",
"unsigned",
"Kind",
";",
"unsigned",
"ErrorInfo",
";",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"std",
"::",
"string",
">",
",",
"4",
">",
"MapAndConstraints",
";",
"unsigned",
"MatchResult",
"=",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Kind",
",",
"Inst",
",",
"MapAndConstraints",
",",
"ErrorInfo",
",",
"false",
")",
";",
"switch",
"(",
"MatchResult",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"{",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
")",
";",
"return",
"false",
";",
"}",
"case",
"Match_MissingFeature",
":",
"Error",
"(",
"IDLoc",
",",
"\"instruction requires a CPU feature not currently enabled\"",
")",
";",
"return",
"true",
";",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0U",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"MipsOperand",
"*",
")",
"Operands",
"[",
"ErrorInfo",
"]",
")",
"->",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"invalid instruction\"",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"Mips",
"Mips",
"4",
"\"instruction requires a CPU feature not currently enabled\"",
"0U",
"\"too few operands for instruction\"",
"Mips",
"\"invalid operand for instruction\"",
"\"invalid instruction\""
] | MipsAsmParser41 | MatchAndEmitInstruction | Mips | CPU | LLVM | 16,464 | 199 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"rx_function_arg_size",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
")",
"{",
"unsigned",
"int",
"num_bytes",
";",
"num_bytes",
"=",
"(",
"mode",
"==",
"BLKmode",
")",
"?",
"int_size_in_bytes",
"(",
"type",
")",
":",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"return",
"rx_round_up",
"(",
"num_bytes",
",",
"UNITS_PER_WORD",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"bytes",
"in",
"the",
"argument",
"registers",
"occupied",
"by",
"an",
"argument",
"of",
"type",
"TYPE",
"and",
"mode",
"MODE",
"."
] | [
"rx"
] | rx | rx_function_arg_size | rx | CPU | GCC | 16,465 | 43 | 1 | [] |
[
"<s>",
"static",
"hashval_t",
"mips_hash_base",
"(",
"rtx",
"base",
")",
"{",
"int",
"do_not_record_p",
";",
"return",
"hash_rtx",
"(",
"base",
",",
"GET_MODE",
"(",
"base",
")",
",",
"&",
"do_not_record_p",
",",
"NULL",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"hash",
"value",
"for",
"SYMBOL_REF",
"or",
"LABEL_REF",
"BASE",
"."
] | [
"mips"
] | mips | mips_hash_base | mips | CPU | GCC | 16,466 | 30 | 1 | [] |
[
"<s>",
"static",
"void",
"write_fn_proto",
"(",
"std",
"::",
"stringstream",
"&",
"s",
",",
"bool",
"is_defn",
",",
"const",
"char",
"*",
"name",
",",
"const_tree",
"decl",
")",
"{",
"const",
"char",
"*",
"replacement",
"=",
"nvptx_name_replacement",
"(",
"name",
")",
";",
"char",
"*",
"replaced_dots",
"=",
"NULL",
";",
"if",
"(",
"replacement",
"!=",
"name",
")",
"name",
"=",
"replacement",
";",
"else",
"{",
"replaced_dots",
"=",
"nvptx_replace_dot",
"(",
"name",
")",
";",
"if",
"(",
"replaced_dots",
")",
"name",
"=",
"replaced_dots",
";",
"}",
"if",
"(",
"name",
"[",
"0",
"]",
"==",
"'*'",
")",
"name",
"++",
";",
"if",
"(",
"is_defn",
")",
"write_fn_proto_1",
"(",
"s",
",",
"false",
",",
"name",
",",
"decl",
")",
";",
"write_fn_proto_1",
"(",
"s",
",",
"is_defn",
",",
"name",
",",
"decl",
")",
";",
"if",
"(",
"replaced_dots",
")",
"XDELETE",
"(",
"replaced_dots",
")",
";",
"}",
"</s>"
] | [
"Write",
"a",
".func",
"or",
".kernel",
"declaration",
"or",
"definition",
"along",
"with",
"a",
"helper",
"comment",
"for",
"use",
"by",
"ld",
".",
"S",
"is",
"the",
"stream",
"to",
"write",
"to",
",",
"DECL",
"the",
"decl",
"for",
"the",
"function",
"with",
"name",
"NAME",
".",
"For",
"definitions",
",",
"emit",
"a",
"declaration",
"too",
"."
] | [
"nvptx",
"0"
] | nvptx | write_fn_proto | nvptx | GPU | GCC | 16,467 | 114 | 1 | [] |
[
"<s>",
"void",
"RISCVAsmPrinter",
"::",
"emitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"if",
"(",
"emitPseudoExpansionLowering",
"(",
"*",
"OutStreamer",
",",
"MI",
")",
")",
"return",
";",
"MCInst",
"TmpInst",
";",
"LowerRISCVMachineInstrToMCInst",
"(",
"MI",
",",
"TmpInst",
",",
"*",
"this",
")",
";",
"auto",
"*",
"MBB",
"=",
"MI",
"->",
"getParent",
"(",
")",
";",
"auto",
"*",
"RVFI",
"=",
"MI",
"->",
"getMF",
"(",
")",
"->",
"getInfo",
"<",
"RISCVMachineFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"RVFI",
"->",
"isHwlpBasicBlock",
"(",
"MBB",
")",
")",
"AsmPrinter",
"::",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"TmpInst",
")",
";",
"else",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"TmpInst",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"to",
"emit",
"instructions",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV"
] | RISCVAsmPrinter1 | emitInstruction | RISCV | CPU | LLVM | 16,468 | 92 | 1 | [] |
[
"<s>",
"static",
"rtx",
"aarch64_gen_load_pair",
"(",
"machine_mode",
"mode",
",",
"rtx",
"reg1",
",",
"rtx",
"mem1",
",",
"rtx",
"reg2",
",",
"rtx",
"mem2",
")",
"{",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_DImode",
":",
"return",
"gen_load_pair_dw_didi",
"(",
"reg1",
",",
"mem1",
",",
"reg2",
",",
"mem2",
")",
";",
"case",
"E_DFmode",
":",
"return",
"gen_load_pair_dw_dfdf",
"(",
"reg1",
",",
"mem1",
",",
"reg2",
",",
"mem2",
")",
";",
"case",
"E_TFmode",
":",
"return",
"gen_load_pair_dw_tftf",
"(",
"reg1",
",",
"mem1",
",",
"reg2",
",",
"mem2",
")",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Generate",
"and",
"regurn",
"a",
"load",
"pair",
"isntruction",
"of",
"mode",
"MODE",
"to",
"load",
"register",
"REG1",
"from",
"MEM1",
"and",
"register",
"REG2",
"from",
"MEM2",
"."
] | [
"aarch64"
] | aarch64 | aarch64_gen_load_pair | aarch64 | CPU | GCC | 16,469 | 78 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"WebAssemblyRegisterInfo::eliminateFrameIndex\"",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"WebAssemblyRegisterInfo::eliminateFrameIndex\""
] | WebAssemblyRegisterInfo11 | eliminateFrameIndex | WebAssembly | Virtual ISA | LLVM | 16,470 | 28 | 1 | [] |
[
"<s>",
"void",
"override_options",
"(",
"void",
")",
"{",
"if",
"(",
"TARGET_OMIT_LEAF_FRAME_POINTER",
")",
"flag_omit_frame_pointer",
"=",
"1",
";",
"if",
"(",
"bfin_lib_id_given",
"&&",
"!",
"TARGET_ID_SHARED_LIBRARY",
")",
"error",
"(",
"\"-mshared-library-id= specified without -mid-shared-library\"",
")",
";",
"if",
"(",
"TARGET_ID_SHARED_LIBRARY",
")",
"flag_pic",
"=",
"1",
";",
"flag_schedule_insns",
"=",
"0",
";",
"}",
"</s>"
] | [
"Set",
"global",
"variables",
"as",
"needed",
"for",
"the",
"options",
"enabled",
"."
] | [
"bfin",
"1",
"\"-mshared-library-id= specified without -mid-shared-library\"",
"1",
"0"
] | bfin2 | override_options | bfin | DSP | GCC | 16,471 | 39 | 1 | [] |
[
"<s>",
"MipsSubtarget",
"::",
"MipsSubtarget",
"(",
"const",
"Triple",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"bool",
"little",
",",
"const",
"MipsTargetMachine",
"&",
"TM",
")",
":",
"MipsGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"MipsArchVersion",
"(",
"MipsDefault",
")",
",",
"IsLittle",
"(",
"little",
")",
",",
"IsSoftFloat",
"(",
"false",
")",
",",
"IsSingleFloat",
"(",
"false",
")",
",",
"IsFPXX",
"(",
"false",
")",
",",
"NoABICalls",
"(",
"false",
")",
",",
"IsFP64bit",
"(",
"false",
")",
",",
"UseOddSPReg",
"(",
"true",
")",
",",
"IsNaN2008bit",
"(",
"false",
")",
",",
"IsGP64bit",
"(",
"false",
")",
",",
"HasVFPU",
"(",
"false",
")",
",",
"HasCnMips",
"(",
"false",
")",
",",
"HasMips3_32",
"(",
"false",
")",
",",
"HasMips3_32r2",
"(",
"false",
")",
",",
"HasMips4_32",
"(",
"false",
")",
",",
"HasMips4_32r2",
"(",
"false",
")",
",",
"HasMips5_32r2",
"(",
"false",
")",
",",
"InMips16Mode",
"(",
"false",
")",
",",
"InMips16HardFloat",
"(",
"Mips16HardFloat",
")",
",",
"InMicroMipsMode",
"(",
"false",
")",
",",
"HasDSP",
"(",
"false",
")",
",",
"HasDSPR2",
"(",
"false",
")",
",",
"HasDSPR3",
"(",
"false",
")",
",",
"AllowMixed16_32",
"(",
"Mixed16_32",
"|",
"Mips_Os16",
")",
",",
"Os16",
"(",
"Mips_Os16",
")",
",",
"HasMSA",
"(",
"false",
")",
",",
"UseTCCInDIV",
"(",
"false",
")",
",",
"HasEVA",
"(",
"false",
")",
",",
"TM",
"(",
"TM",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"TSInfo",
"(",
")",
",",
"InstrInfo",
"(",
"MipsInstrInfo",
"::",
"create",
"(",
"initializeSubtargetDependencies",
"(",
"CPU",
",",
"FS",
",",
"TM",
")",
")",
")",
",",
"FrameLowering",
"(",
"MipsFrameLowering",
"::",
"create",
"(",
"*",
"this",
")",
")",
",",
"TLInfo",
"(",
"MipsTargetLowering",
"::",
"create",
"(",
"TM",
",",
"*",
"this",
")",
")",
"{",
"PreviousInMips16Mode",
"=",
"InMips16Mode",
";",
"if",
"(",
"MipsArchVersion",
"==",
"MipsDefault",
")",
"MipsArchVersion",
"=",
"Mips32",
";",
"if",
"(",
"MipsArchVersion",
"==",
"Mips1",
")",
"report_fatal_error",
"(",
"\"Code generation for MIPS-I is not implemented\"",
",",
"false",
")",
";",
"if",
"(",
"MipsArchVersion",
"==",
"Mips5",
")",
"report_fatal_error",
"(",
"\"Code generation for MIPS-V is not implemented\"",
",",
"false",
")",
";",
"assert",
"(",
"(",
"(",
"!",
"isGP64bit",
"(",
")",
"&&",
"(",
"isABI_O32",
"(",
")",
"||",
"isABI_EABI",
"(",
")",
")",
")",
"||",
"(",
"isGP64bit",
"(",
")",
"&&",
"(",
"isABI_N32",
"(",
")",
"||",
"isABI_N64",
"(",
")",
")",
")",
")",
"&&",
"\"Invalid Arch & ABI pair.\"",
")",
";",
"if",
"(",
"hasMSA",
"(",
")",
"&&",
"!",
"isFP64bit",
"(",
")",
")",
"report_fatal_error",
"(",
"\"MSA requires a 64-bit FPU register file (FR=1 mode). \"",
"\"See -mattr=+fp64.\"",
",",
"false",
")",
";",
"if",
"(",
"!",
"isABI_O32",
"(",
")",
"&&",
"!",
"useOddSPReg",
"(",
")",
")",
"report_fatal_error",
"(",
"\"-mattr=+nooddspreg requires the O32 ABI.\"",
",",
"false",
")",
";",
"if",
"(",
"IsFPXX",
"&&",
"(",
"isABI_N32",
"(",
")",
"||",
"isABI_N64",
"(",
")",
")",
")",
"report_fatal_error",
"(",
"\"FPXX is not permitted for the N32/N64 ABI's.\"",
",",
"false",
")",
";",
"if",
"(",
"hasMips32r6",
"(",
")",
")",
"{",
"StringRef",
"ISA",
"=",
"hasMips64r6",
"(",
")",
"?",
"\"MIPS64r6\"",
":",
"\"MIPS32r6\"",
";",
"assert",
"(",
"isFP64bit",
"(",
")",
")",
";",
"assert",
"(",
"isNaN2008",
"(",
")",
")",
";",
"if",
"(",
"hasDSP",
"(",
")",
")",
"report_fatal_error",
"(",
"ISA",
"+",
"\" is not compatible with the DSP ASE\"",
",",
"false",
")",
";",
"}",
"if",
"(",
"NoABICalls",
"&&",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"report_fatal_error",
"(",
"\"position-independent code requires '-mabicalls'\"",
")",
";",
"UseSmallSection",
"=",
"GPOpt",
";",
"if",
"(",
"!",
"NoABICalls",
"&&",
"GPOpt",
")",
"{",
"errs",
"(",
")",
"<<",
"\"warning: cannot use small-data accesses for '-mabicalls'\"",
"<<",
"\"\\n\"",
";",
"UseSmallSection",
"=",
"false",
";",
"}",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"\"Code generation for MIPS-I is not implemented\"",
"Mips",
"Mips",
"\"Code generation for MIPS-V is not implemented\"",
"\"Invalid Arch & ABI pair.\"",
"\"MSA requires a 64-bit FPU register file (FR=1 mode). \"",
"\"See -mattr=+fp64.\"",
"\"-mattr=+nooddspreg requires the O32 ABI.\"",
"\"FPXX is not permitted for the N32/N64 ABI's.\"",
"Mips",
"Mips",
"\"MIPS64r6\"",
"\"MIPS32r6\"",
"\" is not compatible with the DSP ASE\"",
"\"position-independent code requires '-mabicalls'\"",
"\"warning: cannot use small-data accesses for '-mabicalls'\"",
"\"\\n\""
] | MipsSubtarget (2)1 | MipsSubtarget | Mips | CPU | LLVM | 16,472 | 470 | 1 | [] |
[
"<s>",
"static",
"rtx",
"sh_allocate_initial_value",
"(",
"rtx",
"hard_reg",
")",
"{",
"if",
"(",
"REGNO",
"(",
"hard_reg",
")",
"==",
"PR_REG",
")",
"{",
"if",
"(",
"crtl",
"->",
"is_leaf",
"&&",
"!",
"sh_pr_n_sets",
"(",
")",
")",
"return",
"hard_reg",
";",
"else",
"return",
"gen_frame_mem",
"(",
"Pmode",
",",
"return_address_pointer_rtx",
")",
";",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Return",
"where",
"to",
"allocate",
"pseudo",
"for",
"a",
"given",
"hard",
"register",
"initial",
"value",
"."
] | [
"sh"
] | sh | sh_allocate_initial_value | sh | CPU | GCC | 16,473 | 46 | 1 | [] |
[
"<s>",
"bool",
"i386_pe_valid_dllimport_attribute_p",
"(",
"const_tree",
"decl",
")",
"{",
"if",
"(",
"TARGET_NOP_FUN_DLLIMPORT",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Handle",
"the",
"-mno-fun-dllimport",
"target",
"switch",
"."
] | [
"i386"
] | winnt | i386_pe_valid_dllimport_attribute_p | i386 | CPU | GCC | 16,474 | 25 | 1 | [] |
[
"<s>",
"bool",
"mayNeedRelaxation",
"(",
"const",
"MCInst",
"&",
"Inst",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"the",
"given",
"instruction",
"may",
"need",
"relaxation",
"."
] | [
"AMDGPU"
] | AMDGPUAsmBackend (2) | mayNeedRelaxation | AMDGPU | GPU | LLVM | 16,475 | 15 | 1 | [] |
[
"<s>",
"static",
"int",
"rid_int128",
"(",
"void",
")",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"NUM_INT_N_ENTS",
";",
"i",
"++",
")",
"if",
"(",
"int_n_enabled_p",
"[",
"i",
"]",
"&&",
"int_n_data",
"[",
"i",
"]",
".",
"bitsize",
"==",
"128",
")",
"return",
"RID_INT_N_0",
"+",
"i",
";",
"return",
"RID_MAX",
"+",
"1",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"to",
"find",
"out",
"which",
"RID_INT_N_",
"*",
"code",
"is",
"the",
"one",
"for",
"__int128",
",",
"if",
"any",
".",
"Returns",
"RID_MAX+1",
"if",
"none",
"apply",
",",
"which",
"is",
"safe",
"(",
"for",
"our",
"purposes",
",",
"since",
"we",
"always",
"expect",
"to",
"have",
"__int128",
")",
"to",
"compare",
"against",
"."
] | [
"powerpcspe",
"0",
"128",
"1"
] | powerpcspe-c | rid_int128 | powerpcspe | CPU | GCC | 16,476 | 50 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isUsedByReturnOnly",
"(",
"SDNode",
"*",
"N",
",",
"SDValue",
"&",
"Chain",
")",
"const",
"{",
"if",
"(",
"N",
"->",
"getNumValues",
"(",
")",
"!=",
"1",
"||",
"!",
"N",
"->",
"hasNUsesOfValue",
"(",
"1",
",",
"0",
")",
")",
"return",
"false",
";",
"SDValue",
"TCChain",
"=",
"Chain",
";",
"SDNode",
"*",
"Copy",
"=",
"*",
"N",
"->",
"use_begin",
"(",
")",
";",
"if",
"(",
"Copy",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"CopyToReg",
")",
"{",
"if",
"(",
"Copy",
"->",
"getOperand",
"(",
"Copy",
"->",
"getNumOperands",
"(",
")",
"-",
"1",
")",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"Glue",
")",
"return",
"false",
";",
"TCChain",
"=",
"Copy",
"->",
"getOperand",
"(",
"0",
")",
";",
"}",
"else",
"if",
"(",
"Copy",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"FP_EXTEND",
")",
"return",
"false",
";",
"bool",
"HasRet",
"=",
"false",
";",
"for",
"(",
"SDNode",
"::",
"use_iterator",
"UI",
"=",
"Copy",
"->",
"use_begin",
"(",
")",
",",
"UE",
"=",
"Copy",
"->",
"use_end",
"(",
")",
";",
"UI",
"!=",
"UE",
";",
"++",
"UI",
")",
"{",
"if",
"(",
"UI",
"->",
"getOpcode",
"(",
")",
"!=",
"X86ISD",
"::",
"RET_FLAG",
"&&",
"UI",
"->",
"getOpcode",
"(",
")",
"!=",
"X86ISD",
"::",
"CPS_RET",
")",
"return",
"false",
";",
"if",
"(",
"UI",
"->",
"getNumOperands",
"(",
")",
">",
"4",
")",
"return",
"false",
";",
"if",
"(",
"UI",
"->",
"getNumOperands",
"(",
")",
"==",
"4",
"&&",
"UI",
"->",
"getOperand",
"(",
"UI",
"->",
"getNumOperands",
"(",
")",
"-",
"1",
")",
".",
"getValueType",
"(",
")",
"!=",
"MVT",
"::",
"Glue",
")",
"return",
"false",
";",
"HasRet",
"=",
"true",
";",
"}",
"if",
"(",
"!",
"HasRet",
")",
"return",
"false",
";",
"Chain",
"=",
"TCChain",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"result",
"of",
"the",
"specified",
"node",
"is",
"used",
"by",
"a",
"return",
"node",
"only",
"."
] | [
"X86",
"X86",
"1",
"1",
"0",
"ISD::CopyToReg",
"1",
"MVT::Glue",
"0",
"ISD::FP_EXTEND",
"X86ISD::RET_FLAG",
"X86ISD::CPS_RET",
"4",
"4",
"1",
"MVT::Glue"
] | X86ISelLowering34 | isUsedByReturnOnly | X86 | CPU | LLVM | 16,477 | 246 | 1 | [] |
[
"<s>",
"void",
"PatmosSinglePathInfo",
"::",
"print",
"(",
"raw_ostream",
"&",
"os",
",",
"const",
"Module",
"*",
"M",
")",
"const",
"{",
"assert",
"(",
"Root",
")",
";",
"os",
"<<",
"\"========================================\\n\"",
";",
"Root",
"->",
"dump",
"(",
"os",
",",
"0",
",",
"true",
")",
";",
"os",
"<<",
"\"========================================\\n\"",
";",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"Patmos",
"Patmos",
"\"========================================\\n\"",
"0",
"\"========================================\\n\""
] | PatmosSinglePathInfo | print | Patmos | VLIW | LLVM | 16,478 | 41 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"MCS51AsmPrinter",
"::",
"lowerConstant",
"(",
"const",
"Constant",
"*",
"CV",
")",
"{",
"MCContext",
"&",
"Ctx",
"=",
"OutContext",
";",
"if",
"(",
"const",
"GlobalValue",
"*",
"GV",
"=",
"dyn_cast",
"<",
"GlobalValue",
">",
"(",
"CV",
")",
")",
"{",
"bool",
"IsProgMem",
"=",
"GV",
"->",
"getAddressSpace",
"(",
")",
"==",
"MCS51",
"::",
"ProgramMemory",
";",
"if",
"(",
"IsProgMem",
")",
"{",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"getSymbol",
"(",
"GV",
")",
",",
"Ctx",
")",
";",
"return",
"MCS51MCExpr",
"::",
"create",
"(",
"MCS51MCExpr",
"::",
"VK_MCS51_PM",
",",
"Expr",
",",
"false",
",",
"Ctx",
")",
";",
"}",
"}",
"return",
"AsmPrinter",
"::",
"lowerConstant",
"(",
"CV",
")",
";",
"}",
"</s>"
] | [
"Lower",
"the",
"specified",
"LLVM",
"Constant",
"to",
"an",
"MCExpr",
"."
] | [
"MCS51",
"MCS51",
"MCS51::ProgramMemory",
"MCS51",
"MCS51",
"MCS51"
] | MCS51AsmPrinter | lowerConstant | MCS51 | MPU | LLVM | 16,479 | 97 | 1 | [] |
[
"<s>",
"static",
"void",
"pa_extra_live_on_entry",
"(",
"bitmap",
"regs",
")",
"{",
"if",
"(",
"TARGET_64BIT",
")",
"bitmap_set_bit",
"(",
"regs",
",",
"ARG_POINTER_REGNUM",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_EXTRA_LIVE_ON_ENTRY",
".",
"The",
"argument",
"pointer",
"is",
"only",
"marked",
"as",
"live",
"on",
"entry",
"by",
"df-scan",
"when",
"it",
"is",
"a",
"fixed",
"register",
".",
"It",
"is",
"n't",
"a",
"fixed",
"register",
"in",
"the",
"64-bit",
"runtime",
",",
"so",
"we",
"need",
"to",
"mark",
"it",
"here",
"."
] | [
"pa"
] | pa | pa_extra_live_on_entry | pa | CPU | GCC | 16,480 | 20 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"areMemAccessesTriviallyDisjoint",
"(",
"const",
"MachineInstr",
"&",
"MIa",
",",
"const",
"MachineInstr",
"&",
"MIb",
")",
"const",
"{",
"assert",
"(",
"MIa",
".",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIa must load from or modify a memory location\"",
")",
";",
"assert",
"(",
"MIb",
".",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIb must load from or modify a memory location\"",
")",
";",
"if",
"(",
"MIa",
".",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIb",
".",
"hasUnmodeledSideEffects",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MIa",
".",
"hasOrderedMemoryRef",
"(",
")",
"||",
"MIb",
".",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"isDS",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isDS",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"||",
"isSegmentSpecificFLAT",
"(",
"MIb",
")",
";",
"}",
"if",
"(",
"isMUBUF",
"(",
"MIa",
")",
"||",
"isMTBUF",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isMUBUF",
"(",
"MIb",
")",
"||",
"isMTBUF",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"&&",
"!",
"isSMRD",
"(",
"MIb",
")",
";",
"}",
"if",
"(",
"isSMRD",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isSMRD",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"&&",
"!",
"isMUBUF",
"(",
"MIb",
")",
"&&",
"!",
"isMTBUF",
"(",
"MIb",
")",
";",
"}",
"if",
"(",
"isFLAT",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isFLAT",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Sometimes",
",",
"it",
"is",
"possible",
"for",
"the",
"target",
"to",
"tell",
",",
"even",
"without",
"aliasing",
"information",
",",
"that",
"two",
"MIs",
"access",
"different",
"memory",
"addresses",
"."
] | [
"AMDGPU",
"SI",
"\"MIa must load from or modify a memory location\"",
"\"MIb must load from or modify a memory location\""
] | SIInstrInfo11 | areMemAccessesTriviallyDisjoint | AMDGPU | GPU | LLVM | 16,481 | 230 | 1 | [] |
[
"<s>",
"void",
"mvs_free_label_list",
"(",
")",
"{",
"if",
"(",
"label_anchor",
")",
"{",
"label_node_t",
"*",
"last_lp",
"=",
"label_anchor",
";",
"while",
"(",
"last_lp",
"->",
"label_next",
")",
"last_lp",
"=",
"last_lp",
"->",
"label_next",
";",
"last_lp",
"->",
"label_next",
"=",
"free_anchor",
";",
"free_anchor",
"=",
"label_anchor",
";",
"}",
"label_anchor",
"=",
"0",
";",
"}",
"</s>"
] | [
"The",
"label",
"list",
"for",
"the",
"current",
"page",
"freed",
"by",
"linking",
"the",
"list",
"onto",
"the",
"free",
"label",
"element",
"chain",
"."
] | [
"i370",
"0"
] | i370 | mvs_free_label_list | i370 | CPU | GCC | 16,482 | 44 | 1 | [] |
[
"<s>",
"SDValue",
"NVPTXTargetLowering",
"::",
"getSqrtEstimate",
"(",
"SDValue",
"Operand",
",",
"SelectionDAG",
"&",
"DAG",
",",
"int",
"Enabled",
",",
"int",
"&",
"ExtraSteps",
",",
"bool",
"&",
"UseOneConst",
",",
"bool",
"Reciprocal",
")",
"const",
"{",
"if",
"(",
"!",
"(",
"Enabled",
"==",
"ReciprocalEstimate",
"::",
"Enabled",
"||",
"(",
"Enabled",
"==",
"ReciprocalEstimate",
"::",
"Unspecified",
"&&",
"!",
"usePrecSqrtF32",
"(",
")",
")",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"ExtraSteps",
"==",
"ReciprocalEstimate",
"::",
"Unspecified",
")",
"ExtraSteps",
"=",
"0",
";",
"SDLoc",
"DL",
"(",
"Operand",
")",
";",
"EVT",
"VT",
"=",
"Operand",
".",
"getValueType",
"(",
")",
";",
"bool",
"Ftz",
"=",
"useF32FTZ",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
")",
";",
"auto",
"MakeIntrinsicCall",
"=",
"[",
"&",
"]",
"(",
"Intrinsic",
"::",
"ID",
"IID",
")",
"{",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getConstant",
"(",
"IID",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
",",
"Operand",
")",
";",
"}",
";",
"if",
"(",
"Reciprocal",
"||",
"ExtraSteps",
">",
"0",
")",
"{",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"MakeIntrinsicCall",
"(",
"Ftz",
"?",
"Intrinsic",
"::",
"nvvm_rsqrt_approx_ftz_f",
":",
"Intrinsic",
"::",
"nvvm_rsqrt_approx_f",
")",
";",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
")",
"return",
"MakeIntrinsicCall",
"(",
"Intrinsic",
"::",
"nvvm_rsqrt_approx_d",
")",
";",
"else",
"return",
"SDValue",
"(",
")",
";",
"}",
"else",
"{",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"MakeIntrinsicCall",
"(",
"Ftz",
"?",
"Intrinsic",
"::",
"nvvm_sqrt_approx_ftz_f",
":",
"Intrinsic",
"::",
"nvvm_sqrt_approx_f",
")",
";",
"else",
"{",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getConstant",
"(",
"Intrinsic",
"::",
"nvvm_rcp_approx_ftz_d",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
",",
"MakeIntrinsicCall",
"(",
"Intrinsic",
"::",
"nvvm_rsqrt_approx_d",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Hooks",
"for",
"building",
"estimates",
"in",
"place",
"of",
"slower",
"divisions",
"and",
"square",
"roots",
"."
] | [
"NVPTX",
"NVPTX",
"0",
"Intrinsic::ID",
"ISD::INTRINSIC_WO_CHAIN",
"MVT::i32",
"0",
"MVT::f32",
"Intrinsic::nvvm_rsqrt_approx_ftz_f",
"Intrinsic::nvvm_rsqrt_approx_f",
"MVT::f64",
"Intrinsic::nvvm_rsqrt_approx_d",
"MVT::f32",
"Intrinsic::nvvm_sqrt_approx_ftz_f",
"Intrinsic::nvvm_sqrt_approx_f",
"ISD::INTRINSIC_WO_CHAIN",
"Intrinsic::nvvm_rcp_approx_ftz_d",
"MVT::i32",
"Intrinsic::nvvm_rsqrt_approx_d"
] | NVPTXISelLowering (2)1 | getSqrtEstimate | NVPTX | GPU | LLVM | 16,483 | 260 | 1 | [] |
[
"<s>",
"const",
"CAHPMCExpr",
"*",
"CAHPMCExpr",
"::",
"create",
"(",
"const",
"MCExpr",
"*",
"Expr",
",",
"VariantKind",
"Kind",
",",
"MCContext",
"&",
"Ctx",
")",
"{",
"return",
"new",
"(",
"Ctx",
")",
"CAHPMCExpr",
"(",
"Expr",
",",
"Kind",
")",
";",
"}",
"</s>"
] | [
"This",
"creates",
"an",
"identified",
"struct",
"."
] | [
"CAHP",
"CAHP",
"CAHP",
"CAHP"
] | CAHPMCExpr | create | CAHP | CPU | LLVM | 16,484 | 33 | 1 | [] |
[
"<s>",
"bool",
"ARMDAGToDAGISel",
"::",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"unsigned",
"ConstraintID",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"{",
"switch",
"(",
"ConstraintID",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected asm memory constraint\"",
")",
";",
"case",
"InlineAsm",
"::",
"Constraint_m",
":",
"case",
"InlineAsm",
"::",
"Constraint_o",
":",
"case",
"InlineAsm",
"::",
"Constraint_Q",
":",
"case",
"InlineAsm",
"::",
"Constraint_Um",
":",
"case",
"InlineAsm",
"::",
"Constraint_Un",
":",
"case",
"InlineAsm",
"::",
"Constraint_Uq",
":",
"case",
"InlineAsm",
"::",
"Constraint_Us",
":",
"case",
"InlineAsm",
"::",
"Constraint_Ut",
":",
"case",
"InlineAsm",
"::",
"Constraint_Uv",
":",
"case",
"InlineAsm",
"::",
"Constraint_Uy",
":",
"OutOps",
".",
"push_back",
"(",
"Op",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"ARM",
"ARM",
"\"Unexpected asm memory constraint\""
] | ARMISelDAGToDAG10 | SelectInlineAsmMemoryOperand | ARM | CPU | LLVM | 16,485 | 100 | 1 | [] |
[
"<s>",
"int",
"fldi_ok",
"(",
")",
"{",
"return",
"!",
"TARGET_SH4",
"||",
"TARGET_FMOVD",
"||",
"reload_completed",
";",
"}",
"</s>"
] | [
"For",
"-m4",
"and",
"-m4-single-only",
",",
"mode",
"switching",
"is",
"used",
".",
"If",
"we",
"are",
"compiling",
"without",
"-mfmovd",
",",
"movsf_ie",
"is",
"n't",
"taken",
"into",
"account",
"for",
"mode",
"switching",
".",
"We",
"could",
"check",
"in",
"machine_dependent_reorg",
"for",
"cases",
"where",
"we",
"know",
"we",
"are",
"in",
"single",
"precision",
"mode",
",",
"but",
"there",
"is",
"interface",
"to",
"find",
"that",
"out",
"during",
"reload",
",",
"so",
"we",
"must",
"avoid",
"choosing",
"an",
"fldi",
"alternative",
"during",
"reload",
"and",
"thus",
"failing",
"to",
"allocate",
"a",
"scratch",
"register",
"for",
"the",
"constant",
"loading",
"."
] | [
"sh"
] | sh2 | fldi_ok | sh | CPU | GCC | 16,486 | 14 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"X86TargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"X86PassConfig",
"*",
"PC",
"=",
"new",
"X86PassConfig",
"(",
"this",
",",
"PM",
")",
";",
"if",
"(",
"Subtarget",
".",
"hasCMov",
"(",
")",
")",
"PC",
"->",
"enablePass",
"(",
"&",
"EarlyIfConverterID",
")",
";",
"return",
"PC",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine50 | createPassConfig | X86 | CPU | LLVM | 16,487 | 43 | 1 | [] |
[
"<s>",
"const",
"AMDGPUCommonSubtarget",
"&",
"AMDGPUCommonSubtarget",
"::",
"get",
"(",
"const",
"TargetMachine",
"&",
"TM",
",",
"const",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"amdgcn",
")",
"return",
"static_cast",
"<",
"const",
"AMDGPUCommonSubtarget",
"&",
">",
"(",
"TM",
".",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
"F",
")",
")",
";",
"else",
"return",
"static_cast",
"<",
"const",
"AMDGPUCommonSubtarget",
"&",
">",
"(",
"TM",
".",
"getSubtarget",
"<",
"R600Subtarget",
">",
"(",
"F",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"generated",
"Value",
"for",
"a",
"given",
"VPValue",
"and",
"given",
"Part",
"and",
"Lane",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"R600"
] | AMDGPUSubtarget76 | get | AMDGPU | GPU | LLVM | 16,488 | 74 | 1 | [] |
[
"<s>",
"void",
"AlphaRegisterInfo",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"const",
"TargetFrameInfo",
"*",
"TFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"{",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"uint64_t",
"Amount",
"=",
"Old",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"unsigned",
"Align",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"(",
"Amount",
"+",
"Align",
"-",
"1",
")",
"/",
"Align",
"*",
"Align",
";",
"MachineInstr",
"*",
"New",
";",
"if",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"Alpha",
"::",
"ADJUSTSTACKDOWN",
")",
"{",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"LDA",
")",
",",
"Alpha",
"::",
"R30",
")",
".",
"addImm",
"(",
"-",
"Amount",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"Alpha",
"::",
"ADJUSTSTACKUP",
")",
";",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"LDA",
")",
",",
"Alpha",
"::",
"R30",
")",
".",
"addImm",
"(",
"Amount",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
";",
"}",
"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",
")",
"."
] | [
"Alpha",
"Alpha",
"0",
"0",
"1",
"Alpha::ADJUSTSTACKDOWN",
"Alpha::LDA",
"Alpha::R30",
"Alpha::R30",
"Alpha::ADJUSTSTACKUP",
"Alpha::LDA",
"Alpha::R30",
"Alpha::R30"
] | AlphaRegisterInfo3 | eliminateCallFramePseudoInstr | Alpha | MPU | LLVM | 16,489 | 233 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"SystemZTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'r'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i32",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"SystemZ",
"::",
"GR32RegisterClass",
")",
";",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i128",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"SystemZ",
"::",
"GR128RegisterClass",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"SystemZ",
"::",
"GR64RegisterClass",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"SystemZ",
"SystemZ",
"1",
"0",
"MVT::i32",
"0U",
"SystemZ::GR32RegisterClass",
"MVT::i128",
"0U",
"SystemZ::GR128RegisterClass",
"0U",
"SystemZ::GR64RegisterClass"
] | SystemZISelLowering101 | getRegForInlineAsmConstraint | SystemZ | CPU | LLVM | 16,490 | 118 | 1 | [] |
[
"<s>",
"static",
"void",
"aarch64_emit_atomic_swap",
"(",
"machine_mode",
"mode",
",",
"rtx",
"dst",
",",
"rtx",
"value",
",",
"rtx",
"mem",
",",
"rtx",
"model",
")",
"{",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_QImode",
":",
"gen",
"=",
"gen_aarch64_atomic_swpqi",
";",
"break",
";",
"case",
"E_HImode",
":",
"gen",
"=",
"gen_aarch64_atomic_swphi",
";",
"break",
";",
"case",
"E_SImode",
":",
"gen",
"=",
"gen_aarch64_atomic_swpsi",
";",
"break",
";",
"case",
"E_DImode",
":",
"gen",
"=",
"gen_aarch64_atomic_swpdi",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"emit_insn",
"(",
"gen",
"(",
"dst",
",",
"mem",
",",
"value",
",",
"model",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"atomic",
"swap",
"."
] | [
"aarch64"
] | aarch645 | aarch64_emit_atomic_swap | aarch64 | CPU | GCC | 16,491 | 98 | 1 | [] |
[
"<s>",
"bool",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"DLX"
] | DLXFrameLowering | hasFP | DLX | CPU | LLVM | 16,492 | 14 | 1 | [] |
[
"<s>",
"MVT",
"getScalarShiftAmountTy",
"(",
"EVT",
"LHSTy",
")",
"const",
"override",
"{",
"return",
"MVT",
"::",
"i32",
";",
"}",
"</s>"
] | [
"Return",
"the",
"type",
"to",
"use",
"for",
"a",
"scalar",
"shift",
"opcode",
",",
"given",
"the",
"shifted",
"amount",
"type",
"."
] | [
"NVPTX",
"MVT::i32"
] | NVPTXISelLowering1 | getScalarShiftAmountTy | NVPTX | GPU | LLVM | 16,493 | 15 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"VIDEOCORE DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Videocore",
"\"VIDEOCORE DAG->DAG Pattern Instruction Selection\""
] | VideocoreISelDAGToDAG | getPassName | Videocore | DSP | LLVM | 16,494 | 13 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"VirtRegMap",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"X86"
] | X86TileConfig (2) | getAnalysisUsage | X86 | CPU | LLVM | 16,495 | 42 | 1 | [] |
[
"<s>",
"static",
"tree",
"aarch64_build_builtin_va_list",
"(",
"void",
")",
"{",
"tree",
"va_list_name",
";",
"tree",
"f_stack",
",",
"f_grtop",
",",
"f_vrtop",
",",
"f_groff",
",",
"f_vroff",
";",
"va_list_type",
"=",
"lang_hooks",
".",
"types",
".",
"make_type",
"(",
"RECORD_TYPE",
")",
";",
"va_list_name",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"TYPE_DECL",
",",
"get_identifier",
"(",
"\"__va_list\"",
")",
",",
"va_list_type",
")",
";",
"DECL_ARTIFICIAL",
"(",
"va_list_name",
")",
"=",
"1",
";",
"TYPE_NAME",
"(",
"va_list_type",
")",
"=",
"va_list_name",
";",
"TYPE_STUB_DECL",
"(",
"va_list_type",
")",
"=",
"va_list_name",
";",
"f_stack",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__stack\"",
")",
",",
"ptr_type_node",
")",
";",
"f_grtop",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__gr_top\"",
")",
",",
"ptr_type_node",
")",
";",
"f_vrtop",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__vr_top\"",
")",
",",
"ptr_type_node",
")",
";",
"f_groff",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__gr_offs\"",
")",
",",
"integer_type_node",
")",
";",
"f_vroff",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__vr_offs\"",
")",
",",
"integer_type_node",
")",
";",
"DECL_ARTIFICIAL",
"(",
"f_stack",
")",
"=",
"1",
";",
"DECL_ARTIFICIAL",
"(",
"f_grtop",
")",
"=",
"1",
";",
"DECL_ARTIFICIAL",
"(",
"f_vrtop",
")",
"=",
"1",
";",
"DECL_ARTIFICIAL",
"(",
"f_groff",
")",
"=",
"1",
";",
"DECL_ARTIFICIAL",
"(",
"f_vroff",
")",
"=",
"1",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_stack",
")",
"=",
"va_list_type",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_grtop",
")",
"=",
"va_list_type",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_vrtop",
")",
"=",
"va_list_type",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_groff",
")",
"=",
"va_list_type",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_vroff",
")",
"=",
"va_list_type",
";",
"TYPE_FIELDS",
"(",
"va_list_type",
")",
"=",
"f_stack",
";",
"DECL_CHAIN",
"(",
"f_stack",
")",
"=",
"f_grtop",
";",
"DECL_CHAIN",
"(",
"f_grtop",
")",
"=",
"f_vrtop",
";",
"DECL_CHAIN",
"(",
"f_vrtop",
")",
"=",
"f_groff",
";",
"DECL_CHAIN",
"(",
"f_groff",
")",
"=",
"f_vroff",
";",
"layout_type",
"(",
"va_list_type",
")",
";",
"return",
"va_list_type",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_BUILD_BUILTIN_VA_LIST",
".",
"Return",
"the",
"type",
"to",
"use",
"as",
"__builtin_va_list",
".",
"AAPCS64",
"\\S",
"7.1.4",
"requires",
"that",
"va_list",
"be",
"a",
"typedef",
"for",
"a",
"type",
"defined",
"as",
":",
"struct",
"__va_list",
"{",
"void",
"*",
"__stack",
";",
"void",
"*",
"__gr_top",
";",
"void",
"*",
"__vr_top",
";",
"int",
"__gr_offs",
";",
"int",
"__vr_offs",
";",
"}",
";"
] | [
"aarch64",
"\"__va_list\"",
"1",
"\"__stack\"",
"\"__gr_top\"",
"\"__vr_top\"",
"\"__gr_offs\"",
"\"__vr_offs\"",
"1",
"1",
"1",
"1",
"1"
] | aarch642 | aarch64_build_builtin_va_list | aarch64 | CPU | GCC | 16,496 | 263 | 1 | [] |
[
"<s>",
"bool",
"SNESTargetLowering",
"::",
"getPreIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"EVT",
"VT",
";",
"const",
"SDNode",
"*",
"Op",
";",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"if",
"(",
"const",
"LoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"VT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"Op",
"=",
"LD",
"->",
"getBasePtr",
"(",
")",
".",
"getNode",
"(",
")",
";",
"if",
"(",
"LD",
"->",
"getExtensionType",
"(",
")",
"!=",
"ISD",
"::",
"NON_EXTLOAD",
")",
"return",
"false",
";",
"if",
"(",
"SNES",
"::",
"isProgramMemoryAccess",
"(",
"LD",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"const",
"StoreSDNode",
"*",
"ST",
"=",
"dyn_cast",
"<",
"StoreSDNode",
">",
"(",
"N",
")",
")",
"{",
"VT",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
";",
"Op",
"=",
"ST",
"->",
"getBasePtr",
"(",
")",
".",
"getNode",
"(",
")",
";",
"if",
"(",
"SNES",
"::",
"isProgramMemoryAccess",
"(",
"ST",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"else",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"i8",
"&&",
"VT",
"!=",
"MVT",
"::",
"i16",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"Op",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"ADD",
"&&",
"Op",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SUB",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"const",
"ConstantSDNode",
"*",
"RHS",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
"->",
"getOperand",
"(",
"1",
")",
")",
")",
"{",
"int",
"RHSC",
"=",
"RHS",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"Op",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SUB",
")",
"RHSC",
"=",
"-",
"RHSC",
";",
"if",
"(",
"(",
"VT",
"==",
"MVT",
"::",
"i16",
"&&",
"RHSC",
"!=",
"-",
"2",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"i8",
"&&",
"RHSC",
"!=",
"-",
"1",
")",
")",
"{",
"return",
"false",
";",
"}",
"Base",
"=",
"Op",
"->",
"getOperand",
"(",
"0",
")",
";",
"Offset",
"=",
"DAG",
".",
"getConstant",
"(",
"RHSC",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
";",
"AM",
"=",
"ISD",
"::",
"PRE_DEC",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"by",
"value",
",",
"base",
"pointer",
"and",
"offset",
"pointer",
"and",
"addressing",
"mode",
"by",
"reference",
"if",
"the",
"node",
"'s",
"address",
"can",
"be",
"legally",
"represented",
"as",
"pre-indexed",
"load",
"/",
"store",
"address",
"."
] | [
"SNES",
"SNES",
"ISD::MemIndexedMode",
"ISD::NON_EXTLOAD",
"SNES::isProgramMemoryAccess",
"SNES::isProgramMemoryAccess",
"MVT::i8",
"MVT::i16",
"ISD::ADD",
"ISD::SUB",
"1",
"ISD::SUB",
"MVT::i16",
"2",
"MVT::i8",
"1",
"0",
"MVT::i8",
"ISD::PRE_DEC"
] | SNESISelLowering | getPreIndexedAddressParts | SNES | DSP | LLVM | 16,497 | 331 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"SlotIndexes",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"SlotIndexes",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"PowerPC"
] | PPCInstrInfo1 | getAnalysisUsage | PowerPC | CPU | LLVM | 16,498 | 54 | 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",
";",
"start_sequence",
"(",
")",
";",
"XEXP",
"(",
"dup",
",",
"0",
")",
"=",
"force_reg",
"(",
"GET_MODE_INNER",
"(",
"mode",
")",
",",
"val",
")",
";",
"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"
] | i3865 | ix86_vector_duplicate_value | i386 | CPU | GCC | 16,499 | 120 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.