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>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"Profile guided if-conversion pass for the TMS320C64X target\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"TMS320C64X",
"\"Profile guided if-conversion pass for the TMS320C64X target\""
] | TMS320C64XIfConversion | getPassName | TMS320C64X | VLIW | LLVM | 31,100 | 13 | 1 | [] |
[
"<s>",
"void",
"RISCVTargetStreamer",
"::",
"finish",
"(",
")",
"{",
"finishAttributeSection",
"(",
")",
";",
"}",
"</s>"
] | [
"finish",
"-",
"after",
"all",
"the",
"new",
"live",
"ranges",
"have",
"been",
"created",
",",
"compute",
"the",
"remaining",
"live",
"range",
",",
"and",
"rewrite",
"instructions",
"to",
"use",
"the",
"new",
"registers",
"."
] | [
"RI5CY",
"RISCV"
] | RISCVTargetStreamer | finish | RI5CY | CPU | LLVM | 31,101 | 12 | 1 | [] |
[
"<s>",
"int",
"TPCSchedStrategy",
"::",
"pressureChange",
"(",
"const",
"SUnit",
"*",
"SU",
",",
"bool",
"isBotUp",
")",
"{",
"PressureDiff",
"&",
"PD",
"=",
"DAG",
"->",
"getPressureDiff",
"(",
"SU",
")",
";",
"for",
"(",
"auto",
"&",
"P",
":",
"PD",
")",
"{",
"if",
"(",
"!",
"P",
".",
"isValid",
"(",
")",
")",
"continue",
";",
"if",
"(",
"HighPressureSets",
"[",
"P",
".",
"getPSet",
"(",
")",
"]",
")",
"{",
"return",
"(",
"isBotUp",
"?",
"P",
".",
"getUnitInc",
"(",
")",
":",
"-",
"P",
".",
"getUnitInc",
"(",
")",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Check",
"if",
"the",
"instruction",
"changes",
"the",
"register",
"pressure",
"of",
"a",
"register",
"in",
"the",
"high",
"pressure",
"set",
"."
] | [
"TPC",
"TPC",
"0"
] | TPCMachineScheduler | pressureChange | TPC | Virtual ISA | LLVM | 31,102 | 81 | 1 | [] |
[
"<s>",
"HexagonSubtarget",
"&",
"HexagonSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"if",
"(",
"CPUString",
".",
"empty",
"(",
")",
")",
"CPUString",
"=",
"\"hexagonv4\"",
";",
"if",
"(",
"CPUString",
"==",
"\"hexagonv2\"",
")",
"{",
"HexagonArchVersion",
"=",
"V2",
";",
"}",
"else",
"if",
"(",
"CPUString",
"==",
"\"hexagonv3\"",
")",
"{",
"EnableV3",
"=",
"true",
";",
"HexagonArchVersion",
"=",
"V3",
";",
"}",
"else",
"if",
"(",
"CPUString",
"==",
"\"hexagonv4\"",
")",
"{",
"HexagonArchVersion",
"=",
"V4",
";",
"}",
"else",
"if",
"(",
"CPUString",
"==",
"\"hexagonv5\"",
")",
"{",
"HexagonArchVersion",
"=",
"V5",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Unrecognized Hexagon processor version\"",
")",
";",
"}",
"ParseSubtargetFeatures",
"(",
"CPUString",
",",
"FS",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"\"hexagonv4\"",
"\"hexagonv2\"",
"Hexagon",
"\"hexagonv3\"",
"Hexagon",
"\"hexagonv4\"",
"Hexagon",
"\"hexagonv5\"",
"Hexagon",
"\"Unrecognized Hexagon processor version\""
] | HexagonSubtarget18 | initializeSubtargetDependencies | Hexagon | DSP | LLVM | 31,103 | 100 | 1 | [] |
[
"<s>",
"void",
"SystemZFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"const",
"SystemZInstrInfo",
"*",
"ZII",
"=",
"static_cast",
"<",
"const",
"SystemZInstrInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"SystemZMachineFunctionInfo",
"*",
"ZFI",
"=",
"MF",
".",
"getInfo",
"<",
"SystemZMachineFunctionInfo",
">",
"(",
")",
";",
"assert",
"(",
"MBBI",
"->",
"isReturn",
"(",
")",
"&&",
"\"Can only insert epilogue into returning blocks\"",
")",
";",
"uint64_t",
"StackSize",
"=",
"getAllocatedStackSize",
"(",
"MF",
")",
";",
"if",
"(",
"ZFI",
"->",
"getLowSavedGPR",
"(",
")",
")",
"{",
"--",
"MBBI",
";",
"unsigned",
"Opcode",
"=",
"MBBI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"!=",
"SystemZ",
"::",
"LMG",
")",
"llvm_unreachable",
"(",
"\"Expected to see callee-save register restore code\"",
")",
";",
"unsigned",
"AddrOpNo",
"=",
"2",
";",
"DebugLoc",
"DL",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"uint64_t",
"Offset",
"=",
"StackSize",
"+",
"MBBI",
"->",
"getOperand",
"(",
"AddrOpNo",
"+",
"1",
")",
".",
"getImm",
"(",
")",
";",
"unsigned",
"NewOpcode",
"=",
"ZII",
"->",
"getOpcodeForOffset",
"(",
"Opcode",
",",
"Offset",
")",
";",
"if",
"(",
"!",
"NewOpcode",
")",
"{",
"uint64_t",
"NumBytes",
"=",
"Offset",
"-",
"0x7fff8",
";",
"emitIncrement",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"MBBI",
"->",
"getOperand",
"(",
"AddrOpNo",
")",
".",
"getReg",
"(",
")",
",",
"NumBytes",
",",
"ZII",
")",
";",
"Offset",
"-=",
"NumBytes",
";",
"NewOpcode",
"=",
"ZII",
"->",
"getOpcodeForOffset",
"(",
"Opcode",
",",
"Offset",
")",
";",
"assert",
"(",
"NewOpcode",
"&&",
"\"No restore instruction available\"",
")",
";",
"}",
"MBBI",
"->",
"setDesc",
"(",
"ZII",
"->",
"get",
"(",
"NewOpcode",
")",
")",
";",
"MBBI",
"->",
"getOperand",
"(",
"AddrOpNo",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"}",
"else",
"if",
"(",
"StackSize",
")",
"{",
"DebugLoc",
"DL",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"emitIncrement",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"SystemZ",
"::",
"R15D",
",",
"StackSize",
",",
"ZII",
")",
";",
"}",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"\"Can only insert epilogue into returning blocks\"",
"SystemZ::LMG",
"\"Expected to see callee-save register restore code\"",
"2",
"1",
"0x7fff8",
"\"No restore instruction available\"",
"1",
"SystemZ::R15D"
] | SystemZFrameLowering36 | emitEpilogue | SystemZ | CPU | LLVM | 31,104 | 280 | 1 | [] |
[
"<s>",
"static",
"bool",
"m32r_rtx_costs",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"int",
"outer_code",
"ATTRIBUTE_UNUSED",
",",
"int",
"opno",
"ATTRIBUTE_UNUSED",
",",
"int",
"*",
"total",
",",
"bool",
"speed",
"ATTRIBUTE_UNUSED",
")",
"{",
"int",
"code",
"=",
"GET_CODE",
"(",
"x",
")",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"CONST_INT",
":",
"if",
"(",
"INT16_P",
"(",
"INTVAL",
"(",
"x",
")",
")",
")",
"{",
"*",
"total",
"=",
"0",
";",
"return",
"true",
";",
"}",
"case",
"CONST",
":",
"case",
"LABEL_REF",
":",
"case",
"SYMBOL_REF",
":",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"1",
")",
";",
"return",
"true",
";",
"case",
"CONST_DOUBLE",
":",
"{",
"rtx",
"high",
",",
"low",
";",
"split_double",
"(",
"x",
",",
"&",
"high",
",",
"&",
"low",
")",
";",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"!",
"INT16_P",
"(",
"INTVAL",
"(",
"high",
")",
")",
"+",
"!",
"INT16_P",
"(",
"INTVAL",
"(",
"low",
")",
")",
")",
";",
"return",
"true",
";",
"}",
"case",
"MULT",
":",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"3",
")",
";",
"return",
"true",
";",
"case",
"DIV",
":",
"case",
"UDIV",
":",
"case",
"MOD",
":",
"case",
"UMOD",
":",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"10",
")",
";",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"Cost",
"functions",
"."
] | [
"m32r",
"0",
"1",
"3",
"10"
] | m32r | m32r_rtx_costs | m32r | MPU | GCC | 31,105 | 176 | 1 | [] |
[
"<s>",
"static",
"void",
"emit_push_sfr",
"(",
"rtx",
"sfr",
",",
"bool",
"frame_related_p",
",",
"bool",
"clr_p",
")",
"{",
"rtx_insn",
"*",
"insn",
";",
"gcc_assert",
"(",
"MEM_P",
"(",
"sfr",
")",
")",
";",
"insn",
"=",
"emit_move_insn",
"(",
"tmp_reg_rtx",
",",
"sfr",
")",
";",
"if",
"(",
"frame_related_p",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"emit_push_byte",
"(",
"AVR_TMP_REGNO",
",",
"frame_related_p",
")",
";",
"if",
"(",
"clr_p",
")",
"{",
"insn",
"=",
"emit_move_insn",
"(",
"sfr",
",",
"const0_rtx",
")",
";",
"if",
"(",
"frame_related_p",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"}",
"</s>"
] | [
"Helper",
"for",
"expand_prologue",
".",
"Emit",
"a",
"push",
"of",
"a",
"SFR",
"via",
"tmp_reg",
".",
"SFR",
"is",
"a",
"MEM",
"representing",
"the",
"memory",
"location",
"of",
"the",
"SFR",
".",
"If",
"CLR_P",
"then",
"clear",
"the",
"SFR",
"after",
"the",
"push",
"using",
"zero_reg",
"."
] | [
"avr",
"1",
"1"
] | avr4 | emit_push_sfr | avr | MPU | GCC | 31,106 | 80 | 1 | [] |
[
"<s>",
"bool",
"RISCVMCExpr",
"::",
"evaluateAsConstant",
"(",
"int64_t",
"&",
"Res",
")",
"const",
"{",
"MCValue",
"Value",
";",
"if",
"(",
"Kind",
"==",
"VK_RISCV_PCREL_HI",
"||",
"Kind",
"==",
"VK_RISCV_PCREL_LO",
")",
"return",
"false",
";",
"if",
"(",
"!",
"getSubExpr",
"(",
")",
"->",
"evaluateAsRelocatable",
"(",
"Value",
",",
"nullptr",
",",
"nullptr",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Value",
".",
"isAbsolute",
"(",
")",
")",
"return",
"false",
";",
"Res",
"=",
"evaluateAsInt64",
"(",
"Value",
".",
"getConstant",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Evaluates",
"the",
"fixup",
"as",
"a",
"constant",
"value",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV"
] | RISCVMCExpr18 | evaluateAsConstant | RISCV | CPU | LLVM | 31,107 | 73 | 1 | [] |
[
"<s>",
"bool",
"requiresVirtualBaseRegisters",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"wants",
"the",
"LocalStackAllocation",
"pass",
"to",
"be",
"run",
"and",
"virtual",
"base",
"registers",
"used",
"for",
"more",
"efficient",
"stack",
"access",
"."
] | [
"PowerPC"
] | PPCRegisterInfo (2)1 | requiresVirtualBaseRegisters | PowerPC | CPU | LLVM | 31,108 | 15 | 1 | [] |
[
"<s>",
"bool",
"DLXTargetObjectFile",
"::",
"isGlobalInSmallSection",
"(",
"const",
"GlobalObject",
"*",
"GO",
",",
"const",
"TargetMachine",
"&",
"TM",
",",
"SectionKind",
"Kind",
")",
"const",
"{",
"return",
"isGlobalInSmallSectionImpl",
"(",
"GO",
",",
"TM",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"global",
"address",
"should",
"be",
"placed",
"into",
"small",
"data/bss",
"section",
"."
] | [
"DLX",
"DLX"
] | DLXTargetObjectFile | isGlobalInSmallSection | DLX | CPU | LLVM | 31,109 | 29 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"RISCV"
] | RISCVTargetMachine (2) | getObjFileLowering | RISCV | CPU | LLVM | 31,110 | 16 | 1 | [] |
[
"<s>",
"BitVector",
"SystemZRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"const",
"SystemZFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"{",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R11D",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R11L",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R11H",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R10Q",
")",
";",
"}",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R15D",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R15L",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R15H",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"R14Q",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"A0",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"A1",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"FPC",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ::R11D",
"SystemZ::R11L",
"SystemZ::R11H",
"SystemZ::R10Q",
"SystemZ::R15D",
"SystemZ::R15L",
"SystemZ::R15H",
"SystemZ::R14Q",
"SystemZ::A0",
"SystemZ::A1",
"SystemZ::FPC"
] | SystemZRegisterInfo15 | getReservedRegs | SystemZ | CPU | LLVM | 31,111 | 144 | 1 | [] |
[
"<s>",
"void",
"MSP430InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"DestReg",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"PseudoSourceValue",
"::",
"getFixedStack",
"(",
"FrameIdx",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"0",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIdx",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FrameIdx",
")",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR16RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV16rm",
")",
")",
".",
"addReg",
"(",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR8RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV8rm",
")",
")",
".",
"addReg",
"(",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Cannot store this register to stack slot!\"",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"MSP430",
"MSP430",
"0",
"MSP430::GR16RegClass",
"MSP430::MOV16rm",
"0",
"MSP430::GR8RegClass",
"MSP430::MOV8rm",
"0",
"\"Cannot store this register to stack slot!\""
] | MSP430InstrInfo38 | loadRegFromStackSlot | MSP430 | MPU | LLVM | 31,112 | 210 | 1 | [] |
[
"<s>",
"static",
"void",
"constant_int_to_128bit_vector",
"(",
"rtx",
"op",
",",
"machine_mode",
"mode",
",",
"size_t",
"byte_num",
",",
"vec_const_128bit_type",
"*",
"info",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"uvalue",
"=",
"UINTVAL",
"(",
"op",
")",
";",
"unsigned",
"bitsize",
"=",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
";",
"for",
"(",
"int",
"shift",
"=",
"bitsize",
"-",
"8",
";",
"shift",
">=",
"0",
";",
"shift",
"-=",
"8",
")",
"info",
"->",
"bytes",
"[",
"byte_num",
"++",
"]",
"=",
"(",
"uvalue",
">>",
"shift",
")",
"&",
"0xff",
";",
"}",
"</s>"
] | [
"Copy",
"an",
"integer",
"constant",
"to",
"the",
"vector",
"constant",
"structure",
"."
] | [
"rs6000",
"8",
"0",
"8",
"0xff"
] | rs6000 | constant_int_to_128bit_vector | rs6000 | CPU | GCC | 31,113 | 69 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
")",
"const",
"{",
"bool",
"HaveCond",
"=",
"false",
";",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"MBB",
".",
"terminators",
"(",
")",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"true",
";",
"case",
"WebAssembly",
"::",
"BR_IF",
":",
"if",
"(",
"HaveCond",
")",
"return",
"true",
";",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isMBB",
"(",
")",
")",
"return",
"true",
";",
"Cond",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"true",
")",
")",
";",
"Cond",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"TBB",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"HaveCond",
"=",
"true",
";",
"break",
";",
"case",
"WebAssembly",
"::",
"BR_UNLESS",
":",
"if",
"(",
"HaveCond",
")",
"return",
"true",
";",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isMBB",
"(",
")",
")",
"return",
"true",
";",
"Cond",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"false",
")",
")",
";",
"Cond",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"TBB",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"HaveCond",
"=",
"true",
";",
"break",
";",
"case",
"WebAssembly",
"::",
"BR",
":",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isMBB",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"HaveCond",
")",
"TBB",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"else",
"FBB",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"break",
";",
"}",
"if",
"(",
"MI",
".",
"isBarrier",
"(",
")",
")",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly::BR_IF",
"0",
"1",
"0",
"WebAssembly::BR_UNLESS",
"0",
"1",
"0",
"WebAssembly::BR",
"0",
"0",
"0"
] | WebAssemblyInstrInfo1 | analyzeBranch | WebAssembly | Virtual ISA | LLVM | 31,114 | 278 | 1 | [] |
[
"<s>",
"SDValue",
"SparcTargetLowering",
"::",
"withTargetFlags",
"(",
"SDValue",
"Op",
",",
"unsigned",
"TF",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"const",
"GlobalAddressSDNode",
"*",
"GA",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"Op",
")",
")",
"return",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GA",
"->",
"getGlobal",
"(",
")",
",",
"SDLoc",
"(",
"GA",
")",
",",
"GA",
"->",
"getValueType",
"(",
"0",
")",
",",
"GA",
"->",
"getOffset",
"(",
")",
",",
"TF",
")",
";",
"if",
"(",
"const",
"ConstantPoolSDNode",
"*",
"CP",
"=",
"dyn_cast",
"<",
"ConstantPoolSDNode",
">",
"(",
"Op",
")",
")",
"return",
"DAG",
".",
"getTargetConstantPool",
"(",
"CP",
"->",
"getConstVal",
"(",
")",
",",
"CP",
"->",
"getValueType",
"(",
"0",
")",
",",
"CP",
"->",
"getAlignment",
"(",
")",
",",
"CP",
"->",
"getOffset",
"(",
")",
",",
"TF",
")",
";",
"if",
"(",
"const",
"BlockAddressSDNode",
"*",
"BA",
"=",
"dyn_cast",
"<",
"BlockAddressSDNode",
">",
"(",
"Op",
")",
")",
"return",
"DAG",
".",
"getTargetBlockAddress",
"(",
"BA",
"->",
"getBlockAddress",
"(",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"0",
",",
"TF",
")",
";",
"if",
"(",
"const",
"ExternalSymbolSDNode",
"*",
"ES",
"=",
"dyn_cast",
"<",
"ExternalSymbolSDNode",
">",
"(",
"Op",
")",
")",
"return",
"DAG",
".",
"getTargetExternalSymbol",
"(",
"ES",
"->",
"getSymbol",
"(",
")",
",",
"ES",
"->",
"getValueType",
"(",
"0",
")",
",",
"TF",
")",
";",
"llvm_unreachable",
"(",
"\"Unhandled address SDNode\"",
")",
";",
"}",
"</s>"
] | [
"}",
"Custom",
"DAGCombine"
] | [
"Sparc",
"Sparc",
"0",
"0",
"0",
"0",
"\"Unhandled address SDNode\""
] | SparcISelLowering (2)2 | withTargetFlags | Sparc | CPU | LLVM | 31,115 | 191 | 1 | [] |
[
"<s>",
"void",
"PPCRegisterInfo",
"::",
"lowerACCRestore",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"unsigned",
"FrameIndex",
")",
"const",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"PPCSubtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"Register",
"DestReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"MI",
".",
"definesRegister",
"(",
"DestReg",
")",
"&&",
"\"RESTORE_ACC does not define its destination\"",
")",
";",
"bool",
"IsPrimed",
"=",
"PPC",
"::",
"ACCRCRegClass",
".",
"contains",
"(",
"DestReg",
")",
";",
"Register",
"Reg",
"=",
"PPC",
"::",
"VSRp0",
"+",
"(",
"DestReg",
"-",
"(",
"IsPrimed",
"?",
"PPC",
"::",
"ACC0",
":",
"PPC",
"::",
"UACC0",
")",
")",
"*",
"2",
";",
"bool",
"IsLittleEndian",
"=",
"Subtarget",
".",
"isLittleEndian",
"(",
")",
";",
"emitAccSpillRestoreInfo",
"(",
"MBB",
",",
"IsPrimed",
",",
"true",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"LXVP",
")",
",",
"Reg",
")",
",",
"FrameIndex",
",",
"IsLittleEndian",
"?",
"32",
":",
"0",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"LXVP",
")",
",",
"Reg",
"+",
"1",
")",
",",
"FrameIndex",
",",
"IsLittleEndian",
"?",
"0",
":",
"32",
")",
";",
"if",
"(",
"IsPrimed",
")",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"XXMTACC",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"DestReg",
")",
";",
"MBB",
".",
"erase",
"(",
"II",
")",
";",
"}",
"</s>"
] | [
"lowerACCRestore",
"-",
"Generate",
"the",
"code",
"to",
"restore",
"the",
"accumulator",
"register",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"0",
"\"RESTORE_ACC does not define its destination\"",
"PPC::ACCRCRegClass",
"PPC::VSRp0",
"PPC::ACC0",
"PPC::UACC0",
"2",
"PPC::LXVP",
"32",
"0",
"PPC::LXVP",
"1",
"0",
"32",
"PPC::XXMTACC"
] | PPCRegisterInfo (2)3 | lowerACCRestore | PowerPC | CPU | LLVM | 31,116 | 261 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"override",
"{",
"assert",
"(",
"(",
"Kind",
"==",
"k_Register",
")",
"&&",
"\"Invalid access!\"",
")",
";",
"return",
"Reg",
".",
"RegNum",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"MINA32",
"\"Invalid access!\""
] | MINA32AsmParser | getReg | MINA32 | CPU | LLVM | 31,117 | 24 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_tribools_ok_for_inlining_p",
"(",
"int",
"caller",
",",
"int",
"callee",
",",
"int",
"dont_care",
",",
"int",
"def",
")",
"{",
"if",
"(",
"callee",
"==",
"dont_care",
")",
"return",
"true",
";",
"if",
"(",
"caller",
"==",
"dont_care",
")",
"return",
"true",
";",
"return",
"(",
"callee",
"==",
"caller",
"||",
"callee",
"==",
"def",
")",
";",
"}",
"</s>"
] | [
"Helper",
"for",
"aarch64_can_inline_p",
".",
"In",
"the",
"case",
"where",
"CALLER",
"and",
"CALLEE",
"are",
"tri-bool",
"options",
"(",
"yes",
",",
"no",
",",
"do",
"n't",
"care",
")",
"and",
"the",
"default",
"value",
"is",
"DEF",
",",
"determine",
"whether",
"to",
"reject",
"inlining",
"."
] | [
"aarch64"
] | aarch64 | aarch64_tribools_ok_for_inlining_p | aarch64 | CPU | GCC | 31,118 | 47 | 1 | [] |
[
"<s>",
"void",
"SICAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"if",
"(",
"MI",
"->",
"isDebugValue",
"(",
")",
")",
"{",
"SmallString",
"<",
"128",
">",
"Str",
";",
"raw_svector_ostream",
"OS",
"(",
"Str",
")",
";",
"PrintDebugValueComment",
"(",
"MI",
",",
"OS",
")",
";",
"return",
";",
"}",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"I",
"=",
"MI",
"->",
"getIterator",
"(",
")",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"E",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"instr_end",
"(",
")",
";",
"do",
"{",
"if",
"(",
"emitPseudoExpansionLowering",
"(",
"*",
"OutStreamer",
",",
"&",
"*",
"I",
")",
")",
"continue",
";",
"if",
"(",
"I",
"->",
"isPseudo",
"(",
")",
")",
"llvm_unreachable",
"(",
"\"Pseudo opcode found in EmitInstruction()\"",
")",
";",
"MCInst",
"TmpInst0",
";",
"MCInstLowering",
".",
"Lower",
"(",
"&",
"*",
"I",
",",
"TmpInst0",
")",
";",
"OutStreamer",
"->",
"EmitInstruction",
"(",
"TmpInst0",
",",
"getSubtargetInfo",
"(",
")",
")",
";",
"}",
"while",
"(",
"(",
"++",
"I",
"!=",
"E",
")",
"&&",
"I",
"->",
"isInsideBundle",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"SIC",
"SIC",
"128",
"\"Pseudo opcode found in EmitInstruction()\""
] | SICAsmPrinter | EmitInstruction | SIC | CPU | LLVM | 31,119 | 140 | 1 | [] |
[
"<s>",
"TargetIRAnalysis",
"AArch64TargetMachine",
"::",
"getTargetIRAnalysis",
"(",
")",
"{",
"return",
"TargetIRAnalysis",
"(",
"[",
"this",
"]",
"(",
"Function",
"&",
"F",
")",
"{",
"return",
"TargetTransformInfo",
"(",
"AArch64TTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetIRAnalysis",
"appropriate",
"for",
"the",
"target",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine29 | getTargetIRAnalysis | AArch64 | CPU | LLVM | 31,120 | 34 | 1 | [] |
[
"<s>",
"static",
"int",
"rs6000_use_sched_lookahead_guard",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"ready_index",
")",
"{",
"if",
"(",
"ready_index",
"==",
"0",
")",
"return",
"0",
";",
"if",
"(",
"rs6000_tune",
"!=",
"PROCESSOR_CELL",
")",
"return",
"0",
";",
"gcc_assert",
"(",
"insn",
"!=",
"NULL_RTX",
"&&",
"INSN_P",
"(",
"insn",
")",
")",
";",
"if",
"(",
"!",
"reload_completed",
"||",
"is_nonpipeline_insn",
"(",
"insn",
")",
"||",
"is_microcoded_insn",
"(",
"insn",
")",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"We",
"are",
"choosing",
"insn",
"from",
"the",
"ready",
"queue",
".",
"Return",
"zero",
"if",
"INSN",
"can",
"be",
"chosen",
"."
] | [
"rs6000",
"0",
"0",
"0",
"1",
"0"
] | rs6000 | rs6000_use_sched_lookahead_guard | rs6000 | CPU | GCC | 31,121 | 64 | 1 | [] |
[
"<s>",
"int",
"ccr_bit",
"(",
"rtx",
"op",
",",
"int",
"scc_p",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"op",
")",
";",
"machine_mode",
"cc_mode",
";",
"int",
"cc_regnum",
";",
"int",
"base_bit",
";",
"rtx",
"reg",
";",
"if",
"(",
"!",
"COMPARISON_P",
"(",
"op",
")",
")",
"return",
"-",
"1",
";",
"reg",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"reg",
")",
"==",
"REG",
"&&",
"CR_REGNO_P",
"(",
"REGNO",
"(",
"reg",
")",
")",
")",
";",
"cc_mode",
"=",
"GET_MODE",
"(",
"reg",
")",
";",
"cc_regnum",
"=",
"REGNO",
"(",
"reg",
")",
";",
"base_bit",
"=",
"4",
"*",
"(",
"cc_regnum",
"-",
"CR0_REGNO",
")",
";",
"validate_condition_mode",
"(",
"code",
",",
"cc_mode",
")",
";",
"gcc_assert",
"(",
"!",
"scc_p",
"||",
"code",
"==",
"EQ",
"||",
"code",
"==",
"GT",
"||",
"code",
"==",
"LT",
"||",
"code",
"==",
"UNORDERED",
"||",
"code",
"==",
"GTU",
"||",
"code",
"==",
"LTU",
")",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"NE",
":",
"return",
"scc_p",
"?",
"base_bit",
"+",
"3",
":",
"base_bit",
"+",
"2",
";",
"case",
"EQ",
":",
"return",
"base_bit",
"+",
"2",
";",
"case",
"GT",
":",
"case",
"GTU",
":",
"case",
"UNLE",
":",
"return",
"base_bit",
"+",
"1",
";",
"case",
"LT",
":",
"case",
"LTU",
":",
"case",
"UNGE",
":",
"return",
"base_bit",
";",
"case",
"ORDERED",
":",
"case",
"UNORDERED",
":",
"return",
"base_bit",
"+",
"3",
";",
"case",
"GE",
":",
"case",
"GEU",
":",
"return",
"scc_p",
"?",
"base_bit",
"+",
"3",
":",
"base_bit",
";",
"case",
"LE",
":",
"case",
"LEU",
":",
"return",
"scc_p",
"?",
"base_bit",
"+",
"3",
":",
"base_bit",
"+",
"1",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Given",
"a",
"comparison",
"operation",
",",
"return",
"the",
"bit",
"number",
"in",
"CCR",
"to",
"test",
".",
"We",
"know",
"this",
"is",
"a",
"valid",
"comparison",
".",
"SCC_P",
"is",
"1",
"if",
"this",
"is",
"for",
"an",
"scc",
".",
"That",
"means",
"that",
"%",
"D",
"will",
"have",
"been",
"used",
"instead",
"of",
"%",
"C",
",",
"so",
"the",
"bits",
"will",
"be",
"in",
"different",
"places",
".",
"Return",
"-1",
"if",
"OP",
"is",
"n't",
"a",
"valid",
"comparison",
"for",
"some",
"reason",
"."
] | [
"powerpcspe",
"1",
"0",
"4",
"3",
"2",
"2",
"1",
"3",
"3",
"3",
"1"
] | powerpcspe | ccr_bit | powerpcspe | CPU | GCC | 31,122 | 235 | 1 | [] |
[
"<s>",
"unsigned",
"getPointerSize",
"(",
")",
"const",
"{",
"return",
"4",
";",
"}",
"</s>"
] | [
"Layout",
"pointer",
"size",
"in",
"bytes",
",",
"rounded",
"up",
"to",
"a",
"whole",
"number",
"of",
"bytes",
"."
] | [
"LC3",
"4"
] | LC3AsmBackend | getPointerSize | LC3 | CPU | LLVM | 31,123 | 10 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUTargetLowering",
"::",
"ComputeNumSignBitsForTargetNode",
"(",
"SDValue",
"Op",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPUISD",
"::",
"BFE_I32",
":",
"{",
"ConstantSDNode",
"*",
"Width",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
";",
"if",
"(",
"!",
"Width",
")",
"return",
"1",
";",
"unsigned",
"SignBits",
"=",
"32",
"-",
"Width",
"->",
"getZExtValue",
"(",
")",
"+",
"1",
";",
"ConstantSDNode",
"*",
"Offset",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"if",
"(",
"!",
"Offset",
"||",
"!",
"Offset",
"->",
"isNullValue",
"(",
")",
")",
"return",
"SignBits",
";",
"unsigned",
"Op0SignBits",
"=",
"DAG",
".",
"ComputeNumSignBits",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
",",
"Depth",
"+",
"1",
")",
";",
"return",
"std",
"::",
"max",
"(",
"SignBits",
",",
"Op0SignBits",
")",
";",
"}",
"case",
"AMDGPUISD",
"::",
"BFE_U32",
":",
"{",
"ConstantSDNode",
"*",
"Width",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
";",
"return",
"Width",
"?",
"32",
"-",
"(",
"Width",
"->",
"getZExtValue",
"(",
")",
"&",
"0x1f",
")",
":",
"1",
";",
"}",
"case",
"AMDGPUISD",
"::",
"CARRY",
":",
"case",
"AMDGPUISD",
"::",
"BORROW",
":",
"return",
"31",
";",
"default",
":",
"return",
"1",
";",
"}",
"}",
"</s>"
] | [
"Determine",
"the",
"number",
"of",
"bits",
"in",
"the",
"operation",
"that",
"are",
"sign",
"bits",
"."
] | [
"R600",
"AMDGPUISD::BFE_I32",
"2",
"1",
"32",
"1",
"1",
"0",
"1",
"AMDGPUISD::BFE_U32",
"2",
"32",
"0x1f",
"1",
"AMDGPUISD::CARRY",
"AMDGPUISD::BORROW",
"31",
"1"
] | AMDGPUISelLowering98 | ComputeNumSignBitsForTargetNode | R600 | GPU | LLVM | 31,124 | 194 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"RISCV_EXPAND_SSR_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"RI5CY",
"RISCV"
] | RISCVExpandSSRInsts | getPassName | RI5CY | CPU | LLVM | 31,125 | 11 | 1 | [] |
[
"<s>",
"uint32_t",
"HSAILMachineFunctionInfo",
"::",
"getStackSize",
"(",
")",
"{",
"if",
"(",
"mStackSize",
"==",
"-",
"1",
")",
"{",
"uint32_t",
"privSize",
"=",
"0",
";",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"mMF",
"->",
"getFrameInfo",
"(",
")",
";",
"privSize",
"=",
"MFI",
"->",
"getOffsetAdjustment",
"(",
")",
"+",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"const",
"HSAILTargetMachine",
"*",
"TM",
"=",
"reinterpret_cast",
"<",
"const",
"HSAILTargetMachine",
"*",
">",
"(",
"&",
"mMF",
"->",
"getTarget",
"(",
")",
")",
";",
"bool",
"addStackSize",
"=",
"TM",
"->",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"None",
";",
"Function",
"::",
"const_arg_iterator",
"I",
"=",
"mMF",
"->",
"getFunction",
"(",
")",
"->",
"arg_begin",
"(",
")",
";",
"Function",
"::",
"const_arg_iterator",
"Ie",
"=",
"mMF",
"->",
"getFunction",
"(",
")",
"->",
"arg_end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"Ie",
")",
"{",
"Type",
"*",
"curType",
"=",
"I",
"->",
"getType",
"(",
")",
";",
"++",
"I",
";",
"if",
"(",
"dyn_cast",
"<",
"PointerType",
">",
"(",
"curType",
")",
")",
"{",
"Type",
"*",
"CT",
"=",
"dyn_cast",
"<",
"PointerType",
">",
"(",
"curType",
")",
"->",
"getElementType",
"(",
")",
";",
"if",
"(",
"CT",
"->",
"isStructTy",
"(",
")",
"&&",
"dyn_cast",
"<",
"PointerType",
">",
"(",
"curType",
")",
"->",
"getAddressSpace",
"(",
")",
"==",
"HSAILAS",
"::",
"PRIVATE_ADDRESS",
")",
"{",
"addStackSize",
"=",
"true",
";",
"}",
"}",
"}",
"if",
"(",
"addStackSize",
")",
"{",
"privSize",
"+=",
"getScratchSize",
"(",
")",
";",
"}",
"mStackSize",
"=",
"privSize",
";",
"}",
"return",
"(",
"uint32_t",
")",
"mStackSize",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"bytes",
"that",
"must",
"be",
"allocated",
"to",
"hold",
"all",
"of",
"the",
"fixed",
"size",
"frame",
"objects",
"."
] | [
"HSAIL",
"HSAIL",
"1",
"0",
"HSAIL",
"HSAIL",
"HSAILAS::PRIVATE_ADDRESS"
] | HSAILMachineFunctionInfo | getStackSize | HSAIL | Virtual ISA | LLVM | 31,126 | 211 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_save_reg",
"(",
"unsigned",
"int",
"regno",
",",
"bool",
"maybe_eh_return",
",",
"bool",
"ignore_outlined",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"no_caller_saved_registers",
")",
"{",
"rtx",
"reg",
"=",
"crtl",
"->",
"return_rtx",
";",
"if",
"(",
"reg",
")",
"{",
"unsigned",
"int",
"i",
"=",
"REGNO",
"(",
"reg",
")",
";",
"unsigned",
"int",
"nregs",
"=",
"REG_NREGS",
"(",
"reg",
")",
";",
"while",
"(",
"nregs",
"--",
">",
"0",
")",
"if",
"(",
"(",
"i",
"+",
"nregs",
")",
"==",
"regno",
")",
"return",
"false",
";",
"reg",
"=",
"crtl",
"->",
"return_bnd",
";",
"if",
"(",
"reg",
")",
"{",
"i",
"=",
"REGNO",
"(",
"reg",
")",
";",
"nregs",
"=",
"REG_NREGS",
"(",
"reg",
")",
";",
"while",
"(",
"nregs",
"--",
">",
"0",
")",
"if",
"(",
"(",
"i",
"+",
"nregs",
")",
"==",
"regno",
")",
"return",
"false",
";",
"}",
"}",
"return",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"!",
"fixed_regs",
"[",
"regno",
"]",
"&&",
"!",
"STACK_REGNO_P",
"(",
"regno",
")",
"&&",
"!",
"MMX_REGNO_P",
"(",
"regno",
")",
"&&",
"(",
"regno",
"!=",
"HARD_FRAME_POINTER_REGNUM",
"||",
"!",
"frame_pointer_needed",
")",
")",
";",
"}",
"if",
"(",
"regno",
"==",
"REAL_PIC_OFFSET_TABLE_REGNUM",
"&&",
"pic_offset_table_rtx",
")",
"{",
"if",
"(",
"ix86_use_pseudo_pic_reg",
"(",
")",
")",
"{",
"if",
"(",
"!",
"TARGET_64BIT",
"&&",
"flag_pic",
"&&",
"crtl",
"->",
"profile",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"df_regs_ever_live_p",
"(",
"REAL_PIC_OFFSET_TABLE_REGNUM",
")",
"||",
"crtl",
"->",
"profile",
"||",
"crtl",
"->",
"calls_eh_return",
"||",
"crtl",
"->",
"uses_const_pool",
"||",
"cfun",
"->",
"has_nonlocal_label",
")",
"return",
"ix86_select_alt_pic_regnum",
"(",
")",
"==",
"INVALID_REGNUM",
";",
"}",
"if",
"(",
"crtl",
"->",
"calls_eh_return",
"&&",
"maybe_eh_return",
")",
"{",
"unsigned",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
";",
"i",
"++",
")",
"{",
"unsigned",
"test",
"=",
"EH_RETURN_DATA_REGNO",
"(",
"i",
")",
";",
"if",
"(",
"test",
"==",
"INVALID_REGNUM",
")",
"break",
";",
"if",
"(",
"test",
"==",
"regno",
")",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"ignore_outlined",
"&&",
"cfun",
"->",
"machine",
"->",
"call_ms2sysv",
")",
"{",
"unsigned",
"count",
"=",
"cfun",
"->",
"machine",
"->",
"call_ms2sysv_extra_regs",
"+",
"xlogue_layout",
"::",
"MIN_REGS",
";",
"if",
"(",
"xlogue_layout",
"::",
"is_stub_managed_reg",
"(",
"regno",
",",
"count",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"crtl",
"->",
"drap_reg",
"&&",
"regno",
"==",
"REGNO",
"(",
"crtl",
"->",
"drap_reg",
")",
"&&",
"!",
"cfun",
"->",
"machine",
"->",
"no_drap_save_restore",
")",
"return",
"true",
";",
"return",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"!",
"call_used_regs",
"[",
"regno",
"]",
"&&",
"!",
"fixed_regs",
"[",
"regno",
"]",
"&&",
"(",
"regno",
"!=",
"HARD_FRAME_POINTER_REGNUM",
"||",
"!",
"frame_pointer_needed",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"1",
"if",
"we",
"need",
"to",
"save",
"REGNO",
"."
] | [
"i386",
"0",
"0",
"0"
] | i3867 | ix86_save_reg | i386 | CPU | GCC | 31,127 | 364 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"BPFRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"return",
"CSR_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"BPF",
"BPF"
] | BPFRegisterInfo (2) | getCalleeSavedRegs | BPF | Virtual ISA | LLVM | 31,128 | 18 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"X86RegisterInfo",
"::",
"getMatchingSuperRegClass",
"(",
"const",
"TargetRegisterClass",
"*",
"A",
",",
"const",
"TargetRegisterClass",
"*",
"B",
",",
"unsigned",
"SubIdx",
")",
"const",
"{",
"if",
"(",
"!",
"Is64Bit",
"&&",
"SubIdx",
"==",
"X86",
"::",
"sub_8bit",
")",
"{",
"A",
"=",
"X86GenRegisterInfo",
"::",
"getSubClassWithSubReg",
"(",
"A",
",",
"X86",
"::",
"sub_8bit_hi",
")",
";",
"if",
"(",
"!",
"A",
")",
"return",
"nullptr",
";",
"}",
"return",
"X86GenRegisterInfo",
"::",
"getMatchingSuperRegClass",
"(",
"A",
",",
"B",
",",
"SubIdx",
")",
";",
"}",
"</s>"
] | [
"getMatchingSuperRegClass",
"-",
"Return",
"a",
"subclass",
"of",
"the",
"specified",
"register",
"class",
"A",
"so",
"that",
"each",
"register",
"in",
"it",
"has",
"a",
"sub-register",
"of",
"the",
"specified",
"sub-register",
"index",
"which",
"is",
"in",
"the",
"specified",
"register",
"class",
"B",
"."
] | [
"X86",
"X86",
"X86::sub_8bit",
"X86",
"X86::sub_8bit_hi",
"X86"
] | X86RegisterInfo (2) | getMatchingSuperRegClass | X86 | CPU | LLVM | 31,129 | 69 | 1 | [] |
[
"<s>",
"void",
"X86InsertPrefetch",
"::",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineModuleInfo",
">",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"X86",
"X86"
] | X86InsertPrefetch (2) | getAnalysisUsage | X86 | CPU | LLVM | 31,130 | 27 | 1 | [] |
[
"<s>",
"Value",
"*",
"Simplifier",
"::",
"simplify",
"(",
"Context",
"&",
"C",
")",
"{",
"WorkListType",
"Q",
";",
"Q",
".",
"push_back",
"(",
"C",
".",
"Root",
")",
";",
"unsigned",
"Count",
"=",
"0",
";",
"const",
"unsigned",
"Limit",
"=",
"100000",
";",
"while",
"(",
"!",
"Q",
".",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"Count",
"++",
">=",
"Limit",
")",
"break",
";",
"Instruction",
"*",
"U",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"Q",
".",
"pop_front_val",
"(",
")",
")",
";",
"if",
"(",
"!",
"U",
"||",
"U",
"->",
"getParent",
"(",
")",
"||",
"!",
"C",
".",
"Used",
".",
"count",
"(",
"U",
")",
")",
"continue",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"Rule",
"&",
"R",
":",
"Rules",
")",
"{",
"Value",
"*",
"W",
"=",
"R",
"(",
"U",
",",
"C",
".",
"Ctx",
")",
";",
"if",
"(",
"!",
"W",
")",
"continue",
";",
"Changed",
"=",
"true",
";",
"C",
".",
"record",
"(",
"W",
")",
";",
"C",
".",
"replace",
"(",
"U",
",",
"W",
")",
";",
"Q",
".",
"push_back",
"(",
"C",
".",
"Root",
")",
";",
"break",
";",
"}",
"if",
"(",
"!",
"Changed",
")",
"{",
"for",
"(",
"Value",
"*",
"Op",
":",
"U",
"->",
"operands",
"(",
")",
")",
"Q",
".",
"push_back",
"(",
"Op",
")",
";",
"}",
"}",
"assert",
"(",
"Count",
"<",
"Limit",
"&&",
"\"Infinite loop in HLIR/simplify?\"",
")",
";",
"return",
"C",
".",
"Root",
";",
"}",
"</s>"
] | [
"Go",
"through",
"all",
"the",
"nodes",
"in",
"the",
"graph",
"and",
"collapse",
"any",
"two",
"nodes",
"'",
"a",
"'",
"and",
"'",
"b",
"'",
"if",
"all",
"of",
"the",
"following",
"are",
"true",
":"
] | [
"Hexagon",
"0",
"100000",
"\"Infinite loop in HLIR/simplify?\""
] | HexagonLoopIdiomRecognition26 | simplify | Hexagon | DSP | LLVM | 31,131 | 200 | 1 | [] |
[
"<s>",
"static",
"OR1KOperand",
"*",
"CreateReg",
"(",
"unsigned",
"RegNo",
",",
"SMLoc",
"S",
",",
"SMLoc",
"E",
")",
"{",
"OR1KOperand",
"*",
"Op",
"=",
"new",
"OR1KOperand",
"(",
"Register",
")",
";",
"Op",
"->",
"Reg",
".",
"RegNum",
"=",
"RegNo",
";",
"Op",
"->",
"StartLoc",
"=",
"S",
";",
"Op",
"->",
"EndLoc",
"=",
"E",
";",
"return",
"Op",
";",
"}",
"</s>"
] | [
"CreateReg",
"-",
"Allocate",
"a",
"single",
"virtual",
"register",
"for",
"the",
"given",
"type",
"."
] | [
"OR1K",
"OR1K",
"OR1K",
"OR1K"
] | OR1KAsmParser | CreateReg | OR1K | CPU | LLVM | 31,132 | 49 | 1 | [] |
[
"<s>",
"rtx",
"gen_split_move_double",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"rtx",
"dest",
"=",
"operands",
"[",
"0",
"]",
";",
"rtx",
"src",
"=",
"operands",
"[",
"1",
"]",
";",
"rtx",
"val",
";",
"if",
"(",
"GET_CODE",
"(",
"dest",
")",
"==",
"SUBREG",
")",
"alter_subreg",
"(",
"&",
"dest",
",",
"true",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"SUBREG",
")",
"alter_subreg",
"(",
"&",
"src",
",",
"true",
")",
";",
"start_sequence",
"(",
")",
";",
"if",
"(",
"REG_P",
"(",
"dest",
")",
")",
"{",
"int",
"dregno",
"=",
"REGNO",
"(",
"dest",
")",
";",
"if",
"(",
"REG_P",
"(",
"src",
")",
")",
"{",
"int",
"sregno",
"=",
"REGNO",
"(",
"src",
")",
";",
"int",
"reverse",
"=",
"(",
"dregno",
"==",
"sregno",
"+",
"1",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operand_subword",
"(",
"dest",
",",
"reverse",
",",
"TRUE",
",",
"mode",
")",
",",
"operand_subword",
"(",
"src",
",",
"reverse",
",",
"TRUE",
",",
"mode",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operand_subword",
"(",
"dest",
",",
"!",
"reverse",
",",
"TRUE",
",",
"mode",
")",
",",
"operand_subword",
"(",
"src",
",",
"!",
"reverse",
",",
"TRUE",
",",
"mode",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"CONST_INT_P",
"(",
"src",
")",
"||",
"GET_CODE",
"(",
"src",
")",
"==",
"CONST_DOUBLE",
")",
"{",
"rtx",
"words",
"[",
"2",
"]",
";",
"split_double",
"(",
"src",
",",
"&",
"words",
"[",
"0",
"]",
",",
"&",
"words",
"[",
"1",
"]",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operand_subword",
"(",
"dest",
",",
"0",
",",
"TRUE",
",",
"mode",
")",
",",
"words",
"[",
"0",
"]",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operand_subword",
"(",
"dest",
",",
"1",
",",
"TRUE",
",",
"mode",
")",
",",
"words",
"[",
"1",
"]",
")",
")",
";",
"}",
"else",
"if",
"(",
"MEM_P",
"(",
"src",
")",
")",
"{",
"int",
"reverse",
"=",
"refers_to_regno_p",
"(",
"dregno",
",",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operand_subword",
"(",
"dest",
",",
"reverse",
",",
"TRUE",
",",
"mode",
")",
",",
"adjust_address",
"(",
"src",
",",
"SImode",
",",
"reverse",
"*",
"UNITS_PER_WORD",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operand_subword",
"(",
"dest",
",",
"!",
"reverse",
",",
"TRUE",
",",
"mode",
")",
",",
"adjust_address",
"(",
"src",
",",
"SImode",
",",
"!",
"reverse",
"*",
"UNITS_PER_WORD",
")",
")",
")",
";",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"}",
"else",
"if",
"(",
"MEM_P",
"(",
"dest",
")",
"&&",
"REG_P",
"(",
"src",
")",
")",
"{",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"adjust_address",
"(",
"dest",
",",
"SImode",
",",
"0",
")",
",",
"operand_subword",
"(",
"src",
",",
"0",
",",
"TRUE",
",",
"mode",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"adjust_address",
"(",
"dest",
",",
"SImode",
",",
"UNITS_PER_WORD",
")",
",",
"operand_subword",
"(",
"src",
",",
"1",
",",
"TRUE",
",",
"mode",
")",
")",
")",
";",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"val",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"return",
"val",
";",
"}",
"</s>"
] | [
"Split",
"a",
"2",
"word",
"move",
"(",
"DI",
"or",
"DF",
")",
"into",
"component",
"parts",
"."
] | [
"m32r",
"0",
"0",
"1",
"1",
"2",
"0",
"1",
"0",
"0",
"1",
"1",
"0",
"0",
"0",
"1"
] | m32r | gen_split_move_double | m32r | MPU | GCC | 31,133 | 438 | 1 | [] |
[
"<s>",
"bool",
"mayNeedRelaxation",
"(",
"const",
"MCInst",
"&",
"Inst",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"mayNeedRelaxation() unimplemented\"",
")",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"the",
"given",
"instruction",
"may",
"need",
"relaxation",
"."
] | [
"Z80",
"\"mayNeedRelaxation() unimplemented\""
] | Z80AsmBackend | mayNeedRelaxation | Z80 | MPU | LLVM | 31,134 | 16 | 1 | [] |
[
"<s>",
"HOST_WIDE_INT",
"c6x_initial_elimination_offset",
"(",
"int",
"from",
",",
"int",
"to",
")",
"{",
"struct",
"c6x_frame",
"frame",
";",
"c6x_compute_frame_layout",
"(",
"&",
"frame",
")",
";",
"if",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
"&&",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"return",
"0",
";",
"else",
"if",
"(",
"from",
"==",
"FRAME_POINTER_REGNUM",
"&&",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"return",
"-",
"frame",
".",
"frame_pointer_offset",
";",
"else",
"{",
"gcc_assert",
"(",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
";",
"if",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
")",
"return",
"frame",
".",
"to_allocate",
"+",
"(",
"frame",
".",
"push_rts",
"?",
"56",
":",
"0",
")",
";",
"gcc_assert",
"(",
"from",
"==",
"FRAME_POINTER_REGNUM",
")",
";",
"return",
"frame",
".",
"to_allocate",
"-",
"frame",
".",
"frame_pointer_offset",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"offset",
"between",
"two",
"registers",
",",
"one",
"to",
"be",
"eliminated",
",",
"and",
"the",
"other",
"its",
"replacement",
",",
"at",
"the",
"start",
"of",
"a",
"routine",
"."
] | [
"c6x",
"0",
"56",
"0"
] | c6x | c6x_initial_elimination_offset | c6x | VLIW | GCC | 31,135 | 98 | 1 | [] |
[
"<s>",
"bool",
"SystemZTargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
",",
"bool",
"ForCodeSize",
")",
"const",
"{",
"if",
"(",
"Imm",
".",
"isZero",
"(",
")",
"||",
"Imm",
".",
"isNegZero",
"(",
")",
")",
"return",
"true",
";",
"return",
"SystemZVectorConstantInfo",
"(",
"Imm",
")",
".",
"isVectorConstantLegal",
"(",
"Subtarget",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ"
] | SystemZISelLowering (2)2 | isFPImmLegal | SystemZ | CPU | LLVM | 31,136 | 47 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m68k_call_m68k_read_tp",
"(",
"void",
")",
"{",
"rtx",
"a0",
";",
"rtx",
"eqv",
";",
"rtx_insn",
"*",
"insns",
";",
"rtx",
"dest",
";",
"start_sequence",
"(",
")",
";",
"m68k_libcall_value_in_a0_p",
"=",
"true",
";",
"a0",
"=",
"emit_library_call_value",
"(",
"m68k_get_m68k_read_tp",
"(",
")",
",",
"NULL_RTX",
",",
"LCT_PURE",
",",
"Pmode",
")",
";",
"m68k_libcall_value_in_a0_p",
"=",
"false",
";",
"insns",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"eqv",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"const1_rtx",
")",
",",
"UNSPEC_RELOC32",
")",
";",
"gcc_assert",
"(",
"can_create_pseudo_p",
"(",
")",
")",
";",
"dest",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_libcall_block",
"(",
"insns",
",",
"dest",
",",
"a0",
",",
"eqv",
")",
";",
"return",
"dest",
";",
"}",
"</s>"
] | [
"Emit",
"instruction",
"sequence",
"that",
"calls",
"__m68k_read_tp",
".",
"A",
"pseudo",
"register",
"with",
"result",
"of",
"__m68k_read_tp",
"call",
"is",
"returned",
"."
] | [
"m68k",
"1"
] | m68k | m68k_call_m68k_read_tp | m68k | MPU | GCC | 31,137 | 102 | 1 | [] |
[
"<s>",
"bool",
"isLegalMaskedLoad",
"(",
"Type",
"*",
"DataType",
",",
"Align",
"Alignment",
")",
"{",
"return",
"isLegalMaskedLoadStore",
"(",
"DataType",
",",
"Alignment",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"supports",
"masked",
"load",
"."
] | [
"RISCV"
] | RISCVTargetTransformInfo10 | isLegalMaskedLoad | RISCV | CPU | LLVM | 31,138 | 20 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SI Fold Operands\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU",
"\"SI Fold Operands\""
] | SIFoldOperands1 | getPassName | AMDGPU | GPU | LLVM | 31,139 | 13 | 1 | [] |
[
"<s>",
"bool",
"preferZeroCompareBranch",
"(",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"heuristic",
"to",
"prefer",
"icmp",
"eq",
"zero",
"should",
"be",
"used",
"in",
"code",
"gen",
"prepare",
"."
] | [
"ARM"
] | ARMISelLowering | preferZeroCompareBranch | ARM | CPU | LLVM | 31,140 | 11 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_assemble_visibility",
"(",
"tree",
"decl",
",",
"int",
"vis",
")",
"{",
"if",
"(",
"TARGET_XCOFF",
")",
"return",
";",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
"&&",
"DOT_SYMBOLS",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"{",
"static",
"const",
"char",
"*",
"const",
"visibility_types",
"[",
"]",
"=",
"{",
"NULL",
",",
"\"protected\"",
",",
"\"hidden\"",
",",
"\"internal\"",
"}",
";",
"const",
"char",
"*",
"name",
",",
"*",
"type",
";",
"name",
"=",
"(",
"(",
"*",
"targetm",
".",
"strip_name_encoding",
")",
"(",
"IDENTIFIER_POINTER",
"(",
"DECL_ASSEMBLER_NAME",
"(",
"decl",
")",
")",
")",
")",
";",
"type",
"=",
"visibility_types",
"[",
"vis",
"]",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.%s\\t%s\\n\"",
",",
"type",
",",
"name",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.%s\\t.%s\\n\"",
",",
"type",
",",
"name",
")",
";",
"}",
"else",
"default_assemble_visibility",
"(",
"decl",
",",
"vis",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"assembler",
"directive",
"to",
"set",
"symbol",
"visibility",
"for",
"DECL",
"to",
"VISIBILITY_TYPE",
"."
] | [
"rs6000",
"\"protected\"",
"\"hidden\"",
"\"internal\"",
"\"\\t.%s\\t%s\\n\"",
"\"\\t.%s\\t.%s\\n\""
] | rs6000 | rs6000_assemble_visibility | rs6000 | CPU | GCC | 31,141 | 119 | 1 | [] |
[
"<s>",
"bool",
"enableShrinkWrapping",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"will",
"correctly",
"handle",
"shrink",
"wrapping",
"."
] | [
"AArch64"
] | AArch64FrameLowering (2)1 | enableShrinkWrapping | AArch64 | CPU | LLVM | 31,142 | 15 | 1 | [] |
[
"<s>",
"static",
"int",
"mergeSPUpdates",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"unsigned",
"StackPtr",
",",
"bool",
"doMergeWithPrevious",
")",
"{",
"if",
"(",
"(",
"doMergeWithPrevious",
"&&",
"MBBI",
"==",
"MBB",
".",
"begin",
"(",
")",
")",
"||",
"(",
"!",
"doMergeWithPrevious",
"&&",
"MBBI",
"==",
"MBB",
".",
"end",
"(",
")",
")",
")",
"return",
"0",
";",
"MachineBasicBlock",
"::",
"iterator",
"PI",
"=",
"doMergeWithPrevious",
"?",
"std",
"::",
"prev",
"(",
"MBBI",
")",
":",
"MBBI",
";",
"MachineBasicBlock",
"::",
"iterator",
"NI",
"=",
"doMergeWithPrevious",
"?",
"0",
":",
"std",
"::",
"next",
"(",
"MBBI",
")",
";",
"unsigned",
"Opc",
"=",
"PI",
"->",
"getOpcode",
"(",
")",
";",
"int",
"Offset",
"=",
"0",
";",
"if",
"(",
"(",
"Opc",
"==",
"X86",
"::",
"ADD64ri32",
"||",
"Opc",
"==",
"X86",
"::",
"ADD64ri8",
"||",
"Opc",
"==",
"X86",
"::",
"ADD32ri",
"||",
"Opc",
"==",
"X86",
"::",
"ADD32ri8",
"||",
"Opc",
"==",
"X86",
"::",
"LEA32r",
"||",
"Opc",
"==",
"X86",
"::",
"LEA64_32r",
")",
"&&",
"PI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"Offset",
"+=",
"PI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";",
"if",
"(",
"!",
"doMergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";",
"}",
"else",
"if",
"(",
"(",
"Opc",
"==",
"X86",
"::",
"SUB64ri32",
"||",
"Opc",
"==",
"X86",
"::",
"SUB64ri8",
"||",
"Opc",
"==",
"X86",
"::",
"SUB32ri",
"||",
"Opc",
"==",
"X86",
"::",
"SUB32ri8",
")",
"&&",
"PI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"Offset",
"-=",
"PI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";",
"if",
"(",
"!",
"doMergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";",
"}",
"return",
"Offset",
";",
"}",
"</s>"
] | [
"Check",
"the",
"instruction",
"before/after",
"the",
"passed",
"instruction",
"."
] | [
"X86",
"0",
"0",
"0",
"X86::ADD64ri32",
"X86::ADD64ri8",
"X86::ADD32ri",
"X86::ADD32ri8",
"X86::LEA32r",
"X86::LEA64_32r",
"0",
"2",
"X86::SUB64ri32",
"X86::SUB64ri8",
"X86::SUB32ri",
"X86::SUB32ri8",
"0",
"2"
] | X86FrameLowering (2) | mergeSPUpdates | X86 | CPU | LLVM | 31,143 | 258 | 1 | [] |
[
"<s>",
"bool",
"AArch64CallLowering",
"::",
"isTypeIsValidForThisReturn",
"(",
"EVT",
"Ty",
")",
"const",
"{",
"return",
"Ty",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
";",
"}",
"</s>"
] | [
"For",
"targets",
"which",
"support",
"the",
"``",
"returned",
"''",
"parameter",
"attribute",
",",
"returns",
"true",
"if",
"the",
"given",
"type",
"is",
"a",
"valid",
"one",
"to",
"use",
"with",
"``",
"returned",
"''",
"."
] | [
"AArch64",
"AArch64",
"64"
] | AArch64CallLowering13 | isTypeIsValidForThisReturn | AArch64 | CPU | LLVM | 31,144 | 20 | 1 | [] |
[
"<s>",
"static",
"tree",
"alpha_fold_builtin_zapnot",
"(",
"tree",
"*",
"op",
",",
"unsigned",
"HOST_WIDE_INT",
"opint",
"[",
"]",
",",
"long",
"op_const",
")",
"{",
"if",
"(",
"op_const",
"&",
"2",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"mask",
"=",
"0",
";",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"8",
";",
"++",
"i",
")",
"if",
"(",
"(",
"opint",
"[",
"1",
"]",
">>",
"i",
")",
"&",
"1",
")",
"mask",
"|=",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0xff",
"<<",
"(",
"i",
"*",
"8",
")",
";",
"if",
"(",
"op_const",
"&",
"1",
")",
"return",
"build_int_cst",
"(",
"alpha_dimode_u",
",",
"opint",
"[",
"0",
"]",
"&",
"mask",
")",
";",
"if",
"(",
"op",
")",
"return",
"fold_build2",
"(",
"BIT_AND_EXPR",
",",
"alpha_dimode_u",
",",
"op",
"[",
"0",
"]",
",",
"build_int_cst",
"(",
"alpha_dimode_u",
",",
"mask",
")",
")",
";",
"}",
"else",
"if",
"(",
"(",
"op_const",
"&",
"1",
")",
"&&",
"opint",
"[",
"0",
"]",
"==",
"0",
")",
"return",
"build_int_cst",
"(",
"alpha_dimode_u",
",",
"0",
")",
";",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Fold",
"the",
"builtin",
"for",
"the",
"ZAPNOT",
"instruction",
".",
"This",
"is",
"essentially",
"a",
"specialized",
"form",
"of",
"an",
"AND",
"operation",
".",
"Other",
"byte",
"manipulation",
"instructions",
"are",
"defined",
"in",
"terms",
"of",
"this",
"instruction",
",",
"so",
"this",
"is",
"also",
"used",
"as",
"a",
"subroutine",
"for",
"other",
"builtins",
".",
"OP",
"contains",
"the",
"tree",
"operands",
";",
"OPINT",
"contains",
"the",
"extracted",
"integer",
"values",
".",
"Bit",
"N",
"of",
"OP_CONST",
"it",
"set",
"if",
"OPINT",
"[",
"N",
"]",
"is",
"valid",
".",
"OP",
"may",
"be",
"null",
"if",
"only",
"OPINT",
"may",
"be",
"considered",
"."
] | [
"alpha",
"2",
"0",
"0",
"8",
"1",
"1",
"0xff",
"8",
"1",
"0",
"0",
"1",
"0",
"0",
"0"
] | alpha | alpha_fold_builtin_zapnot | alpha | MPU | GCC | 31,145 | 146 | 1 | [] |
[
"<s>",
"unsigned",
"AAPInstrInfo",
"::",
"insertIndirectBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"&",
"DestBB",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"int64_t",
"BrOffset",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"auto",
"&",
"MI",
"=",
"*",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"AAP",
"::",
"BRA",
")",
")",
".",
"addMBB",
"(",
"&",
"DestBB",
")",
";",
"return",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"Insert",
"an",
"unconditional",
"indirect",
"branch",
"at",
"the",
"end",
"of",
"MBB",
"to",
"NewDestBB",
"."
] | [
"AAP",
"AAP",
"AAP::BRA"
] | AAPInstrInfo | insertIndirectBranch | AAP | MPU | LLVM | 31,146 | 60 | 1 | [] |
[
"<s>",
"inline",
"hashval_t",
"registered_function_hasher",
"::",
"hash",
"(",
"value_type",
"value",
")",
"{",
"return",
"value",
"->",
"instance",
".",
"hash",
"(",
")",
";",
"}",
"</s>"
] | [
"Hash",
"function",
"for",
"builtin",
"functions",
"with",
"up",
"to",
"3",
"arguments",
"and",
"a",
"return",
"type",
"."
] | [
"riscv"
] | riscv-vector-builtins | hash | riscv | CPU | GCC | 31,147 | 20 | 1 | [] |
[
"<s>",
"static",
"void",
"riscv_for_each_saved_reg",
"(",
"poly_int64",
"sp_offset",
",",
"riscv_save_restore_fn",
"fn",
",",
"bool",
"epilogue",
",",
"bool",
"maybe_eh_return",
")",
"{",
"HOST_WIDE_INT",
"offset",
";",
"unsigned",
"int",
"regno",
";",
"unsigned",
"int",
"start",
"=",
"GP_REG_FIRST",
";",
"unsigned",
"int",
"limit",
"=",
"GP_REG_LAST",
";",
"offset",
"=",
"(",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"gp_sp_offset",
"-",
"sp_offset",
")",
".",
"to_constant",
"(",
")",
"+",
"UNITS_PER_WORD",
";",
"for",
"(",
"regno",
"=",
"riscv_next_saved_reg",
"(",
"start",
",",
"limit",
",",
"&",
"offset",
",",
"false",
")",
";",
"regno",
"!=",
"INVALID_REGNUM",
";",
"regno",
"=",
"riscv_next_saved_reg",
"(",
"regno",
",",
"limit",
",",
"&",
"offset",
")",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"reg_is_wrapped_separately",
"[",
"regno",
"]",
")",
"continue",
";",
"if",
"(",
"epilogue",
"&&",
"!",
"maybe_eh_return",
"&&",
"riscv_is_eh_return_data_register",
"(",
"regno",
")",
")",
"continue",
";",
"if",
"(",
"TARGET_XTHEADMEMPAIR",
")",
"{",
"HOST_WIDE_INT",
"offset2",
"=",
"offset",
";",
"unsigned",
"int",
"regno2",
"=",
"riscv_next_saved_reg",
"(",
"regno",
",",
"limit",
",",
"&",
"offset2",
")",
";",
"if",
"(",
"regno2",
"!=",
"INVALID_REGNUM",
"&&",
"!",
"cfun",
"->",
"machine",
"->",
"reg_is_wrapped_separately",
"[",
"regno2",
"]",
"&&",
"!",
"(",
"epilogue",
"&&",
"!",
"maybe_eh_return",
"&&",
"riscv_is_eh_return_data_register",
"(",
"regno2",
")",
")",
")",
"{",
"bool",
"load_p",
"=",
"(",
"fn",
"==",
"riscv_restore_reg",
")",
";",
"rtx",
"operands",
"[",
"4",
"]",
";",
"th_mempair_prepare_save_restore_operands",
"(",
"operands",
",",
"load_p",
",",
"word_mode",
",",
"regno",
",",
"offset",
",",
"regno2",
",",
"offset2",
")",
";",
"if",
"(",
"th_mempair_operands_p",
"(",
"operands",
",",
"load_p",
",",
"word_mode",
")",
")",
"{",
"th_mempair_save_restore_regs",
"(",
"operands",
",",
"load_p",
",",
"word_mode",
")",
";",
"offset",
"=",
"offset2",
";",
"regno",
"=",
"regno2",
";",
"continue",
";",
"}",
"}",
"}",
"riscv_save_restore_reg",
"(",
"word_mode",
",",
"regno",
",",
"offset",
",",
"fn",
")",
";",
"}",
"offset",
"=",
"(",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"fp_sp_offset",
"-",
"sp_offset",
")",
".",
"to_constant",
"(",
")",
";",
"for",
"(",
"unsigned",
"int",
"regno",
"=",
"FP_REG_FIRST",
";",
"regno",
"<=",
"FP_REG_LAST",
";",
"regno",
"++",
")",
"if",
"(",
"BITSET_P",
"(",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"fmask",
",",
"regno",
"-",
"FP_REG_FIRST",
")",
")",
"{",
"bool",
"handle_reg",
"=",
"!",
"cfun",
"->",
"machine",
"->",
"reg_is_wrapped_separately",
"[",
"regno",
"]",
";",
"machine_mode",
"mode",
"=",
"TARGET_DOUBLE_FLOAT",
"?",
"DFmode",
":",
"SFmode",
";",
"if",
"(",
"handle_reg",
")",
"riscv_save_restore_reg",
"(",
"mode",
",",
"regno",
",",
"offset",
",",
"fn",
")",
";",
"offset",
"-=",
"GET_MODE_SIZE",
"(",
"mode",
")",
".",
"to_constant",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Call",
"FN",
"for",
"each",
"register",
"that",
"is",
"saved",
"by",
"the",
"current",
"function",
".",
"SP_OFFSET",
"is",
"the",
"offset",
"of",
"the",
"current",
"stack",
"pointer",
"from",
"the",
"start",
"of",
"the",
"frame",
"."
] | [
"riscv",
"4"
] | riscv1 | riscv_for_each_saved_reg | riscv | CPU | GCC | 31,148 | 349 | 1 | [] |
[
"<s>",
"void",
"rs6000_emit_le_vsx_move",
"(",
"rtx",
"dest",
",",
"rtx",
"source",
",",
"machine_mode",
"mode",
")",
"{",
"gcc_assert",
"(",
"!",
"BYTES_BIG_ENDIAN",
"&&",
"VECTOR_MEM_VSX_P",
"(",
"mode",
")",
"&&",
"!",
"TARGET_P9_VECTOR",
"&&",
"!",
"gpr_or_gpr_p",
"(",
"dest",
",",
"source",
")",
"&&",
"(",
"MEM_P",
"(",
"source",
")",
"^",
"MEM_P",
"(",
"dest",
")",
")",
")",
";",
"if",
"(",
"MEM_P",
"(",
"source",
")",
")",
"{",
"gcc_assert",
"(",
"REG_P",
"(",
"dest",
")",
"||",
"GET_CODE",
"(",
"dest",
")",
"==",
"SUBREG",
")",
";",
"rs6000_emit_le_vsx_load",
"(",
"dest",
",",
"source",
",",
"mode",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"REG_P",
"(",
"source",
")",
")",
"source",
"=",
"force_reg",
"(",
"mode",
",",
"source",
")",
";",
"rs6000_emit_le_vsx_store",
"(",
"dest",
",",
"source",
",",
"mode",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"a",
"sequence",
"representing",
"a",
"little-endian",
"VSX",
"load",
"or",
"store",
",",
"moving",
"data",
"from",
"SOURCE",
"to",
"DEST",
"in",
"mode",
"MODE",
".",
"This",
"is",
"done",
"separately",
"from",
"rs6000_emit_move",
"to",
"ensure",
"it",
"is",
"called",
"only",
"during",
"expand",
".",
"LE",
"VSX",
"loads",
"and",
"stores",
"introduced",
"later",
"are",
"handled",
"with",
"a",
"split",
".",
"The",
"expand-time",
"RTL",
"generation",
"allows",
"us",
"to",
"optimize",
"away",
"redundant",
"pairs",
"of",
"register-permutes",
"."
] | [
"powerpcspe"
] | powerpcspe | rs6000_emit_le_vsx_move | powerpcspe | CPU | GCC | 31,149 | 110 | 1 | [] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Wasn't expecting to be able to lower this!\"",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"LowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"LowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"return",
"LowerGlobalTLSAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"LowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SETCC",
":",
"return",
"LowerSETCC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INIT_TRAMPOLINE",
":",
"return",
"LowerINIT_TRAMPOLINE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ADJUST_TRAMPOLINE",
":",
"return",
"LowerADJUST_TRAMPOLINE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"VAARG",
":",
"return",
"LowerVAARG",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"VACOPY",
":",
"return",
"LowerVACOPY",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"STACKRESTORE",
":",
"return",
"LowerSTACKRESTORE",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"EH_SJLJ_SETJMP",
":",
"return",
"lowerEH_SJLJ_SETJMP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EH_SJLJ_LONGJMP",
":",
"return",
"lowerEH_SJLJ_LONGJMP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"LowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"LowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"TRUNCATE",
":",
"return",
"LowerTRUNCATE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_UINT",
":",
"case",
"ISD",
"::",
"FP_TO_SINT",
":",
"return",
"LowerFP_TO_INT",
"(",
"Op",
",",
"DAG",
",",
"SDLoc",
"(",
"Op",
")",
")",
";",
"case",
"ISD",
"::",
"UINT_TO_FP",
":",
"case",
"ISD",
"::",
"SINT_TO_FP",
":",
"return",
"LowerINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FLT_ROUNDS_",
":",
"return",
"LowerFLT_ROUNDS_",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL_PARTS",
":",
"return",
"LowerSHL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRL_PARTS",
":",
"return",
"LowerSRL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRA_PARTS",
":",
"return",
"LowerSRA_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BUILD_VECTOR",
":",
"return",
"LowerBUILD_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VECTOR_SHUFFLE",
":",
"return",
"LowerVECTOR_SHUFFLE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SCALAR_TO_VECTOR",
":",
"return",
"LowerSCALAR_TO_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"LowerSIGN_EXTEND_INREG",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"LowerMUL",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
":",
"return",
"SDValue",
"(",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"PowerPC",
"PPC",
"\"Wasn't expecting to be able to lower this!\"",
"ISD::ConstantPool",
"ISD::BlockAddress",
"ISD::GlobalAddress",
"ISD::GlobalTLSAddress",
"ISD::JumpTable",
"ISD::SETCC",
"ISD::INIT_TRAMPOLINE",
"ISD::ADJUST_TRAMPOLINE",
"ISD::VASTART",
"PPC",
"ISD::VAARG",
"PPC",
"ISD::VACOPY",
"PPC",
"ISD::STACKRESTORE",
"PPC",
"ISD::DYNAMIC_STACKALLOC",
"PPC",
"ISD::EH_SJLJ_SETJMP",
"ISD::EH_SJLJ_LONGJMP",
"ISD::LOAD",
"ISD::STORE",
"ISD::TRUNCATE",
"ISD::SELECT_CC",
"ISD::FP_TO_UINT",
"ISD::FP_TO_SINT",
"ISD::UINT_TO_FP",
"ISD::SINT_TO_FP",
"ISD::FLT_ROUNDS_",
"ISD::SHL_PARTS",
"ISD::SRL_PARTS",
"ISD::SRA_PARTS",
"ISD::BUILD_VECTOR",
"ISD::VECTOR_SHUFFLE",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::SCALAR_TO_VECTOR",
"ISD::SIGN_EXTEND_INREG",
"ISD::MUL",
"ISD::INTRINSIC_W_CHAIN",
"ISD::RETURNADDR",
"ISD::FRAMEADDR"
] | PPCISelLowering120 | LowerOperation | PowerPC | CPU | LLVM | 31,150 | 496 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrItins",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"PowerPC"
] | PPCSubtarget (2)1 | getInstrItineraryData | PowerPC | CPU | LLVM | 31,151 | 14 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_emit_restore_regs_using_pop",
"(",
"void",
")",
"{",
"unsigned",
"int",
"regno",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"!",
"SSE_REGNO_P",
"(",
"regno",
")",
"&&",
"ix86_save_reg",
"(",
"regno",
",",
"false",
")",
")",
"ix86_emit_restore_reg_using_pop",
"(",
"gen_rtx_REG",
"(",
"word_mode",
",",
"regno",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"restore",
"saved",
"registers",
"using",
"POP",
"insns",
"."
] | [
"i386",
"0"
] | i3864 | ix86_emit_restore_regs_using_pop | i386 | CPU | GCC | 31,152 | 50 | 1 | [] |
[
"<s>",
"int",
"nonpic_symbol_mentioned_p",
"(",
"rtx",
"x",
")",
"{",
"register",
"const",
"char",
"*",
"fmt",
";",
"register",
"int",
"i",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"LABEL_REF",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"PC",
")",
"return",
"1",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_DOUBLE",
")",
"return",
"0",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"UNSPEC",
"&&",
"(",
"XINT",
"(",
"x",
",",
"1",
")",
"==",
"UNSPEC_PIC",
"||",
"XINT",
"(",
"x",
",",
"1",
")",
"==",
"UNSPEC_GOT",
"||",
"XINT",
"(",
"x",
",",
"1",
")",
"==",
"UNSPEC_GOTOFF",
"||",
"XINT",
"(",
"x",
",",
"1",
")",
"==",
"UNSPEC_GOTPLT",
"||",
"XINT",
"(",
"x",
",",
"1",
")",
"==",
"UNSPEC_GOTTPOFF",
"||",
"XINT",
"(",
"x",
",",
"1",
")",
"==",
"UNSPEC_DTPOFF",
"||",
"XINT",
"(",
"x",
",",
"1",
")",
"==",
"UNSPEC_PLT",
")",
")",
"return",
"0",
";",
"fmt",
"=",
"GET_RTX_FORMAT",
"(",
"GET_CODE",
"(",
"x",
")",
")",
";",
"for",
"(",
"i",
"=",
"GET_RTX_LENGTH",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'E'",
")",
"{",
"register",
"int",
"j",
";",
"for",
"(",
"j",
"=",
"XVECLEN",
"(",
"x",
",",
"i",
")",
"-",
"1",
";",
"j",
">=",
"0",
";",
"j",
"--",
")",
"if",
"(",
"nonpic_symbol_mentioned_p",
"(",
"XVECEXP",
"(",
"x",
",",
"i",
",",
"j",
")",
")",
")",
"return",
"1",
";",
"}",
"else",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'e'",
"&&",
"nonpic_symbol_mentioned_p",
"(",
"XEXP",
"(",
"x",
",",
"i",
")",
")",
")",
"return",
"1",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"X",
"references",
"a",
"SYMBOL_REF",
"or",
"LABEL_REF",
"whose",
"symbol",
"is",
"n't",
"protected",
"by",
"a",
"PIC",
"unspec",
"."
] | [
"sh",
"1",
"0",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"0",
"1",
"0",
"1",
"0",
"1",
"1",
"0"
] | sh3 | nonpic_symbol_mentioned_p | sh | CPU | GCC | 31,153 | 244 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"TeakRegisterInfo",
"::",
"getPointerRegClass",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"unsigned",
"Kind",
")",
"const",
"{",
"if",
"(",
"Kind",
"==",
"1",
")",
"return",
"&",
"Teak",
"::",
"ABRegsRegClass",
";",
"return",
"&",
"Teak",
"::",
"GRRegsRegClass",
";",
"}",
"</s>"
] | [
"getPointerRegClass",
"-",
"Returns",
"a",
"TargetRegisterClass",
"used",
"for",
"pointer",
"values",
"."
] | [
"Teak",
"Teak",
"1",
"Teak::ABRegsRegClass",
"Teak::GRRegsRegClass"
] | TeakRegisterInfo | getPointerRegClass | Teak | DSP | LLVM | 31,154 | 36 | 1 | [] |
[
"<s>",
"unsigned",
"RISCVInstrInfo",
"::",
"insertBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"TBB",
",",
"MachineBasicBlock",
"*",
"FBB",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"int",
"*",
"BytesAdded",
")",
"const",
"{",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"=",
"0",
";",
"assert",
"(",
"TBB",
"&&",
"\"insertBranch must not be told to insert a fallthrough\"",
")",
";",
"assert",
"(",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"3",
"||",
"Cond",
".",
"size",
"(",
")",
"==",
"0",
")",
"&&",
"\"RISCV branch conditions have two components!\"",
")",
";",
"if",
"(",
"Cond",
".",
"empty",
"(",
")",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"RISCV",
"::",
"PseudoBR",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"+=",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"return",
"1",
";",
"}",
"auto",
"CC",
"=",
"static_cast",
"<",
"RISCVCC",
"::",
"CondCode",
">",
"(",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
";",
"MachineInstr",
"&",
"CondMI",
"=",
"*",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"getBrCond",
"(",
"CC",
")",
")",
".",
"add",
"(",
"Cond",
"[",
"1",
"]",
")",
".",
"add",
"(",
"Cond",
"[",
"2",
"]",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"+=",
"getInstSizeInBytes",
"(",
"CondMI",
")",
";",
"if",
"(",
"!",
"FBB",
")",
"return",
"1",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"RISCV",
"::",
"PseudoBR",
")",
")",
".",
"addMBB",
"(",
"FBB",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"+=",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"return",
"2",
";",
"}",
"</s>"
] | [
"Insert",
"branch",
"code",
"into",
"the",
"end",
"of",
"the",
"specified",
"MachineBasicBlock",
"."
] | [
"RISCV",
"RISCV",
"0",
"\"insertBranch must not be told to insert a fallthrough\"",
"3",
"0",
"\"RISCV branch conditions have two components!\"",
"RISCV::PseudoBR",
"1",
"RISCVCC::CondCode",
"0",
"1",
"2",
"1",
"RISCV::PseudoBR",
"2"
] | RISCVInstrInfo (2) | insertBranch | RISCV | CPU | LLVM | 31,155 | 243 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"X86TargetMachine",
"*",
"TM",
"=",
"static_cast",
"<",
"const",
"X86TargetMachine",
"*",
">",
"(",
"&",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"TM",
"->",
"getFrameLowering",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"X86MachineFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"StackAlignment",
"=",
"TFI",
"->",
"getStackAlignment",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RI",
".",
"getNumVirtRegs",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"TargetRegisterInfo",
"::",
"index2VirtReg",
"(",
"i",
")",
";",
"if",
"(",
"RI",
".",
"getRegClass",
"(",
"Reg",
")",
"->",
"getAlignment",
"(",
")",
">",
"StackAlignment",
")",
"{",
"FuncInfo",
"->",
"setForceFramePointer",
"(",
"true",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"0"
] | X86RegisterInfo101 | runOnMachineFunction | X86 | CPU | LLVM | 31,156 | 137 | 1 | [] |
[
"<s>",
"void",
"CSKYTargetStreamer",
"::",
"finish",
"(",
")",
"{",
"if",
"(",
"ConstantCounter",
"!=",
"0",
")",
"{",
"ConstantPool",
"->",
"emitAll",
"(",
"Streamer",
")",
";",
"}",
"finishAttributeSection",
"(",
")",
";",
"}",
"</s>"
] | [
"finish",
"-",
"after",
"all",
"the",
"new",
"live",
"ranges",
"have",
"been",
"created",
",",
"compute",
"the",
"remaining",
"live",
"range",
",",
"and",
"rewrite",
"instructions",
"to",
"use",
"the",
"new",
"registers",
"."
] | [
"CSKY",
"CSKY",
"0"
] | CSKYTargetStreamer | finish | CSKY | CPU | LLVM | 31,157 | 27 | 1 | [] |
[
"<s>",
"void",
"ARMAsmBackend",
"::",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"MCInst",
"&",
"Res",
")",
"const",
"{",
"unsigned",
"RelaxedOp",
"=",
"getRelaxedOpcode",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"RelaxedOp",
"==",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"SmallString",
"<",
"256",
">",
"Tmp",
";",
"raw_svector_ostream",
"OS",
"(",
"Tmp",
")",
";",
"Inst",
".",
"dump_pretty",
"(",
"OS",
")",
";",
"OS",
"<<",
"\"\\n\"",
";",
"report_fatal_error",
"(",
"\"unexpected instruction to relax: \"",
"+",
"OS",
".",
"str",
"(",
")",
")",
";",
"}",
"if",
"(",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"tCBZ",
"||",
"Inst",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"tCBNZ",
")",
"&&",
"RelaxedOp",
"==",
"ARM",
"::",
"tHINT",
")",
"{",
"Res",
".",
"setOpcode",
"(",
"RelaxedOp",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"0",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"14",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"0",
")",
")",
";",
"return",
";",
"}",
"Res",
"=",
"Inst",
";",
"Res",
".",
"setOpcode",
"(",
"RelaxedOp",
")",
";",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"ARM",
"ARM",
"256",
"\"\\n\"",
"\"unexpected instruction to relax: \"",
"ARM::tCBZ",
"ARM::tCBNZ",
"ARM::tHINT",
"0",
"14",
"0"
] | ARMAsmBackend (2)1 | relaxInstruction | ARM | CPU | LLVM | 31,158 | 163 | 1 | [] |
[
"<s>",
"const",
"unsigned",
"*",
"BlackfinRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"using",
"namespace",
"BF",
";",
"static",
"const",
"unsigned",
"CalleeSavedRegs",
"[",
"]",
"=",
"{",
"FP",
",",
"R4",
",",
"R5",
",",
"R6",
",",
"R7",
",",
"P3",
",",
"P4",
",",
"P5",
",",
"0",
"}",
";",
"return",
"CalleeSavedRegs",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Blackfin",
"BF",
"0"
] | BlackfinRegisterInfo1 | getCalleeSavedRegs | Blackfin | DSP | LLVM | 31,159 | 49 | 1 | [] |
[
"<s>",
"void",
"MSP430FrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MSP430MachineFunctionInfo",
"*",
"MSP430FI",
"=",
"MF",
".",
"getInfo",
"<",
"MSP430MachineFunctionInfo",
">",
"(",
")",
";",
"const",
"MSP430InstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"MSP430InstrInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"uint64_t",
"NumBytes",
"=",
"0",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"uint64_t",
"FrameSize",
"=",
"StackSize",
"-",
"2",
";",
"NumBytes",
"=",
"FrameSize",
"-",
"MSP430FI",
"->",
"getCalleeSavedFrameSize",
"(",
")",
";",
"MFI",
"->",
"setOffsetAdjustment",
"(",
"-",
"NumBytes",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"MSP430",
"::",
"PUSH16r",
")",
")",
".",
"addReg",
"(",
"MSP430",
"::",
"FPW",
",",
"RegState",
"::",
"Kill",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"MSP430",
"::",
"MOV16rr",
")",
",",
"MSP430",
"::",
"FPW",
")",
".",
"addReg",
"(",
"MSP430",
"::",
"SPW",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"llvm",
"::",
"next",
"(",
"MF",
".",
"begin",
"(",
")",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"I",
"->",
"addLiveIn",
"(",
"MSP430",
"::",
"FPW",
")",
";",
"}",
"else",
"NumBytes",
"=",
"StackSize",
"-",
"MSP430FI",
"->",
"getCalleeSavedFrameSize",
"(",
")",
";",
"while",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"(",
"MBBI",
"->",
"getOpcode",
"(",
")",
"==",
"MSP430",
"::",
"PUSH16r",
")",
")",
"++",
"MBBI",
";",
"if",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"NumBytes",
")",
"{",
"if",
"(",
"NumBytes",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"MSP430",
"::",
"SUB16ri",
")",
",",
"MSP430",
"::",
"SPW",
")",
".",
"addReg",
"(",
"MSP430",
"::",
"SPW",
")",
".",
"addImm",
"(",
"NumBytes",
")",
";",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"MSP430",
"MSP430",
"MSP430",
"MSP430",
"MSP430",
"MSP430",
"MSP430",
"0",
"2",
"MSP430",
"MSP430::PUSH16r",
"MSP430::FPW",
"MSP430::MOV16rr",
"MSP430::FPW",
"MSP430::SPW",
"MSP430::FPW",
"MSP430",
"MSP430::PUSH16r",
"MSP430::SUB16ri",
"MSP430::SPW",
"MSP430::SPW",
"3"
] | MSP430FrameLowering14 | emitPrologue | MSP430 | MPU | LLVM | 31,160 | 364 | 1 | [] |
[
"<s>",
"static",
"int",
"function_arg_slotno",
"(",
"const",
"struct",
"sparc_args",
"*",
"cum",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"bool",
"named",
",",
"bool",
"incoming",
",",
"int",
"*",
"pregno",
",",
"int",
"*",
"ppadding",
")",
"{",
"int",
"regbase",
"=",
"(",
"incoming",
"?",
"SPARC_INCOMING_INT_ARG_FIRST",
":",
"SPARC_OUTGOING_INT_ARG_FIRST",
")",
";",
"int",
"slotno",
"=",
"cum",
"->",
"words",
";",
"enum",
"mode_class",
"mclass",
";",
"int",
"regno",
";",
"*",
"ppadding",
"=",
"0",
";",
"if",
"(",
"type",
"&&",
"TREE_ADDRESSABLE",
"(",
"type",
")",
")",
"return",
"-",
"1",
";",
"if",
"(",
"TARGET_ARCH32",
"&&",
"mode",
"==",
"BLKmode",
"&&",
"type",
"&&",
"TYPE_ALIGN",
"(",
"type",
")",
"%",
"PARM_BOUNDARY",
"!=",
"0",
")",
"return",
"-",
"1",
";",
"if",
"(",
"TARGET_ARCH64",
"&&",
"(",
"type",
"?",
"TYPE_ALIGN",
"(",
"type",
")",
":",
"GET_MODE_ALIGNMENT",
"(",
"mode",
")",
")",
">=",
"128",
"&&",
"(",
"slotno",
"&",
"1",
")",
"!=",
"0",
")",
"slotno",
"++",
",",
"*",
"ppadding",
"=",
"1",
";",
"mclass",
"=",
"GET_MODE_CLASS",
"(",
"mode",
")",
";",
"if",
"(",
"type",
"&&",
"TREE_CODE",
"(",
"type",
")",
"==",
"VECTOR_TYPE",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
"==",
"REAL_TYPE",
")",
"{",
"gcc_assert",
"(",
"mode",
"==",
"BLKmode",
")",
";",
"}",
"else",
"{",
"gcc_assert",
"(",
"mode",
"!=",
"BLKmode",
")",
";",
"mclass",
"=",
"MODE_FLOAT",
";",
"}",
"}",
"switch",
"(",
"mclass",
")",
"{",
"case",
"MODE_FLOAT",
":",
"case",
"MODE_COMPLEX_FLOAT",
":",
"case",
"MODE_VECTOR_INT",
":",
"if",
"(",
"TARGET_ARCH64",
"&&",
"TARGET_FPU",
"&&",
"named",
")",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_FP_ARG_MAX",
")",
"return",
"-",
"1",
";",
"regno",
"=",
"SPARC_FP_ARG_FIRST",
"+",
"slotno",
"*",
"2",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"4",
")",
"regno",
"++",
";",
"break",
";",
"}",
"case",
"MODE_INT",
":",
"case",
"MODE_COMPLEX_INT",
":",
"if",
"(",
"slotno",
">=",
"SPARC_INT_ARG_MAX",
")",
"return",
"-",
"1",
";",
"regno",
"=",
"regbase",
"+",
"slotno",
";",
"break",
";",
"case",
"MODE_RANDOM",
":",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"return",
"-",
"1",
";",
"gcc_assert",
"(",
"mode",
"==",
"BLKmode",
")",
";",
"if",
"(",
"TARGET_ARCH32",
"||",
"!",
"type",
"||",
"(",
"TREE_CODE",
"(",
"type",
")",
"!=",
"RECORD_TYPE",
"&&",
"TREE_CODE",
"(",
"type",
")",
"!=",
"VECTOR_TYPE",
")",
")",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_INT_ARG_MAX",
")",
"return",
"-",
"1",
";",
"regno",
"=",
"regbase",
"+",
"slotno",
";",
"}",
"else",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_FP_ARG_MAX",
")",
"return",
"-",
"1",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"RECORD_TYPE",
")",
"{",
"classify_data_t",
"data",
"=",
"{",
"false",
",",
"false",
",",
"false",
"}",
";",
"traverse_record_type",
"<",
"classify_data_t",
",",
"classify_registers",
">",
"(",
"type",
",",
"named",
",",
"&",
"data",
")",
";",
"if",
"(",
"data",
".",
"fp_regs",
"&&",
"!",
"data",
".",
"fp_regs_in_first_word",
"&&",
"slotno",
">=",
"SPARC_FP_ARG_MAX",
"-",
"1",
")",
"return",
"-",
"1",
";",
"if",
"(",
"!",
"data",
".",
"fp_regs",
"&&",
"data",
".",
"int_regs",
"&&",
"slotno",
">=",
"SPARC_INT_ARG_MAX",
")",
"return",
"-",
"1",
";",
"}",
"return",
"slotno",
";",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"*",
"pregno",
"=",
"regno",
";",
"return",
"slotno",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"slot",
"number",
"to",
"pass",
"an",
"argument",
"in",
".",
"Return",
"the",
"slot",
"number",
"or",
"-1",
"if",
"passing",
"on",
"the",
"stack",
".",
"CUM",
"is",
"a",
"variable",
"of",
"type",
"CUMULATIVE_ARGS",
"which",
"gives",
"info",
"about",
"the",
"preceding",
"args",
"and",
"about",
"the",
"function",
"being",
"called",
".",
"MODE",
"is",
"the",
"argument",
"'s",
"machine",
"mode",
".",
"TYPE",
"is",
"the",
"data",
"type",
"of",
"the",
"argument",
"(",
"as",
"a",
"tree",
")",
".",
"This",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
".",
"NAMED",
"is",
"nonzero",
"if",
"this",
"argument",
"is",
"a",
"named",
"parameter",
"(",
"otherwise",
"it",
"is",
"an",
"extra",
"parameter",
"matching",
"an",
"ellipsis",
")",
".",
"INCOMING_P",
"is",
"zero",
"for",
"FUNCTION_ARG",
",",
"nonzero",
"for",
"FUNCTION_INCOMING_ARG",
".",
"*",
"PREGNO",
"records",
"the",
"register",
"number",
"to",
"use",
"if",
"scalar",
"type",
".",
"*",
"PPADDING",
"records",
"the",
"amount",
"of",
"padding",
"needed",
"in",
"words",
"."
] | [
"sparc",
"0",
"1",
"0",
"1",
"128",
"1",
"0",
"1",
"1",
"2",
"4",
"1",
"1",
"1",
"1",
"1",
"1",
"1"
] | sparc5 | function_arg_slotno | sparc | CPU | GCC | 31,161 | 440 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"ARM64 load / store optimization pass\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM64",
"\"ARM64 load / store optimization pass\""
] | ARM64LoadStoreOptimizer1 | getPassName | ARM64 | CPU | LLVM | 31,162 | 13 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"NVPTXTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"0",
";",
"case",
"NVPTXISD",
"::",
"CALL",
":",
"return",
"\"NVPTXISD::CALL\"",
";",
"case",
"NVPTXISD",
"::",
"RET_FLAG",
":",
"return",
"\"NVPTXISD::RET_FLAG\"",
";",
"case",
"NVPTXISD",
"::",
"Wrapper",
":",
"return",
"\"NVPTXISD::Wrapper\"",
";",
"case",
"NVPTXISD",
"::",
"DeclareParam",
":",
"return",
"\"NVPTXISD::DeclareParam\"",
";",
"case",
"NVPTXISD",
"::",
"DeclareScalarParam",
":",
"return",
"\"NVPTXISD::DeclareScalarParam\"",
";",
"case",
"NVPTXISD",
"::",
"DeclareRet",
":",
"return",
"\"NVPTXISD::DeclareRet\"",
";",
"case",
"NVPTXISD",
"::",
"DeclareRetParam",
":",
"return",
"\"NVPTXISD::DeclareRetParam\"",
";",
"case",
"NVPTXISD",
"::",
"PrintCall",
":",
"return",
"\"NVPTXISD::PrintCall\"",
";",
"case",
"NVPTXISD",
"::",
"LoadParam",
":",
"return",
"\"NVPTXISD::LoadParam\"",
";",
"case",
"NVPTXISD",
"::",
"LoadParamV2",
":",
"return",
"\"NVPTXISD::LoadParamV2\"",
";",
"case",
"NVPTXISD",
"::",
"LoadParamV4",
":",
"return",
"\"NVPTXISD::LoadParamV4\"",
";",
"case",
"NVPTXISD",
"::",
"StoreParam",
":",
"return",
"\"NVPTXISD::StoreParam\"",
";",
"case",
"NVPTXISD",
"::",
"StoreParamV2",
":",
"return",
"\"NVPTXISD::StoreParamV2\"",
";",
"case",
"NVPTXISD",
"::",
"StoreParamV4",
":",
"return",
"\"NVPTXISD::StoreParamV4\"",
";",
"case",
"NVPTXISD",
"::",
"StoreParamS32",
":",
"return",
"\"NVPTXISD::StoreParamS32\"",
";",
"case",
"NVPTXISD",
"::",
"StoreParamU32",
":",
"return",
"\"NVPTXISD::StoreParamU32\"",
";",
"case",
"NVPTXISD",
"::",
"CallArgBegin",
":",
"return",
"\"NVPTXISD::CallArgBegin\"",
";",
"case",
"NVPTXISD",
"::",
"CallArg",
":",
"return",
"\"NVPTXISD::CallArg\"",
";",
"case",
"NVPTXISD",
"::",
"LastCallArg",
":",
"return",
"\"NVPTXISD::LastCallArg\"",
";",
"case",
"NVPTXISD",
"::",
"CallArgEnd",
":",
"return",
"\"NVPTXISD::CallArgEnd\"",
";",
"case",
"NVPTXISD",
"::",
"CallVoid",
":",
"return",
"\"NVPTXISD::CallVoid\"",
";",
"case",
"NVPTXISD",
"::",
"CallVal",
":",
"return",
"\"NVPTXISD::CallVal\"",
";",
"case",
"NVPTXISD",
"::",
"CallSymbol",
":",
"return",
"\"NVPTXISD::CallSymbol\"",
";",
"case",
"NVPTXISD",
"::",
"Prototype",
":",
"return",
"\"NVPTXISD::Prototype\"",
";",
"case",
"NVPTXISD",
"::",
"MoveParam",
":",
"return",
"\"NVPTXISD::MoveParam\"",
";",
"case",
"NVPTXISD",
"::",
"StoreRetval",
":",
"return",
"\"NVPTXISD::StoreRetval\"",
";",
"case",
"NVPTXISD",
"::",
"StoreRetvalV2",
":",
"return",
"\"NVPTXISD::StoreRetvalV2\"",
";",
"case",
"NVPTXISD",
"::",
"StoreRetvalV4",
":",
"return",
"\"NVPTXISD::StoreRetvalV4\"",
";",
"case",
"NVPTXISD",
"::",
"PseudoUseParam",
":",
"return",
"\"NVPTXISD::PseudoUseParam\"",
";",
"case",
"NVPTXISD",
"::",
"RETURN",
":",
"return",
"\"NVPTXISD::RETURN\"",
";",
"case",
"NVPTXISD",
"::",
"CallSeqBegin",
":",
"return",
"\"NVPTXISD::CallSeqBegin\"",
";",
"case",
"NVPTXISD",
"::",
"CallSeqEnd",
":",
"return",
"\"NVPTXISD::CallSeqEnd\"",
";",
"case",
"NVPTXISD",
"::",
"LoadV2",
":",
"return",
"\"NVPTXISD::LoadV2\"",
";",
"case",
"NVPTXISD",
"::",
"LoadV4",
":",
"return",
"\"NVPTXISD::LoadV4\"",
";",
"case",
"NVPTXISD",
"::",
"LDGV2",
":",
"return",
"\"NVPTXISD::LDGV2\"",
";",
"case",
"NVPTXISD",
"::",
"LDGV4",
":",
"return",
"\"NVPTXISD::LDGV4\"",
";",
"case",
"NVPTXISD",
"::",
"LDUV2",
":",
"return",
"\"NVPTXISD::LDUV2\"",
";",
"case",
"NVPTXISD",
"::",
"LDUV4",
":",
"return",
"\"NVPTXISD::LDUV4\"",
";",
"case",
"NVPTXISD",
"::",
"StoreV2",
":",
"return",
"\"NVPTXISD::StoreV2\"",
";",
"case",
"NVPTXISD",
"::",
"StoreV4",
":",
"return",
"\"NVPTXISD::StoreV4\"",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"NVPTX",
"NVPTX",
"0",
"NVPTXISD::CALL",
"\"NVPTXISD::CALL\"",
"NVPTXISD::RET_FLAG",
"\"NVPTXISD::RET_FLAG\"",
"NVPTXISD::Wrapper",
"\"NVPTXISD::Wrapper\"",
"NVPTXISD::DeclareParam",
"\"NVPTXISD::DeclareParam\"",
"NVPTXISD::DeclareScalarParam",
"\"NVPTXISD::DeclareScalarParam\"",
"NVPTXISD::DeclareRet",
"\"NVPTXISD::DeclareRet\"",
"NVPTXISD::DeclareRetParam",
"\"NVPTXISD::DeclareRetParam\"",
"NVPTXISD::PrintCall",
"\"NVPTXISD::PrintCall\"",
"NVPTXISD::LoadParam",
"\"NVPTXISD::LoadParam\"",
"NVPTXISD::LoadParamV2",
"\"NVPTXISD::LoadParamV2\"",
"NVPTXISD::LoadParamV4",
"\"NVPTXISD::LoadParamV4\"",
"NVPTXISD::StoreParam",
"\"NVPTXISD::StoreParam\"",
"NVPTXISD::StoreParamV2",
"\"NVPTXISD::StoreParamV2\"",
"NVPTXISD::StoreParamV4",
"\"NVPTXISD::StoreParamV4\"",
"NVPTXISD::StoreParamS32",
"\"NVPTXISD::StoreParamS32\"",
"NVPTXISD::StoreParamU32",
"\"NVPTXISD::StoreParamU32\"",
"NVPTXISD::CallArgBegin",
"\"NVPTXISD::CallArgBegin\"",
"NVPTXISD::CallArg",
"\"NVPTXISD::CallArg\"",
"NVPTXISD::LastCallArg",
"\"NVPTXISD::LastCallArg\"",
"NVPTXISD::CallArgEnd",
"\"NVPTXISD::CallArgEnd\"",
"NVPTXISD::CallVoid",
"\"NVPTXISD::CallVoid\"",
"NVPTXISD::CallVal",
"\"NVPTXISD::CallVal\"",
"NVPTXISD::CallSymbol",
"\"NVPTXISD::CallSymbol\"",
"NVPTXISD::Prototype",
"\"NVPTXISD::Prototype\"",
"NVPTXISD::MoveParam",
"\"NVPTXISD::MoveParam\"",
"NVPTXISD::StoreRetval",
"\"NVPTXISD::StoreRetval\"",
"NVPTXISD::StoreRetvalV2",
"\"NVPTXISD::StoreRetvalV2\"",
"NVPTXISD::StoreRetvalV4",
"\"NVPTXISD::StoreRetvalV4\"",
"NVPTXISD::PseudoUseParam",
"\"NVPTXISD::PseudoUseParam\"",
"NVPTXISD::RETURN",
"\"NVPTXISD::RETURN\"",
"NVPTXISD::CallSeqBegin",
"\"NVPTXISD::CallSeqBegin\"",
"NVPTXISD::CallSeqEnd",
"\"NVPTXISD::CallSeqEnd\"",
"NVPTXISD::LoadV2",
"\"NVPTXISD::LoadV2\"",
"NVPTXISD::LoadV4",
"\"NVPTXISD::LoadV4\"",
"NVPTXISD::LDGV2",
"\"NVPTXISD::LDGV2\"",
"NVPTXISD::LDGV4",
"\"NVPTXISD::LDGV4\"",
"NVPTXISD::LDUV2",
"\"NVPTXISD::LDUV2\"",
"NVPTXISD::LDUV4",
"\"NVPTXISD::LDUV4\"",
"NVPTXISD::StoreV2",
"\"NVPTXISD::StoreV2\"",
"NVPTXISD::StoreV4",
"\"NVPTXISD::StoreV4\""
] | NVPTXISelLowering22 | getTargetNodeName | NVPTX | GPU | LLVM | 31,163 | 344 | 1 | [] |
[
"<s>",
"void",
"AVRTargetStreamer",
"::",
"finish",
"(",
")",
"{",
"MCStreamer",
"&",
"OS",
"=",
"getStreamer",
"(",
")",
";",
"MCContext",
"&",
"Context",
"=",
"OS",
".",
"getContext",
"(",
")",
";",
"MCSymbol",
"*",
"DoCopyData",
"=",
"Context",
".",
"getOrCreateSymbol",
"(",
"\"__do_copy_data\"",
")",
";",
"MCSymbol",
"*",
"DoClearBss",
"=",
"Context",
".",
"getOrCreateSymbol",
"(",
"\"__do_clear_bss\"",
")",
";",
"OS",
".",
"emitRawComment",
"(",
"\" Declaring this symbol tells the CRT that it should\"",
")",
";",
"OS",
".",
"emitRawComment",
"(",
"\"copy all variables from program memory to RAM on startup\"",
")",
";",
"OS",
".",
"EmitSymbolAttribute",
"(",
"DoCopyData",
",",
"MCSA_Global",
")",
";",
"OS",
".",
"emitRawComment",
"(",
"\" Declaring this symbol tells the CRT that it should\"",
")",
";",
"OS",
".",
"emitRawComment",
"(",
"\"clear the zeroed data section on startup\"",
")",
";",
"OS",
".",
"EmitSymbolAttribute",
"(",
"DoClearBss",
",",
"MCSA_Global",
")",
";",
"}",
"</s>"
] | [
"finish",
"-",
"after",
"all",
"the",
"new",
"live",
"ranges",
"have",
"been",
"created",
",",
"compute",
"the",
"remaining",
"live",
"range",
",",
"and",
"rewrite",
"instructions",
"to",
"use",
"the",
"new",
"registers",
"."
] | [
"AVR",
"AVR",
"\"__do_copy_data\"",
"\"__do_clear_bss\"",
"\" Declaring this symbol tells the CRT that it should\"",
"\"copy all variables from program memory to RAM on startup\"",
"\" Declaring this symbol tells the CRT that it should\"",
"\"clear the zeroed data section on startup\""
] | AVRTargetStreamer1 | finish | AVR | MPU | LLVM | 31,164 | 94 | 1 | [] |
[
"<s>",
"void",
"AlphaInstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"DebugLoc",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"if",
"(",
"Alpha",
"::",
"GPRCRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Alpha",
"::",
"BISr",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"else",
"if",
"(",
"Alpha",
"::",
"F4RCRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Alpha",
"::",
"CPYSS",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"else",
"if",
"(",
"Alpha",
"::",
"F8RCRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Alpha",
"::",
"CPYST",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Attempt to copy register that is not GPR or FPR\"",
")",
";",
"}",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"Alpha",
"Alpha",
"Alpha::GPRCRegClass",
"Alpha::BISr",
"Alpha::F4RCRegClass",
"Alpha::CPYSS",
"Alpha::F8RCRegClass",
"Alpha::CPYST",
"\"Attempt to copy register that is not GPR or FPR\""
] | AlphaInstrInfo | copyPhysReg | Alpha | MPU | LLVM | 31,165 | 183 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"MipsDAGToDAGISel",
"::",
"getGlobalBaseReg",
"(",
")",
"{",
"unsigned",
"GlobalBaseReg",
"=",
"MF",
"->",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"return",
"CurDAG",
"->",
"getRegister",
"(",
"GlobalBaseReg",
",",
"TLI",
"->",
"getPointerTy",
"(",
")",
")",
".",
"getNode",
"(",
")",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"Mips",
"Mips",
"Mips"
] | MipsISelDAGToDAG59 | getGlobalBaseReg | Mips | CPU | LLVM | 31,166 | 43 | 1 | [] |
[
"<s>",
"AtomicOrdering",
"getFailureOrdering",
"(",
")",
"const",
"{",
"return",
"FailureOrdering",
";",
"}",
"</s>"
] | [
"For",
"cmpxchg",
"atomic",
"operations",
",",
"return",
"the",
"atomic",
"ordering",
"requirements",
"when",
"store",
"does",
"not",
"occur",
"."
] | [
"AMDGPU"
] | SIMemoryLegalizer | getFailureOrdering | AMDGPU | GPU | LLVM | 31,167 | 10 | 1 | [] |
[
"<s>",
"FunctionPass",
"*",
"createTargetRegisterAllocator",
"(",
"bool",
")",
"override",
"{",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"createTargetRegisterAllocator",
"-",
"Create",
"the",
"register",
"allocator",
"pass",
"for",
"this",
"target",
"at",
"the",
"current",
"optimization",
"level",
"."
] | [
"DirectX"
] | DirectXTargetMachine | createTargetRegisterAllocator | DirectX | Virtual ISA | LLVM | 31,168 | 12 | 1 | [] |
[
"<s>",
"XCoreTargetMachine",
"::",
"XCoreTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"TLOF",
"(",
"make_unique",
"<",
"XCoreTargetObjectFile",
">",
"(",
")",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"*",
"this",
")",
"{",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"XCore",
"XCore",
"XCore",
"\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"",
"XCore"
] | XCoreTargetMachine42 | XCoreTargetMachine | XCore | MPU | LLVM | 31,169 | 89 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"override",
"{",
"return",
"Subtarget",
"->",
"inMips16Mode",
"(",
")",
"?",
"nullptr",
":",
"&",
"getSubtargetImpl",
"(",
")",
"->",
"getInstrItineraryData",
"(",
")",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"Mips",
"Mips"
] | MipsTargetMachine3 | getInstrItineraryData | Mips | CPU | LLVM | 31,170 | 28 | 1 | [] |
[
"<s>",
"bool",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"override",
"{",
"FeatureBitset",
"Features",
"=",
"coalesceFeatures",
"(",
"M",
")",
";",
"std",
"::",
"string",
"FeatureStr",
"=",
"getFeatureString",
"(",
"Features",
")",
";",
"WasmTM",
"->",
"setTargetFeatureString",
"(",
"FeatureStr",
")",
";",
"for",
"(",
"auto",
"&",
"F",
":",
"M",
")",
"replaceFeatures",
"(",
"F",
",",
"FeatureStr",
")",
";",
"bool",
"StrippedAtomics",
"=",
"false",
";",
"bool",
"StrippedTLS",
"=",
"false",
";",
"if",
"(",
"!",
"Features",
"[",
"WebAssembly",
"::",
"FeatureAtomics",
"]",
")",
"StrippedAtomics",
"=",
"stripAtomics",
"(",
"M",
")",
";",
"if",
"(",
"!",
"Features",
"[",
"WebAssembly",
"::",
"FeatureBulkMemory",
"]",
")",
"StrippedTLS",
"=",
"stripThreadLocals",
"(",
"M",
")",
";",
"if",
"(",
"StrippedAtomics",
"&&",
"!",
"StrippedTLS",
")",
"stripThreadLocals",
"(",
"M",
")",
";",
"else",
"if",
"(",
"StrippedTLS",
"&&",
"!",
"StrippedAtomics",
")",
"stripAtomics",
"(",
"M",
")",
";",
"recordFeatures",
"(",
"M",
",",
"Features",
",",
"StrippedAtomics",
"||",
"StrippedTLS",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"WebAssembly",
"WebAssembly::FeatureAtomics",
"WebAssembly::FeatureBulkMemory"
] | WebAssemblyTargetMachine13 | runOnModule | WebAssembly | Virtual ISA | LLVM | 31,171 | 133 | 1 | [] |
[
"<s>",
"static",
"tree",
"fully_fold_convert",
"(",
"tree",
"type",
",",
"tree",
"expr",
")",
"{",
"tree",
"result",
"=",
"fold_convert",
"(",
"type",
",",
"expr",
")",
";",
"bool",
"maybe_const",
"=",
"true",
";",
"if",
"(",
"!",
"c_dialect_cxx",
"(",
")",
")",
"result",
"=",
"c_fully_fold",
"(",
"result",
",",
"false",
",",
"&",
"maybe_const",
")",
";",
"return",
"result",
";",
"}",
"</s>"
] | [
"In",
"addition",
"to",
"calling",
"fold_convert",
"for",
"EXPR",
"of",
"type",
"TYPE",
",",
"also",
"call",
"c_fully_fold",
"to",
"remove",
"any",
"C_MAYBE_CONST_EXPRs",
"that",
"could",
"be",
"hiding",
"there",
"(",
"PR47197",
")",
"."
] | [
"powerpcspe"
] | powerpcspe-c | fully_fold_convert | powerpcspe | CPU | GCC | 31,172 | 49 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_init_neon_builtins",
"(",
"void",
")",
"{",
"unsigned",
"int",
"i",
",",
"fcode",
"=",
"ARM_BUILTIN_NEON_PATTERN_START",
";",
"arm_init_simd_builtin_types",
"(",
")",
";",
"arm_init_simd_builtin_scalar_types",
"(",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"neon_builtin_data",
")",
";",
"i",
"++",
",",
"fcode",
"++",
")",
"{",
"arm_builtin_datum",
"*",
"d",
"=",
"&",
"neon_builtin_data",
"[",
"i",
"]",
";",
"arm_init_builtin",
"(",
"fcode",
",",
"d",
",",
"\"__builtin_neon\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Set",
"up",
"all",
"the",
"NEON",
"builtins",
",",
"even",
"builtins",
"for",
"instructions",
"that",
"are",
"not",
"in",
"the",
"current",
"target",
"ISA",
"to",
"allow",
"the",
"user",
"to",
"compile",
"particular",
"modules",
"with",
"different",
"target",
"specific",
"options",
"that",
"differ",
"from",
"the",
"command",
"line",
"options",
".",
"Such",
"builtins",
"will",
"be",
"rejected",
"in",
"arm_expand_builtin",
"."
] | [
"arm",
"0",
"\"__builtin_neon\""
] | arm-builtins | arm_init_neon_builtins | arm | CPU | GCC | 31,173 | 64 | 1 | [] |
[
"<s>",
"MCFragment",
"*",
"findAssociatedFragment",
"(",
")",
"const",
"override",
"{",
"return",
"getSubExpr",
"(",
")",
"->",
"findAssociatedFragment",
"(",
")",
";",
"}",
"</s>"
] | [
"Find",
"the",
"``",
"associated",
"section",
"''",
"for",
"this",
"expression",
",",
"which",
"is",
"currently",
"defined",
"as",
"the",
"absolute",
"section",
"for",
"constants",
",",
"or",
"otherwise",
"the",
"section",
"associated",
"with",
"the",
"first",
"defined",
"symbol",
"in",
"the",
"expression",
"."
] | [
"Nyuzi"
] | NyuziMCExpr | findAssociatedFragment | Nyuzi | GPU | LLVM | 31,174 | 18 | 1 | [] |
[
"<s>",
"static",
"inline",
"_uw8",
"next_unwind_byte",
"(",
"__gnu_unwind_state",
"*",
"uws",
")",
"{",
"_uw8",
"b",
";",
"if",
"(",
"uws",
"->",
"bytes_left",
"==",
"0",
")",
"{",
"if",
"(",
"uws",
"->",
"words_left",
"==",
"0",
")",
"return",
"CODE_FINISH",
";",
"uws",
"->",
"words_left",
"--",
";",
"uws",
"->",
"data",
"=",
"*",
"(",
"uws",
"->",
"next",
"++",
")",
";",
"uws",
"->",
"bytes_left",
"=",
"3",
";",
"}",
"else",
"uws",
"->",
"bytes_left",
"--",
";",
"b",
"=",
"(",
"uws",
"->",
"data",
">>",
"24",
")",
"&",
"0xff",
";",
"uws",
"->",
"data",
"<<=",
"8",
";",
"return",
"b",
";",
"}",
"</s>"
] | [
"Return",
"the",
"next",
"byte",
"of",
"unwinding",
"information",
",",
"or",
"CODE_FINISH",
"if",
"there",
"is",
"no",
"data",
"remaining",
"."
] | [
"arm",
"0",
"0",
"3",
"24",
"0xff",
"8"
] | pr-support | next_unwind_byte | arm | CPU | GCC | 31,175 | 85 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_validate_mcpu",
"(",
"const",
"char",
"*",
"str",
",",
"const",
"struct",
"processor",
"*",
"*",
"res",
",",
"unsigned",
"long",
"*",
"isa_flags",
")",
"{",
"std",
"::",
"string",
"invalid_extension",
";",
"enum",
"aarch64_parse_opt_result",
"parse_res",
"=",
"aarch64_parse_cpu",
"(",
"str",
",",
"res",
",",
"isa_flags",
",",
"&",
"invalid_extension",
")",
";",
"if",
"(",
"parse_res",
"==",
"AARCH64_PARSE_OK",
")",
"return",
"true",
";",
"switch",
"(",
"parse_res",
")",
"{",
"case",
"AARCH64_PARSE_MISSING_ARG",
":",
"error",
"(",
"\"missing cpu name in %<-mcpu=%s%>\"",
",",
"str",
")",
";",
"break",
";",
"case",
"AARCH64_PARSE_INVALID_ARG",
":",
"error",
"(",
"\"unknown value %qs for %<-mcpu%>\"",
",",
"str",
")",
";",
"aarch64_print_hint_for_core",
"(",
"str",
")",
";",
"break",
";",
"case",
"AARCH64_PARSE_INVALID_FEATURE",
":",
"error",
"(",
"\"invalid feature modifier %qs in %<-mcpu=%s%>\"",
",",
"invalid_extension",
".",
"c_str",
"(",
")",
",",
"str",
")",
";",
"aarch64_print_hint_for_extensions",
"(",
"invalid_extension",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Validate",
"a",
"command-line",
"-mcpu",
"option",
".",
"Parse",
"the",
"cpu",
"and",
"extensions",
"(",
"if",
"any",
")",
"specified",
"in",
"STR",
"and",
"throw",
"errors",
"if",
"appropriate",
".",
"Put",
"the",
"results",
"if",
"they",
"are",
"valid",
"in",
"RES",
"and",
"ISA_FLAGS",
".",
"Return",
"whether",
"the",
"option",
"is",
"valid",
"."
] | [
"aarch64",
"\"missing cpu name in %<-mcpu=%s%>\"",
"\"unknown value %qs for %<-mcpu%>\"",
"\"invalid feature modifier %qs in %<-mcpu=%s%>\""
] | aarch646 | aarch64_validate_mcpu | aarch64 | CPU | GCC | 31,176 | 120 | 1 | [] |
[
"<s>",
"int",
"shmedia_cleanup_truncate",
"(",
"rtx",
"*",
"p",
",",
"void",
"*",
"n_changes",
")",
"{",
"rtx",
"x",
"=",
"*",
"p",
",",
"reg",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"!=",
"TRUNCATE",
")",
"return",
"0",
";",
"reg",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"reg",
")",
")",
">",
"8",
"&&",
"GET_CODE",
"(",
"reg",
")",
"==",
"REG",
")",
"{",
"enum",
"machine_mode",
"reg_mode",
"=",
"GET_MODE",
"(",
"reg",
")",
";",
"XEXP",
"(",
"x",
",",
"0",
")",
"=",
"simplify_subreg",
"(",
"DImode",
",",
"reg",
",",
"reg_mode",
",",
"subreg_lowpart_offset",
"(",
"DImode",
",",
"reg_mode",
")",
")",
";",
"*",
"(",
"int",
"*",
")",
"n_changes",
"+=",
"1",
";",
"return",
"-",
"1",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Look",
"through",
"X",
"cleaning",
"up",
"truncates",
"of",
"registers",
"that",
"span",
"multiple",
"actual",
"hard",
"registers",
".",
"Return",
"the",
"number",
"of",
"changes",
"made",
"."
] | [
"sh",
"0",
"0",
"8",
"0",
"1",
"1",
"0"
] | sh3 | shmedia_cleanup_truncate | sh | CPU | GCC | 31,177 | 111 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonInstrInfo",
"::",
"reduceLoopCount",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineInstr",
"*",
"IndVar",
",",
"MachineInstr",
"&",
"Cmp",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"SmallVectorImpl",
"<",
"MachineInstr",
"*",
">",
"&",
"PrevInsts",
",",
"unsigned",
"Iter",
",",
"unsigned",
"MaxIter",
")",
"const",
"{",
"assert",
"(",
"(",
"!",
"IndVar",
")",
"&&",
"isEndLoopN",
"(",
"Cmp",
".",
"getOpcode",
"(",
")",
")",
"&&",
"\"Expecting a hardware loop\"",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"Cmp",
".",
"getDebugLoc",
"(",
")",
";",
"SmallPtrSet",
"<",
"MachineBasicBlock",
"*",
",",
"8",
">",
"VisitedBBs",
";",
"MachineInstr",
"*",
"Loop",
"=",
"findLoopInstr",
"(",
"&",
"MBB",
",",
"Cmp",
".",
"getOpcode",
"(",
")",
",",
"VisitedBBs",
")",
";",
"if",
"(",
"!",
"Loop",
")",
"return",
"0",
";",
"if",
"(",
"Loop",
"->",
"getOpcode",
"(",
")",
"==",
"Hexagon",
"::",
"J2_loop0i",
"||",
"Loop",
"->",
"getOpcode",
"(",
")",
"==",
"Hexagon",
"::",
"J2_loop1i",
")",
"{",
"int64_t",
"Offset",
"=",
"Loop",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Offset",
"<=",
"1",
")",
"Loop",
"->",
"eraseFromParent",
"(",
")",
";",
"else",
"Loop",
"->",
"getOperand",
"(",
"1",
")",
".",
"setImm",
"(",
"Offset",
"-",
"1",
")",
";",
"return",
"Offset",
"-",
"1",
";",
"}",
"assert",
"(",
"Loop",
"->",
"getOpcode",
"(",
")",
"==",
"Hexagon",
"::",
"J2_loop0r",
"&&",
"\"Unexpected instruction\"",
")",
";",
"unsigned",
"LoopCount",
"=",
"Loop",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"LoopEnd",
"=",
"createVR",
"(",
"MF",
",",
"MVT",
"::",
"i1",
")",
";",
"MachineInstr",
"*",
"NewCmp",
"=",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"Hexagon",
"::",
"C2_cmpgtui",
")",
",",
"LoopEnd",
")",
".",
"addReg",
"(",
"LoopCount",
")",
".",
"addImm",
"(",
"1",
")",
";",
"unsigned",
"NewLoopCount",
"=",
"createVR",
"(",
"MF",
",",
"MVT",
"::",
"i32",
")",
";",
"MachineInstr",
"*",
"NewAdd",
"=",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"Hexagon",
"::",
"A2_addi",
")",
",",
"NewLoopCount",
")",
".",
"addReg",
"(",
"LoopCount",
")",
".",
"addImm",
"(",
"-",
"1",
")",
";",
"for",
"(",
"SmallVectorImpl",
"<",
"MachineInstr",
"*",
">",
"::",
"iterator",
"I",
"=",
"PrevInsts",
".",
"begin",
"(",
")",
",",
"E",
"=",
"PrevInsts",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"(",
"*",
"I",
")",
"->",
"substituteRegister",
"(",
"LoopCount",
",",
"NewLoopCount",
",",
"0",
",",
"getRegisterInfo",
"(",
")",
")",
";",
"PrevInsts",
".",
"clear",
"(",
")",
";",
"PrevInsts",
".",
"push_back",
"(",
"NewCmp",
")",
";",
"PrevInsts",
".",
"push_back",
"(",
"NewAdd",
")",
";",
"if",
"(",
"Iter",
"==",
"MaxIter",
")",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"Hexagon",
"::",
"J2_loop0r",
")",
")",
".",
"addMBB",
"(",
"Loop",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
")",
".",
"addReg",
"(",
"NewLoopCount",
")",
";",
"if",
"(",
"Iter",
"==",
"0",
")",
"Loop",
"->",
"eraseFromParent",
"(",
")",
";",
"Cond",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"Hexagon",
"::",
"J2_jumpf",
")",
")",
";",
"Cond",
".",
"push_back",
"(",
"NewCmp",
"->",
"getOperand",
"(",
"0",
")",
")",
";",
"return",
"NewLoopCount",
";",
"}",
"</s>"
] | [
"Generate",
"code",
"to",
"reduce",
"the",
"loop",
"iteration",
"by",
"one",
"and",
"check",
"if",
"the",
"loop",
"is",
"finished",
"."
] | [
"Hexagon",
"Hexagon",
"\"Expecting a hardware loop\"",
"8",
"0",
"Hexagon::J2_loop0i",
"Hexagon::J2_loop1i",
"1",
"1",
"1",
"1",
"1",
"Hexagon::J2_loop0r",
"\"Unexpected instruction\"",
"1",
"MVT::i1",
"Hexagon::C2_cmpgtui",
"1",
"MVT::i32",
"Hexagon::A2_addi",
"1",
"0",
"Hexagon::J2_loop0r",
"0",
"0",
"Hexagon::J2_jumpf",
"0"
] | HexagonInstrInfo3 | reduceLoopCount | Hexagon | DSP | LLVM | 31,178 | 451 | 1 | [] |
[
"<s>",
"bool",
"DeadCodeElimination",
"::",
"erase",
"(",
"const",
"SetVector",
"<",
"NodeId",
">",
"&",
"Nodes",
")",
"{",
"if",
"(",
"Nodes",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"NodeList",
"DRNs",
",",
"DINs",
";",
"for",
"(",
"auto",
"I",
":",
"Nodes",
")",
"{",
"auto",
"BA",
"=",
"DFG",
".",
"addr",
"<",
"NodeBase",
"*",
">",
"(",
"I",
")",
";",
"uint16_t",
"Type",
"=",
"BA",
".",
"Addr",
"->",
"getType",
"(",
")",
";",
"if",
"(",
"Type",
"==",
"NodeAttrs",
"::",
"Ref",
")",
"{",
"DRNs",
".",
"push_back",
"(",
"DFG",
".",
"addr",
"<",
"RefNode",
"*",
">",
"(",
"I",
")",
")",
";",
"continue",
";",
"}",
"uint16_t",
"Kind",
"=",
"BA",
".",
"Addr",
"->",
"getKind",
"(",
")",
";",
"if",
"(",
"Kind",
"==",
"NodeAttrs",
"::",
"Stmt",
"||",
"Kind",
"==",
"NodeAttrs",
"::",
"Phi",
")",
"{",
"for",
"(",
"auto",
"N",
":",
"NodeAddr",
"<",
"CodeNode",
"*",
">",
"(",
"BA",
")",
".",
"Addr",
"->",
"members",
"(",
"DFG",
")",
")",
"DRNs",
".",
"push_back",
"(",
"N",
")",
";",
"DINs",
".",
"push_back",
"(",
"DFG",
".",
"addr",
"<",
"InstrNode",
"*",
">",
"(",
"I",
")",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Unexpected code node\"",
")",
";",
"return",
"false",
";",
"}",
"}",
"auto",
"UsesFirst",
"=",
"[",
"]",
"(",
"NodeAddr",
"<",
"RefNode",
"*",
">",
"A",
",",
"NodeAddr",
"<",
"RefNode",
"*",
">",
"B",
")",
"->",
"bool",
"{",
"uint16_t",
"KindA",
"=",
"A",
".",
"Addr",
"->",
"getKind",
"(",
")",
",",
"KindB",
"=",
"B",
".",
"Addr",
"->",
"getKind",
"(",
")",
";",
"if",
"(",
"KindA",
"==",
"NodeAttrs",
"::",
"Use",
"&&",
"KindB",
"==",
"NodeAttrs",
"::",
"Def",
")",
"return",
"true",
";",
"if",
"(",
"KindA",
"==",
"NodeAttrs",
"::",
"Def",
"&&",
"KindB",
"==",
"NodeAttrs",
"::",
"Use",
")",
"return",
"false",
";",
"return",
"A",
".",
"Id",
"<",
"B",
".",
"Id",
";",
"}",
";",
"std",
"::",
"sort",
"(",
"DRNs",
".",
"begin",
"(",
")",
",",
"DRNs",
".",
"end",
"(",
")",
",",
"UsesFirst",
")",
";",
"if",
"(",
"trace",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"\"Removing dead ref nodes:\\n\"",
";",
"for",
"(",
"NodeAddr",
"<",
"RefNode",
"*",
">",
"RA",
":",
"DRNs",
")",
"{",
"if",
"(",
"trace",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"\" \"",
"<<",
"PrintNode",
"<",
"RefNode",
"*",
">",
"(",
"RA",
",",
"DFG",
")",
"<<",
"'\\n'",
";",
"if",
"(",
"DFG",
".",
"IsUse",
"(",
"RA",
")",
")",
"DFG",
".",
"unlinkUse",
"(",
"RA",
",",
"true",
")",
";",
"else",
"if",
"(",
"DFG",
".",
"IsDef",
"(",
"RA",
")",
")",
"DFG",
".",
"unlinkDef",
"(",
"RA",
",",
"true",
")",
";",
"}",
"for",
"(",
"NodeAddr",
"<",
"InstrNode",
"*",
">",
"IA",
":",
"DINs",
")",
"{",
"NodeAddr",
"<",
"BlockNode",
"*",
">",
"BA",
"=",
"IA",
".",
"Addr",
"->",
"getOwner",
"(",
"DFG",
")",
";",
"BA",
".",
"Addr",
"->",
"removeMember",
"(",
"IA",
",",
"DFG",
")",
";",
"if",
"(",
"!",
"DFG",
".",
"IsCode",
"<",
"NodeAttrs",
"::",
"Stmt",
">",
"(",
"IA",
")",
")",
"continue",
";",
"MachineInstr",
"*",
"MI",
"=",
"NodeAddr",
"<",
"StmtNode",
"*",
">",
"(",
"IA",
")",
".",
"Addr",
"->",
"getCode",
"(",
")",
";",
"if",
"(",
"trace",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"\"erasing: \"",
"<<",
"*",
"MI",
";",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"erase",
"-",
"Erases",
"an",
"element",
"identified",
"by",
"Key",
",",
"if",
"it",
"exists",
"."
] | [
"Hexagon",
"\"Unexpected code node\"",
"\"Removing dead ref nodes:\\n\"",
"\" \"",
"\"erasing: \""
] | RDFDeadCode10 | erase | Hexagon | DSP | LLVM | 31,179 | 470 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"PowerPC"
] | PPCMIPeephole1 | getAnalysisUsage | PowerPC | CPU | LLVM | 31,180 | 36 | 1 | [] |
[
"<s>",
"static",
"bool",
"pdp11_scalar_mode_supported_p",
"(",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"return",
"true",
";",
"return",
"default_scalar_mode_supported_p",
"(",
"mode",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_SCALAR_MODE_SUPPORTED_P",
"."
] | [
"pdp11"
] | pdp114 | pdp11_scalar_mode_supported_p | pdp11 | MPU | GCC | 31,181 | 24 | 1 | [] |
[
"<s>",
"int",
"mems_ok_for_quad_peep",
"(",
"rtx",
"mem1",
",",
"rtx",
"mem2",
")",
"{",
"rtx",
"addr1",
",",
"addr2",
";",
"unsigned",
"int",
"reg1",
",",
"reg2",
";",
"int",
"offset1",
",",
"offset2",
";",
"if",
"(",
"MEM_VOLATILE_P",
"(",
"mem1",
")",
"||",
"MEM_VOLATILE_P",
"(",
"mem2",
")",
")",
"return",
"0",
";",
"addr1",
"=",
"XEXP",
"(",
"mem1",
",",
"0",
")",
";",
"addr2",
"=",
"XEXP",
"(",
"mem2",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr1",
")",
"==",
"PLUS",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr1",
",",
"0",
")",
")",
"!=",
"REG",
")",
"return",
"0",
";",
"else",
"{",
"reg1",
"=",
"REGNO",
"(",
"XEXP",
"(",
"addr1",
",",
"0",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr1",
",",
"1",
")",
")",
"!=",
"CONST_INT",
")",
"return",
"0",
";",
"offset1",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"addr1",
",",
"1",
")",
")",
";",
"}",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"addr1",
")",
"!=",
"REG",
")",
"return",
"0",
";",
"else",
"{",
"reg1",
"=",
"REGNO",
"(",
"addr1",
")",
";",
"offset1",
"=",
"0",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"addr2",
")",
"==",
"PLUS",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr2",
",",
"0",
")",
")",
"!=",
"REG",
")",
"return",
"0",
";",
"else",
"{",
"reg2",
"=",
"REGNO",
"(",
"XEXP",
"(",
"addr2",
",",
"0",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr2",
",",
"1",
")",
")",
"!=",
"CONST_INT",
")",
"return",
"0",
";",
"offset2",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"addr2",
",",
"1",
")",
")",
";",
"}",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"addr2",
")",
"!=",
"REG",
")",
"return",
"0",
";",
"else",
"{",
"reg2",
"=",
"REGNO",
"(",
"addr2",
")",
";",
"offset2",
"=",
"0",
";",
"}",
"if",
"(",
"reg1",
"!=",
"reg2",
")",
"return",
"0",
";",
"if",
"(",
"offset2",
"!=",
"offset1",
"+",
"8",
")",
"return",
"0",
";",
"return",
"1",
";",
"}",
"</s>"
] | [
"Return",
"1",
"if",
"addr1",
"and",
"addr2",
"are",
"suitable",
"for",
"lfq",
"or",
"stfq",
"insn",
".",
"addr1",
"and",
"addr2",
"must",
"be",
"in",
"consecutive",
"memory",
"locations",
"(",
"addr2",
"==",
"addr1",
"+",
"8",
")",
"."
] | [
"powerpcspe",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"1",
"0",
"0",
"0",
"8",
"0",
"1"
] | powerpcspe | mems_ok_for_quad_peep | powerpcspe | CPU | GCC | 31,182 | 281 | 1 | [] |
[
"<s>",
"bool",
"mn10300_match_ccmode",
"(",
"rtx",
"insn",
",",
"machine_mode",
"cc_mode",
")",
"{",
"rtx",
"op1",
",",
"flags",
";",
"machine_mode",
"flags_mode",
";",
"gcc_checking_assert",
"(",
"XVECLEN",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
")",
"==",
"2",
")",
";",
"op1",
"=",
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
",",
"0",
")",
";",
"gcc_checking_assert",
"(",
"GET_CODE",
"(",
"SET_SRC",
"(",
"op1",
")",
")",
"==",
"COMPARE",
")",
";",
"flags",
"=",
"SET_DEST",
"(",
"op1",
")",
";",
"flags_mode",
"=",
"GET_MODE",
"(",
"flags",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"SET_SRC",
"(",
"op1",
")",
")",
"!=",
"flags_mode",
")",
"return",
"false",
";",
"if",
"(",
"GET_MODE_CLASS",
"(",
"flags_mode",
")",
"!=",
"MODE_CC",
")",
"return",
"false",
";",
"if",
"(",
"cc_flags_for_mode",
"(",
"flags_mode",
")",
"&",
"~",
"cc_flags_for_mode",
"(",
"cc_mode",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"A",
"helper",
"function",
"for",
"matching",
"parallels",
"that",
"set",
"the",
"flags",
"."
] | [
"mn10300",
"0",
"2",
"0",
"0"
] | mn10300 | mn10300_match_ccmode | mn10300 | MPU | GCC | 31,183 | 121 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"DivergenceAnalysis",
">",
"(",
")",
";",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"AMDGPU"
] | AMDGPUAnnotateUniformValues16 | getAnalysisUsage | AMDGPU | GPU | LLVM | 31,184 | 26 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"getAddrModeArguments",
"(",
"IntrinsicInst",
"*",
"II",
",",
"SmallVectorImpl",
"<",
"Value",
"*",
">",
"&",
"Ops",
",",
"Type",
"*",
"&",
"AccessTy",
")",
"const",
"{",
"switch",
"(",
"II",
"->",
"getIntrinsicID",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"amdgcn_atomic_inc",
":",
"case",
"Intrinsic",
"::",
"amdgcn_atomic_dec",
":",
"case",
"Intrinsic",
"::",
"amdgcn_ds_fadd",
":",
"case",
"Intrinsic",
"::",
"amdgcn_ds_fmin",
":",
"case",
"Intrinsic",
"::",
"amdgcn_ds_fmax",
":",
"{",
"Value",
"*",
"Ptr",
"=",
"II",
"->",
"getArgOperand",
"(",
"0",
")",
";",
"AccessTy",
"=",
"II",
"->",
"getType",
"(",
")",
";",
"Ops",
".",
"push_back",
"(",
"Ptr",
")",
";",
"return",
"true",
";",
"}",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"CodeGenPrepare",
"sinks",
"address",
"calculations",
"into",
"the",
"same",
"BB",
"as",
"Load/Store",
"instructions",
"reading",
"the",
"address",
"."
] | [
"AMDGPU",
"SI",
"Intrinsic::amdgcn_atomic_inc",
"Intrinsic::amdgcn_atomic_dec",
"Intrinsic::amdgcn_ds_fadd",
"Intrinsic::amdgcn_ds_fmin",
"Intrinsic::amdgcn_ds_fmax",
"0"
] | SIISelLowering (2)3 | getAddrModeArguments | AMDGPU | GPU | LLVM | 31,185 | 96 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUTargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
")",
"const",
"{",
"EVT",
"ScalarVT",
"=",
"VT",
".",
"getScalarType",
"(",
")",
";",
"return",
"(",
"ScalarVT",
"==",
"MVT",
"::",
"f32",
"||",
"ScalarVT",
"==",
"MVT",
"::",
"f64",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"AMDGPU",
"AMDGPU",
"MVT::f32",
"MVT::f64"
] | AMDGPUISelLowering (2) | isFPImmLegal | AMDGPU | GPU | LLVM | 31,186 | 40 | 1 | [] |
[
"<s>",
"void",
"RISCVRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
"&&",
"\"Unexpected non-zero SPAdj value\"",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"RISCVInstrInfo",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"FrameReg",
";",
"int",
"Offset",
"=",
"getFrameLowering",
"(",
"MF",
")",
"->",
"getFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"FrameReg",
")",
"+",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"!",
"isInt",
"<",
"32",
">",
"(",
"Offset",
")",
")",
"{",
"report_fatal_error",
"(",
"\"Frame offsets outside of the signed 32-bit range not supported\"",
")",
";",
"}",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"bool",
"FrameRegIsKill",
"=",
"false",
";",
"if",
"(",
"!",
"isInt",
"<",
"12",
">",
"(",
"Offset",
")",
")",
"{",
"assert",
"(",
"isInt",
"<",
"32",
">",
"(",
"Offset",
")",
"&&",
"\"Int32 expected\"",
")",
";",
"Register",
"ScratchReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"RISCV",
"::",
"GPRRegClass",
")",
";",
"TII",
"->",
"movImm",
"(",
"MBB",
",",
"II",
",",
"DL",
",",
"ScratchReg",
",",
"Offset",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"RISCV",
"::",
"ADD",
")",
",",
"ScratchReg",
")",
".",
"addReg",
"(",
"FrameReg",
")",
".",
"addReg",
"(",
"ScratchReg",
",",
"RegState",
"::",
"Kill",
")",
";",
"Offset",
"=",
"0",
";",
"FrameReg",
"=",
"ScratchReg",
";",
"FrameRegIsKill",
"=",
"true",
";",
"}",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"FrameReg",
",",
"false",
",",
"false",
",",
"FrameRegIsKill",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"RISCV",
"RISCV",
"0",
"\"Unexpected non-zero SPAdj value\"",
"RISCV",
"RISCV",
"1",
"32",
"\"Frame offsets outside of the signed 32-bit range not supported\"",
"12",
"32",
"\"Int32 expected\"",
"RISCV::GPRRegClass",
"RISCV::ADD",
"0",
"1"
] | RISCVRegisterInfo10 | eliminateFrameIndex | RISCV | CPU | LLVM | 31,187 | 304 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"TGSITargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"TGSIISD",
"::",
"LOAD_INPUT",
":",
"return",
"\"TGSIISD::LOAD_INPUT\"",
";",
"case",
"TGSIISD",
"::",
"CALL",
":",
"return",
"\"TGSIISD::CALL\"",
";",
"case",
"TGSIISD",
"::",
"RET",
":",
"return",
"\"TGSIISD::RET\"",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Invalid opcode\"",
")",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"TGSI",
"TGSI",
"TGSIISD::LOAD_INPUT",
"\"TGSIISD::LOAD_INPUT\"",
"TGSIISD::CALL",
"\"TGSIISD::CALL\"",
"TGSIISD::RET",
"\"TGSIISD::RET\"",
"\"Invalid opcode\""
] | TGSIISelLowering | getTargetNodeName | TGSI | Virtual ISA | LLVM | 31,188 | 50 | 1 | [] |
[
"<s>",
"virtual",
"const",
"MipsSubtarget",
"*",
"getSubtargetImpl",
"(",
")",
"const",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"Mips",
"Mips"
] | MipsTargetMachine | getSubtargetImpl | Mips | CPU | LLVM | 31,189 | 14 | 1 | [] |
[
"<s>",
"void",
"ELFTeeRISCAsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"char",
"*",
"Data",
",",
"unsigned",
"DataSize",
",",
"uint64_t",
"Value",
")",
"const",
"{",
"unsigned",
"Size",
"=",
"getFixupKindSize",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"assert",
"(",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"Size",
"<=",
"DataSize",
"&&",
"\"Invalid fixup offset!\"",
")",
";",
"char",
"*",
"data",
"=",
"Data",
"+",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"switch",
"(",
"Size",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Cannot fixup unknown value.\"",
")",
";",
"case",
"1",
":",
"llvm_unreachable",
"(",
"\"Cannot fixup 1 byte value.\"",
")",
";",
"case",
"8",
":",
"llvm_unreachable",
"(",
"\"Cannot fixup 8 byte value.\"",
")",
";",
"case",
"4",
":",
"case",
"2",
":",
"llvm_unreachable",
"(",
"\"Write Code here to fixup\\n\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"TeeRISC",
"TeeRISC",
"\"Invalid fixup offset!\"",
"\"Cannot fixup unknown value.\"",
"1",
"\"Cannot fixup 1 byte value.\"",
"8",
"\"Cannot fixup 8 byte value.\"",
"4",
"2",
"\"Write Code here to fixup\\n\""
] | TeeRISCAsmBackend | applyFixup | TeeRISC | CPU | LLVM | 31,190 | 102 | 1 | [] |
[
"<s>",
"bool",
"HexagonTargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
",",
"unsigned",
"Alignment",
",",
"MachineMemOperand",
"::",
"Flags",
"Flags",
",",
"bool",
"*",
"Fast",
")",
"const",
"{",
"MVT",
"SVT",
"=",
"VT",
".",
"getSimpleVT",
"(",
")",
";",
"if",
"(",
"Subtarget",
".",
"isHVXVectorType",
"(",
"SVT",
",",
"true",
")",
")",
"return",
"allowsHvxMisalignedMemoryAccesses",
"(",
"SVT",
",",
"Alignment",
",",
"Flags",
",",
"Fast",
")",
";",
"if",
"(",
"Fast",
")",
"*",
"Fast",
"=",
"false",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonISelLowering103 | allowsMisalignedMemoryAccesses | Hexagon | DSP | LLVM | 31,191 | 70 | 1 | [] |
[
"<s>",
"BitVector",
"SystemZRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"const",
"SystemZFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"const",
"SystemZSubtarget",
"*",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"SystemZSubtarget",
">",
"(",
")",
";",
"SystemZCallingConventionRegisters",
"*",
"Regs",
"=",
"Subtarget",
"->",
"getSpecialRegisters",
"(",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"for",
"(",
"MCRegAliasIterator",
"AI",
"(",
"Regs",
"->",
"getFramePointerRegister",
"(",
")",
",",
"this",
",",
"true",
")",
";",
"AI",
".",
"isValid",
"(",
")",
";",
"++",
"AI",
")",
"Reserved",
".",
"set",
"(",
"*",
"AI",
")",
";",
"for",
"(",
"MCRegAliasIterator",
"AI",
"(",
"Regs",
"->",
"getStackPointerRegister",
"(",
")",
",",
"this",
",",
"true",
")",
";",
"AI",
".",
"isValid",
"(",
")",
";",
"++",
"AI",
")",
"Reserved",
".",
"set",
"(",
"*",
"AI",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"A0",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"A1",
")",
";",
"Reserved",
".",
"set",
"(",
"SystemZ",
"::",
"FPC",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ::A0",
"SystemZ::A1",
"SystemZ::FPC"
] | SystemZRegisterInfo10 | getReservedRegs | SystemZ | CPU | LLVM | 31,192 | 161 | 1 | [] |
[
"<s>",
"SDValue",
"ARMSelectionDAGInfo",
"::",
"EmitTargetCodeForMemmove",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"Align",
"Alignment",
",",
"bool",
"isVolatile",
",",
"MachinePointerInfo",
"DstPtrInfo",
",",
"MachinePointerInfo",
"SrcPtrInfo",
")",
"const",
"{",
"return",
"EmitSpecializedLibcall",
"(",
"DAG",
",",
"dl",
",",
"Chain",
",",
"Dst",
",",
"Src",
",",
"Size",
",",
"Alignment",
".",
"value",
"(",
")",
",",
"RTLIB",
"::",
"MEMMOVE",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memmove",
"."
] | [
"ARM",
"ARM"
] | ARMSelectionDAGInfo18 | EmitTargetCodeForMemmove | ARM | CPU | LLVM | 31,193 | 67 | 1 | [] |
[
"<s>",
"bool",
"NVPTXLowerAggrCopies",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"SmallVector",
"<",
"LoadInst",
"*",
",",
"4",
">",
"AggrLoads",
";",
"SmallVector",
"<",
"MemIntrinsic",
"*",
",",
"4",
">",
"MemCalls",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"F",
".",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"LLVMContext",
"&",
"Context",
"=",
"F",
".",
"getParent",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"const",
"TargetTransformInfo",
"&",
"TTI",
"=",
"getAnalysis",
"<",
"TargetTransformInfoWrapperPass",
">",
"(",
")",
".",
"getTTI",
"(",
"F",
")",
";",
"for",
"(",
"BasicBlock",
"&",
"BB",
":",
"F",
")",
"{",
"for",
"(",
"Instruction",
"&",
"I",
":",
"BB",
")",
"{",
"if",
"(",
"LoadInst",
"*",
"LI",
"=",
"dyn_cast",
"<",
"LoadInst",
">",
"(",
"&",
"I",
")",
")",
"{",
"if",
"(",
"!",
"LI",
"->",
"hasOneUse",
"(",
")",
")",
"continue",
";",
"if",
"(",
"DL",
".",
"getTypeStoreSize",
"(",
"LI",
"->",
"getType",
"(",
")",
")",
"<",
"MaxAggrCopySize",
")",
"continue",
";",
"if",
"(",
"StoreInst",
"*",
"SI",
"=",
"dyn_cast",
"<",
"StoreInst",
">",
"(",
"LI",
"->",
"user_back",
"(",
")",
")",
")",
"{",
"if",
"(",
"SI",
"->",
"getOperand",
"(",
"0",
")",
"!=",
"LI",
")",
"continue",
";",
"AggrLoads",
".",
"push_back",
"(",
"LI",
")",
";",
"}",
"}",
"else",
"if",
"(",
"MemIntrinsic",
"*",
"IntrCall",
"=",
"dyn_cast",
"<",
"MemIntrinsic",
">",
"(",
"&",
"I",
")",
")",
"{",
"if",
"(",
"ConstantInt",
"*",
"LenCI",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"IntrCall",
"->",
"getLength",
"(",
")",
")",
")",
"{",
"if",
"(",
"LenCI",
"->",
"getZExtValue",
"(",
")",
">=",
"MaxAggrCopySize",
")",
"{",
"MemCalls",
".",
"push_back",
"(",
"IntrCall",
")",
";",
"}",
"}",
"else",
"{",
"MemCalls",
".",
"push_back",
"(",
"IntrCall",
")",
";",
"}",
"}",
"}",
"}",
"if",
"(",
"AggrLoads",
".",
"size",
"(",
")",
"==",
"0",
"&&",
"MemCalls",
".",
"size",
"(",
")",
"==",
"0",
")",
"{",
"return",
"false",
";",
"}",
"for",
"(",
"LoadInst",
"*",
"LI",
":",
"AggrLoads",
")",
"{",
"auto",
"*",
"SI",
"=",
"cast",
"<",
"StoreInst",
">",
"(",
"*",
"LI",
"->",
"user_begin",
"(",
")",
")",
";",
"Value",
"*",
"SrcAddr",
"=",
"LI",
"->",
"getOperand",
"(",
"0",
")",
";",
"Value",
"*",
"DstAddr",
"=",
"SI",
"->",
"getOperand",
"(",
"1",
")",
";",
"unsigned",
"NumLoads",
"=",
"DL",
".",
"getTypeStoreSize",
"(",
"LI",
"->",
"getType",
"(",
")",
")",
";",
"ConstantInt",
"*",
"CopyLen",
"=",
"ConstantInt",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"Context",
")",
",",
"NumLoads",
")",
";",
"createMemCpyLoopKnownSize",
"(",
"SI",
",",
"SrcAddr",
",",
"DstAddr",
",",
"CopyLen",
",",
"LI",
"->",
"getAlign",
"(",
")",
",",
"SI",
"->",
"getAlign",
"(",
")",
",",
"LI",
"->",
"isVolatile",
"(",
")",
",",
"SI",
"->",
"isVolatile",
"(",
")",
",",
"true",
",",
"TTI",
")",
";",
"SI",
"->",
"eraseFromParent",
"(",
")",
";",
"LI",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"for",
"(",
"MemIntrinsic",
"*",
"MemCall",
":",
"MemCalls",
")",
"{",
"if",
"(",
"MemCpyInst",
"*",
"Memcpy",
"=",
"dyn_cast",
"<",
"MemCpyInst",
">",
"(",
"MemCall",
")",
")",
"{",
"expandMemCpyAsLoop",
"(",
"Memcpy",
",",
"TTI",
")",
";",
"}",
"else",
"if",
"(",
"MemMoveInst",
"*",
"Memmove",
"=",
"dyn_cast",
"<",
"MemMoveInst",
">",
"(",
"MemCall",
")",
")",
"{",
"expandMemMoveAsLoop",
"(",
"Memmove",
")",
";",
"}",
"else",
"if",
"(",
"MemSetInst",
"*",
"Memset",
"=",
"dyn_cast",
"<",
"MemSetInst",
">",
"(",
"MemCall",
")",
")",
"{",
"expandMemSetAsLoop",
"(",
"Memset",
")",
";",
"}",
"MemCall",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"NVPTX",
"NVPTX",
"4",
"4",
"0",
"0",
"0",
"0",
"1"
] | NVPTXLowerAggrCopies12 | runOnFunction | NVPTX | GPU | LLVM | 31,194 | 488 | 1 | [] |
[
"<s>",
"void",
"RISCVDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"MVT",
"XLenVT",
"=",
"Subtarget",
"->",
"getXLenVT",
"(",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"== \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"Node",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
";",
"}",
"EVT",
"VT",
"=",
"Node",
"->",
"getValueType",
"(",
"0",
")",
";",
"if",
"(",
"Opcode",
"==",
"ISD",
"::",
"Constant",
"&&",
"VT",
"==",
"XLenVT",
")",
"{",
"auto",
"*",
"ConstNode",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Node",
")",
";",
"if",
"(",
"ConstNode",
"->",
"isNullValue",
"(",
")",
")",
"{",
"SDValue",
"New",
"=",
"CurDAG",
"->",
"getCopyFromReg",
"(",
"CurDAG",
"->",
"getEntryNode",
"(",
")",
",",
"SDLoc",
"(",
"Node",
")",
",",
"RISCV",
"::",
"X0",
",",
"XLenVT",
")",
";",
"ReplaceNode",
"(",
"Node",
",",
"New",
".",
"getNode",
"(",
")",
")",
";",
"return",
";",
"}",
"}",
"if",
"(",
"Opcode",
"==",
"ISD",
"::",
"FrameIndex",
")",
"{",
"SDLoc",
"DL",
"(",
"Node",
")",
";",
"SDValue",
"Imm",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"0",
",",
"DL",
",",
"XLenVT",
")",
";",
"int",
"FI",
"=",
"dyn_cast",
"<",
"FrameIndexSDNode",
">",
"(",
"Node",
")",
"->",
"getIndex",
"(",
")",
";",
"EVT",
"VT",
"=",
"Node",
"->",
"getValueType",
"(",
"0",
")",
";",
"SDValue",
"TFI",
"=",
"CurDAG",
"->",
"getTargetFrameIndex",
"(",
"FI",
",",
"VT",
")",
";",
"ReplaceNode",
"(",
"Node",
",",
"CurDAG",
"->",
"getMachineNode",
"(",
"RISCV",
"::",
"ADDI",
",",
"DL",
",",
"VT",
",",
"TFI",
",",
"Imm",
")",
")",
";",
"return",
";",
"}",
"SelectCode",
"(",
"Node",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"RISCV",
"RISCV",
"\"== \"",
"\"\\n\"",
"1",
"0",
"ISD::Constant",
"RISCV::X0",
"ISD::FrameIndex",
"0",
"0",
"RISCV::ADDI"
] | RISCVISelDAGToDAG32 | Select | RISCV | CPU | LLVM | 31,195 | 251 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_v9branch",
"(",
"rtx",
"op",
",",
"rtx",
"dest",
",",
"int",
"reg",
",",
"int",
"label",
",",
"int",
"reversed",
",",
"int",
"annul",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"static",
"char",
"string",
"[",
"64",
"]",
";",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"op",
")",
";",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
";",
"rtx",
"note",
";",
"int",
"far",
";",
"char",
"*",
"p",
";",
"far",
"=",
"get_attr_length",
"(",
"insn",
")",
">=",
"3",
";",
"if",
"(",
"reversed",
"^",
"far",
")",
"code",
"=",
"reverse_condition",
"(",
"code",
")",
";",
"gcc_assert",
"(",
"mode",
"==",
"DImode",
")",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"NE",
":",
"strcpy",
"(",
"string",
",",
"\"brnz\"",
")",
";",
"break",
";",
"case",
"EQ",
":",
"strcpy",
"(",
"string",
",",
"\"brz\"",
")",
";",
"break",
";",
"case",
"GE",
":",
"strcpy",
"(",
"string",
",",
"\"brgez\"",
")",
";",
"break",
";",
"case",
"LT",
":",
"strcpy",
"(",
"string",
",",
"\"brlz\"",
")",
";",
"break",
";",
"case",
"LE",
":",
"strcpy",
"(",
"string",
",",
"\"brlez\"",
")",
";",
"break",
";",
"case",
"GT",
":",
"strcpy",
"(",
"string",
",",
"\"brgz\"",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"p",
"=",
"strchr",
"(",
"string",
",",
"'\\0'",
")",
";",
"if",
"(",
"annul",
"&&",
"!",
"far",
")",
"{",
"strcpy",
"(",
"p",
",",
"\",a\"",
")",
";",
"p",
"+=",
"2",
";",
"}",
"if",
"(",
"insn",
"&&",
"(",
"note",
"=",
"find_reg_note",
"(",
"insn",
",",
"REG_BR_PROB",
",",
"NULL_RTX",
")",
")",
")",
"{",
"strcpy",
"(",
"p",
",",
"(",
"(",
"XINT",
"(",
"note",
",",
"0",
")",
">=",
"REG_BR_PROB_BASE",
"/",
"2",
")",
"^",
"far",
")",
"?",
"\",pt\"",
":",
"\",pn\"",
")",
";",
"p",
"+=",
"3",
";",
"}",
"*",
"p",
"=",
"p",
"<",
"string",
"+",
"8",
"?",
"'\\t'",
":",
"' '",
";",
"p",
"++",
";",
"*",
"p",
"++",
"=",
"'%'",
";",
"*",
"p",
"++",
"=",
"'0'",
"+",
"reg",
";",
"*",
"p",
"++",
"=",
"','",
";",
"*",
"p",
"++",
"=",
"' '",
";",
"if",
"(",
"far",
")",
"{",
"int",
"veryfar",
"=",
"1",
",",
"delta",
";",
"if",
"(",
"INSN_ADDRESSES_SET_P",
"(",
")",
")",
"{",
"delta",
"=",
"(",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"dest",
")",
")",
"-",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"insn",
")",
")",
")",
";",
"if",
"(",
"delta",
">=",
"-",
"260000",
"&&",
"delta",
"<",
"260000",
")",
"veryfar",
"=",
"0",
";",
"}",
"strcpy",
"(",
"p",
",",
"\".+12\\n\\t nop\\n\\t\"",
")",
";",
"if",
"(",
"annul",
"||",
"!",
"final_sequence",
")",
"p",
"[",
"3",
"]",
"=",
"'6'",
";",
"p",
"+=",
"12",
";",
"if",
"(",
"veryfar",
")",
"{",
"strcpy",
"(",
"p",
",",
"\"b\\t\"",
")",
";",
"p",
"+=",
"2",
";",
"}",
"else",
"{",
"strcpy",
"(",
"p",
",",
"\"ba,pt\\t%%xcc, \"",
")",
";",
"p",
"+=",
"13",
";",
"}",
"}",
"*",
"p",
"++",
"=",
"'%'",
";",
"*",
"p",
"++",
"=",
"'l'",
";",
"*",
"p",
"++",
"=",
"'0'",
"+",
"label",
";",
"*",
"p",
"++",
"=",
"'%'",
";",
"*",
"p",
"++",
"=",
"'#'",
";",
"*",
"p",
"=",
"'\\0'",
";",
"return",
"string",
";",
"}",
"</s>"
] | [
"Return",
"the",
"string",
"to",
"output",
"a",
"conditional",
"branch",
"to",
"LABEL",
",",
"testing",
"register",
"REG",
".",
"LABEL",
"is",
"the",
"operand",
"number",
"of",
"the",
"label",
";",
"REG",
"is",
"the",
"operand",
"number",
"of",
"the",
"reg",
".",
"OP",
"is",
"the",
"conditional",
"expression",
".",
"The",
"mode",
"of",
"REG",
"says",
"what",
"kind",
"of",
"comparison",
"we",
"made",
".",
"REVERSED",
"is",
"non-zero",
"if",
"we",
"should",
"reverse",
"the",
"sense",
"of",
"the",
"comparison",
".",
"ANNUL",
"is",
"non-zero",
"if",
"we",
"should",
"generate",
"an",
"annulling",
"branch",
".",
"NOOP",
"is",
"non-zero",
"if",
"we",
"have",
"to",
"follow",
"this",
"branch",
"by",
"a",
"noop",
"."
] | [
"sparc",
"64",
"0",
"3",
"\"brnz\"",
"\"brz\"",
"\"brgez\"",
"\"brlz\"",
"\"brlez\"",
"\"brgz\"",
"\",a\"",
"2",
"0",
"2",
"\",pt\"",
"\",pn\"",
"3",
"8",
"1",
"260000",
"260000",
"0",
"\".+12\\n\\t nop\\n\\t\"",
"3",
"12",
"\"b\\t\"",
"2",
"\"ba,pt\\t%%xcc, \"",
"13"
] | sparc4 | output_v9branch | sparc | CPU | GCC | 31,196 | 453 | 1 | [] |
[
"<s>",
"unsigned",
"getMinimumNopSize",
"(",
")",
"const",
"override",
"{",
"return",
"2",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"minimum",
"size",
"of",
"a",
"nop",
"in",
"bytes",
"on",
"this",
"target",
"."
] | [
"M680x0",
"2"
] | M680x0AsmBackend | getMinimumNopSize | M680x0 | MPU | LLVM | 31,197 | 11 | 1 | [] |
[
"<s>",
"Z80Subtarget",
"&",
"Z80Subtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"ParseSubtargetFeatures",
"(",
"CPU",
",",
"FS",
")",
";",
"HasIdxHalfRegs",
"=",
"HasUndocOps",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"Z80",
"Z80",
"Z80"
] | Z80Subtarget1 | initializeSubtargetDependencies | Z80 | MPU | LLVM | 31,198 | 29 | 1 | [] |
[
"<s>",
"int",
"h8300_hard_regno_mode_ok",
"(",
"int",
"regno",
",",
"enum",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"TARGET_H8300",
")",
"return",
"(",
"(",
"regno",
"&",
"1",
")",
"==",
"0",
")",
"||",
"(",
"mode",
"==",
"HImode",
")",
"||",
"(",
"mode",
"==",
"QImode",
")",
";",
"else",
"return",
"regno",
"==",
"MAC_REG",
"?",
"mode",
"==",
"SImode",
":",
"1",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"HARD_REGNO_MODE_OK",
"."
] | [
"h8300",
"1",
"0",
"1"
] | h83003 | h8300_hard_regno_mode_ok | h8300 | MPU | GCC | 31,199 | 51 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.