ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"static",
"void",
"mips_maybe_swap_ready",
"(",
"rtx_insn",
"*",
"*",
"ready",
",",
"int",
"pos1",
",",
"int",
"pos2",
",",
"int",
"limit",
")",
"{",
"if",
"(",
"pos1",
"<",
"pos2",
"&&",
"INSN_PRIORITY",
"(",
"ready",
"[",
"pos1",
"]",
")",
"+",
"limit",
">=",
"INSN_PRIORITY",
"(",
"ready",
"[",
"pos2",
"]",
")",
")",
"{",
"rtx_insn",
"*",
"temp",
";",
"temp",
"=",
"ready",
"[",
"pos1",
"]",
";",
"ready",
"[",
"pos1",
"]",
"=",
"ready",
"[",
"pos2",
"]",
";",
"ready",
"[",
"pos2",
"]",
"=",
"temp",
";",
"}",
"}",
"</s>"
] | [
"If",
"the",
"priority",
"of",
"the",
"instruction",
"at",
"POS2",
"in",
"the",
"ready",
"queue",
"READY",
"is",
"within",
"LIMIT",
"units",
"of",
"that",
"of",
"the",
"instruction",
"at",
"POS1",
",",
"swap",
"the",
"instructions",
"if",
"POS2",
"is",
"not",
"already",
"less",
"than",
"POS1",
"."
] | [
"mips"
] | mips | mips_maybe_swap_ready | mips | CPU | GCC | 18,400 | 74 | 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",
")",
";",
"StrippedTLS",
"=",
"stripThreadLocals",
"(",
"M",
")",
";",
"}",
"else",
"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"
] | WebAssemblyTargetMachine24 | runOnModule | WebAssembly | Virtual ISA | LLVM | 18,401 | 145 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"MachineModuleInfo",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"Sparc"
] | SparcCodeEmitter3 | getAnalysisUsage | Sparc | CPU | LLVM | 18,402 | 27 | 1 | [] |
[
"<s>",
"void",
"TMS320C64XInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"dstReg",
",",
"int",
"frameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"rc",
";",
"if",
"(",
"!",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"dstReg",
")",
")",
"{",
"assert",
"(",
"RC",
")",
";",
"if",
"(",
"RC",
"==",
"TMS320C64X",
"::",
"PredRegsRegisterClass",
")",
"rc",
"=",
"TMS320C64X",
"::",
"ARegsRegisterClass",
";",
"else",
"rc",
"=",
"RC",
";",
"}",
"else",
"rc",
"=",
"findRegisterSide",
"(",
"dstReg",
",",
"MBB",
".",
"getParent",
"(",
")",
")",
";",
"bool",
"xdata",
"=",
"(",
"rc",
"==",
"TMS320C64X",
"::",
"BRegsRegisterClass",
")",
";",
"addFormOp",
"(",
"addDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"TMS320C64X",
"::",
"word_load_1",
")",
")",
".",
"addReg",
"(",
"dstReg",
",",
"RegState",
"::",
"Define",
")",
".",
"addReg",
"(",
"TMS320C64X",
"::",
"A15",
")",
".",
"addFrameIndex",
"(",
"frameIndex",
")",
")",
",",
"TMS320C64XII",
"::",
"unit_d",
",",
"xdata",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"TMS320C64X",
"TMS320C64X",
"TMS320C64X::PredRegsRegisterClass",
"TMS320C64X::ARegsRegisterClass",
"TMS320C64X::BRegsRegisterClass",
"TMS320C64X::word_load_1",
"TMS320C64X::A15",
"TMS320C64XII::unit_d"
] | TMS320C64XInstrInfo | loadRegFromStackSlot | TMS320C64X | VLIW | LLVM | 18,403 | 169 | 1 | [] |
[
"<s>",
"void",
"MipsSEFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedRegs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedRegs",
",",
"RS",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"MipsFunctionInfo",
"*",
"MipsFI",
"=",
"MF",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
";",
"MipsABIInfo",
"ABI",
"=",
"STI",
".",
"getABI",
"(",
")",
";",
"unsigned",
"RA",
"=",
"ABI",
".",
"GetReturnAddress",
"(",
")",
";",
"unsigned",
"FP",
"=",
"ABI",
".",
"GetFramePtr",
"(",
")",
";",
"unsigned",
"BP",
"=",
"ABI",
".",
"GetBasePtr",
"(",
")",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"setAliasRegs",
"(",
"MF",
",",
"SavedRegs",
",",
"RA",
")",
";",
"setAliasRegs",
"(",
"MF",
",",
"SavedRegs",
",",
"FP",
")",
";",
"}",
"if",
"(",
"hasBP",
"(",
"MF",
")",
")",
"setAliasRegs",
"(",
"MF",
",",
"SavedRegs",
",",
"BP",
")",
";",
"if",
"(",
"MipsFI",
"->",
"callsEhReturn",
"(",
")",
")",
"MipsFI",
"->",
"createEhDataRegsFI",
"(",
"MF",
")",
";",
"if",
"(",
"MipsFI",
"->",
"isISR",
"(",
")",
")",
"MipsFI",
"->",
"createISRRegFI",
"(",
"MF",
")",
";",
"if",
"(",
"ExpandPseudo",
"(",
"MF",
")",
".",
"expand",
"(",
")",
")",
"{",
"const",
"TargetRegisterClass",
"&",
"RC",
"=",
"STI",
".",
"isGP64bit",
"(",
")",
"?",
"Mips",
"::",
"GPR64RegClass",
":",
"Mips",
"::",
"GPR32RegClass",
";",
"int",
"FI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"CreateStackObject",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"RC",
")",
",",
"TRI",
"->",
"getSpillAlign",
"(",
"RC",
")",
",",
"false",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"FI",
")",
";",
"}",
"uint64_t",
"MaxSPOffset",
"=",
"estimateStackSize",
"(",
"MF",
")",
";",
"if",
"(",
"STI",
".",
"isCheri",
"(",
")",
")",
"{",
"if",
"(",
"STI",
".",
"isABI_CheriPureCap",
"(",
")",
")",
"{",
"if",
"(",
"isInt",
"<",
"10",
">",
"(",
"MaxSPOffset",
")",
")",
"return",
";",
"}",
"else",
"if",
"(",
"isInt",
"<",
"15",
">",
"(",
"MaxSPOffset",
")",
")",
"return",
";",
"}",
"else",
"if",
"(",
"isIntN",
"(",
"STI",
".",
"hasMSA",
"(",
")",
"?",
"10",
":",
"16",
",",
"MaxSPOffset",
")",
"&&",
"!",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"hasVarSizedObjects",
"(",
")",
")",
"return",
";",
"const",
"TargetRegisterClass",
"&",
"RC",
"=",
"ABI",
".",
"ArePtrs64bit",
"(",
")",
"?",
"Mips",
"::",
"GPR64RegClass",
":",
"Mips",
"::",
"GPR32RegClass",
";",
"int",
"FI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"CreateStackObject",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"RC",
")",
",",
"TRI",
"->",
"getSpillAlign",
"(",
"RC",
")",
",",
"false",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"FI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips::GPR64RegClass",
"Mips::GPR32RegClass",
"10",
"15",
"10",
"16",
"Mips::GPR64RegClass",
"Mips::GPR32RegClass"
] | MipsSEFrameLowering40 | determineCalleeSaves | Mips | CPU | LLVM | 18,404 | 373 | 1 | [] |
[
"<s>",
"int",
"h8300_current_function_interrupt_function_p",
"(",
"void",
")",
"{",
"return",
"(",
"h8300_interrupt_function_p",
"(",
"current_function_decl",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"the",
"current",
"function",
"is",
"an",
"interrupt",
"function",
"."
] | [
"h8300"
] | h8300 | h8300_current_function_interrupt_function_p | h8300 | MPU | GCC | 18,405 | 15 | 1 | [] |
[
"<s>",
"unsigned",
"MipsAsmParser",
"::",
"getReg",
"(",
"int",
"RC",
",",
"int",
"RegNo",
")",
"{",
"return",
"*",
"(",
"getContext",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
".",
"getRegClass",
"(",
"RC",
")",
".",
"begin",
"(",
")",
"+",
"RegNo",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"Mips",
"Mips"
] | MipsAsmParser41 | getReg | Mips | CPU | LLVM | 18,406 | 36 | 1 | [] |
[
"<s>",
"bool",
"AArch64PromoteConstant",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
",",
"PromotionCacheTy",
"&",
"PromotionCache",
")",
"{",
"SmallVector",
"<",
"UpdateRecord",
",",
"64",
">",
"Updates",
";",
"for",
"(",
"Instruction",
"&",
"I",
":",
"instructions",
"(",
"&",
"F",
")",
")",
"{",
"for",
"(",
"Use",
"&",
"U",
":",
"I",
".",
"operands",
"(",
")",
")",
"{",
"Constant",
"*",
"Cst",
"=",
"dyn_cast",
"<",
"Constant",
">",
"(",
"U",
")",
";",
"if",
"(",
"!",
"Cst",
"||",
"isa",
"<",
"GlobalValue",
">",
"(",
"Cst",
")",
"||",
"!",
"containsOnlyConstantData",
"(",
"Cst",
")",
")",
"continue",
";",
"if",
"(",
"!",
"shouldConvert",
"(",
"*",
"Cst",
",",
"PromotionCache",
")",
")",
"continue",
";",
"unsigned",
"OpNo",
"=",
"&",
"U",
"-",
"I",
".",
"op_begin",
"(",
")",
";",
"if",
"(",
"!",
"shouldConvertUse",
"(",
"Cst",
",",
"&",
"I",
",",
"OpNo",
")",
")",
"continue",
";",
"Updates",
".",
"emplace_back",
"(",
"Cst",
",",
"&",
"I",
",",
"OpNo",
")",
";",
"}",
"}",
"if",
"(",
"Updates",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"promoteConstants",
"(",
"F",
",",
"Updates",
",",
"PromotionCache",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"AArch64",
"AArch64",
"64"
] | AArch64PromoteConstant26 | runOnFunction | AArch64 | CPU | LLVM | 18,407 | 159 | 1 | [] |
[
"<s>",
"rtx",
"frv_gen_GPsym2reg",
"(",
"rtx",
"dest",
",",
"rtx",
"src",
")",
"{",
"tree",
"gp",
"=",
"get_identifier",
"(",
"\"_gp\"",
")",
";",
"rtx",
"gp_sym",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"IDENTIFIER_POINTER",
"(",
"gp",
")",
")",
";",
"return",
"gen_symGOT2reg",
"(",
"dest",
",",
"gp_sym",
",",
"src",
",",
"GEN_INT",
"(",
"R_FRV_GOT12",
")",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"_gp",
"symbol",
"into",
"DEST",
".",
"SRC",
"is",
"supposed",
"to",
"be",
"the",
"FDPIC",
"register",
"."
] | [
"frv",
"\"_gp\""
] | frv | frv_gen_GPsym2reg | frv | VLIW | GCC | 18,408 | 47 | 1 | [] |
[
"<s>",
"Register",
"TL45RegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TL45Subtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"TL45Subtarget",
">",
"(",
")",
";",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"Subtarget",
".",
"getFrameLowering",
"(",
")",
";",
"return",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"TL45",
"::",
"bp",
":",
"TL45",
"::",
"sp",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"TL45",
"TL45",
"TL45",
"TL45",
"TL45::bp",
"TL45::sp"
] | TL45RegisterInfo | getFrameRegister | TL45 | MPU | LLVM | 18,409 | 54 | 1 | [] |
[
"<s>",
"static",
"RTX_CODE",
"compare_condition",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx_insn",
"*",
"next",
"=",
"next_real_insn",
"(",
"insn",
")",
";",
"if",
"(",
"next",
"&&",
"JUMP_P",
"(",
"next",
")",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"next",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"PARALLEL",
")",
"pat",
"=",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"0",
")",
";",
"rtx",
"src",
"=",
"SET_SRC",
"(",
"pat",
")",
";",
"if",
"(",
"IF_THEN_ELSE",
"==",
"GET_CODE",
"(",
"src",
")",
")",
"return",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
";",
"}",
"return",
"UNKNOWN",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"condition",
"of",
"compare",
"insn",
"INSN",
",",
"or",
"UNKNOWN",
"."
] | [
"avr",
"0",
"0",
"0"
] | avr | compare_condition | avr | MPU | GCC | 18,410 | 89 | 1 | [] |
[
"<s>",
"const",
"RegisterBankInfo",
"*",
"M68kSubtarget",
"::",
"getRegBankInfo",
"(",
")",
"const",
"{",
"return",
"RegBankInfo",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"If",
"the",
"information",
"for",
"the",
"register",
"banks",
"is",
"available",
",",
"return",
"it",
"."
] | [
"M68k",
"M68k"
] | M68kSubtarget | getRegBankInfo | M68k | MPU | LLVM | 18,411 | 18 | 1 | [] |
[
"<s>",
"unsigned",
"PPCTTIImpl",
"::",
"getNumberOfRegisters",
"(",
"unsigned",
"ClassID",
")",
"const",
"{",
"assert",
"(",
"ClassID",
"==",
"GPRRC",
"||",
"ClassID",
"==",
"FPRRC",
"||",
"ClassID",
"==",
"VRRC",
"||",
"ClassID",
"==",
"VSXRC",
")",
";",
"if",
"(",
"ST",
"->",
"hasVSX",
"(",
")",
")",
"{",
"assert",
"(",
"ClassID",
"==",
"GPRRC",
"||",
"ClassID",
"==",
"VSXRC",
")",
";",
"return",
"ClassID",
"==",
"GPRRC",
"?",
"32",
":",
"64",
";",
"}",
"assert",
"(",
"ClassID",
"==",
"GPRRC",
"||",
"ClassID",
"==",
"FPRRC",
"||",
"ClassID",
"==",
"VRRC",
")",
";",
"return",
"32",
";",
"}",
"</s>"
] | [
"�",
"?",
"Vector",
"TTI",
"begin",
"�",
"?"
] | [
"PowerPC",
"PPC",
"32",
"64",
"32"
] | PPCTargetTransformInfo35 | getNumberOfRegisters | PowerPC | CPU | LLVM | 18,412 | 78 | 1 | [] |
[
"<s>",
"bool",
"HexagonGatherPacketize",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"if",
"(",
"!",
"EnableGatherPacketize",
")",
"return",
"false",
";",
"auto",
"&",
"ST",
"=",
"Fn",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
";",
"bool",
"HasV65",
"=",
"ST",
".",
"hasV65TOps",
"(",
")",
";",
"bool",
"UseHVX",
"=",
"ST",
".",
"useHVXOps",
"(",
")",
";",
"if",
"(",
"!",
"(",
"HasV65",
"&",
"UseHVX",
")",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"Fn",
")",
"{",
"bool",
"VtmpDef",
"=",
"false",
";",
"MachineBasicBlock",
"::",
"iterator",
"MII",
",",
"MIE",
",",
"DefMII",
";",
"for",
"(",
"MII",
"=",
"MBB",
".",
"begin",
"(",
")",
",",
"MIE",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"MII",
"!=",
"MIE",
";",
"++",
"MII",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"MII",
";",
"if",
"(",
"VtmpDef",
")",
"{",
"if",
"(",
"!",
"isVtmpUse",
"(",
"MI",
")",
")",
"continue",
";",
"MBB",
".",
"splice",
"(",
"std",
"::",
"next",
"(",
"DefMII",
")",
",",
"&",
"MBB",
",",
"MII",
")",
";",
"finalizeBundle",
"(",
"MBB",
",",
"DefMII",
".",
"getInstrIterator",
"(",
")",
",",
"std",
"::",
"next",
"(",
"MII",
")",
".",
"getInstrIterator",
"(",
")",
")",
";",
"VtmpDef",
"=",
"false",
";",
"continue",
";",
"}",
"if",
"(",
"!",
"(",
"isVtmpDef",
"(",
"MI",
")",
")",
")",
"continue",
";",
"VtmpDef",
"=",
"true",
";",
"DefMII",
"=",
"MII",
";",
"}",
"assert",
"(",
"!",
"VtmpDef",
"&&",
"\"VTMP producer and consumer not in same block\"",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"\"VTMP producer and consumer not in same block\""
] | HexagonGatherPacketize1 | runOnMachineFunction | Hexagon | DSP | LLVM | 18,413 | 212 | 1 | [] |
[
"<s>",
"SDValue",
"XtensaTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"ret",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"Xtensa",
"Xtensa"
] | XtensaISelLowering1 | LowerOperation | Xtensa | MPU | LLVM | 18,414 | 21 | 1 | [] |
[
"<s>",
"static",
"tree",
"aarch64_d_handle_target_float_abi",
"(",
"void",
")",
"{",
"const",
"char",
"*",
"abi",
"=",
"\"hard\"",
";",
"return",
"build_string_literal",
"(",
"strlen",
"(",
"abi",
")",
"+",
"1",
",",
"abi",
")",
";",
"}",
"</s>"
] | [
"Handle",
"a",
"call",
"to",
"`",
"__traits",
"(",
"getTargetInfo",
",",
"``",
"floatAbi",
"''",
")",
"'",
"."
] | [
"aarch64",
"\"hard\"",
"1"
] | aarch64-d | aarch64_d_handle_target_float_abi | aarch64 | CPU | GCC | 18,415 | 28 | 1 | [] |
[
"<s>",
"unsigned",
"X86InstrInfo",
"::",
"getPartialRegUpdateClearance",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"OpNum",
"!=",
"0",
"||",
"!",
"hasPartialRegUpdate",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
")",
"return",
"0",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"Reg",
")",
")",
"{",
"if",
"(",
"MO",
".",
"readsReg",
"(",
")",
"||",
"MI",
".",
"readsVirtualRegister",
"(",
"Reg",
")",
")",
"return",
"0",
";",
"}",
"else",
"{",
"if",
"(",
"MI",
".",
"readsRegister",
"(",
"Reg",
",",
"TRI",
")",
")",
"return",
"0",
";",
"}",
"return",
"PartialRegUpdateClearance",
";",
"}",
"</s>"
] | [
"Inform",
"the",
"BreakFalseDeps",
"pass",
"how",
"many",
"idle",
"instructions",
"we",
"would",
"like",
"before",
"a",
"partial",
"register",
"update",
"."
] | [
"X86",
"X86",
"0",
"0",
"0",
"0",
"0"
] | X86InstrInfo (2)1 | getPartialRegUpdateClearance | X86 | CPU | LLVM | 18,416 | 110 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_version\"",
")",
"return",
"ParseDirectiveHSACodeObjectVersion",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_isa\"",
")",
"return",
"ParseDirectiveHSACodeObjectISA",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"AMDGPU",
"::",
"CodeObject",
"::",
"MetadataAssemblerDirectiveBegin",
")",
"return",
"ParseDirectiveCodeObjectMetadata",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amd_kernel_code_t\"",
")",
"return",
"ParseDirectiveAMDKernelCodeT",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsatext\"",
")",
"return",
"ParseSectionDirectiveHSAText",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_kernel\"",
")",
"return",
"ParseDirectiveAMDGPUHsaKernel",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_module_global\"",
")",
"return",
"ParseDirectiveAMDGPUHsaModuleGlobal",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_program_global\"",
")",
"return",
"ParseDirectiveAMDGPUHsaProgramGlobal",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsadata_global_agent\"",
")",
"return",
"ParseSectionDirectiveHSADataGlobalAgent",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsadata_global_program\"",
")",
"return",
"ParseSectionDirectiveHSADataGlobalProgram",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsarodata_readonly_agent\"",
")",
"return",
"ParseSectionDirectiveHSARodataReadonlyAgent",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"AMDGPU",
"AMDGPU",
"\".hsa_code_object_version\"",
"\".hsa_code_object_isa\"",
"AMDGPU::CodeObject",
"\".amd_kernel_code_t\"",
"\".hsatext\"",
"\".amdgpu_hsa_kernel\"",
"AMDGPU",
"\".amdgpu_hsa_module_global\"",
"AMDGPU",
"\".amdgpu_hsa_program_global\"",
"AMDGPU",
"\".hsadata_global_agent\"",
"\".hsadata_global_program\"",
"\".hsarodata_readonly_agent\""
] | AMDGPUAsmParser22 | ParseDirective | AMDGPU | GPU | LLVM | 18,417 | 147 | 1 | [] |
[
"<s>",
"static",
"bool",
"ft32_return_in_memory",
"(",
"const_tree",
"type",
",",
"const_tree",
"fntype",
"ATTRIBUTE_UNUSED",
")",
"{",
"const",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"return",
"(",
"size",
"==",
"-",
"1",
"||",
"size",
">",
"2",
"*",
"UNITS_PER_WORD",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_RETURN_IN_MEMORY",
"."
] | [
"ft32",
"1",
"2"
] | ft32 | ft32_return_in_memory | ft32 | MPU | GCC | 18,418 | 36 | 1 | [] |
[
"<s>",
"void",
"Thumb2InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"RC",
"==",
"ARM",
"::",
"GPRRegisterClass",
"||",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"PseudoSourceValue",
"::",
"getFixedStack",
"(",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"0",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"t2STRi12",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"return",
";",
"}",
"ARMBaseInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MBB",
",",
"I",
",",
"SrcReg",
",",
"isKill",
",",
"FI",
",",
"RC",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::GPRRegisterClass",
"ARM::tGPRRegisterClass",
"0",
"ARM::t2STRi12",
"0",
"ARM"
] | Thumb2InstrInfo4 | storeRegToStackSlot | ARM | CPU | LLVM | 18,419 | 189 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"SIRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"switch",
"(",
"CC",
")",
"{",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"Cold",
":",
"case",
"CallingConv",
"::",
"AMDGPU_Gfx",
":",
"return",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
".",
"hasGFX90AInsts",
"(",
")",
"?",
"CSR_AMDGPU_HighRegs_With_AGPRs_RegMask",
":",
"CSR_AMDGPU_HighRegs_RegMask",
";",
"default",
":",
"return",
"nullptr",
";",
"}",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | SIRegisterInfo1 | getCallPreservedMask | AMDGPU | GPU | LLVM | 18,420 | 69 | 1 | [] |
[
"<s>",
"void",
"Z80InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"dl",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"dl",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"Z80",
"::",
"GR8RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"dl",
",",
"get",
"(",
"Z80",
"::",
"LD8xmr",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"Z80",
"::",
"BR16RegClass",
"||",
"Z80",
"::",
"BR16RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"dl",
",",
"get",
"(",
"Z80",
"::",
"LD16xmr",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
";",
"}",
"else",
"llvm_unreachable",
"(",
"\"Can't store this register to stack slot\"",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"Z80",
"Z80",
"Z80::GR8RegClass",
"Z80::LD8xmr",
"0",
"Z80::BR16RegClass",
"Z80::BR16RegClass",
"Z80::LD16xmr",
"0",
"\"Can't store this register to stack slot\""
] | Z80InstrInfo | storeRegToStackSlot | Z80 | MPU | LLVM | 18,421 | 165 | 1 | [] |
[
"<s>",
"bool",
"FixupLEAPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Func",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"Func",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"MF",
"=",
"&",
"Func",
";",
"const",
"X86Subtarget",
"&",
"ST",
"=",
"Func",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"OptIncDec",
"=",
"!",
"ST",
".",
"slowIncDec",
"(",
")",
"||",
"Func",
".",
"getFunction",
"(",
")",
".",
"optForMinSize",
"(",
")",
";",
"OptLEA",
"=",
"ST",
".",
"LEAusesAG",
"(",
")",
"||",
"ST",
".",
"slowLEA",
"(",
")",
"||",
"ST",
".",
"slow3OpsLEA",
"(",
")",
";",
"if",
"(",
"!",
"OptLEA",
"&&",
"!",
"OptIncDec",
")",
"return",
"false",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Start X86FixupLEAs\\n\"",
";",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"Func",
".",
"begin",
"(",
")",
",",
"E",
"=",
"Func",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"processBasicBlock",
"(",
"Func",
",",
"I",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"End X86FixupLEAs\\n\"",
";",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"\"Start X86FixupLEAs\\n\"",
"\"End X86FixupLEAs\\n\""
] | X86FixupLEAs29 | runOnMachineFunction | X86 | CPU | LLVM | 18,422 | 160 | 1 | [] |
[
"<s>",
"static",
"bool",
"expand_vec_perm_interleave3",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"unsigned",
"i",
",",
"nelt",
";",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"if",
"(",
"d",
"->",
"one_operand_p",
")",
"return",
"false",
";",
"if",
"(",
"TARGET_AVX2",
"&&",
"GET_MODE_SIZE",
"(",
"d",
"->",
"vmode",
")",
"==",
"32",
")",
";",
"else",
"if",
"(",
"TARGET_AVX",
"&&",
"(",
"d",
"->",
"vmode",
"==",
"V8SFmode",
"||",
"d",
"->",
"vmode",
"==",
"V4DFmode",
")",
")",
";",
"else",
"return",
"false",
";",
"nelt",
"=",
"d",
"->",
"nelt",
";",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
"!=",
"0",
"&&",
"d",
"->",
"perm",
"[",
"0",
"]",
"!=",
"nelt",
"/",
"2",
")",
"return",
"false",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nelt",
";",
"i",
"+=",
"2",
")",
"if",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"!=",
"d",
"->",
"perm",
"[",
"0",
"]",
"+",
"i",
"/",
"2",
"||",
"d",
"->",
"perm",
"[",
"i",
"+",
"1",
"]",
"!=",
"d",
"->",
"perm",
"[",
"0",
"]",
"+",
"i",
"/",
"2",
"+",
"nelt",
")",
"return",
"false",
";",
"if",
"(",
"d",
"->",
"testing_p",
")",
"return",
"true",
";",
"switch",
"(",
"d",
"->",
"vmode",
")",
"{",
"case",
"V32QImode",
":",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
")",
"gen",
"=",
"gen_vec_interleave_highv32qi",
";",
"else",
"gen",
"=",
"gen_vec_interleave_lowv32qi",
";",
"break",
";",
"case",
"V16HImode",
":",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
")",
"gen",
"=",
"gen_vec_interleave_highv16hi",
";",
"else",
"gen",
"=",
"gen_vec_interleave_lowv16hi",
";",
"break",
";",
"case",
"V8SImode",
":",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
")",
"gen",
"=",
"gen_vec_interleave_highv8si",
";",
"else",
"gen",
"=",
"gen_vec_interleave_lowv8si",
";",
"break",
";",
"case",
"V4DImode",
":",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
")",
"gen",
"=",
"gen_vec_interleave_highv4di",
";",
"else",
"gen",
"=",
"gen_vec_interleave_lowv4di",
";",
"break",
";",
"case",
"V8SFmode",
":",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
")",
"gen",
"=",
"gen_vec_interleave_highv8sf",
";",
"else",
"gen",
"=",
"gen_vec_interleave_lowv8sf",
";",
"break",
";",
"case",
"V4DFmode",
":",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
")",
"gen",
"=",
"gen_vec_interleave_highv4df",
";",
"else",
"gen",
"=",
"gen_vec_interleave_lowv4df",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"emit_insn",
"(",
"gen",
"(",
"d",
"->",
"target",
",",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"ix86_expand_vec_perm_builtin_1",
".",
"Try",
"to",
"simplify",
"a",
"two",
"vector",
"permutation",
"using",
"2",
"intra-lane",
"interleave",
"insns",
"and",
"cross-lane",
"shuffle",
"for",
"32-byte",
"vectors",
"."
] | [
"i386",
"32",
"0",
"0",
"0",
"2",
"0",
"2",
"0",
"2",
"1",
"0",
"2",
"0",
"0",
"0",
"0",
"0",
"0"
] | i3864 | expand_vec_perm_interleave3 | i386 | CPU | GCC | 18,423 | 348 | 1 | [] |
[
"<s>",
"static",
"MCSymbol",
"*",
"GetSymbolFromOperand",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"AsmPrinter",
"&",
"AP",
")",
"{",
"const",
"TargetMachine",
"&",
"TM",
"=",
"AP",
".",
"TM",
";",
"Mangler",
"*",
"Mang",
"=",
"AP",
".",
"Mang",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"AP",
".",
"getDataLayout",
"(",
")",
";",
"MCContext",
"&",
"Ctx",
"=",
"AP",
".",
"OutContext",
";",
"SmallString",
"<",
"128",
">",
"Name",
";",
"StringRef",
"Suffix",
";",
"if",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"PPCII",
"::",
"MO_NLP_FLAG",
")",
"Suffix",
"=",
"\"$non_lazy_ptr\"",
";",
"if",
"(",
"!",
"Suffix",
".",
"empty",
"(",
")",
")",
"Name",
"+=",
"DL",
".",
"getPrivateGlobalPrefix",
"(",
")",
";",
"if",
"(",
"!",
"MO",
".",
"isGlobal",
"(",
")",
")",
"{",
"assert",
"(",
"MO",
".",
"isSymbol",
"(",
")",
"&&",
"\"Isn't a symbol reference\"",
")",
";",
"Mangler",
"::",
"getNameWithPrefix",
"(",
"Name",
",",
"MO",
".",
"getSymbolName",
"(",
")",
",",
"DL",
")",
";",
"}",
"else",
"{",
"const",
"GlobalValue",
"*",
"GV",
"=",
"MO",
".",
"getGlobal",
"(",
")",
";",
"TM",
".",
"getNameWithPrefix",
"(",
"Name",
",",
"GV",
",",
"*",
"Mang",
")",
";",
"}",
"Name",
"+=",
"Suffix",
";",
"MCSymbol",
"*",
"Sym",
"=",
"Ctx",
".",
"getOrCreateSymbol",
"(",
"Name",
")",
";",
"if",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"PPCII",
"::",
"MO_NLP_FLAG",
")",
"{",
"MachineModuleInfoMachO",
"&",
"MachO",
"=",
"getMachOMMI",
"(",
"AP",
")",
";",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"&",
"StubSym",
"=",
"MachO",
".",
"getGVStubEntry",
"(",
"Sym",
")",
";",
"if",
"(",
"!",
"StubSym",
".",
"getPointer",
"(",
")",
")",
"{",
"assert",
"(",
"MO",
".",
"isGlobal",
"(",
")",
"&&",
"\"Extern symbol not handled yet\"",
")",
";",
"StubSym",
"=",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"(",
"AP",
".",
"getSymbol",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
",",
"!",
"MO",
".",
"getGlobal",
"(",
")",
"->",
"hasInternalLinkage",
"(",
")",
")",
";",
"}",
"return",
"Sym",
";",
"}",
"return",
"Sym",
";",
"}",
"</s>"
] | [
"Lower",
"an",
"MO_GlobalAddress",
"or",
"MO_ExternalSymbol",
"operand",
"to",
"an",
"MCSymbol",
"."
] | [
"PowerPC",
"128",
"PPCII::MO_NLP_FLAG",
"\"$non_lazy_ptr\"",
"\"Isn't a symbol reference\"",
"PPCII::MO_NLP_FLAG",
"\"Extern symbol not handled yet\""
] | PPCMCInstLower7 | GetSymbolFromOperand | PowerPC | CPU | LLVM | 18,424 | 265 | 1 | [] |
[
"<s>",
"unsigned",
"MBlazeInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"MBlaze",
"::",
"LWI",
")",
"{",
"if",
"(",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isFI",
"(",
")",
")",
"&&",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isImm",
"(",
")",
")",
"&&",
"(",
"isZeroImm",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
")",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"MBlaze",
"MBlaze",
"MBlaze::LWI",
"2",
"1",
"1",
"2",
"0",
"0"
] | MBlazeInstrInfo | isLoadFromStackSlot | MBlaze | MPU | LLVM | 18,425 | 101 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"mayBeEmittedAsTailCall",
"(",
"const",
"CallInst",
"*",
"CI",
")",
"const",
"{",
"if",
"(",
"!",
"CI",
"->",
"isTailCall",
"(",
")",
")",
"return",
"false",
";",
"ImmutableCallSite",
"CS",
"(",
"CI",
")",
";",
"CallingConv",
"::",
"ID",
"CalleeCC",
"=",
"CS",
".",
"getCallingConv",
"(",
")",
";",
"if",
"(",
"!",
"mayTailCallThisCC",
"(",
"CalleeCC",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"may",
"be",
"able",
"emit",
"the",
"call",
"instruction",
"as",
"a",
"tail",
"call",
"."
] | [
"X86",
"X86"
] | X86ISelLowering130 | mayBeEmittedAsTailCall | X86 | CPU | LLVM | 18,426 | 56 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isLegalICmpImmediate",
"(",
"int64_t",
"Imm",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"ARM_AM",
"::",
"getSOImmVal",
"(",
"std",
"::",
"abs",
"(",
"Imm",
")",
")",
"!=",
"-",
"1",
";",
"if",
"(",
"Subtarget",
"->",
"isThumb2",
"(",
")",
")",
"return",
"ARM_AM",
"::",
"getT2SOImmVal",
"(",
"std",
"::",
"abs",
"(",
"Imm",
")",
")",
"!=",
"-",
"1",
";",
"return",
"Imm",
">=",
"0",
"&&",
"Imm",
"<=",
"255",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"immediate",
"is",
"legal",
"icmp",
"immediate",
",",
"that",
"is",
"the",
"target",
"has",
"icmp",
"instructions",
"which",
"can",
"compare",
"a",
"register",
"against",
"the",
"immediate",
"without",
"having",
"to",
"materialize",
"the",
"immediate",
"into",
"a",
"register",
"."
] | [
"ARM",
"ARM",
"ARM_AM::getSOImmVal",
"1",
"ARM_AM::getT2SOImmVal",
"1",
"0",
"255"
] | ARMISelLowering (2)2 | isLegalICmpImmediate | ARM | CPU | LLVM | 18,427 | 69 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_elim_entry_set_got",
"(",
"rtx",
"reg",
")",
"{",
"basic_block",
"bb",
"=",
"ENTRY_BLOCK_PTR_FOR_FN",
"(",
"cfun",
")",
"->",
"next_bb",
";",
"rtx_insn",
"*",
"c_insn",
"=",
"BB_HEAD",
"(",
"bb",
")",
";",
"if",
"(",
"!",
"NONDEBUG_INSN_P",
"(",
"c_insn",
")",
")",
"c_insn",
"=",
"next_nonnote_nondebug_insn",
"(",
"c_insn",
")",
";",
"if",
"(",
"c_insn",
"&&",
"NONJUMP_INSN_P",
"(",
"c_insn",
")",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"c_insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"PARALLEL",
")",
"{",
"rtx",
"vec",
"=",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"vec",
")",
"==",
"SET",
"&&",
"XINT",
"(",
"XEXP",
"(",
"vec",
",",
"1",
")",
",",
"1",
")",
"==",
"UNSPEC_SET_GOT",
"&&",
"REGNO",
"(",
"XEXP",
"(",
"vec",
",",
"0",
")",
")",
"==",
"REGNO",
"(",
"reg",
")",
")",
"delete_insn",
"(",
"c_insn",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Delete",
"SET_GOT",
"right",
"after",
"entry",
"block",
"if",
"it",
"is",
"allocated",
"to",
"reg",
"."
] | [
"i386",
"0",
"0",
"1",
"1",
"0"
] | i386 | ix86_elim_entry_set_got | i386 | CPU | GCC | 18,428 | 128 | 1 | [] |
[
"<s>",
"bool",
"AArch64FrameLowering",
"::",
"assignCalleeSavedSpillSlots",
"(",
"MachineFunction",
"&",
"MF",
",",
"const",
"TargetRegisterInfo",
"*",
"RegInfo",
",",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"unsigned",
"&",
"MinCSFrameIndex",
",",
"unsigned",
"&",
"MaxCSFrameIndex",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"true",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"auto",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"AArch64FunctionInfo",
">",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"CS",
":",
"CSI",
")",
"{",
"unsigned",
"Reg",
"=",
"CS",
".",
"getReg",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"RegInfo",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"int",
"FrameIdx",
";",
"unsigned",
"Size",
"=",
"RegInfo",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
";",
"Align",
"Alignment",
"(",
"RegInfo",
"->",
"getSpillAlignment",
"(",
"*",
"RC",
")",
")",
";",
"FrameIdx",
"=",
"MFI",
".",
"CreateStackObject",
"(",
"Size",
",",
"Alignment",
",",
"true",
")",
";",
"CS",
".",
"setFrameIdx",
"(",
"FrameIdx",
")",
";",
"if",
"(",
"(",
"unsigned",
")",
"FrameIdx",
"<",
"MinCSFrameIndex",
")",
"MinCSFrameIndex",
"=",
"FrameIdx",
";",
"if",
"(",
"(",
"unsigned",
")",
"FrameIdx",
">",
"MaxCSFrameIndex",
")",
"MaxCSFrameIndex",
"=",
"FrameIdx",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
"&&",
"AFI",
"->",
"hasSwiftAsyncContext",
"(",
")",
"&&",
"Reg",
"==",
"AArch64",
"::",
"FP",
")",
"{",
"FrameIdx",
"=",
"MFI",
".",
"CreateStackObject",
"(",
"8",
",",
"Alignment",
",",
"true",
")",
";",
"AFI",
"->",
"setSwiftAsyncContextFrameIdx",
"(",
"FrameIdx",
")",
";",
"if",
"(",
"(",
"unsigned",
")",
"FrameIdx",
"<",
"MinCSFrameIndex",
")",
"MinCSFrameIndex",
"=",
"FrameIdx",
";",
"if",
"(",
"(",
"unsigned",
")",
"FrameIdx",
">",
"MaxCSFrameIndex",
")",
"MaxCSFrameIndex",
"=",
"FrameIdx",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"function",
"will",
"assign",
"callee",
"saved",
"gprs",
"to",
"volatile",
"vector",
"registers",
"for",
"prologue",
"spills",
"when",
"applicable",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64::FP",
"8"
] | AArch64FrameLowering100 | assignCalleeSavedSpillSlots | AArch64 | CPU | LLVM | 18,429 | 240 | 1 | [] |
[
"<s>",
"static",
"pad_direction",
"sparc_function_arg_padding",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
")",
"{",
"if",
"(",
"TARGET_ARCH64",
"&&",
"type",
"&&",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"return",
"PAD_UPWARD",
";",
"return",
"default_function_arg_padding",
"(",
"mode",
",",
"type",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG_PADDING",
".",
"For",
"the",
"64-bit",
"ABI",
"structs",
"are",
"always",
"stored",
"left",
"shifted",
"in",
"their",
"argument",
"slot",
"."
] | [
"sparc"
] | sparc | sparc_function_arg_padding | sparc | CPU | GCC | 18,430 | 34 | 1 | [] |
[
"<s>",
"static",
"int",
"interrupt_function_p",
"(",
"tree",
"func",
")",
"{",
"tree",
"a",
";",
"if",
"(",
"TREE_CODE",
"(",
"func",
")",
"!=",
"FUNCTION_DECL",
")",
"return",
"0",
";",
"a",
"=",
"lookup_attribute",
"(",
"\"interrupt\"",
",",
"DECL_ATTRIBUTES",
"(",
"func",
")",
")",
";",
"return",
"a",
"!=",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"FUNC",
"is",
"an",
"interrupt",
"function",
"as",
"specified",
"by",
"the",
"``",
"interrupt",
"''",
"attribute",
"."
] | [
"avr",
"0",
"\"interrupt\""
] | avr3 | interrupt_function_p | avr | MPU | GCC | 18,431 | 41 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"LanaiInstrInfo",
"::",
"optimizeSelect",
"(",
"MachineInstr",
"&",
"MI",
",",
"SmallPtrSetImpl",
"<",
"MachineInstr",
"*",
">",
"&",
"SeenMIs",
",",
"bool",
"PreferFalse",
")",
"const",
"{",
"assert",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Lanai",
"::",
"SELECT",
"&&",
"\"unknown select instruction\"",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"MachineInstr",
"*",
"DefMI",
"=",
"canFoldIntoSelect",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
",",
"MRI",
",",
"this",
")",
";",
"bool",
"Invert",
"=",
"!",
"DefMI",
";",
"if",
"(",
"!",
"DefMI",
")",
"DefMI",
"=",
"canFoldIntoSelect",
"(",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
",",
"MRI",
",",
"this",
")",
";",
"if",
"(",
"!",
"DefMI",
")",
"return",
"nullptr",
";",
"MachineOperand",
"FalseReg",
"=",
"MI",
".",
"getOperand",
"(",
"Invert",
"?",
"1",
":",
"2",
")",
";",
"unsigned",
"DestReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"PreviousClass",
"=",
"MRI",
".",
"getRegClass",
"(",
"FalseReg",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"!",
"MRI",
".",
"constrainRegClass",
"(",
"DestReg",
",",
"PreviousClass",
")",
")",
"return",
"nullptr",
";",
"MachineInstrBuilder",
"NewMI",
"=",
"BuildMI",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"DefMI",
"->",
"getDesc",
"(",
")",
",",
"DestReg",
")",
";",
"const",
"MCInstrDesc",
"&",
"DefDesc",
"=",
"DefMI",
"->",
"getDesc",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"1",
",",
"e",
"=",
"DefDesc",
".",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
"&&",
"!",
"DefDesc",
".",
"OpInfo",
"[",
"i",
"]",
".",
"isPredicate",
"(",
")",
";",
"++",
"i",
")",
"NewMI",
".",
"addOperand",
"(",
"DefMI",
"->",
"getOperand",
"(",
"i",
")",
")",
";",
"unsigned",
"CondCode",
"=",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Invert",
")",
"NewMI",
".",
"addImm",
"(",
"getOppositeCondition",
"(",
"LPCC",
"::",
"CondCode",
"(",
"CondCode",
")",
")",
")",
";",
"else",
"NewMI",
".",
"addImm",
"(",
"CondCode",
")",
";",
"NewMI",
".",
"copyImplicitOps",
"(",
"MI",
")",
";",
"FalseReg",
".",
"setImplicit",
"(",
")",
";",
"NewMI",
".",
"addOperand",
"(",
"FalseReg",
")",
";",
"NewMI",
"->",
"tieOperands",
"(",
"0",
",",
"NewMI",
"->",
"getNumOperands",
"(",
")",
"-",
"1",
")",
";",
"SeenMIs",
".",
"insert",
"(",
"NewMI",
")",
";",
"SeenMIs",
".",
"erase",
"(",
"DefMI",
")",
";",
"if",
"(",
"DefMI",
"->",
"getParent",
"(",
")",
"!=",
"MI",
".",
"getParent",
"(",
")",
")",
"NewMI",
"->",
"clearKillInfo",
"(",
")",
";",
"DefMI",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"NewMI",
";",
"}",
"</s>"
] | [
"Given",
"a",
"select",
"instruction",
"that",
"was",
"understood",
"by",
"analyzeSelect",
"and",
"returned",
"Optimizable",
"=",
"true",
",",
"attempt",
"to",
"optimize",
"MI",
"by",
"merging",
"it",
"with",
"one",
"of",
"its",
"operands",
"."
] | [
"Lanai",
"Lanai",
"Lanai::SELECT",
"\"unknown select instruction\"",
"1",
"2",
"1",
"2",
"0",
"1",
"3",
"0",
"1"
] | LanaiInstrInfo | optimizeSelect | Lanai | CPU | LLVM | 18,432 | 382 | 1 | [] |
[
"<s>",
"const",
"RegisterBank",
"&",
"M88kRegisterBankInfo",
"::",
"getRegBankFromRegClass",
"(",
"const",
"TargetRegisterClass",
"&",
"RC",
",",
"LLT",
"Ty",
")",
"const",
"{",
"switch",
"(",
"RC",
".",
"getID",
"(",
")",
")",
"{",
"case",
"M88k",
"::",
"GPRRCRegClassID",
":",
"case",
"M88k",
"::",
"GPR64RCRegClassID",
":",
"return",
"getRegBank",
"(",
"M88k",
"::",
"GRRegBankID",
")",
";",
"case",
"M88k",
"::",
"XRRCRegClassID",
":",
"return",
"getRegBank",
"(",
"M88k",
"::",
"XRRegBankID",
")",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected register class\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Get",
"a",
"register",
"bank",
"that",
"covers",
"RC",
"."
] | [
"M88k",
"M88k",
"M88k::GPRRCRegClassID",
"M88k::GPR64RCRegClassID",
"M88k::GRRegBankID",
"M88k::XRRCRegClassID",
"M88k::XRRegBankID",
"\"Unexpected register class\""
] | M88kRegisterBankInfo | getRegBankFromRegClass | M88k | MPU | LLVM | 18,433 | 66 | 1 | [] |
[
"<s>",
"rtx",
"rs6000_emit_eqne",
"(",
"machine_mode",
"mode",
",",
"rtx",
"op1",
",",
"rtx",
"op2",
",",
"rtx",
"scratch",
")",
"{",
"if",
"(",
"op2",
"==",
"const0_rtx",
")",
"return",
"op1",
";",
"if",
"(",
"GET_CODE",
"(",
"scratch",
")",
"==",
"SCRATCH",
")",
"scratch",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"if",
"(",
"logical_operand",
"(",
"op2",
",",
"mode",
")",
")",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"scratch",
",",
"gen_rtx_XOR",
"(",
"mode",
",",
"op1",
",",
"op2",
")",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"scratch",
",",
"gen_rtx_PLUS",
"(",
"mode",
",",
"op1",
",",
"negate_rtx",
"(",
"mode",
",",
"op2",
")",
")",
")",
")",
";",
"return",
"scratch",
";",
"}",
"</s>"
] | [
"Emit",
"RTL",
"that",
"sets",
"a",
"register",
"to",
"zero",
"if",
"OP1",
"and",
"OP2",
"are",
"equal",
".",
"SCRATCH",
"can",
"be",
"used",
"as",
"that",
"dest",
"register",
".",
"Return",
"the",
"dest",
"register",
"."
] | [
"rs6000"
] | rs60004 | rs6000_emit_eqne | rs6000 | CPU | GCC | 18,434 | 98 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_branchy_insn",
"(",
"enum",
"rtx_code",
"code",
",",
"const",
"char",
"*",
"template",
",",
"rtx",
"insn",
",",
"rtx",
"*",
"operands",
")",
"{",
"rtx",
"next_insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
";",
"if",
"(",
"next_insn",
"&&",
"GET_CODE",
"(",
"next_insn",
")",
"==",
"JUMP_INSN",
"&&",
"condjump_p",
"(",
"next_insn",
")",
")",
"{",
"rtx",
"src",
"=",
"SET_SRC",
"(",
"PATTERN",
"(",
"next_insn",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"IF_THEN_ELSE",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
"!=",
"code",
")",
"{",
"operands",
"[",
"9",
"]",
"=",
"gen_label_rtx",
"(",
")",
";",
"emit_label_after",
"(",
"operands",
"[",
"9",
"]",
",",
"next_insn",
")",
";",
"INSN_ADDRESSES_NEW",
"(",
"operands",
"[",
"9",
"]",
",",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"next_insn",
")",
")",
"+",
"get_attr_length",
"(",
"next_insn",
")",
")",
";",
"return",
"template",
";",
"}",
"else",
"{",
"int",
"offset",
"=",
"(",
"branch_dest",
"(",
"next_insn",
")",
"-",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"next_insn",
")",
")",
"+",
"4",
")",
";",
"if",
"(",
"offset",
">=",
"-",
"252",
"&&",
"offset",
"<=",
"258",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"IF_THEN_ELSE",
")",
"src",
"=",
"XEXP",
"(",
"src",
",",
"1",
")",
";",
"operands",
"[",
"9",
"]",
"=",
"src",
";",
"return",
"template",
";",
"}",
"}",
"}",
"operands",
"[",
"9",
"]",
"=",
"gen_label_rtx",
"(",
")",
";",
"emit_label_after",
"(",
"operands",
"[",
"9",
"]",
",",
"insn",
")",
";",
"INSN_ADDRESSES_NEW",
"(",
"operands",
"[",
"9",
"]",
",",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"insn",
")",
")",
"+",
"get_attr_length",
"(",
"insn",
")",
")",
";",
"return",
"template",
";",
"}",
"</s>"
] | [
"Output",
"a",
"code",
"sequence",
"for",
"INSN",
"using",
"TEMPL",
"with",
"OPERANDS",
";",
"but",
"before",
",",
"fill",
"in",
"operands",
"9",
"as",
"a",
"label",
"to",
"the",
"successor",
"insn",
".",
"We",
"try",
"to",
"use",
"jump",
"threading",
"where",
"possible",
".",
"IF",
"CODE",
"matches",
"the",
"comparison",
"in",
"the",
"IF_THEN_ELSE",
"of",
"a",
"following",
"jump",
",",
"we",
"assume",
"the",
"jump",
"is",
"taken",
".",
"I.e",
".",
"EQ",
"means",
"follow",
"jmp",
"and",
"bf",
",",
"NE",
"means",
"follow",
"jmp",
"and",
"bt",
",",
"if",
"the",
"address",
"is",
"in",
"range",
"."
] | [
"sh",
"0",
"9",
"9",
"9",
"4",
"252",
"258",
"1",
"9",
"9",
"9",
"9"
] | sh3 | output_branchy_insn | sh | CPU | GCC | 18,435 | 233 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"SILowerI1Copies",
"::",
"getSaluInsertionAtEnd",
"(",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"auto",
"InsertionPt",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"bool",
"TerminatorsUseSCC",
"=",
"false",
";",
"for",
"(",
"auto",
"I",
"=",
"InsertionPt",
",",
"E",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"bool",
"DefsSCC",
";",
"instrDefsUsesSCC",
"(",
"*",
"I",
",",
"DefsSCC",
",",
"TerminatorsUseSCC",
")",
";",
"if",
"(",
"TerminatorsUseSCC",
"||",
"DefsSCC",
")",
"break",
";",
"}",
"if",
"(",
"!",
"TerminatorsUseSCC",
")",
"return",
"InsertionPt",
";",
"while",
"(",
"InsertionPt",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"InsertionPt",
"--",
";",
"bool",
"DefSCC",
",",
"UseSCC",
";",
"instrDefsUsesSCC",
"(",
"*",
"InsertionPt",
",",
"DefSCC",
",",
"UseSCC",
")",
";",
"if",
"(",
"DefSCC",
")",
"return",
"InsertionPt",
";",
"}",
"llvm_unreachable",
"(",
"\"SCC used by terminator but no def in block\"",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"point",
"at",
"the",
"end",
"of",
"the",
"given",
"MBB",
"to",
"insert",
"SALU",
"instructions",
"for",
"lane",
"mask",
"calculation",
"."
] | [
"AMDGPU",
"SI",
"\"SCC used by terminator but no def in block\""
] | SILowerI1Copies1 | getSaluInsertionAtEnd | AMDGPU | GPU | LLVM | 18,436 | 123 | 1 | [] |
[
"<s>",
"static",
"tree",
"make_resolver_func",
"(",
"const",
"tree",
"default_decl",
",",
"const",
"tree",
"ifunc_alias_decl",
",",
"basic_block",
"*",
"empty_bb",
")",
"{",
"char",
"*",
"resolver_name",
";",
"tree",
"decl",
",",
"type",
",",
"decl_name",
",",
"t",
";",
"if",
"(",
"TREE_PUBLIC",
"(",
"default_decl",
")",
"==",
"0",
")",
"{",
"char",
"*",
"ifunc_name",
"=",
"make_unique_name",
"(",
"default_decl",
",",
"\"ifunc\"",
",",
"true",
")",
";",
"symtab",
"->",
"change_decl_assembler_name",
"(",
"ifunc_alias_decl",
",",
"get_identifier",
"(",
"ifunc_name",
")",
")",
";",
"XDELETEVEC",
"(",
"ifunc_name",
")",
";",
"}",
"resolver_name",
"=",
"make_unique_name",
"(",
"default_decl",
",",
"\"resolver\"",
",",
"false",
")",
";",
"type",
"=",
"build_function_type_list",
"(",
"ptr_type_node",
",",
"NULL_TREE",
")",
";",
"decl",
"=",
"build_fn_decl",
"(",
"resolver_name",
",",
"type",
")",
";",
"decl_name",
"=",
"get_identifier",
"(",
"resolver_name",
")",
";",
"SET_DECL_ASSEMBLER_NAME",
"(",
"decl",
",",
"decl_name",
")",
";",
"DECL_NAME",
"(",
"decl",
")",
"=",
"decl_name",
";",
"TREE_USED",
"(",
"decl",
")",
"=",
"1",
";",
"DECL_ARTIFICIAL",
"(",
"decl",
")",
"=",
"1",
";",
"DECL_IGNORED_P",
"(",
"decl",
")",
"=",
"1",
";",
"TREE_PUBLIC",
"(",
"decl",
")",
"=",
"0",
";",
"DECL_UNINLINABLE",
"(",
"decl",
")",
"=",
"1",
";",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"0",
";",
"DECL_EXTERNAL",
"(",
"ifunc_alias_decl",
")",
"=",
"0",
";",
"DECL_CONTEXT",
"(",
"decl",
")",
"=",
"NULL_TREE",
";",
"DECL_INITIAL",
"(",
"decl",
")",
"=",
"make_node",
"(",
"BLOCK",
")",
";",
"DECL_STATIC_CONSTRUCTOR",
"(",
"decl",
")",
"=",
"0",
";",
"if",
"(",
"DECL_COMDAT_GROUP",
"(",
"default_decl",
")",
"||",
"TREE_PUBLIC",
"(",
"default_decl",
")",
")",
"{",
"DECL_COMDAT",
"(",
"decl",
")",
"=",
"1",
";",
"make_decl_one_only",
"(",
"decl",
",",
"DECL_ASSEMBLER_NAME",
"(",
"decl",
")",
")",
";",
"}",
"t",
"=",
"build_decl",
"(",
"UNKNOWN_LOCATION",
",",
"RESULT_DECL",
",",
"NULL_TREE",
",",
"ptr_type_node",
")",
";",
"DECL_ARTIFICIAL",
"(",
"t",
")",
"=",
"1",
";",
"DECL_IGNORED_P",
"(",
"t",
")",
"=",
"1",
";",
"DECL_RESULT",
"(",
"decl",
")",
"=",
"t",
";",
"gimplify_function_tree",
"(",
"decl",
")",
";",
"push_cfun",
"(",
"DECL_STRUCT_FUNCTION",
"(",
"decl",
")",
")",
";",
"*",
"empty_bb",
"=",
"init_lowered_empty_function",
"(",
"decl",
",",
"false",
",",
"profile_count",
"::",
"uninitialized",
"(",
")",
")",
";",
"cgraph_node",
"::",
"add_new_function",
"(",
"decl",
",",
"true",
")",
";",
"symtab",
"->",
"call_cgraph_insertion_hooks",
"(",
"cgraph_node",
"::",
"get_create",
"(",
"decl",
")",
")",
";",
"pop_cfun",
"(",
")",
";",
"gcc_assert",
"(",
"ifunc_alias_decl",
"!=",
"NULL",
")",
";",
"DECL_ATTRIBUTES",
"(",
"ifunc_alias_decl",
")",
"=",
"make_attribute",
"(",
"\"ifunc\"",
",",
"resolver_name",
",",
"DECL_ATTRIBUTES",
"(",
"ifunc_alias_decl",
")",
")",
";",
"cgraph_node",
"::",
"create_same_body_alias",
"(",
"ifunc_alias_decl",
",",
"decl",
")",
";",
"XDELETEVEC",
"(",
"resolver_name",
")",
";",
"return",
"decl",
";",
"}",
"</s>"
] | [
"Make",
"the",
"resolver",
"function",
"decl",
"to",
"dispatch",
"the",
"versions",
"of",
"a",
"multi-",
"versioned",
"function",
",",
"DEFAULT_DECL",
".",
"Create",
"an",
"empty",
"basic",
"block",
"in",
"the",
"resolver",
"and",
"store",
"the",
"pointer",
"in",
"EMPTY_BB",
".",
"Return",
"the",
"decl",
"of",
"the",
"resolver",
"function",
"."
] | [
"i386",
"0",
"\"ifunc\"",
"\"resolver\"",
"1",
"1",
"1",
"0",
"1",
"0",
"0",
"0",
"1",
"1",
"1",
"\"ifunc\""
] | i3867 | make_resolver_func | i386 | CPU | GCC | 18,437 | 355 | 1 | [] |
[
"<s>",
"EVT",
"M680x0TargetLowering",
"::",
"getSetCCResultType",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"LLVMContext",
"&",
"Context",
",",
"EVT",
"VT",
")",
"const",
"{",
"return",
"MVT",
"::",
"i8",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"M680x0",
"M680x0",
"MVT::i8"
] | M680x0ISelLowering | getSetCCResultType | M680x0 | MPU | LLVM | 18,438 | 25 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"override",
"{",
"return",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"MMIX"
] | MMIXFrameLowering | eliminateCallFramePseudoInstr | MMIX | CPU | LLVM | 18,439 | 30 | 1 | [] |
[
"<s>",
"int",
"fp_sethi_p",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"CONST_DOUBLE",
")",
"{",
"REAL_VALUE_TYPE",
"r",
";",
"long",
"i",
";",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"r",
",",
"op",
")",
";",
"REAL_VALUE_TO_TARGET_SINGLE",
"(",
"r",
",",
"i",
")",
";",
"return",
"!",
"SPARC_SIMM13_P",
"(",
"i",
")",
"&&",
"SPARC_SETHI_P",
"(",
"i",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Nonzero",
"if",
"OP",
"is",
"a",
"floating",
"point",
"constant",
"which",
"can",
"be",
"loaded",
"into",
"an",
"integer",
"register",
"using",
"a",
"single",
"sethi",
"instruction",
"."
] | [
"sparc",
"0"
] | sparc3 | fp_sethi_p | sparc | CPU | GCC | 18,440 | 54 | 1 | [] |
[
"<s>",
"void",
"X86AsmPrinter",
"::",
"emitStartOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
".",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatELF",
"(",
")",
")",
"{",
"unsigned",
"FeatureFlagsAnd",
"=",
"0",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-branch\"",
")",
")",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_IBT",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-return\"",
")",
")",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_SHSTK",
";",
"if",
"(",
"FeatureFlagsAnd",
")",
"{",
"if",
"(",
"!",
"TT",
".",
"isArch32Bit",
"(",
")",
"&&",
"!",
"TT",
".",
"isArch64Bit",
"(",
")",
")",
"llvm_unreachable",
"(",
"\"CFProtection used on invalid architecture!\"",
")",
";",
"MCSection",
"*",
"Cur",
"=",
"OutStreamer",
"->",
"getCurrentSectionOnly",
"(",
")",
";",
"MCSection",
"*",
"Nt",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".note.gnu.property\"",
",",
"ELF",
"::",
"SHT_NOTE",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Nt",
")",
";",
"int",
"WordSize",
"=",
"TT",
".",
"isArch64Bit",
"(",
")",
"?",
"8",
":",
"4",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"4",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"8",
"+",
"WordSize",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"ELF",
"::",
"NT_GNU_PROPERTY_TYPE_0",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitBytes",
"(",
"StringRef",
"(",
"\"GNU\"",
",",
"4",
")",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_AND",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"4",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"FeatureFlagsAnd",
")",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"endSection",
"(",
"Nt",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Cur",
")",
";",
"}",
"}",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"OutStreamer",
"->",
"SwitchSection",
"(",
"getObjFileLowering",
"(",
")",
".",
"getTextSection",
"(",
")",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatCOFF",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"S",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"StringRef",
"(",
"\"@feat.00\"",
")",
")",
";",
"OutStreamer",
"->",
"BeginCOFFSymbolDef",
"(",
"S",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolStorageClass",
"(",
"COFF",
"::",
"IMAGE_SYM_CLASS_STATIC",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolType",
"(",
"COFF",
"::",
"IMAGE_SYM_DTYPE_NULL",
")",
";",
"OutStreamer",
"->",
"EndCOFFSymbolDef",
"(",
")",
";",
"int64_t",
"Feat00Flags",
"=",
"0",
";",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86",
")",
"{",
"Feat00Flags",
"|=",
"1",
";",
"}",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cfguard\"",
")",
")",
"Feat00Flags",
"|=",
"0x800",
";",
"OutStreamer",
"->",
"emitSymbolAttribute",
"(",
"S",
",",
"MCSA_Global",
")",
";",
"OutStreamer",
"->",
"emitAssignment",
"(",
"S",
",",
"MCConstantExpr",
"::",
"create",
"(",
"Feat00Flags",
",",
"MMI",
"->",
"getContext",
"(",
")",
")",
")",
";",
"}",
"OutStreamer",
"->",
"emitSyntaxDirective",
"(",
")",
";",
"bool",
"is16",
"=",
"TT",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"CODE16",
";",
"if",
"(",
"M",
".",
"getModuleInlineAsm",
"(",
")",
".",
"empty",
"(",
")",
"&&",
"is16",
")",
"OutStreamer",
"->",
"emitAssemblerFlag",
"(",
"MCAF_Code16",
")",
";",
"}",
"</s>"
] | [
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"start",
"of",
"their",
"file",
"."
] | [
"X86",
"X86",
"0",
"\"cf-protection-branch\"",
"X86",
"\"cf-protection-return\"",
"X86",
"\"CFProtection used on invalid architecture!\"",
"\".note.gnu.property\"",
"8",
"4",
"4",
"4",
"8",
"4",
"4",
"8",
"4",
"4",
"\"GNU\"",
"4",
"X86",
"4",
"4",
"4",
"8",
"\"@feat.00\"",
"0",
"1",
"\"cfguard\"",
"0x800"
] | X86AsmPrinter10 | emitStartOfAsmFile | X86 | CPU | LLVM | 18,441 | 446 | 1 | [] |
[
"<s>",
"ScheduleHazardRecognizer",
"*",
"PPCInstrInfo",
"::",
"CreateTargetHazardRecognizer",
"(",
"const",
"TargetMachine",
"*",
"TM",
",",
"const",
"ScheduleDAG",
"*",
"DAG",
")",
"const",
"{",
"unsigned",
"Directive",
"=",
"TM",
"->",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
".",
"getDarwinDirective",
"(",
")",
";",
"if",
"(",
"Directive",
"==",
"PPC",
"::",
"DIR_440",
"||",
"Directive",
"==",
"PPC",
"::",
"DIR_A2",
")",
"{",
"const",
"InstrItineraryData",
"*",
"II",
"=",
"TM",
"->",
"getInstrItineraryData",
"(",
")",
";",
"return",
"new",
"PPCScoreboardHazardRecognizer",
"(",
"II",
",",
"DAG",
")",
";",
"}",
"return",
"TargetInstrInfoImpl",
"::",
"CreateTargetHazardRecognizer",
"(",
"TM",
",",
"DAG",
")",
";",
"}",
"</s>"
] | [
"Allocate",
"and",
"return",
"a",
"hazard",
"recognizer",
"to",
"use",
"for",
"this",
"target",
"when",
"scheduling",
"the",
"machine",
"instructions",
"before",
"register",
"allocation",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC::DIR_440",
"PPC::DIR_A2",
"PPC"
] | PPCInstrInfo45 | CreateTargetHazardRecognizer | PowerPC | CPU | LLVM | 18,442 | 81 | 1 | [] |
[
"<s>",
"static",
"bool",
"bfin_can_use_doloop_p",
"(",
"const",
"widest_int",
"&",
",",
"const",
"widest_int",
"&",
"iterations_max",
",",
"unsigned",
"int",
",",
"bool",
")",
"{",
"return",
"(",
"wi",
"::",
"ltu_p",
"(",
"iterations_max",
",",
"0xFFFFFFFF",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CAN_USE_DOLOOP_P",
"."
] | [
"bfin",
"0xFFFFFFFF"
] | bfin | bfin_can_use_doloop_p | bfin | DSP | GCC | 18,443 | 32 | 1 | [] |
[
"<s>",
"static",
"void",
"pro_epilogue_adjust_stack",
"(",
"rtx",
"dest",
",",
"rtx",
"src",
",",
"rtx",
"offset",
",",
"int",
"style",
")",
"{",
"rtx",
"insn",
";",
"if",
"(",
"!",
"TARGET_64BIT",
")",
"insn",
"=",
"emit_insn",
"(",
"gen_pro_epilogue_adjust_stack_1",
"(",
"dest",
",",
"src",
",",
"offset",
")",
")",
";",
"else",
"if",
"(",
"x86_64_immediate_operand",
"(",
"offset",
",",
"DImode",
")",
")",
"insn",
"=",
"emit_insn",
"(",
"gen_pro_epilogue_adjust_stack_rex64",
"(",
"dest",
",",
"src",
",",
"offset",
")",
")",
";",
"else",
"{",
"rtx",
"r11",
";",
"gcc_assert",
"(",
"style",
")",
";",
"r11",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"FIRST_REX_INT_REG",
"+",
"3",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"DImode",
",",
"r11",
",",
"offset",
")",
")",
";",
"if",
"(",
"style",
"<",
"0",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_pro_epilogue_adjust_stack_rex64_2",
"(",
"dest",
",",
"src",
",",
"r11",
",",
"offset",
")",
")",
";",
"}",
"if",
"(",
"style",
"<",
"0",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"</s>"
] | [
"Expand",
"prologue",
"or",
"epilogue",
"stack",
"adjustment",
".",
"The",
"pattern",
"exist",
"to",
"put",
"a",
"dependency",
"on",
"all",
"ebp-based",
"memory",
"accesses",
".",
"STYLE",
"should",
"be",
"negative",
"if",
"instructions",
"should",
"be",
"marked",
"as",
"frame",
"related",
",",
"zero",
"if",
"%",
"r11",
"register",
"is",
"live",
"and",
"can",
"not",
"be",
"freely",
"used",
"and",
"positive",
"otherwise",
"."
] | [
"i386",
"3",
"0",
"1",
"0",
"1"
] | i3863 | pro_epilogue_adjust_stack | i386 | CPU | GCC | 18,444 | 142 | 1 | [] |
[
"<s>",
"void",
"aarch64_post_cfi_startproc",
"(",
"FILE",
"*",
"f",
",",
"tree",
"ignored",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"laid_out",
"&&",
"aarch64_return_address_signing_enabled",
"(",
")",
"&&",
"aarch64_ra_sign_key",
"==",
"AARCH64_KEY_B",
")",
"asm_fprintf",
"(",
"f",
",",
"\"\\t.cfi_b_key_frame\\n\"",
")",
";",
"}",
"</s>"
] | [
"Triggered",
"after",
"a",
".cfi_startproc",
"directive",
"is",
"emitted",
"into",
"the",
"assembly",
"file",
".",
"Used",
"to",
"output",
"the",
".cfi_b_key_frame",
"directive",
"when",
"signing",
"the",
"current",
"function",
"with",
"the",
"B",
"key",
"."
] | [
"aarch64",
"\"\\t.cfi_b_key_frame\\n\""
] | aarch64 | aarch64_post_cfi_startproc | aarch64 | CPU | GCC | 18,445 | 38 | 1 | [] |
[
"<s>",
"static",
"void",
"mips16_fp_args",
"(",
"FILE",
"*",
"file",
",",
"int",
"fp_code",
",",
"int",
"from_fp_p",
")",
"{",
"const",
"char",
"*",
"s",
";",
"int",
"gparg",
",",
"fparg",
";",
"unsigned",
"int",
"f",
";",
"gcc_assert",
"(",
"TARGET_OLDABI",
")",
";",
"if",
"(",
"from_fp_p",
")",
"s",
"=",
"\"mfc1\"",
";",
"else",
"s",
"=",
"\"mtc1\"",
";",
"gparg",
"=",
"GP_ARG_FIRST",
";",
"fparg",
"=",
"FP_ARG_FIRST",
";",
"for",
"(",
"f",
"=",
"(",
"unsigned",
"int",
")",
"fp_code",
";",
"f",
"!=",
"0",
";",
"f",
">>=",
"2",
")",
"{",
"if",
"(",
"(",
"f",
"&",
"3",
")",
"==",
"1",
")",
"{",
"if",
"(",
"(",
"fparg",
"&",
"1",
")",
"!=",
"0",
")",
"++",
"fparg",
";",
"fprintf",
"(",
"file",
",",
"\"\\t%s\\t%s,%s\\n\"",
",",
"s",
",",
"reg_names",
"[",
"gparg",
"]",
",",
"reg_names",
"[",
"fparg",
"]",
")",
";",
"}",
"else",
"if",
"(",
"(",
"f",
"&",
"3",
")",
"==",
"2",
")",
"{",
"if",
"(",
"TARGET_64BIT",
")",
"fprintf",
"(",
"file",
",",
"\"\\td%s\\t%s,%s\\n\"",
",",
"s",
",",
"reg_names",
"[",
"gparg",
"]",
",",
"reg_names",
"[",
"fparg",
"]",
")",
";",
"else",
"{",
"if",
"(",
"(",
"fparg",
"&",
"1",
")",
"!=",
"0",
")",
"++",
"fparg",
";",
"if",
"(",
"TARGET_BIG_ENDIAN",
")",
"fprintf",
"(",
"file",
",",
"\"\\t%s\\t%s,%s\\n\\t%s\\t%s,%s\\n\"",
",",
"s",
",",
"reg_names",
"[",
"gparg",
"]",
",",
"reg_names",
"[",
"fparg",
"+",
"1",
"]",
",",
"s",
",",
"reg_names",
"[",
"gparg",
"+",
"1",
"]",
",",
"reg_names",
"[",
"fparg",
"]",
")",
";",
"else",
"fprintf",
"(",
"file",
",",
"\"\\t%s\\t%s,%s\\n\\t%s\\t%s,%s\\n\"",
",",
"s",
",",
"reg_names",
"[",
"gparg",
"]",
",",
"reg_names",
"[",
"fparg",
"]",
",",
"s",
",",
"reg_names",
"[",
"gparg",
"+",
"1",
"]",
",",
"reg_names",
"[",
"fparg",
"+",
"1",
"]",
")",
";",
"++",
"gparg",
";",
"++",
"fparg",
";",
"}",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"++",
"gparg",
";",
"++",
"fparg",
";",
"}",
"}",
"</s>"
] | [
"Write",
"out",
"code",
"to",
"move",
"floating",
"point",
"arguments",
"in",
"or",
"out",
"of",
"general",
"registers",
".",
"Output",
"the",
"instructions",
"to",
"FILE",
".",
"FP_CODE",
"is",
"the",
"code",
"describing",
"which",
"arguments",
"are",
"present",
"(",
"see",
"the",
"comment",
"at",
"the",
"definition",
"of",
"CUMULATIVE_ARGS",
"in",
"mips.h",
")",
".",
"FROM_FP_P",
"is",
"nonzero",
"if",
"we",
"are",
"copying",
"from",
"the",
"floating",
"point",
"registers",
"."
] | [
"mips",
"\"mfc1\"",
"\"mtc1\"",
"0",
"2",
"3",
"1",
"1",
"0",
"\"\\t%s\\t%s,%s\\n\"",
"3",
"2",
"\"\\td%s\\t%s,%s\\n\"",
"1",
"0",
"\"\\t%s\\t%s,%s\\n\\t%s\\t%s,%s\\n\"",
"1",
"1",
"\"\\t%s\\t%s,%s\\n\\t%s\\t%s,%s\\n\"",
"1",
"1"
] | mips3 | mips16_fp_args | mips | CPU | GCC | 18,446 | 264 | 1 | [] |
[
"<s>",
"unsigned",
"SystemZRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"FrameIndexValue",
"*",
"Value",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
"&&",
"\"Unxpected\"",
")",
";",
"unsigned",
"i",
"=",
"0",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"while",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
")",
"{",
"++",
"i",
";",
"assert",
"(",
"i",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
"&&",
"\"Instr doesn't have FrameIndex operand!\"",
")",
";",
"}",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"BasePtr",
"=",
"(",
"hasFP",
"(",
"MF",
")",
"?",
"SystemZ",
"::",
"R11D",
":",
"SystemZ",
"::",
"R15D",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"ChangeToRegister",
"(",
"BasePtr",
",",
"false",
")",
";",
"int",
"Offset",
"=",
"getFrameIndexOffset",
"(",
"MF",
",",
"FrameIndex",
")",
"+",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"1",
")",
".",
"getImm",
"(",
")",
";",
"MI",
".",
"setDesc",
"(",
"TII",
".",
"getMemoryInstr",
"(",
"MI",
".",
"getOpcode",
"(",
")",
",",
"Offset",
")",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"SystemZ",
"SystemZ",
"0",
"\"Unxpected\"",
"0",
"\"Instr doesn't have FrameIndex operand!\"",
"SystemZ::R11D",
"SystemZ::R15D",
"1",
"1",
"0"
] | SystemZRegisterInfo2 | eliminateFrameIndex | SystemZ | CPU | LLVM | 18,447 | 196 | 1 | [] |
[
"<s>",
"bool",
"AArch64PreLegalizerCombiner",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"MF",
".",
"getProperties",
"(",
")",
".",
"hasProperty",
"(",
"MachineFunctionProperties",
"::",
"Property",
"::",
"FailedISel",
")",
")",
"return",
"false",
";",
"auto",
"*",
"TPC",
"=",
"&",
"getAnalysis",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"AArch64PreLegalizerCombinerInfo",
"PCInfo",
";",
"Combiner",
"C",
"(",
"PCInfo",
",",
"TPC",
")",
";",
"return",
"C",
".",
"combineMachineInstrs",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64PreLegalizerCombiner24 | runOnMachineFunction | AArch64 | CPU | LLVM | 18,448 | 62 | 1 | [] |
[
"<s>",
"static",
"bool",
"sh_legitimate_combined_insn",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"p",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"p",
")",
"==",
"SET",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"p",
",",
"0",
")",
")",
"&&",
"GET_MODE",
"(",
"XEXP",
"(",
"p",
",",
"0",
")",
")",
"==",
"SImode",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"p",
",",
"1",
")",
")",
"==",
"ZERO_EXTEND",
"&&",
"MEM_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"p",
",",
"1",
")",
",",
"0",
")",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"function",
"implements",
"the",
"legitimate_combined_insn",
"target",
"hook",
",",
"which",
"the",
"combine",
"pass",
"uses",
"to",
"early",
"reject",
"combined",
"insns",
",",
"before",
"it",
"tries",
"to",
"recog",
"the",
"insn",
"and",
"determine",
"its",
"cost",
"."
] | [
"sh",
"0",
"0",
"1",
"1",
"0"
] | sh | sh_legitimate_combined_insn | sh | CPU | GCC | 18,449 | 82 | 1 | [] |
[
"<s>",
"void",
"X86IntelInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"StringRef",
"Annot",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annot",
")",
";",
"if",
"(",
"CommentStream",
")",
"EmitAnyX86InstComments",
"(",
"MI",
",",
"*",
"CommentStream",
",",
"getRegisterName",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"X86",
"X86",
"X86"
] | X86IntelInstPrinter27 | printInst | X86 | CPU | LLVM | 18,450 | 47 | 1 | [] |
[
"<s>",
"static",
"bool",
"get_memref_parts",
"(",
"rtx",
"mem",
",",
"rtx",
"*",
"base",
",",
"HOST_WIDE_INT",
"*",
"offset",
",",
"HOST_WIDE_INT",
"*",
"size",
")",
"{",
"rtx",
"addr_rtx",
";",
"if",
"(",
"MEM_SIZE_KNOWN_P",
"(",
"mem",
")",
")",
"*",
"size",
"=",
"MEM_SIZE",
"(",
"mem",
")",
";",
"else",
"return",
"false",
";",
"addr_rtx",
"=",
"(",
"XEXP",
"(",
"mem",
",",
"0",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr_rtx",
")",
"==",
"PRE_MODIFY",
")",
"addr_rtx",
"=",
"XEXP",
"(",
"addr_rtx",
",",
"1",
")",
";",
"*",
"offset",
"=",
"0",
";",
"while",
"(",
"GET_CODE",
"(",
"addr_rtx",
")",
"==",
"PLUS",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"addr_rtx",
",",
"1",
")",
")",
")",
"{",
"*",
"offset",
"+=",
"INTVAL",
"(",
"XEXP",
"(",
"addr_rtx",
",",
"1",
")",
")",
";",
"addr_rtx",
"=",
"XEXP",
"(",
"addr_rtx",
",",
"0",
")",
";",
"}",
"if",
"(",
"!",
"REG_P",
"(",
"addr_rtx",
")",
")",
"return",
"false",
";",
"*",
"base",
"=",
"addr_rtx",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Try",
"to",
"determine",
"base/offset/size",
"parts",
"of",
"the",
"given",
"MEM",
".",
"Return",
"true",
"if",
"successful",
",",
"false",
"if",
"all",
"the",
"values",
"could",
"n't",
"be",
"determined",
".",
"This",
"function",
"only",
"looks",
"for",
"REG",
"or",
"REG+CONST",
"address",
"forms",
".",
"REG+REG",
"address",
"form",
"will",
"return",
"false",
"."
] | [
"rs6000",
"0",
"1",
"0",
"1",
"1",
"0"
] | rs60001 | get_memref_parts | rs6000 | CPU | GCC | 18,451 | 139 | 1 | [] |
[
"<s>",
"void",
"Initialize",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"bool",
"isPIC",
")",
"{",
"const",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"ConstPoolId2AddrMap",
".",
"resize",
"(",
"AFI",
"->",
"getNumPICLabels",
"(",
")",
")",
";",
"JumpTableId2AddrMap",
".",
"resize",
"(",
"AFI",
"->",
"getNumJumpTables",
"(",
")",
")",
";",
"IsPIC",
"=",
"isPIC",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMJITInfo4 | Initialize | ARM | CPU | LLVM | 18,452 | 53 | 1 | [] |
[
"<s>",
"bool",
"isToken",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"k_Token",
";",
"}",
"</s>"
] | [
"isToken",
"-",
"Is",
"this",
"a",
"token",
"operand",
"?"
] | [
"Mips"
] | MipsAsmParser (2)4 | isToken | Mips | CPU | LLVM | 18,453 | 13 | 1 | [] |
[
"<s>",
"bool",
"HexagonSplitDoubleRegs",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Splitting double registers in function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"auto",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
";",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"MLI",
"=",
"&",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"UUSetMap",
"P2Rs",
";",
"LoopRegMap",
"IRM",
";",
"collectIndRegs",
"(",
"IRM",
")",
";",
"partitionRegisters",
"(",
"P2Rs",
")",
";",
"LLVM_DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"Register partitioning: (partition #0 is fixed)\\n\"",
";",
"for",
"(",
"UUSetMap",
"::",
"iterator",
"I",
"=",
"P2Rs",
".",
"begin",
"(",
")",
",",
"E",
"=",
"P2Rs",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"dbgs",
"(",
")",
"<<",
"'#'",
"<<",
"I",
"->",
"first",
"<<",
"\" -> \"",
";",
"dump_partition",
"(",
"dbgs",
"(",
")",
",",
"I",
"->",
"second",
",",
"*",
"TRI",
")",
";",
"dbgs",
"(",
")",
"<<",
"'\\n'",
";",
"}",
"}",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"int",
"Limit",
"=",
"MaxHSDR",
";",
"for",
"(",
"UUSetMap",
"::",
"iterator",
"I",
"=",
"P2Rs",
".",
"begin",
"(",
")",
",",
"E",
"=",
"P2Rs",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"first",
"==",
"0",
")",
"continue",
";",
"if",
"(",
"Limit",
">=",
"0",
"&&",
"Counter",
">=",
"Limit",
")",
"break",
";",
"USet",
"&",
"Part",
"=",
"I",
"->",
"second",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Calculating profit for partition #\"",
"<<",
"I",
"->",
"first",
"<<",
"'\\n'",
")",
";",
"if",
"(",
"!",
"isProfitable",
"(",
"Part",
",",
"IRM",
")",
")",
"continue",
";",
"Counter",
"++",
";",
"Changed",
"|=",
"splitPartition",
"(",
"Part",
")",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Hexagon",
"Hexagon",
"\"Splitting double registers in function: \"",
"Hexagon",
"\"Register partitioning: (partition #0 is fixed)\\n\"",
"\" -> \"",
"0",
"0",
"\"Calculating profit for partition #\""
] | HexagonSplitDouble1 | runOnMachineFunction | Hexagon | DSP | LLVM | 18,454 | 290 | 1 | [] |
[
"<s>",
"void",
"FISCMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"Desc",
".",
"getSize",
"(",
")",
"!=",
"4",
")",
"{",
"llvm_unreachable",
"(",
"\"Unexpected instruction size!\"",
")",
";",
"}",
"const",
"uint32_t",
"Binary",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"EmitConstant",
"(",
"Binary",
",",
"Desc",
".",
"getSize",
"(",
")",
",",
"OS",
")",
";",
"++",
"MCNumEmitted",
";",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"FISC",
"FISC",
"4",
"\"Unexpected instruction size!\""
] | FISCMCCodeEmitter | encodeInstruction | FISC | CPU | LLVM | 18,455 | 91 | 1 | [] |
[
"<s>",
"bool",
"M68kFrameLowering",
"::",
"hasReservedCallFrame",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"!",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"hasVarSizedObjects",
"(",
")",
"&&",
"!",
"MF",
".",
"getInfo",
"<",
"M68kMachineFunctionInfo",
">",
"(",
")",
"->",
"getHasPushSequences",
"(",
")",
";",
"}",
"</s>"
] | [
"hasReservedCallFrame",
"-",
"Under",
"normal",
"circumstances",
",",
"when",
"a",
"frame",
"pointer",
"is",
"not",
"required",
",",
"we",
"reserve",
"argument",
"space",
"for",
"call",
"sites",
"in",
"the",
"function",
"immediately",
"on",
"entry",
"to",
"the",
"current",
"function",
"."
] | [
"M68k",
"M68k",
"M68k"
] | M68kFrameLowering | hasReservedCallFrame | M68k | MPU | LLVM | 18,456 | 39 | 1 | [] |
[
"<s>",
"int",
"registers_ok_for_quad_peep",
"(",
"rtx",
"reg1",
",",
"rtx",
"reg2",
")",
"{",
"if",
"(",
"!",
"REG_P",
"(",
"reg1",
")",
"||",
"!",
"REG_P",
"(",
"reg2",
")",
")",
"return",
"0",
";",
"if",
"(",
"!",
"FP_REGNO_P",
"(",
"REGNO",
"(",
"reg1",
")",
")",
"||",
"!",
"FP_REGNO_P",
"(",
"REGNO",
"(",
"reg2",
")",
")",
")",
"return",
"0",
";",
"return",
"(",
"REGNO",
"(",
"reg1",
")",
"==",
"REGNO",
"(",
"reg2",
")",
"-",
"1",
")",
";",
"}",
"</s>"
] | [
"Return",
"1",
"if",
"REGNO",
"(",
"reg1",
")",
"==",
"REGNO",
"(",
"reg2",
")",
"-",
"1",
"making",
"them",
"candidates",
"for",
"lfq",
"and",
"stfq",
"insns",
".",
"Note",
"reg1",
"and",
"reg2",
"*",
"must",
"*",
"be",
"hard",
"registers",
".",
"To",
"be",
"sure",
"we",
"will",
"abort",
"if",
"we",
"are",
"passed",
"pseudo",
"registers",
"."
] | [
"rs6000",
"0",
"0",
"1"
] | rs6000 | registers_ok_for_quad_peep | rs6000 | CPU | GCC | 18,457 | 66 | 1 | [] |
[
"<s>",
"bool",
"Thumb1FrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"bool",
"isVarArg",
"=",
"AFI",
"->",
"getArgRegsSaveSize",
"(",
")",
">",
"0",
";",
"DebugLoc",
"DL",
"=",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"ARM",
"::",
"tPOP",
")",
")",
";",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"bool",
"NumRegs",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"0",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"1",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
"==",
"ARM",
"::",
"LR",
"&&",
"MBB",
".",
"succ_empty",
"(",
")",
")",
"{",
"if",
"(",
"isVarArg",
")",
"continue",
";",
"if",
"(",
"!",
"STI",
".",
"hasV5TOps",
"(",
")",
")",
"continue",
";",
"Reg",
"=",
"ARM",
"::",
"PC",
";",
"(",
"*",
"MIB",
")",
".",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"ARM",
"::",
"tPOP_RET",
")",
")",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"MIB",
".",
"copyImplicitOps",
"(",
"&",
"*",
"MI",
")",
";",
"MI",
"=",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"MIB",
".",
"addReg",
"(",
"Reg",
",",
"getDefRegState",
"(",
"true",
")",
")",
";",
"NumRegs",
"=",
"true",
";",
"}",
"if",
"(",
"NumRegs",
")",
"MBB",
".",
"insert",
"(",
"MI",
",",
"&",
"*",
"MIB",
")",
";",
"else",
"MF",
".",
"DeleteMachineInstr",
"(",
"MIB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] | [
"ARM",
"ARM",
"ARM",
"0",
"ARM::tPOP",
"0",
"1",
"ARM::LR",
"ARM::PC",
"ARM::tPOP_RET"
] | Thumb1FrameLowering (2) | restoreCalleeSavedRegisters | ARM | CPU | LLVM | 18,458 | 300 | 1 | [] |
[
"<s>",
"const",
"MINA32Subtarget",
"*",
"MINA32TargetMachine",
"::",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
")",
"const",
"{",
"return",
"&",
"SubTarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"MINA32",
"MINA32",
"MINA32"
] | MINA32TargetMachine | getSubtargetImpl | MINA32 | CPU | LLVM | 18,459 | 18 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"c6x_function_arg_round_boundary",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
")",
"{",
"return",
"c6x_function_arg_boundary",
"(",
"mode",
",",
"type",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG_ROUND_BOUNDARY",
"."
] | [
"c6x"
] | c6x | c6x_function_arg_round_boundary | c6x | VLIW | GCC | 18,460 | 21 | 1 | [] |
[
"<s>",
"unsigned",
"Cpu0AsmParser",
"::",
"getReg",
"(",
"int",
"RC",
",",
"int",
"RegNo",
")",
"{",
"return",
"*",
"(",
"getContext",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
"->",
"getRegClass",
"(",
"RC",
")",
".",
"begin",
"(",
")",
"+",
"RegNo",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"Cpu0",
"Cpu0"
] | Cpu0AsmParser | getReg | Cpu0 | CPU | LLVM | 18,461 | 36 | 1 | [] |
[
"<s>",
"static",
"rtx",
"gen_pop",
"(",
"rtx",
"arg",
")",
"{",
"if",
"(",
"REG_P",
"(",
"arg",
")",
"&&",
"GET_MODE",
"(",
"arg",
")",
"!=",
"word_mode",
")",
"arg",
"=",
"gen_rtx_REG",
"(",
"word_mode",
",",
"REGNO",
"(",
"arg",
")",
")",
";",
"return",
"gen_rtx_SET",
"(",
"arg",
",",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"gen_rtx_POST_INC",
"(",
"Pmode",
",",
"stack_pointer_rtx",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Generate",
"an",
"``",
"pop",
"''",
"pattern",
"for",
"input",
"ARG",
"."
] | [
"i386"
] | i3865 | gen_pop | i386 | CPU | GCC | 18,462 | 53 | 1 | [] |
[
"<s>",
"void",
"GBZ80FrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"I",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Cannot handle this call frame pseudo instruction\"",
")",
";",
"case",
"GBZ80",
"::",
"ADJCALLSTACKDOWN",
":",
"case",
"GBZ80",
"::",
"ADJCALLSTACKUP",
":",
"break",
";",
"}",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"GBZ80",
"GB",
"\"Cannot handle this call frame pseudo instruction\"",
"GBZ80::ADJCALLSTACKDOWN",
"GBZ80::ADJCALLSTACKUP"
] | GBZ80FrameLowering (2) | eliminateCallFramePseudoInstr | GBZ80 | MPU | LLVM | 18,463 | 64 | 1 | [] |
[
"<s>",
"rtx",
"rs6000_find_base_term",
"(",
"rtx",
"op",
")",
"{",
"rtx",
"base",
";",
"base",
"=",
"op",
";",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"CONST",
")",
"base",
"=",
"XEXP",
"(",
"base",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"PLUS",
")",
"base",
"=",
"XEXP",
"(",
"base",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"UNSPEC",
")",
"switch",
"(",
"XINT",
"(",
"base",
",",
"1",
")",
")",
"{",
"case",
"UNSPEC_TOCREL",
":",
"case",
"UNSPEC_MACHOPIC_OFFSET",
":",
"return",
"XVECEXP",
"(",
"base",
",",
"0",
",",
"0",
")",
";",
"}",
"return",
"op",
";",
"}",
"</s>"
] | [
"Implement",
"FIND_BASE_TERM",
"."
] | [
"rs6000",
"0",
"0",
"1",
"0",
"0"
] | rs6000 | rs6000_find_base_term | rs6000 | CPU | GCC | 18,464 | 90 | 1 | [] |
[
"<s>",
"int",
"AArch64LoadStoreOpt",
"::",
"getMemSize",
"(",
"MachineInstr",
"*",
"MemMI",
")",
"{",
"switch",
"(",
"MemMI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Opcode has unknown size!\"",
")",
";",
"case",
"AArch64",
"::",
"STRSui",
":",
"case",
"AArch64",
"::",
"STURSi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"STRDui",
":",
"case",
"AArch64",
"::",
"STURDi",
":",
"return",
"8",
";",
"case",
"AArch64",
"::",
"STRQui",
":",
"case",
"AArch64",
"::",
"STURQi",
":",
"return",
"16",
";",
"case",
"AArch64",
"::",
"STRWui",
":",
"case",
"AArch64",
"::",
"STURWi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"STRXui",
":",
"case",
"AArch64",
"::",
"STURXi",
":",
"return",
"8",
";",
"case",
"AArch64",
"::",
"LDRSui",
":",
"case",
"AArch64",
"::",
"LDURSi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"LDRDui",
":",
"case",
"AArch64",
"::",
"LDURDi",
":",
"return",
"8",
";",
"case",
"AArch64",
"::",
"LDRQui",
":",
"case",
"AArch64",
"::",
"LDURQi",
":",
"return",
"16",
";",
"case",
"AArch64",
"::",
"LDRWui",
":",
"case",
"AArch64",
"::",
"LDURWi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"LDRXui",
":",
"case",
"AArch64",
"::",
"LDURXi",
":",
"return",
"8",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"memory",
"access",
"."
] | [
"AArch64",
"AArch64",
"\"Opcode has unknown size!\"",
"AArch64::STRSui",
"AArch64::STURSi",
"4",
"AArch64::STRDui",
"AArch64::STURDi",
"8",
"AArch64::STRQui",
"AArch64::STURQi",
"16",
"AArch64::STRWui",
"AArch64::STURWi",
"4",
"AArch64::STRXui",
"AArch64::STURXi",
"8",
"AArch64::LDRSui",
"AArch64::LDURSi",
"4",
"AArch64::LDRDui",
"AArch64::LDURDi",
"8",
"AArch64::LDRQui",
"AArch64::LDURQi",
"16",
"AArch64::LDRWui",
"AArch64::LDURWi",
"4",
"AArch64::LDRXui",
"AArch64::LDURXi",
"8"
] | AArch64LoadStoreOptimizer41 | getMemSize | AArch64 | CPU | LLVM | 18,465 | 158 | 1 | [] |
[
"<s>",
"static",
"bool",
"xtensa_output_addr_const_extra",
"(",
"FILE",
"*",
"fp",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"UNSPEC",
"&&",
"XVECLEN",
"(",
"x",
",",
"0",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"XINT",
"(",
"x",
",",
"1",
")",
")",
"{",
"case",
"UNSPEC_TPOFF",
":",
"output_addr_const",
"(",
"fp",
",",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
";",
"fputs",
"(",
"\"@TPOFF\"",
",",
"fp",
")",
";",
"return",
"true",
";",
"case",
"UNSPEC_DTPOFF",
":",
"output_addr_const",
"(",
"fp",
",",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
";",
"fputs",
"(",
"\"@DTPOFF\"",
",",
"fp",
")",
";",
"return",
"true",
";",
"case",
"UNSPEC_PLT",
":",
"if",
"(",
"flag_pic",
")",
"{",
"output_addr_const",
"(",
"fp",
",",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
";",
"fputs",
"(",
"\"@PLT\"",
",",
"fp",
")",
";",
"return",
"true",
";",
"}",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA",
"."
] | [
"xtensa",
"0",
"1",
"1",
"0",
"0",
"\"@TPOFF\"",
"0",
"0",
"\"@DTPOFF\"",
"0",
"0",
"\"@PLT\""
] | xtensa | xtensa_output_addr_const_extra | xtensa | MPU | GCC | 18,466 | 140 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"WebAssembly Register Numbering\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"WebAssembly",
"\"WebAssembly Register Numbering\""
] | WebAssemblyRegNumbering (2) | getPassName | WebAssembly | Virtual ISA | LLVM | 18,467 | 13 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"arm_identify_fpu_from_isa",
"(",
"sbitmap",
"isa",
")",
"{",
"auto_sbitmap",
"fpubits",
"(",
"isa_num_bits",
")",
";",
"auto_sbitmap",
"cand_fpubits",
"(",
"isa_num_bits",
")",
";",
"bitmap_and",
"(",
"fpubits",
",",
"isa",
",",
"isa_all_fpubits",
")",
";",
"if",
"(",
"bitmap_empty_p",
"(",
"fpubits",
")",
")",
"return",
"\"softvfp\"",
";",
"for",
"(",
"unsigned",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"TARGET_FPU_auto",
";",
"i",
"++",
")",
"{",
"arm_initialize_isa",
"(",
"cand_fpubits",
",",
"all_fpus",
"[",
"i",
"]",
".",
"isa_bits",
")",
";",
"if",
"(",
"bitmap_equal_p",
"(",
"fpubits",
",",
"cand_fpubits",
")",
")",
"return",
"all_fpus",
"[",
"i",
"]",
".",
"name",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Match",
"an",
"ISA",
"feature",
"bitmap",
"to",
"a",
"named",
"FPU",
".",
"We",
"always",
"use",
"the",
"first",
"entry",
"that",
"exactly",
"matches",
"the",
"feature",
"set",
",",
"so",
"that",
"we",
"effectively",
"canonicalize",
"the",
"FPU",
"name",
"for",
"the",
"assembler",
"."
] | [
"arm",
"\"softvfp\"",
"0"
] | arm7 | arm_identify_fpu_from_isa | arm | CPU | GCC | 18,468 | 92 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"MipsDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"Selecting: \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"== \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"Node",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
"nullptr",
";",
"}",
"std",
"::",
"pair",
"<",
"bool",
",",
"SDNode",
"*",
">",
"Ret",
"=",
"selectNode",
"(",
"Node",
")",
";",
"if",
"(",
"Ret",
".",
"first",
")",
"return",
"Ret",
".",
"second",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"GLOBAL_OFFSET_TABLE",
":",
"return",
"getGlobalBaseReg",
"(",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"case",
"ISD",
"::",
"STORE",
":",
"assert",
"(",
"cast",
"<",
"MemSDNode",
">",
"(",
"Node",
")",
"->",
"getMemoryVT",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"/",
"8",
"<=",
"cast",
"<",
"MemSDNode",
">",
"(",
"Node",
")",
"->",
"getAlignment",
"(",
")",
"&&",
"\"Unexpected unaligned loads/stores.\"",
")",
";",
"break",
";",
"}",
"SDNode",
"*",
"ResNode",
"=",
"SelectCode",
"(",
"Node",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"=> \"",
")",
";",
"if",
"(",
"ResNode",
"==",
"nullptr",
"||",
"ResNode",
"==",
"Node",
")",
"DEBUG",
"(",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
")",
";",
"else",
"DEBUG",
"(",
"ResNode",
"->",
"dump",
"(",
"CurDAG",
")",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"return",
"ResNode",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Mips",
"Mips",
"\"Selecting: \"",
"\"\\n\"",
"\"== \"",
"\"\\n\"",
"1",
"ISD::GLOBAL_OFFSET_TABLE",
"ISD::LOAD",
"ISD::STORE",
"8",
"\"Unexpected unaligned loads/stores.\"",
"\"=> \"",
"\"\\n\""
] | MipsISelDAGToDAG33 | Select | Mips | CPU | LLVM | 18,469 | 241 | 1 | [] |
[
"<s>",
"static",
"void",
"alpha_expand_unaligned_load_words",
"(",
"rtx",
"*",
"out_regs",
",",
"rtx",
"smem",
",",
"HOST_WIDE_INT",
"words",
",",
"HOST_WIDE_INT",
"ofs",
")",
"{",
"rtx",
"const",
"im8",
"=",
"GEN_INT",
"(",
"-",
"8",
")",
";",
"rtx",
"ext_tmps",
"[",
"MAX_MOVE_WORDS",
"]",
",",
"data_regs",
"[",
"MAX_MOVE_WORDS",
"+",
"1",
"]",
";",
"rtx",
"sreg",
",",
"areg",
",",
"tmp",
",",
"smema",
";",
"HOST_WIDE_INT",
"i",
";",
"smema",
"=",
"XEXP",
"(",
"smem",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"smema",
")",
"==",
"LO_SUM",
")",
"smema",
"=",
"force_reg",
"(",
"Pmode",
",",
"smema",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"words",
";",
"++",
"i",
")",
"{",
"data_regs",
"[",
"i",
"]",
"=",
"out_regs",
"[",
"i",
"]",
";",
"ext_tmps",
"[",
"i",
"]",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"}",
"data_regs",
"[",
"words",
"]",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"if",
"(",
"ofs",
"!=",
"0",
")",
"smem",
"=",
"adjust_address",
"(",
"smem",
",",
"GET_MODE",
"(",
"smem",
")",
",",
"ofs",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"words",
";",
"++",
"i",
")",
"{",
"tmp",
"=",
"change_address",
"(",
"smem",
",",
"DImode",
",",
"gen_rtx_AND",
"(",
"DImode",
",",
"plus_constant",
"(",
"DImode",
",",
"smema",
",",
"8",
"*",
"i",
")",
",",
"im8",
")",
")",
";",
"set_mem_alias_set",
"(",
"tmp",
",",
"0",
")",
";",
"emit_move_insn",
"(",
"data_regs",
"[",
"i",
"]",
",",
"tmp",
")",
";",
"}",
"tmp",
"=",
"change_address",
"(",
"smem",
",",
"DImode",
",",
"gen_rtx_AND",
"(",
"DImode",
",",
"plus_constant",
"(",
"DImode",
",",
"smema",
",",
"8",
"*",
"words",
"-",
"1",
")",
",",
"im8",
")",
")",
";",
"set_mem_alias_set",
"(",
"tmp",
",",
"0",
")",
";",
"emit_move_insn",
"(",
"data_regs",
"[",
"words",
"]",
",",
"tmp",
")",
";",
"sreg",
"=",
"copy_addr_to_reg",
"(",
"smema",
")",
";",
"areg",
"=",
"expand_binop",
"(",
"DImode",
",",
"and_optab",
",",
"sreg",
",",
"GEN_INT",
"(",
"7",
")",
",",
"NULL",
",",
"1",
",",
"OPTAB_WIDEN",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"words",
";",
"++",
"i",
")",
"{",
"emit_insn",
"(",
"gen_extql",
"(",
"data_regs",
"[",
"i",
"]",
",",
"data_regs",
"[",
"i",
"]",
",",
"sreg",
")",
")",
";",
"emit_insn",
"(",
"gen_extqh",
"(",
"ext_tmps",
"[",
"i",
"]",
",",
"data_regs",
"[",
"i",
"+",
"1",
"]",
",",
"sreg",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"ext_tmps",
"[",
"i",
"]",
",",
"gen_rtx_IF_THEN_ELSE",
"(",
"DImode",
",",
"gen_rtx_EQ",
"(",
"DImode",
",",
"areg",
",",
"const0_rtx",
")",
",",
"const0_rtx",
",",
"ext_tmps",
"[",
"i",
"]",
")",
")",
")",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"words",
";",
"++",
"i",
")",
"{",
"out_regs",
"[",
"i",
"]",
"=",
"expand_binop",
"(",
"DImode",
",",
"ior_optab",
",",
"data_regs",
"[",
"i",
"]",
",",
"ext_tmps",
"[",
"i",
"]",
",",
"data_regs",
"[",
"i",
"]",
",",
"1",
",",
"OPTAB_WIDEN",
")",
";",
"}",
"}",
"</s>"
] | [
"Load",
"an",
"integral",
"number",
"of",
"consecutive",
"unaligned",
"quadwords",
"."
] | [
"alpha",
"8",
"1",
"0",
"0",
"0",
"0",
"8",
"0",
"8",
"1",
"0",
"7",
"1",
"0",
"1",
"0",
"1"
] | alpha | alpha_expand_unaligned_load_words | alpha | MPU | GCC | 18,470 | 411 | 1 | [] |
[
"<s>",
"static",
"void",
"gr5_hazard_avoidance",
"(",
"void",
")",
"{",
"unsigned",
"int",
"last_reg",
"=",
"0",
";",
"bool",
"last_insn_call",
"=",
"false",
";",
"rtx_insn",
"*",
"insn",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"if",
"(",
"INSN_P",
"(",
"insn",
")",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"SEQUENCE",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"XVECLEN",
"(",
"pat",
",",
"0",
")",
";",
"i",
"++",
")",
"gr5_avoid_hazard",
"(",
"as_a",
"<",
"rtx_insn",
"*",
">",
"(",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"i",
")",
")",
",",
"&",
"last_reg",
",",
"&",
"last_insn_call",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"CALL_INSN",
")",
"{",
"last_reg",
"=",
"0",
";",
"last_insn_call",
"=",
"false",
";",
"}",
"else",
"gr5_avoid_hazard",
"(",
"insn",
",",
"&",
"last_reg",
",",
"&",
"last_insn_call",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"BARRIER",
")",
"last_reg",
"=",
"0",
";",
"}",
"</s>"
] | [
"Go",
"through",
"the",
"instruction",
"stream",
"and",
"insert",
"nops",
"where",
"necessary",
"to",
"avoid",
"pipeline",
"hazards",
".",
"There",
"are",
"two",
"cases",
":",
"1",
".",
"On",
"the",
"original",
"architecture",
",",
"it",
"is",
"invalid",
"to",
"set",
"the",
"value",
"of",
"a",
"(",
"base",
")",
"register",
"and",
"then",
"use",
"it",
"in",
"an",
"address",
"with",
"a",
"non-zero",
"index",
"in",
"the",
"next",
"instruction",
".",
"2",
".",
"On",
"the",
"MCM",
",",
"setting",
"the",
"value",
"of",
"a",
"(",
"base",
")",
"register",
"and",
"then",
"using",
"it",
"in",
"address",
"(",
"including",
"with",
"zero",
"index",
")",
"in",
"the",
"next",
"instruction",
"will",
"result",
"in",
"a",
"pipeline",
"stall",
"of",
"3",
"cycles",
"."
] | [
"visium",
"0",
"0",
"0",
"0",
"0",
"0"
] | visium | gr5_hazard_avoidance | visium | Virtual ISA | GCC | 18,471 | 158 | 1 | [] |
[
"<s>",
"PPCTargetLowering",
"::",
"ConstraintType",
"PPCTargetLowering",
"::",
"getConstraintType",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'b'",
":",
"case",
"'r'",
":",
"case",
"'f'",
":",
"case",
"'v'",
":",
"case",
"'y'",
":",
"return",
"C_RegisterClass",
";",
"case",
"'Z'",
":",
"return",
"C_Memory",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getConstraintType",
"(",
"Constraint",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constraint",
"letter",
",",
"return",
"the",
"type",
"of",
"constraint",
"for",
"this",
"target",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"1",
"0"
] | PPCISelLowering (2)1 | getConstraintType | PowerPC | CPU | LLVM | 18,472 | 74 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"AMDGPU",
"::",
"IsaInfo",
"::",
"hasCodeObjectV3",
"(",
"&",
"getSTI",
"(",
")",
")",
")",
"{",
"if",
"(",
"IDVal",
"==",
"\".amdgcn_target\"",
")",
"return",
"ParseDirectiveAMDGCNTarget",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdhsa_kernel\"",
")",
"return",
"ParseDirectiveAMDHSAKernel",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"AMDGPU",
"::",
"HSAMD",
"::",
"V3",
"::",
"AssemblerDirectiveBegin",
")",
"return",
"ParseDirectiveHSAMetadata",
"(",
")",
";",
"}",
"else",
"{",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_version\"",
")",
"return",
"ParseDirectiveHSACodeObjectVersion",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_isa\"",
")",
"return",
"ParseDirectiveHSACodeObjectISA",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amd_kernel_code_t\"",
")",
"return",
"ParseDirectiveAMDKernelCodeT",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_kernel\"",
")",
"return",
"ParseDirectiveAMDGPUHsaKernel",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amd_amdgpu_isa\"",
")",
"return",
"ParseDirectiveISAVersion",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"AMDGPU",
"::",
"HSAMD",
"::",
"AssemblerDirectiveBegin",
")",
"return",
"ParseDirectiveHSAMetadata",
"(",
")",
";",
"}",
"if",
"(",
"IDVal",
"==",
"PALMD",
"::",
"AssemblerDirectiveBegin",
")",
"return",
"ParseDirectivePALMetadataBegin",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"PALMD",
"::",
"AssemblerDirective",
")",
"return",
"ParseDirectivePALMetadata",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::IsaInfo",
"\".amdgcn_target\"",
"\".amdhsa_kernel\"",
"AMDGPU::HSAMD",
"\".hsa_code_object_version\"",
"\".hsa_code_object_isa\"",
"\".amd_kernel_code_t\"",
"\".amdgpu_hsa_kernel\"",
"AMDGPU",
"\".amd_amdgpu_isa\"",
"AMDGPU::HSAMD"
] | AMDGPUAsmParser57 | ParseDirective | AMDGPU | GPU | LLVM | 18,473 | 176 | 1 | [] |
[
"<s>",
"void",
"AVRMCInstLower",
"::",
"lowerInstruction",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"const",
"{",
"OutMI",
".",
"setOpcode",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"for",
"(",
"MachineOperand",
"const",
"&",
"MO",
":",
"MI",
".",
"operands",
"(",
")",
")",
"{",
"MCOperand",
"MCOp",
";",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"default",
":",
"MI",
".",
"print",
"(",
"errs",
"(",
")",
")",
";",
"llvm_unreachable",
"(",
"\"unknown operand type\"",
")",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"if",
"(",
"MO",
".",
"isImplicit",
"(",
")",
")",
"continue",
";",
"MCOp",
"=",
"MCOperand",
"::",
"createReg",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"MCOp",
"=",
"MCOperand",
"::",
"createImm",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"MCOp",
"=",
"lowerSymbolOperand",
"(",
"MO",
",",
"Printer",
".",
"getSymbol",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"MCOp",
"=",
"lowerSymbolOperand",
"(",
"MO",
",",
"Printer",
".",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_MachineBasicBlock",
":",
"MCOp",
"=",
"MCOperand",
"::",
"createExpr",
"(",
"MCSymbolRefExpr",
"::",
"create",
"(",
"MO",
".",
"getMBB",
"(",
")",
"->",
"getSymbol",
"(",
")",
",",
"Ctx",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_RegisterMask",
":",
"continue",
";",
"case",
"MachineOperand",
"::",
"MO_BlockAddress",
":",
"MCOp",
"=",
"lowerSymbolOperand",
"(",
"MO",
",",
"Printer",
".",
"GetBlockAddressSymbol",
"(",
"MO",
".",
"getBlockAddress",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"MCOp",
"=",
"lowerSymbolOperand",
"(",
"MO",
",",
"Printer",
".",
"GetJTISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"MCOp",
"=",
"lowerSymbolOperand",
"(",
"MO",
",",
"Printer",
".",
"GetCPISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"}",
"OutMI",
".",
"addOperand",
"(",
"MCOp",
")",
";",
"}",
"}",
"</s>"
] | [
"Lowers",
"a",
"MachineInstr",
"into",
"a",
"MCInst",
"."
] | [
"AVR",
"AVR",
"\"unknown operand type\""
] | AVRMCInstLower | lowerInstruction | AVR | MPU | LLVM | 18,474 | 292 | 1 | [] |
[
"<s>",
"CountValue",
"*",
"HexagonHardwareLoops",
"::",
"getTripCount",
"(",
"MachineLoop",
"*",
"L",
")",
"const",
"{",
"const",
"MachineInstr",
"*",
"IV_Inst",
"=",
"getCanonicalInductionVariable",
"(",
"L",
")",
";",
"if",
"(",
"IV_Inst",
"==",
"0",
")",
"return",
"0",
";",
"const",
"MachineOperand",
"*",
"IV_Opnd",
";",
"const",
"MachineOperand",
"*",
"InitialValue",
";",
"if",
"(",
"!",
"L",
"->",
"contains",
"(",
"IV_Inst",
"->",
"getOperand",
"(",
"2",
")",
".",
"getMBB",
"(",
")",
")",
")",
"{",
"InitialValue",
"=",
"&",
"IV_Inst",
"->",
"getOperand",
"(",
"1",
")",
";",
"IV_Opnd",
"=",
"&",
"IV_Inst",
"->",
"getOperand",
"(",
"3",
")",
";",
"}",
"else",
"{",
"InitialValue",
"=",
"&",
"IV_Inst",
"->",
"getOperand",
"(",
"3",
")",
";",
"IV_Opnd",
"=",
"&",
"IV_Inst",
"->",
"getOperand",
"(",
"1",
")",
";",
"}",
"for",
"(",
"MachineRegisterInfo",
"::",
"reg_iterator",
"RI",
"=",
"MRI",
"->",
"reg_begin",
"(",
"IV_Opnd",
"->",
"getReg",
"(",
")",
")",
",",
"RE",
"=",
"MRI",
"->",
"reg_end",
"(",
")",
";",
"RI",
"!=",
"RE",
";",
"++",
"RI",
")",
"{",
"IV_Opnd",
"=",
"&",
"RI",
".",
"getOperand",
"(",
")",
";",
"const",
"MachineInstr",
"*",
"MI",
"=",
"IV_Opnd",
"->",
"getParent",
"(",
")",
";",
"if",
"(",
"L",
"->",
"contains",
"(",
"MI",
")",
"&&",
"isCompareEqualsImm",
"(",
"MI",
")",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
";",
"assert",
"(",
"MO",
".",
"isImm",
"(",
")",
"&&",
"\"IV Cmp Operand should be 0\"",
")",
";",
"int64_t",
"ImmVal",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"const",
"MachineInstr",
"*",
"IV_DefInstr",
"=",
"MRI",
"->",
"getVRegDef",
"(",
"IV_Opnd",
"->",
"getReg",
"(",
")",
")",
";",
"assert",
"(",
"L",
"->",
"contains",
"(",
"IV_DefInstr",
"->",
"getParent",
"(",
")",
")",
"&&",
"\"IV definition should occurs in loop\"",
")",
";",
"int64_t",
"iv_value",
"=",
"IV_DefInstr",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"ImmVal",
"==",
"0",
")",
"{",
"if",
"(",
"iv_value",
"!=",
"1",
"&&",
"iv_value",
"!=",
"-",
"1",
")",
"{",
"return",
"0",
";",
"}",
"return",
"new",
"CountValue",
"(",
"InitialValue",
"->",
"getReg",
"(",
")",
",",
"iv_value",
">",
"0",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"InitialValue",
"->",
"isReg",
"(",
")",
"&&",
"\"Expecting register for init value\"",
")",
";",
"const",
"MachineInstr",
"*",
"DefInstr",
"=",
"MRI",
"->",
"getVRegDef",
"(",
"InitialValue",
"->",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"DefInstr",
"&&",
"DefInstr",
"->",
"getOpcode",
"(",
")",
"==",
"Hexagon",
"::",
"TFRI",
")",
"{",
"int64_t",
"count",
"=",
"ImmVal",
"-",
"DefInstr",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"(",
"count",
"%",
"iv_value",
")",
"!=",
"0",
")",
"{",
"return",
"0",
";",
"}",
"return",
"new",
"CountValue",
"(",
"count",
"/",
"iv_value",
")",
";",
"}",
"}",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"The",
"trip",
"count",
"of",
"the",
"original",
"loop",
"."
] | [
"Hexagon",
"Hexagon",
"0",
"0",
"2",
"1",
"3",
"3",
"1",
"2",
"\"IV Cmp Operand should be 0\"",
"\"IV definition should occurs in loop\"",
"2",
"0",
"1",
"1",
"0",
"0",
"\"Expecting register for init value\"",
"Hexagon::TFRI",
"1",
"0",
"0",
"0"
] | HexagonHardwareLoops20 | getTripCount | Hexagon | DSP | LLVM | 18,475 | 383 | 1 | [] |
[
"<s>",
"void",
"MipsInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
")",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Mips",
"::",
"RDHWR",
":",
"case",
"Mips",
"::",
"RDHWR64",
":",
"O",
"<<",
"\"\\t.set\\tpush\\n\"",
";",
"O",
"<<",
"\"\\t.set\\tmips32r2\\n\"",
";",
"}",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Mips",
"::",
"RDHWR",
":",
"case",
"Mips",
"::",
"RDHWR64",
":",
"O",
"<<",
"\"\\n\\t.set\\tpop\"",
";",
"}",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"Mips",
"Mips",
"Mips::RDHWR",
"Mips::RDHWR64",
"\"\\t.set\\tpush\\n\"",
"\"\\t.set\\tmips32r2\\n\"",
"Mips::RDHWR",
"Mips::RDHWR64",
"\"\\n\\t.set\\tpop\""
] | MipsInstPrinter14 | printInst | Mips | CPU | LLVM | 18,476 | 93 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"X86InstrInfo",
"::",
"foldMemoryOperandImpl",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineInstr",
"*",
"MI",
",",
"const",
"SmallVectorImpl",
"<",
"unsigned",
">",
"&",
"Ops",
",",
"MachineInstr",
"*",
"LoadMI",
")",
"const",
"{",
"if",
"(",
"NoFusing",
")",
"return",
"NULL",
";",
"unsigned",
"Alignment",
"=",
"0",
";",
"if",
"(",
"LoadMI",
"->",
"hasOneMemOperand",
"(",
")",
")",
"Alignment",
"=",
"LoadMI",
"->",
"memoperands_begin",
"(",
")",
"->",
"getAlignment",
"(",
")",
";",
"else",
"if",
"(",
"LoadMI",
"->",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"V_SET0",
"||",
"LoadMI",
"->",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"V_SETALLONES",
")",
"Alignment",
"=",
"16",
";",
"if",
"(",
"Ops",
".",
"size",
"(",
")",
"==",
"2",
"&&",
"Ops",
"[",
"0",
"]",
"==",
"0",
"&&",
"Ops",
"[",
"1",
"]",
"==",
"1",
")",
"{",
"unsigned",
"NewOpc",
"=",
"0",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"NULL",
";",
"case",
"X86",
"::",
"TEST8rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP8ri",
";",
"break",
";",
"case",
"X86",
"::",
"TEST16rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP16ri",
";",
"break",
";",
"case",
"X86",
"::",
"TEST32rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP32ri",
";",
"break",
";",
"case",
"X86",
"::",
"TEST64rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP64ri32",
";",
"break",
";",
"}",
"MI",
"->",
"setDesc",
"(",
"get",
"(",
"NewOpc",
")",
")",
";",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"ChangeToImmediate",
"(",
"0",
")",
";",
"}",
"else",
"if",
"(",
"Ops",
".",
"size",
"(",
")",
"!=",
"1",
")",
"return",
"NULL",
";",
"SmallVector",
"<",
"MachineOperand",
",",
"X86AddrNumOperands",
">",
"MOs",
";",
"if",
"(",
"LoadMI",
"->",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"V_SET0",
"||",
"LoadMI",
"->",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"V_SETALLONES",
")",
"{",
"unsigned",
"PICBase",
"=",
"0",
";",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"{",
"if",
"(",
"TM",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
".",
"is64Bit",
"(",
")",
")",
"PICBase",
"=",
"X86",
"::",
"RIP",
";",
"else",
"return",
"false",
";",
"}",
"MachineConstantPool",
"&",
"MCP",
"=",
"*",
"MF",
".",
"getConstantPool",
"(",
")",
";",
"const",
"VectorType",
"*",
"Ty",
"=",
"VectorType",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
")",
",",
"4",
")",
";",
"Constant",
"*",
"C",
"=",
"LoadMI",
"->",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"V_SET0",
"?",
"Constant",
"::",
"getNullValue",
"(",
"Ty",
")",
":",
"Constant",
"::",
"getAllOnesValue",
"(",
"Ty",
")",
";",
"unsigned",
"CPI",
"=",
"MCP",
".",
"getConstantPoolIndex",
"(",
"C",
",",
"16",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"PICBase",
",",
"false",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"1",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"0",
",",
"false",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateCPI",
"(",
"CPI",
",",
"0",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"0",
",",
"false",
")",
")",
";",
"}",
"else",
"{",
"unsigned",
"NumOps",
"=",
"LoadMI",
"->",
"getDesc",
"(",
")",
".",
"getNumOperands",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"NumOps",
"-",
"X86AddrNumOperands",
";",
"i",
"!=",
"NumOps",
";",
"++",
"i",
")",
"MOs",
".",
"push_back",
"(",
"LoadMI",
"->",
"getOperand",
"(",
"i",
")",
")",
";",
"}",
"return",
"foldMemoryOperandImpl",
"(",
"MF",
",",
"MI",
",",
"Ops",
"[",
"0",
"]",
",",
"MOs",
",",
"Alignment",
")",
";",
"}",
"</s>"
] | [
"foldMemoryOperand",
"-",
"Same",
"as",
"the",
"previous",
"version",
"except",
"it",
"allows",
"folding",
"of",
"any",
"load",
"and",
"store",
"from",
"/",
"to",
"any",
"address",
",",
"not",
"just",
"from",
"a",
"specific",
"stack",
"slot",
"."
] | [
"X86",
"X86",
"0",
"X86::V_SET0",
"X86::V_SETALLONES",
"16",
"2",
"0",
"0",
"1",
"1",
"0",
"X86::TEST8rr",
"X86::CMP8ri",
"X86::TEST16rr",
"X86::CMP16ri",
"X86::TEST32rr",
"X86::CMP32ri",
"X86::TEST64rr",
"X86::CMP64ri32",
"1",
"0",
"1",
"X86",
"X86::V_SET0",
"X86::V_SETALLONES",
"0",
"X86",
"X86::RIP",
"4",
"X86::V_SET0",
"16",
"1",
"0",
"0",
"0",
"X86",
"0"
] | X86InstrInfo108 | foldMemoryOperandImpl | X86 | CPU | LLVM | 18,477 | 505 | 1 | [] |
[
"<s>",
"void",
"PIC16InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"const",
"Function",
"*",
"Func",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
")",
";",
"const",
"std",
"::",
"string",
"FuncName",
"=",
"Func",
"->",
"getName",
"(",
")",
";",
"char",
"*",
"tmpName",
"=",
"new",
"char",
"[",
"strlen",
"(",
"FuncName",
".",
"c_str",
"(",
")",
")",
"+",
"6",
"]",
";",
"sprintf",
"(",
"tmpName",
",",
"\"%s.tmp\"",
",",
"FuncName",
".",
"c_str",
"(",
")",
")",
";",
"if",
"(",
"RC",
"==",
"PIC16",
"::",
"GPRRegisterClass",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"PIC16",
"::",
"movf",
")",
",",
"DestReg",
")",
".",
"addImm",
"(",
"FI",
")",
".",
"addExternalSymbol",
"(",
"tmpName",
")",
".",
"addImm",
"(",
"1",
")",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"PIC16",
"::",
"FSR16RegisterClass",
")",
"assert",
"(",
"0",
"&&",
"\"Don't know yet how to load an FSR16 from stack slot\"",
")",
";",
"else",
"assert",
"(",
"0",
"&&",
"\"Can't load this register from stack slot\"",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"PIC16",
"PIC16",
"6",
"\"%s.tmp\"",
"PIC16::GPRRegisterClass",
"PIC16::movf",
"1",
"PIC16::FSR16RegisterClass",
"0",
"\"Don't know yet how to load an FSR16 from stack slot\"",
"0",
"\"Can't load this register from stack slot\""
] | PIC16InstrInfo5 | loadRegFromStackSlot | PIC16 | MPU | LLVM | 18,478 | 181 | 1 | [] |
[
"<s>",
"static",
"void",
"nds32_emit_adjust_frame",
"(",
"rtx",
"to_reg",
",",
"rtx",
"from_reg",
",",
"int",
"adjust_value",
")",
"{",
"rtx",
"tmp_reg",
";",
"rtx",
"frame_adjust_insn",
";",
"rtx",
"adjust_value_rtx",
"=",
"GEN_INT",
"(",
"adjust_value",
")",
";",
"if",
"(",
"adjust_value",
"==",
"0",
")",
"return",
";",
"if",
"(",
"!",
"satisfies_constraint_Is15",
"(",
"adjust_value_rtx",
")",
")",
"{",
"tmp_reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"TA_REGNUM",
")",
";",
"emit_move_insn",
"(",
"tmp_reg",
",",
"adjust_value_rtx",
")",
";",
"frame_adjust_insn",
"=",
"gen_addsi3",
"(",
"to_reg",
",",
"from_reg",
",",
"tmp_reg",
")",
";",
"frame_adjust_insn",
"=",
"emit_insn",
"(",
"frame_adjust_insn",
")",
";",
"rtx",
"plus_rtx",
";",
"rtx",
"set_rtx",
";",
"plus_rtx",
"=",
"plus_constant",
"(",
"Pmode",
",",
"from_reg",
",",
"adjust_value",
")",
";",
"set_rtx",
"=",
"gen_rtx_SET",
"(",
"to_reg",
",",
"plus_rtx",
")",
";",
"add_reg_note",
"(",
"frame_adjust_insn",
",",
"REG_FRAME_RELATED_EXPR",
",",
"set_rtx",
")",
";",
"}",
"else",
"{",
"frame_adjust_insn",
"=",
"gen_addsi3",
"(",
"to_reg",
",",
"from_reg",
",",
"adjust_value_rtx",
")",
";",
"frame_adjust_insn",
"=",
"emit_insn",
"(",
"frame_adjust_insn",
")",
";",
"}",
"RTX_FRAME_RELATED_P",
"(",
"frame_adjust_insn",
")",
"=",
"1",
";",
"}",
"</s>"
] | [
"Function",
"that",
"may",
"creates",
"more",
"instructions",
"for",
"large",
"value",
"on",
"adjusting",
"stack",
"pointer",
".",
"In",
"nds32",
"target",
",",
"'addi",
"'",
"can",
"be",
"used",
"for",
"stack",
"pointer",
"adjustment",
"in",
"prologue/epilogue",
"stage",
".",
"However",
",",
"sometimes",
"there",
"are",
"too",
"many",
"local",
"variables",
"so",
"that",
"the",
"adjustment",
"value",
"is",
"not",
"able",
"to",
"be",
"fit",
"in",
"the",
"'addi",
"'",
"instruction",
".",
"One",
"solution",
"is",
"to",
"move",
"value",
"into",
"a",
"register",
"and",
"then",
"use",
"'add",
"'",
"instruction",
".",
"In",
"practice",
",",
"we",
"use",
"TA_REGNUM",
"(",
"$",
"r15",
")",
"to",
"accomplish",
"this",
"purpose",
"."
] | [
"nds32",
"0",
"1"
] | nds32 | nds32_emit_adjust_frame | nds32 | CPU | GCC | 18,479 | 144 | 1 | [] |
[
"<s>",
"bool",
"HexagonSubtarget",
"::",
"useAA",
"(",
")",
"const",
"{",
"if",
"(",
"OptLevel",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Enable",
"use",
"of",
"alias",
"analysis",
"during",
"code",
"generation",
"(",
"during",
"MI",
"scheduling",
",",
"DAGCombine",
",",
"etc",
".",
")",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonSubtarget (2)1 | useAA | Hexagon | DSP | LLVM | 18,480 | 23 | 1 | [] |
[
"<s>",
"ARMSubtarget",
"::",
"ARMSubtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
")",
":",
"ARMGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"ARMProcFamily",
"(",
"Others",
")",
",",
"HasV4TOps",
"(",
"false",
")",
",",
"HasV5TOps",
"(",
"false",
")",
",",
"HasV5TEOps",
"(",
"false",
")",
",",
"HasV6Ops",
"(",
"false",
")",
",",
"HasV6T2Ops",
"(",
"false",
")",
",",
"HasV7Ops",
"(",
"false",
")",
",",
"HasVFPv2",
"(",
"false",
")",
",",
"HasVFPv3",
"(",
"false",
")",
",",
"HasVFPv4",
"(",
"false",
")",
",",
"HasNEON",
"(",
"false",
")",
",",
"UseNEONForSinglePrecisionFP",
"(",
"false",
")",
",",
"UseMulOps",
"(",
"UseFusedMulOps",
")",
",",
"SlowFPVMLx",
"(",
"false",
")",
",",
"HasVMLxForwarding",
"(",
"false",
")",
",",
"SlowFPBrcc",
"(",
"false",
")",
",",
"InThumbMode",
"(",
"false",
")",
",",
"HasThumb2",
"(",
"false",
")",
",",
"IsMClass",
"(",
"false",
")",
",",
"NoARM",
"(",
"false",
")",
",",
"PostRAScheduler",
"(",
"false",
")",
",",
"IsR9Reserved",
"(",
"ReserveR9",
")",
",",
"UseMovt",
"(",
"false",
")",
",",
"SupportsTailCall",
"(",
"false",
")",
",",
"HasFP16",
"(",
"false",
")",
",",
"HasD16",
"(",
"false",
")",
",",
"HasHardwareDivide",
"(",
"false",
")",
",",
"HasHardwareDivideInARM",
"(",
"false",
")",
",",
"HasT2ExtractPack",
"(",
"false",
")",
",",
"HasDataBarrier",
"(",
"false",
")",
",",
"Pref32BitThumb",
"(",
"false",
")",
",",
"AvoidCPSRPartialUpdate",
"(",
"false",
")",
",",
"AvoidMOVsShifterOperand",
"(",
"false",
")",
",",
"HasRAS",
"(",
"false",
")",
",",
"HasMPExtension",
"(",
"false",
")",
",",
"FPOnlySP",
"(",
"false",
")",
",",
"AllowsUnalignedMem",
"(",
"false",
")",
",",
"Thumb2DSP",
"(",
"false",
")",
",",
"stackAlignment",
"(",
"4",
")",
",",
"CPUString",
"(",
"CPU",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"TargetABI",
"(",
"ARM_ABI_APCS",
")",
"{",
"if",
"(",
"CPUString",
".",
"empty",
"(",
")",
")",
"CPUString",
"=",
"\"generic\"",
";",
"std",
"::",
"string",
"ArchFS",
"=",
"ARM_MC",
"::",
"ParseARMTriple",
"(",
"TT",
",",
"CPUString",
")",
";",
"if",
"(",
"!",
"FS",
".",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"!",
"ArchFS",
".",
"empty",
"(",
")",
")",
"ArchFS",
"=",
"ArchFS",
"+",
"\",\"",
"+",
"FS",
";",
"else",
"ArchFS",
"=",
"FS",
";",
"}",
"ParseSubtargetFeatures",
"(",
"CPUString",
",",
"ArchFS",
")",
";",
"if",
"(",
"!",
"HasV6T2Ops",
"&&",
"hasThumb2",
"(",
")",
")",
"HasV4TOps",
"=",
"HasV5TOps",
"=",
"HasV5TEOps",
"=",
"HasV6Ops",
"=",
"HasV6T2Ops",
"=",
"true",
";",
"SchedModel",
"=",
"getSchedModelForCPU",
"(",
"CPUString",
")",
";",
"InstrItins",
"=",
"getInstrItineraryForCPU",
"(",
"CPUString",
")",
";",
"if",
"(",
"(",
"TT",
".",
"find",
"(",
"\"eabi\"",
")",
"!=",
"std",
"::",
"string",
"::",
"npos",
")",
"||",
"(",
"isTargetIOS",
"(",
")",
"&&",
"isMClass",
"(",
")",
")",
")",
"TargetABI",
"=",
"ARM_ABI_AAPCS",
";",
"if",
"(",
"isAAPCS_ABI",
"(",
")",
")",
"stackAlignment",
"=",
"8",
";",
"if",
"(",
"!",
"isTargetIOS",
"(",
")",
")",
"UseMovt",
"=",
"hasV6T2Ops",
"(",
")",
";",
"else",
"{",
"IsR9Reserved",
"=",
"ReserveR9",
"|",
"!",
"HasV6Ops",
";",
"UseMovt",
"=",
"DarwinUseMOVT",
"&&",
"hasV6T2Ops",
"(",
")",
";",
"SupportsTailCall",
"=",
"!",
"getTargetTriple",
"(",
")",
".",
"isOSVersionLT",
"(",
"5",
",",
"0",
")",
";",
"}",
"if",
"(",
"!",
"isThumb",
"(",
")",
"||",
"hasThumb2",
"(",
")",
")",
"PostRAScheduler",
"=",
"true",
";",
"if",
"(",
"!",
"StrictAlign",
"&&",
"hasV6Ops",
"(",
")",
"&&",
"isTargetDarwin",
"(",
")",
")",
"AllowsUnalignedMem",
"=",
"true",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"4",
"ARM",
"\"generic\"",
"ARM",
"ARM",
"\",\"",
"\"eabi\"",
"ARM",
"8",
"5",
"0"
] | ARMSubtarget36 | ARMSubtarget | ARM | CPU | LLVM | 18,481 | 465 | 1 | [] |
[
"<s>",
"unsigned",
"PatmosInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Patmos",
"::",
"SWC",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Patmos",
"::",
"SHC",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Patmos",
"::",
"SBC",
")",
"{",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"4",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"Patmos",
"Patmos",
"Patmos::SWC",
"Patmos::SHC",
"Patmos::SBC",
"2",
"3",
"3",
"0",
"2",
"4",
"0"
] | PatmosInstrInfo1 | isStoreToStackSlot | Patmos | VLIW | LLVM | 18,482 | 118 | 1 | [] |
[
"<s>",
"static",
"int",
"mips_move_to_gpr_cost",
"(",
"reg_class_t",
"from",
")",
"{",
"switch",
"(",
"from",
")",
"{",
"case",
"M16_REGS",
":",
"case",
"GENERAL_REGS",
":",
"return",
"2",
";",
"case",
"ACC_REGS",
":",
"return",
"6",
";",
"case",
"FP_REGS",
":",
"return",
"4",
";",
"case",
"COP0_REGS",
":",
"case",
"COP2_REGS",
":",
"case",
"COP3_REGS",
":",
"return",
"5",
";",
"default",
":",
"return",
"0",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"moving",
"a",
"value",
"from",
"a",
"register",
"of",
"class",
"FROM",
"to",
"a",
"GPR",
".",
"Return",
"0",
"for",
"classes",
"that",
"are",
"unions",
"of",
"other",
"classes",
"handled",
"by",
"this",
"function",
"."
] | [
"mips",
"2",
"6",
"4",
"5",
"0"
] | mips | mips_move_to_gpr_cost | mips | CPU | GCC | 18,483 | 53 | 1 | [] |
[
"<s>",
"static",
"enum",
"internal_test",
"map_test_to_internal_test",
"(",
"enum",
"rtx_code",
"test_code",
")",
"{",
"enum",
"internal_test",
"test",
"=",
"ITEST_MAX",
";",
"switch",
"(",
"test_code",
")",
"{",
"default",
":",
"break",
";",
"case",
"EQ",
":",
"test",
"=",
"ITEST_EQ",
";",
"break",
";",
"case",
"NE",
":",
"test",
"=",
"ITEST_NE",
";",
"break",
";",
"case",
"GT",
":",
"test",
"=",
"ITEST_GT",
";",
"break",
";",
"case",
"GE",
":",
"test",
"=",
"ITEST_GE",
";",
"break",
";",
"case",
"LT",
":",
"test",
"=",
"ITEST_LT",
";",
"break",
";",
"case",
"LE",
":",
"test",
"=",
"ITEST_LE",
";",
"break",
";",
"case",
"GTU",
":",
"test",
"=",
"ITEST_GTU",
";",
"break",
";",
"case",
"GEU",
":",
"test",
"=",
"ITEST_GEU",
";",
"break",
";",
"case",
"LTU",
":",
"test",
"=",
"ITEST_LTU",
";",
"break",
";",
"case",
"LEU",
":",
"test",
"=",
"ITEST_LEU",
";",
"break",
";",
"}",
"return",
"test",
";",
"}",
"</s>"
] | [
"Make",
"normal",
"rtx_code",
"into",
"something",
"we",
"can",
"index",
"from",
"an",
"array"
] | [
"xtensa"
] | xtensa | map_test_to_internal_test | xtensa | MPU | GCC | 18,484 | 120 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isFMAFasterThanFMulAndFAdd",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"hasAnyFMA",
"(",
")",
")",
"return",
"false",
";",
"VT",
"=",
"VT",
".",
"getScalarType",
"(",
")",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"switch",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"case",
"MVT",
"::",
"f16",
":",
"return",
"Subtarget",
".",
"hasFP16",
"(",
")",
";",
"case",
"MVT",
"::",
"f32",
":",
"case",
"MVT",
"::",
"f64",
":",
"return",
"true",
";",
"default",
":",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"an",
"FMA",
"operation",
"is",
"faster",
"than",
"a",
"pair",
"of",
"fmul",
"and",
"fadd",
"instructions",
"."
] | [
"X86",
"X86",
"MVT::f16",
"MVT::f32",
"MVT::f64"
] | X86ISelLowering (2)5 | isFMAFasterThanFMulAndFAdd | X86 | CPU | LLVM | 18,485 | 92 | 1 | [] |
[
"<s>",
"int",
"arc_output_addsi",
"(",
"rtx",
"*",
"operands",
",",
"bool",
"cond_p",
",",
"bool",
"output_p",
")",
"{",
"char",
"format",
"[",
"35",
"]",
";",
"int",
"match",
"=",
"operands_match_p",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"1",
"]",
")",
";",
"int",
"match2",
"=",
"operands_match_p",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"2",
"]",
")",
";",
"int",
"intval",
"=",
"(",
"REG_P",
"(",
"operands",
"[",
"2",
"]",
")",
"?",
"1",
":",
"CONST_INT_P",
"(",
"operands",
"[",
"2",
"]",
")",
"?",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
":",
"0xbadc057",
")",
";",
"int",
"neg_intval",
"=",
"-",
"intval",
";",
"int",
"short_0",
"=",
"satisfies_constraint_Rcq",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"int",
"short_p",
"=",
"(",
"!",
"cond_p",
"&&",
"short_0",
"&&",
"satisfies_constraint_Rcq",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"int",
"ret",
"=",
"0",
";",
"if",
"(",
"output_p",
")",
"\\",
"output_asm_insn",
"(",
"FORMAT",
",",
"operands",
")",
";",
"\\",
"return",
"ret",
";",
"\\",
"}",
"</s>"
] | [
"Emit",
"code",
"for",
"an",
"addsi3",
"instruction",
"with",
"OPERANDS",
".",
"COND_P",
"indicates",
"if",
"this",
"will",
"use",
"conditional",
"execution",
".",
"Return",
"the",
"length",
"of",
"the",
"instruction",
".",
"If",
"OUTPUT_P",
"is",
"false",
",",
"do",
"n't",
"actually",
"output",
"the",
"instruction",
",",
"just",
"return",
"its",
"length",
"."
] | [
"arc",
"35",
"0",
"1",
"0",
"2",
"2",
"1",
"2",
"2",
"0xbadc057",
"0",
"1",
"0"
] | arc6 | arc_output_addsi | arc | MPU | GCC | 18,486 | 143 | 1 | [] |
[
"<s>",
"static",
"section",
"*",
"rs6000_xcoff_select_rtx_section",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"unsigned",
"HOST_WIDE_INT",
"align",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"ASM_OUTPUT_SPECIAL_POOL_ENTRY_P",
"(",
"x",
",",
"mode",
")",
")",
"return",
"toc_section",
";",
"else",
"return",
"read_only_private_data_section",
";",
"}",
"</s>"
] | [
"Select",
"section",
"for",
"constant",
"in",
"constant",
"pool",
".",
"On",
"RS/6000",
",",
"all",
"constants",
"are",
"in",
"the",
"private",
"read-only",
"data",
"area",
".",
"However",
",",
"if",
"this",
"is",
"being",
"placed",
"in",
"the",
"TOC",
"it",
"must",
"be",
"output",
"as",
"a",
"toc",
"entry",
"."
] | [
"powerpcspe"
] | powerpcspe | rs6000_xcoff_select_rtx_section | powerpcspe | CPU | GCC | 18,487 | 34 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"Patmos Single-Path Info\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Patmos",
"\"Patmos Single-Path Info\""
] | PatmosSinglePathInfo | getPassName | Patmos | VLIW | LLVM | 18,488 | 13 | 1 | [] |
[
"<s>",
"static",
"bool",
"expand_vec_perm_movs",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"machine_mode",
"vmode",
"=",
"d",
"->",
"vmode",
";",
"unsigned",
"i",
",",
"nelt",
"=",
"d",
"->",
"nelt",
";",
"rtx",
"x",
";",
"if",
"(",
"d",
"->",
"one_operand_p",
")",
"return",
"false",
";",
"if",
"(",
"!",
"(",
"TARGET_SSE",
"&&",
"(",
"vmode",
"==",
"V4SFmode",
"||",
"vmode",
"==",
"V4SImode",
")",
")",
"&&",
"!",
"(",
"TARGET_MMX_WITH_SSE",
"&&",
"(",
"vmode",
"==",
"V2SFmode",
"||",
"vmode",
"==",
"V2SImode",
")",
")",
"&&",
"!",
"(",
"TARGET_SSE2",
"&&",
"(",
"vmode",
"==",
"V2DFmode",
"||",
"vmode",
"==",
"V2DImode",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
"!=",
"nelt",
"&&",
"d",
"->",
"perm",
"[",
"0",
"]",
"!=",
"0",
")",
"return",
"false",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"if",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"!=",
"i",
"+",
"nelt",
"-",
"d",
"->",
"perm",
"[",
"0",
"]",
")",
"return",
"false",
";",
"if",
"(",
"d",
"->",
"testing_p",
")",
"return",
"true",
";",
"if",
"(",
"d",
"->",
"perm",
"[",
"0",
"]",
"==",
"nelt",
")",
"x",
"=",
"gen_rtx_VEC_MERGE",
"(",
"vmode",
",",
"d",
"->",
"op1",
",",
"d",
"->",
"op0",
",",
"GEN_INT",
"(",
"1",
")",
")",
";",
"else",
"x",
"=",
"gen_rtx_VEC_MERGE",
"(",
"vmode",
",",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
",",
"GEN_INT",
"(",
"1",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"d",
"->",
"target",
",",
"x",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"ix86_expand_vec_perm_builtin_1",
".",
"Try",
"to",
"implement",
"D",
"using",
"movss",
"or",
"movsd",
"."
] | [
"i386",
"0",
"0",
"0",
"1",
"0",
"0",
"1",
"1"
] | i386-expand1 | expand_vec_perm_movs | i386 | CPU | GCC | 18,489 | 224 | 1 | [] |
[
"<s>",
"ScheduleDAGInstrs",
"*",
"createPostMachineScheduler",
"(",
"MachineSchedContext",
"*",
"C",
")",
"const",
"override",
"{",
"const",
"AArch64Subtarget",
"&",
"ST",
"=",
"C",
"->",
"MF",
"->",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"ScheduleDAGMI",
"*",
"DAG",
"=",
"new",
"ScheduleDAGMI",
"(",
"C",
",",
"std",
"::",
"make_unique",
"<",
"AArch64PostRASchedStrategy",
">",
"(",
"C",
")",
",",
"true",
")",
";",
"if",
"(",
"ST",
".",
"hasFusion",
"(",
")",
")",
"{",
"DAG",
"->",
"addMutation",
"(",
"createAArch64MacroFusionDAGMutation",
"(",
")",
")",
";",
"return",
"DAG",
";",
"}",
"return",
"DAG",
";",
"}",
"</s>"
] | [
"Similar",
"to",
"createMachineScheduler",
"but",
"used",
"when",
"postRA",
"machine",
"scheduling",
"is",
"enabled",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine41 | createPostMachineScheduler | AArch64 | CPU | LLVM | 18,490 | 75 | 1 | [] |
[
"<s>",
"void",
"Mips16InstrInfo",
"::",
"adjustStackPtr",
"(",
"unsigned",
"SP",
",",
"int64_t",
"Amount",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"I",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Amount",
")",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Mips",
"::",
"AddiuSpImmX16",
")",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"else",
"adjustStackPtrBigUnrestricted",
"(",
"SP",
",",
"Amount",
",",
"MBB",
",",
"I",
")",
";",
"}",
"</s>"
] | [
"Adjust",
"SP",
"by",
"Amount",
"bytes",
"."
] | [
"Mips",
"Mips",
"16",
"Mips::AddiuSpImmX16"
] | Mips16InstrInfo21 | adjustStackPtr | Mips | CPU | LLVM | 18,491 | 87 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"lowerInterleavedLoad",
"(",
"LoadInst",
"*",
"LI",
",",
"ArrayRef",
"<",
"ShuffleVectorInst",
"*",
">",
"Shuffles",
",",
"ArrayRef",
"<",
"unsigned",
">",
"Indices",
",",
"unsigned",
"Factor",
")",
"const",
"{",
"assert",
"(",
"Factor",
">=",
"2",
"&&",
"Factor",
"<=",
"getMaxSupportedInterleaveFactor",
"(",
")",
"&&",
"\"Invalid interleave factor\"",
")",
";",
"assert",
"(",
"!",
"Shuffles",
".",
"empty",
"(",
")",
"&&",
"\"Empty shufflevector input\"",
")",
";",
"assert",
"(",
"Shuffles",
".",
"size",
"(",
")",
"==",
"Indices",
".",
"size",
"(",
")",
"&&",
"\"Unmatched number of shufflevectors and indices\"",
")",
";",
"IRBuilder",
"<",
">",
"Builder",
"(",
"LI",
")",
";",
"X86InterleavedAccessGroup",
"Grp",
"(",
"LI",
",",
"Shuffles",
",",
"Indices",
",",
"Factor",
",",
"Subtarget",
",",
"Builder",
")",
";",
"return",
"Grp",
".",
"isSupported",
"(",
")",
"&&",
"Grp",
".",
"lowerIntoOptimizedSequence",
"(",
")",
";",
"}",
"</s>"
] | [
"Lower",
"interleaved",
"load",
"(",
"s",
")",
"into",
"target",
"specific",
"instructions/intrinsics",
"."
] | [
"X86",
"X86",
"2",
"\"Invalid interleave factor\"",
"\"Empty shufflevector input\"",
"\"Unmatched number of shufflevectors and indices\"",
"X86"
] | X86InterleavedAccess | lowerInterleavedLoad | X86 | CPU | LLVM | 18,492 | 109 | 1 | [] |
[
"<s>",
"void",
"PPCMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"verifyInstructionPredicates",
"(",
"MI",
",",
"computeAvailableFeatures",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
")",
")",
";",
"uint64_t",
"Bits",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"unsigned",
"Size",
"=",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"support",
"::",
"endianness",
"E",
"=",
"IsLittleEndian",
"?",
"support",
"::",
"little",
":",
"support",
"::",
"big",
";",
"switch",
"(",
"Size",
")",
"{",
"case",
"0",
":",
"break",
";",
"case",
"4",
":",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint32_t",
">",
"(",
"OS",
",",
"Bits",
",",
"E",
")",
";",
"break",
";",
"case",
"8",
":",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint32_t",
">",
"(",
"OS",
",",
"Bits",
">>",
"32",
",",
"E",
")",
";",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint32_t",
">",
"(",
"OS",
",",
"Bits",
",",
"E",
")",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Invalid instruction size\"",
")",
";",
"}",
"++",
"MCNumEmitted",
";",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"PowerPC",
"PPC",
"support::endianness",
"support::little",
"support::big",
"0",
"4",
"support::endian",
"8",
"support::endian",
"32",
"support::endian",
"\"Invalid instruction size\""
] | PPCMCCodeEmitter13 | encodeInstruction | PowerPC | CPU | LLVM | 18,493 | 159 | 1 | [] |
[
"<s>",
"DecodeStatus",
"Mips64Disassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"instr",
",",
"uint64_t",
"&",
"Size",
",",
"const",
"MemoryObject",
"&",
"Region",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"vStream",
",",
"raw_ostream",
"&",
"cStream",
")",
"const",
"{",
"uint32_t",
"Insn",
";",
"DecodeStatus",
"Result",
"=",
"readInstruction32",
"(",
"Region",
",",
"Address",
",",
"Size",
",",
"Insn",
",",
"isBigEndian",
")",
";",
"if",
"(",
"Result",
"==",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"Result",
"=",
"decodeMips64Instruction32",
"(",
"instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"{",
"Size",
"=",
"4",
";",
"return",
"Result",
";",
"}",
"Result",
"=",
"decodeMipsInstruction32",
"(",
"instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"{",
"Size",
"=",
"4",
";",
"return",
"Result",
";",
"}",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"Mips",
"Mips",
"Mips",
"4",
"Mips",
"4"
] | MipsDisassembler23 | getInstruction | Mips | CPU | LLVM | 18,494 | 133 | 1 | [] |
[
"<s>",
"MCDisassembler",
"::",
"DecodeStatus",
"JVMDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"MI",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
",",
"raw_ostream",
"&",
"OS",
",",
"raw_ostream",
"&",
"CS",
")",
"const",
"{",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"JVM",
"JVM"
] | JVMDisassembler | getInstruction | JVM | Virtual ISA | LLVM | 18,495 | 39 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_file_end",
"(",
"void",
")",
"{",
"hash_table",
"<",
"tree_hasher",
">",
"::",
"iterator",
"iter",
";",
"tree",
"decl",
";",
"FOR_EACH_HASH_TABLE_ELEMENT",
"(",
"*",
"needed_fndecls_htab",
",",
"decl",
",",
"tree",
",",
"iter",
")",
"nvptx_record_fndecl",
"(",
"decl",
")",
";",
"fputs",
"(",
"func_decls",
".",
"str",
"(",
")",
".",
"c_str",
"(",
")",
",",
"asm_out_file",
")",
";",
"if",
"(",
"oacc_bcast_size",
")",
"write_shared_buffer",
"(",
"asm_out_file",
",",
"oacc_bcast_sym",
",",
"oacc_bcast_align",
",",
"oacc_bcast_size",
")",
";",
"if",
"(",
"worker_red_size",
")",
"write_shared_buffer",
"(",
"asm_out_file",
",",
"worker_red_sym",
",",
"worker_red_align",
",",
"worker_red_size",
")",
";",
"if",
"(",
"vector_red_size",
")",
"write_shared_buffer",
"(",
"asm_out_file",
",",
"vector_red_sym",
",",
"vector_red_align",
",",
"vector_red_size",
")",
";",
"if",
"(",
"gang_private_shared_size",
")",
"write_shared_buffer",
"(",
"asm_out_file",
",",
"gang_private_shared_sym",
",",
"gang_private_shared_align",
",",
"gang_private_shared_size",
")",
";",
"if",
"(",
"need_softstack_decl",
")",
"{",
"write_var_marker",
"(",
"asm_out_file",
",",
"false",
",",
"true",
",",
"\"__nvptx_stacks\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\".extern .shared .u%d __nvptx_stacks[32];\\n\"",
",",
"POINTER_SIZE",
")",
";",
"}",
"if",
"(",
"need_unisimt_decl",
")",
"{",
"write_var_marker",
"(",
"asm_out_file",
",",
"false",
",",
"true",
",",
"\"__nvptx_uni\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\".extern .shared .u32 __nvptx_uni[32];\\n\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Write",
"out",
"the",
"function",
"declarations",
"we",
"'ve",
"collected",
"."
] | [
"nvptx",
"\"__nvptx_stacks\"",
"\".extern .shared .u%d __nvptx_stacks[32];\\n\"",
"\"__nvptx_uni\"",
"\".extern .shared .u32 __nvptx_uni[32];\\n\""
] | nvptx | nvptx_file_end | nvptx | GPU | GCC | 18,496 | 160 | 1 | [] |
[
"<s>",
"virtual",
"const",
"MipsRegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
"->",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"Mips",
"Mips"
] | MipsTargetMachine1 | getRegisterInfo | Mips | CPU | LLVM | 18,497 | 18 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_function_arg_advance",
"(",
"cumulative_args_t",
"cum_v",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
"ATTRIBUTE_UNUSED",
",",
"bool",
"named",
"ATTRIBUTE_UNUSED",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"if",
"(",
"mode",
"==",
"TImode",
")",
"cum",
"->",
"count",
"+=",
"2",
";",
"else",
"cum",
"->",
"count",
"++",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG_ADVANCE",
"."
] | [
"nvptx",
"2"
] | nvptx2 | nvptx_function_arg_advance | nvptx | GPU | GCC | 18,498 | 47 | 1 | [] |
[
"<s>",
"bool",
"PPCTargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
",",
"unsigned",
",",
"MachineMemOperand",
"::",
"Flags",
",",
"bool",
"*",
"Fast",
")",
"const",
"{",
"if",
"(",
"DisablePPCUnaligned",
")",
"return",
"false",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
".",
"isVector",
"(",
")",
")",
"{",
"if",
"(",
"Subtarget",
".",
"hasVSX",
"(",
")",
")",
"{",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"v2f64",
"&&",
"VT",
"!=",
"MVT",
"::",
"v2i64",
"&&",
"VT",
"!=",
"MVT",
"::",
"v4f32",
"&&",
"VT",
"!=",
"MVT",
"::",
"v4i32",
")",
"return",
"false",
";",
"}",
"else",
"{",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"ppcf128",
")",
"return",
"false",
";",
"if",
"(",
"Fast",
")",
"*",
"Fast",
"=",
"true",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"MVT::v2f64",
"MVT::v2i64",
"MVT::v4f32",
"MVT::v4i32",
"MVT::ppcf128"
] | PPCISelLowering103 | allowsMisalignedMemoryAccesses | PowerPC | CPU | LLVM | 18,499 | 124 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.