ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"void",
"Thumb2InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"RC",
"==",
"ARM",
"::",
"GPRRegisterClass",
"||",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
"||",
"RC",
"==",
"ARM",
"::",
"tcGPRRegisterClass",
"||",
"RC",
"==",
"ARM",
"::",
"rGPRRegisterClass",
")",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"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",
",",
"TRI",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::GPRRegisterClass",
"ARM::tGPRRegisterClass",
"ARM::tcGPRRegisterClass",
"ARM::rGPRRegisterClass",
"0",
"ARM::t2STRi12",
"0",
"ARM"
] | Thumb2InstrInfo15 | storeRegToStackSlot | ARM | CPU | LLVM | 17,600 | 208 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_reorg",
"(",
"void",
")",
"{",
"compute_bb_for_insn",
"(",
")",
";",
"if",
"(",
"flag_mitigate_rop",
")",
"ix86_mitigate_rop",
"(",
")",
";",
"if",
"(",
"TARGET_SEH",
"&&",
"current_function_has_exception_handlers",
"(",
")",
")",
"ix86_seh_fixup_eh_fallthru",
"(",
")",
";",
"if",
"(",
"optimize",
"&&",
"optimize_function_for_speed_p",
"(",
"cfun",
")",
")",
"{",
"if",
"(",
"TARGET_PAD_SHORT_FUNCTION",
")",
"ix86_pad_short_function",
"(",
")",
";",
"else",
"if",
"(",
"TARGET_PAD_RETURNS",
")",
"ix86_pad_returns",
"(",
")",
";",
"if",
"(",
"TARGET_FOUR_JUMP_LIMIT",
")",
"ix86_avoid_jump_mispredicts",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"machine",
"specific",
"optimizations",
".",
"We",
"implement",
"padding",
"of",
"returns",
"for",
"K8",
"CPUs",
"and",
"pass",
"to",
"avoid",
"4",
"jumps",
"in",
"the",
"single",
"16",
"byte",
"window",
"."
] | [
"i386"
] | i3865 | ix86_reorg | i386 | CPU | GCC | 17,601 | 68 | 1 | [] |
[
"<s>",
"const",
"unsigned",
"*",
"TMS320C64XRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"static",
"const",
"unsigned",
"nonvolatileRegs",
"[",
"]",
"=",
"{",
"TMS320C64X",
"::",
"A10",
",",
"TMS320C64X",
"::",
"A11",
",",
"TMS320C64X",
"::",
"A12",
",",
"TMS320C64X",
"::",
"A13",
",",
"TMS320C64X",
"::",
"B10",
",",
"TMS320C64X",
"::",
"B11",
",",
"TMS320C64X",
"::",
"B12",
",",
"TMS320C64X",
"::",
"B13",
",",
"0",
"}",
";",
"return",
"nonvolatileRegs",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"TMS320C64X",
"TMS320C64X",
"TMS320C64X::A10",
"TMS320C64X::A11",
"TMS320C64X::A12",
"TMS320C64X::A13",
"TMS320C64X::B10",
"TMS320C64X::B11",
"TMS320C64X::B12",
"TMS320C64X::B13",
"0"
] | TMS320C64XRegisterInfo | getCalleeSavedRegs | TMS320C64X | VLIW | LLVM | 17,602 | 61 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"*",
"MipsSETargetLowering",
"::",
"EmitInstrWithCustomInserter",
"(",
"MachineInstr",
"*",
"MI",
",",
"MachineBasicBlock",
"*",
"BB",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"MipsTargetLowering",
"::",
"EmitInstrWithCustomInserter",
"(",
"MI",
",",
"BB",
")",
";",
"case",
"Mips",
"::",
"BPOSGE32_PSEUDO",
":",
"return",
"emitBPOSGE32",
"(",
"MI",
",",
"BB",
")",
";",
"case",
"Mips",
"::",
"SNZ_B_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BNZ_B",
")",
";",
"case",
"Mips",
"::",
"SNZ_H_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BNZ_H",
")",
";",
"case",
"Mips",
"::",
"SNZ_W_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BNZ_W",
")",
";",
"case",
"Mips",
"::",
"SNZ_D_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BNZ_D",
")",
";",
"case",
"Mips",
"::",
"SNZ_V_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BNZ_V",
")",
";",
"case",
"Mips",
"::",
"SZ_B_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BZ_B",
")",
";",
"case",
"Mips",
"::",
"SZ_H_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BZ_H",
")",
";",
"case",
"Mips",
"::",
"SZ_W_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BZ_W",
")",
";",
"case",
"Mips",
"::",
"SZ_D_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BZ_D",
")",
";",
"case",
"Mips",
"::",
"SZ_V_PSEUDO",
":",
"return",
"emitMSACBranchPseudo",
"(",
"MI",
",",
"BB",
",",
"Mips",
"::",
"BZ_V",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"should",
"be",
"implemented",
"by",
"targets",
"that",
"mark",
"instructions",
"with",
"the",
"'usesCustomInserter",
"'",
"flag",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips::BPOSGE32_PSEUDO",
"Mips::SNZ_B_PSEUDO",
"Mips::BNZ_B",
"Mips::SNZ_H_PSEUDO",
"Mips::BNZ_H",
"Mips::SNZ_W_PSEUDO",
"Mips::BNZ_W",
"Mips::SNZ_D_PSEUDO",
"Mips::BNZ_D",
"Mips::SNZ_V_PSEUDO",
"Mips::BNZ_V",
"Mips::SZ_B_PSEUDO",
"Mips::BZ_B",
"Mips::SZ_H_PSEUDO",
"Mips::BZ_H",
"Mips::SZ_W_PSEUDO",
"Mips::BZ_W",
"Mips::SZ_D_PSEUDO",
"Mips::BZ_D",
"Mips::SZ_V_PSEUDO",
"Mips::BZ_V"
] | MipsSEISelLowering12 | EmitInstrWithCustomInserter | Mips | CPU | LLVM | 17,603 | 222 | 1 | [] |
[
"<s>",
"rtx",
"tilegx_simd_int",
"(",
"rtx",
"num",
",",
"machine_mode",
"mode",
")",
"{",
"HOST_WIDE_INT",
"n",
"=",
"0",
";",
"gcc_assert",
"(",
"CONST_INT_P",
"(",
"num",
")",
")",
";",
"n",
"=",
"INTVAL",
"(",
"num",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_QImode",
":",
"n",
"=",
"0x0101010101010101LL",
"*",
"(",
"n",
"&",
"0x000000FF",
")",
";",
"break",
";",
"case",
"E_HImode",
":",
"n",
"=",
"0x0001000100010001LL",
"*",
"(",
"n",
"&",
"0x0000FFFF",
")",
";",
"break",
";",
"case",
"E_SImode",
":",
"n",
"=",
"0x0000000100000001LL",
"*",
"(",
"n",
"&",
"0xFFFFFFFF",
")",
";",
"break",
";",
"case",
"E_DImode",
":",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"GEN_INT",
"(",
"n",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"simd",
"variant",
"of",
"the",
"constant",
"NUM",
"of",
"mode",
"MODE",
",",
"by",
"replicating",
"it",
"to",
"fill",
"an",
"interger",
"of",
"mode",
"DImode",
".",
"NUM",
"is",
"first",
"truncated",
"to",
"fit",
"in",
"MODE",
"."
] | [
"tilegx",
"0",
"0x0101010101010101LL",
"0x000000FF",
"0x0001000100010001LL",
"0x0000FFFF",
"0x0000000100000001LL",
"0xFFFFFFFF"
] | tilegx | tilegx_simd_int | tilegx | VLIW | GCC | 17,604 | 99 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"addPass",
"(",
"new",
"CoalesceFeaturesAndStripAtomics",
"(",
"&",
"getWebAssemblyTargetMachine",
"(",
")",
")",
")",
";",
"addPass",
"(",
"createAtomicExpandPass",
"(",
")",
")",
";",
"addPass",
"(",
"createWebAssemblyAddMissingPrototypes",
"(",
")",
")",
";",
"addPass",
"(",
"createWebAssemblyLowerGlobalDtors",
"(",
")",
")",
";",
"addPass",
"(",
"createWebAssemblyFixFunctionBitcasts",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createWebAssemblyOptimizeReturned",
"(",
")",
")",
";",
"if",
"(",
"!",
"WasmEnableEmException",
"&&",
"TM",
"->",
"Options",
".",
"ExceptionModel",
"==",
"ExceptionHandling",
"::",
"None",
")",
"{",
"addPass",
"(",
"createLowerInvokePass",
"(",
")",
")",
";",
"addPass",
"(",
"createUnreachableBlockEliminationPass",
"(",
")",
")",
";",
"}",
"if",
"(",
"WasmEnableEmException",
"||",
"WasmEnableEmSjLj",
")",
"addPass",
"(",
"createWebAssemblyLowerEmscriptenEHSjLj",
"(",
"WasmEnableEmException",
",",
"WasmEnableEmSjLj",
")",
")",
";",
"addPass",
"(",
"createIndirectBrExpandPass",
"(",
")",
")",
";",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly"
] | WebAssemblyTargetMachine33 | addIRPasses | WebAssembly | Virtual ISA | LLVM | 17,605 | 125 | 1 | [] |
[
"<s>",
"rtx",
"alpha_use_linkage",
"(",
"rtx",
"func",
"ATTRIBUTE_UNUSED",
",",
"bool",
"lflag",
"ATTRIBUTE_UNUSED",
",",
"bool",
"rflag",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Return",
"a",
"SYMBOL_REF",
"representing",
"the",
"reference",
"to",
"the",
".linkage",
"entry",
"of",
"function",
"FUNC",
"built",
"for",
"calls",
"made",
"from",
"CFUNDECL",
".",
"LFLAG",
"is",
"1",
"if",
"this",
"is",
"the",
"reference",
"to",
"the",
"linkage",
"pointer",
"value",
",",
"0",
"if",
"this",
"is",
"the",
"reference",
"to",
"the",
"function",
"entry",
"value",
".",
"RFLAG",
"is",
"1",
"if",
"this",
"a",
"reduced",
"reference",
"(",
"code",
"address",
"only",
")",
",",
"0",
"if",
"this",
"is",
"a",
"full",
"reference",
"."
] | [
"alpha"
] | alpha | alpha_use_linkage | alpha | MPU | GCC | 17,606 | 20 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"TPCInstrInfo",
"::",
"foldMemoryOperandImpl",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineInstr",
"&",
"MI",
",",
"ArrayRef",
"<",
"unsigned",
">",
"Ops",
",",
"MachineBasicBlock",
"::",
"iterator",
"InsertPt",
",",
"int",
"FrameIndex",
",",
"LiveIntervals",
"*",
"LIS",
",",
"VirtRegMap",
"*",
"VRM",
")",
"const",
"{",
"const",
"TargetRegisterInfo",
"&",
"TRI",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"if",
"(",
"MI",
".",
"isCopy",
"(",
")",
")",
"{",
"if",
"(",
"Ops",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"(",
"Ops",
"[",
"0",
"]",
"==",
"0",
"||",
"Ops",
"[",
"0",
"]",
"==",
"1",
")",
")",
"{",
"bool",
"IsSpill",
"=",
"Ops",
"[",
"0",
"]",
"==",
"0",
";",
"const",
"MachineOperand",
"&",
"DstMO",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"const",
"MachineOperand",
"&",
"SrcMO",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"Register",
"DstReg",
"=",
"DstMO",
".",
"getReg",
"(",
")",
";",
"Register",
"SrcReg",
"=",
"SrcMO",
".",
"getReg",
"(",
")",
";",
"Register",
"FoldReg",
"=",
"IsSpill",
"?",
"DstReg",
":",
"SrcReg",
";",
"Register",
"LiveReg",
"=",
"IsSpill",
"?",
"SrcReg",
":",
"DstReg",
";",
"assert",
"(",
"FoldReg",
".",
"isVirtual",
"(",
")",
"&&",
"\"Cannot fold physregs\"",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"MRI",
".",
"getRegClass",
"(",
"FoldReg",
")",
";",
"if",
"(",
"LiveReg",
".",
"isPhysical",
"(",
")",
")",
"if",
"(",
"!",
"RC",
"->",
"contains",
"(",
"LiveReg",
")",
")",
"{",
"llvm_unreachable",
"(",
"\"Unrelated regclasses\"",
")",
";",
"}",
"MachineInstr",
"*",
"SpillMI",
"=",
"nullptr",
";",
"if",
"(",
"IsSpill",
")",
"{",
"storeRegToStackSlot",
"(",
"MBB",
",",
"InsertPt",
",",
"SrcReg",
",",
"DstMO",
".",
"isKill",
"(",
")",
",",
"FrameIndex",
",",
"RC",
",",
"&",
"TRI",
")",
";",
"SpillMI",
"=",
"&",
"*",
"--",
"InsertPt",
";",
"if",
"(",
"SrcMO",
".",
"getSubReg",
"(",
")",
"!=",
"0",
")",
"{",
"SpillMI",
"->",
"getOperand",
"(",
"1",
")",
".",
"setSubReg",
"(",
"SrcMO",
".",
"getSubReg",
"(",
")",
")",
";",
"}",
"}",
"else",
"{",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"InsertPt",
",",
"DstReg",
",",
"FrameIndex",
",",
"RC",
",",
"&",
"TRI",
")",
";",
"SpillMI",
"=",
"&",
"*",
"--",
"InsertPt",
";",
"if",
"(",
"DstMO",
".",
"getSubReg",
"(",
")",
"!=",
"0",
")",
"{",
"SpillMI",
"->",
"getOperand",
"(",
"0",
")",
".",
"setSubReg",
"(",
"DstMO",
".",
"getSubReg",
"(",
")",
")",
";",
"}",
"}",
"return",
"SpillMI",
";",
"}",
"}",
"return",
"nullptr",
";",
"}",
"</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",
"."
] | [
"TPC",
"TPC",
"1",
"0",
"0",
"0",
"1",
"0",
"0",
"0",
"1",
"\"Cannot fold physregs\"",
"\"Unrelated regclasses\"",
"0",
"1",
"0",
"0"
] | TPCInstrInfo | foldMemoryOperandImpl | TPC | Virtual ISA | LLVM | 17,607 | 362 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"SmallVectorImpl",
"<",
"MCParsedAsmOperand",
"*",
">",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
")",
"{",
"MCInst",
"Inst",
";",
"unsigned",
"Kind",
";",
"unsigned",
"ErrorInfo",
";",
"unsigned",
"MatchResult",
";",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"std",
"::",
"string",
">",
",",
"4",
">",
"MapAndConstraints",
";",
"MatchResult",
"=",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Kind",
",",
"Inst",
",",
"MapAndConstraints",
",",
"ErrorInfo",
",",
"false",
")",
";",
"switch",
"(",
"MatchResult",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"if",
"(",
"validateInstruction",
"(",
"Inst",
",",
"Operands",
")",
")",
"{",
"forwardITPosition",
"(",
")",
";",
"return",
"true",
";",
"}",
"while",
"(",
"processInstruction",
"(",
"Inst",
",",
"Operands",
")",
")",
";",
"forwardITPosition",
"(",
")",
";",
"if",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"ITasm",
")",
"return",
"false",
";",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"{",
"assert",
"(",
"ErrorInfo",
"&&",
"\"Unknown missing feature!\"",
")",
";",
"std",
"::",
"string",
"Msg",
"=",
"\"instruction requires:\"",
";",
"unsigned",
"Mask",
"=",
"1",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"(",
"sizeof",
"(",
"ErrorInfo",
")",
"*",
"8",
"-",
"1",
")",
";",
"++",
"i",
")",
"{",
"if",
"(",
"ErrorInfo",
"&",
"Mask",
")",
"{",
"Msg",
"+=",
"\" \"",
";",
"Msg",
"+=",
"getSubtargetFeatureName",
"(",
"ErrorInfo",
"&",
"Mask",
")",
";",
"}",
"Mask",
"<<=",
"1",
";",
"}",
"return",
"Error",
"(",
"IDLoc",
",",
"Msg",
")",
";",
"}",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0U",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"ARMOperand",
"*",
")",
"Operands",
"[",
"ErrorInfo",
"]",
")",
"->",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"invalid instruction\"",
",",
"(",
"(",
"ARMOperand",
"*",
")",
"Operands",
"[",
"0",
"]",
")",
"->",
"getLocRange",
"(",
")",
")",
";",
"case",
"Match_RequiresNotITBlock",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"flag setting instruction only valid outside IT block\"",
")",
";",
"case",
"Match_RequiresITBlock",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction only valid inside IT block\"",
")",
";",
"case",
"Match_RequiresV6",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction variant requires ARMv6 or later\"",
")",
";",
"case",
"Match_RequiresThumb2",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction variant requires Thumb2\"",
")",
";",
"case",
"Match_ImmRange0_15",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"(",
"(",
"ARMOperand",
"*",
")",
"Operands",
"[",
"ErrorInfo",
"]",
")",
"->",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"immediate operand must be in the range [0,15]\"",
")",
";",
"}",
"}",
"llvm_unreachable",
"(",
"\"Implement any new match types added!\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"ARM",
"ARM",
"4",
"ARM::ITasm",
"\"Unknown missing feature!\"",
"\"instruction requires:\"",
"1",
"0",
"8",
"1",
"\" \"",
"1",
"0U",
"\"too few operands for instruction\"",
"ARM",
"\"invalid operand for instruction\"",
"\"invalid instruction\"",
"ARM",
"0",
"\"flag setting instruction only valid outside IT block\"",
"\"instruction only valid inside IT block\"",
"\"instruction variant requires ARMv6 or later\"",
"\"instruction variant requires Thumb2\"",
"ARM",
"\"immediate operand must be in the range [0,15]\"",
"\"Implement any new match types added!\""
] | ARMAsmParser65 | MatchAndEmitInstruction | ARM | CPU | LLVM | 17,608 | 419 | 1 | [] |
[
"<s>",
"rtx",
"nvptx_maybe_convert_symbolic_operand",
"(",
"rtx",
"orig_op",
")",
"{",
"if",
"(",
"GET_MODE",
"(",
"orig_op",
")",
"!=",
"Pmode",
")",
"return",
"orig_op",
";",
"rtx",
"op",
"=",
"orig_op",
";",
"while",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"PLUS",
"||",
"GET_CODE",
"(",
"op",
")",
"==",
"CONST",
")",
"op",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"!=",
"SYMBOL_REF",
")",
"return",
"orig_op",
";",
"tree",
"decl",
"=",
"SYMBOL_REF_DECL",
"(",
"op",
")",
";",
"if",
"(",
"decl",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"{",
"nvptx_record_needed_fndecl",
"(",
"decl",
")",
";",
"return",
"orig_op",
";",
"}",
"addr_space_t",
"as",
"=",
"nvptx_addr_space_from_address",
"(",
"op",
")",
";",
"if",
"(",
"as",
"==",
"ADDR_SPACE_GENERIC",
")",
"return",
"orig_op",
";",
"enum",
"unspec",
"code",
";",
"code",
"=",
"(",
"as",
"==",
"ADDR_SPACE_GLOBAL",
"?",
"UNSPEC_FROM_GLOBAL",
":",
"as",
"==",
"ADDR_SPACE_LOCAL",
"?",
"UNSPEC_FROM_LOCAL",
":",
"as",
"==",
"ADDR_SPACE_SHARED",
"?",
"UNSPEC_FROM_SHARED",
":",
"as",
"==",
"ADDR_SPACE_CONST",
"?",
"UNSPEC_FROM_CONST",
":",
"UNSPEC_FROM_PARAM",
")",
";",
"rtx",
"dest",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"dest",
",",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"orig_op",
")",
",",
"code",
")",
")",
")",
";",
"return",
"dest",
";",
"}",
"</s>"
] | [
"When",
"loading",
"an",
"operand",
"ORIG_OP",
",",
"verify",
"whether",
"an",
"address",
"space",
"conversion",
"to",
"generic",
"is",
"required",
",",
"and",
"if",
"so",
",",
"perform",
"it",
".",
"Also",
"check",
"for",
"SYMBOL_REFs",
"for",
"function",
"decls",
"and",
"call",
"nvptx_record_needed_fndecl",
"as",
"needed",
".",
"Return",
"either",
"the",
"original",
"operand",
",",
"or",
"the",
"converted",
"one",
"."
] | [
"nvptx",
"0",
"1"
] | nvptx2 | nvptx_maybe_convert_symbolic_operand | nvptx | GPU | GCC | 17,609 | 177 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"{",
"assert",
"(",
"isReg",
"(",
")",
"&&",
"\"Wrong CountValue accessor\"",
")",
";",
"return",
"Contents",
".",
"RegNum",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"PowerPC",
"\"Wrong CountValue accessor\""
] | PPCCTRLoops2 | getReg | PowerPC | CPU | LLVM | 17,610 | 21 | 1 | [] |
[
"<s>",
"void",
"RISCVFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedRegs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedRegs",
",",
"RS",
")",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"SavedRegs",
".",
"set",
"(",
"RISCV",
"::",
"X1",
")",
";",
"SavedRegs",
".",
"set",
"(",
"RISCV",
"::",
"X8",
")",
";",
"}",
"if",
"(",
"hasBP",
"(",
"MF",
")",
")",
"SavedRegs",
".",
"set",
"(",
"RISCVABI",
"::",
"getBPReg",
"(",
")",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"\"interrupt\"",
")",
"&&",
"MFI",
".",
"hasCalls",
"(",
")",
")",
"{",
"static",
"const",
"MCPhysReg",
"CSRegs",
"[",
"]",
"=",
"{",
"RISCV",
"::",
"X1",
",",
"RISCV",
"::",
"X5",
",",
"RISCV",
"::",
"X6",
",",
"RISCV",
"::",
"X7",
",",
"RISCV",
"::",
"X10",
",",
"RISCV",
"::",
"X11",
",",
"RISCV",
"::",
"X12",
",",
"RISCV",
"::",
"X13",
",",
"RISCV",
"::",
"X14",
",",
"RISCV",
"::",
"X15",
",",
"RISCV",
"::",
"X16",
",",
"RISCV",
"::",
"X17",
",",
"RISCV",
"::",
"X28",
",",
"RISCV",
"::",
"X29",
",",
"RISCV",
"::",
"X30",
",",
"RISCV",
"::",
"X31",
",",
"0",
"}",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"CSRegs",
"[",
"i",
"]",
";",
"++",
"i",
")",
"SavedRegs",
".",
"set",
"(",
"CSRegs",
"[",
"i",
"]",
")",
";",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
".",
"hasStdExtD",
"(",
")",
"||",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
".",
"hasStdExtF",
"(",
")",
")",
"{",
"const",
"MCPhysReg",
"*",
"Regs",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"getCalleeSavedRegs",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"Regs",
"[",
"i",
"]",
";",
"++",
"i",
")",
"if",
"(",
"RISCV",
"::",
"FPR32RegClass",
".",
"contains",
"(",
"Regs",
"[",
"i",
"]",
")",
"||",
"RISCV",
"::",
"FPR64RegClass",
".",
"contains",
"(",
"Regs",
"[",
"i",
"]",
")",
")",
"SavedRegs",
".",
"set",
"(",
"Regs",
"[",
"i",
"]",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"RISCV",
"RISCV",
"RISCV::X1",
"RISCV::X8",
"RISCVABI::getBPReg",
"\"interrupt\"",
"RISCV::X1",
"RISCV::X5",
"RISCV::X6",
"RISCV::X7",
"RISCV::X10",
"RISCV::X11",
"RISCV::X12",
"RISCV::X13",
"RISCV::X14",
"RISCV::X15",
"RISCV::X16",
"RISCV::X17",
"RISCV::X28",
"RISCV::X29",
"RISCV::X30",
"RISCV::X31",
"0",
"0",
"RISCV",
"RISCV",
"0",
"RISCV::FPR32RegClass",
"RISCV::FPR64RegClass"
] | RISCVFrameLowering | determineCalleeSaves | RISCV | CPU | LLVM | 17,611 | 303 | 1 | [] |
[
"<s>",
"bool",
"MipsMCCodeEmitter",
"::",
"isMicroMips",
"(",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"return",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"Mips",
"::",
"FeatureMicroMips",
"]",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"a",
"given",
"symbol",
"has",
"been",
"flagged",
"with",
"MICROMIPS",
"flag",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips::FeatureMicroMips"
] | MipsMCCodeEmitter (2) | isMicroMips | Mips | CPU | LLVM | 17,612 | 25 | 1 | [] |
[
"<s>",
"BitVector",
"HexagonRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"R29",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"R30",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"R31",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"PC",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"D14",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"D15",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"LC0",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"LC1",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"SA0",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"SA1",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"UGP",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"GP",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"CS0",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"CS1",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"CS",
")",
";",
"Reserved",
".",
"set",
"(",
"Hexagon",
"::",
"USR",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::R29",
"Hexagon::R30",
"Hexagon::R31",
"Hexagon::PC",
"Hexagon::D14",
"Hexagon::D15",
"Hexagon::LC0",
"Hexagon::LC1",
"Hexagon::SA0",
"Hexagon::SA1",
"Hexagon::UGP",
"Hexagon::GP",
"Hexagon::CS0",
"Hexagon::CS1",
"Hexagon::CS",
"Hexagon::USR"
] | HexagonRegisterInfo17 | getReservedRegs | Hexagon | DSP | LLVM | 17,613 | 168 | 1 | [] |
[
"<s>",
"const",
"MCFixupKindInfo",
"&",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"ARM",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"\"fixup_arm_ldst_pcrel_12\"",
",",
"1",
",",
"24",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_t2_ldst_pcrel_12\"",
",",
"0",
",",
"32",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"|",
"MCFixupKindInfo",
"::",
"FKF_IsAlignedDownTo32Bits",
"}",
",",
"{",
"\"fixup_arm_pcrel_10\"",
",",
"1",
",",
"24",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_t2_pcrel_10\"",
",",
"0",
",",
"32",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"|",
"MCFixupKindInfo",
"::",
"FKF_IsAlignedDownTo32Bits",
"}",
",",
"{",
"\"fixup_thumb_adr_pcrel_10\"",
",",
"0",
",",
"8",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"|",
"MCFixupKindInfo",
"::",
"FKF_IsAlignedDownTo32Bits",
"}",
",",
"{",
"\"fixup_arm_adr_pcrel_12\"",
",",
"1",
",",
"24",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_t2_adr_pcrel_12\"",
",",
"0",
",",
"32",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"|",
"MCFixupKindInfo",
"::",
"FKF_IsAlignedDownTo32Bits",
"}",
",",
"{",
"\"fixup_arm_condbranch\"",
",",
"0",
",",
"24",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_uncondbranch\"",
",",
"0",
",",
"24",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_t2_condbranch\"",
",",
"0",
",",
"32",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_t2_uncondbranch\"",
",",
"0",
",",
"32",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_thumb_br\"",
",",
"0",
",",
"16",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_thumb_bl\"",
",",
"0",
",",
"32",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_thumb_blx\"",
",",
"7",
",",
"21",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_thumb_cb\"",
",",
"0",
",",
"16",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_thumb_cp\"",
",",
"1",
",",
"8",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_thumb_bcc\"",
",",
"1",
",",
"8",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_movt_hi16\"",
",",
"0",
",",
"20",
",",
"0",
"}",
",",
"{",
"\"fixup_arm_movw_lo16\"",
",",
"0",
",",
"20",
",",
"0",
"}",
",",
"{",
"\"fixup_t2_movt_hi16\"",
",",
"0",
",",
"20",
",",
"0",
"}",
",",
"{",
"\"fixup_t2_movw_lo16\"",
",",
"0",
",",
"20",
",",
"0",
"}",
",",
"{",
"\"fixup_arm_movt_hi16_pcrel\"",
",",
"0",
",",
"20",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_arm_movw_lo16_pcrel\"",
",",
"0",
",",
"20",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_t2_movt_hi16_pcrel\"",
",",
"0",
",",
"20",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_t2_movw_lo16_pcrel\"",
",",
"0",
",",
"20",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"}",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"TargetAsmBackend",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";",
"assert",
"(",
"unsigned",
"(",
"Kind",
"-",
"FirstTargetFixupKind",
")",
"<",
"getNumFixupKinds",
"(",
")",
"&&",
"\"Invalid kind!\"",
")",
";",
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";",
"}",
"</s>"
] | [
"Get",
"information",
"on",
"a",
"fixup",
"kind",
"."
] | [
"ARM",
"ARM::NumTargetFixupKinds",
"\"fixup_arm_ldst_pcrel_12\"",
"1",
"24",
"\"fixup_t2_ldst_pcrel_12\"",
"0",
"32",
"\"fixup_arm_pcrel_10\"",
"1",
"24",
"\"fixup_t2_pcrel_10\"",
"0",
"32",
"\"fixup_thumb_adr_pcrel_10\"",
"0",
"8",
"\"fixup_arm_adr_pcrel_12\"",
"1",
"24",
"\"fixup_t2_adr_pcrel_12\"",
"0",
"32",
"\"fixup_arm_condbranch\"",
"0",
"24",
"\"fixup_arm_uncondbranch\"",
"0",
"24",
"\"fixup_t2_condbranch\"",
"0",
"32",
"\"fixup_t2_uncondbranch\"",
"0",
"32",
"\"fixup_arm_thumb_br\"",
"0",
"16",
"\"fixup_arm_thumb_bl\"",
"0",
"32",
"\"fixup_arm_thumb_blx\"",
"7",
"21",
"\"fixup_arm_thumb_cb\"",
"0",
"16",
"\"fixup_arm_thumb_cp\"",
"1",
"8",
"\"fixup_arm_thumb_bcc\"",
"1",
"8",
"\"fixup_arm_movt_hi16\"",
"0",
"20",
"0",
"\"fixup_arm_movw_lo16\"",
"0",
"20",
"0",
"\"fixup_t2_movt_hi16\"",
"0",
"20",
"0",
"\"fixup_t2_movw_lo16\"",
"0",
"20",
"0",
"\"fixup_arm_movt_hi16_pcrel\"",
"0",
"20",
"\"fixup_arm_movw_lo16_pcrel\"",
"0",
"20",
"\"fixup_t2_movt_hi16_pcrel\"",
"0",
"20",
"\"fixup_t2_movw_lo16_pcrel\"",
"0",
"20",
"\"Invalid kind!\""
] | ARMAsmBackend18 | getFixupKindInfo | ARM | CPU | LLVM | 17,614 | 370 | 1 | [] |
[
"<s>",
"bool",
"MipsAsmPrinter",
"::",
"PrintAsmMemoryOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"assert",
"(",
"OpNum",
"+",
"1",
"<",
"MI",
"->",
"getNumOperands",
"(",
")",
"&&",
"\"Insufficient operands\"",
")",
";",
"const",
"MachineOperand",
"&",
"BaseMO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
";",
"const",
"MachineOperand",
"&",
"OffsetMO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
"+",
"1",
")",
";",
"assert",
"(",
"BaseMO",
".",
"isReg",
"(",
")",
"&&",
"\"Unexpected base pointer for inline asm memory operand.\"",
")",
";",
"assert",
"(",
"OffsetMO",
".",
"isImm",
"(",
")",
"&&",
"\"Unexpected offset for inline asm memory operand.\"",
")",
";",
"int",
"Offset",
"=",
"OffsetMO",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"ExtraCode",
")",
"{",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"case",
"'D'",
":",
"Offset",
"+=",
"4",
";",
"break",
";",
"case",
"'M'",
":",
"if",
"(",
"Subtarget",
"->",
"isLittle",
"(",
")",
")",
"Offset",
"+=",
"4",
";",
"break",
";",
"case",
"'L'",
":",
"if",
"(",
"!",
"Subtarget",
"->",
"isLittle",
"(",
")",
")",
"Offset",
"+=",
"4",
";",
"break",
";",
"default",
":",
"return",
"true",
";",
"}",
"}",
"O",
"<<",
"Offset",
"<<",
"\"($\"",
"<<",
"MipsInstPrinter",
"::",
"getRegisterName",
"(",
"BaseMO",
".",
"getReg",
"(",
")",
")",
"<<",
"\")\"",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"operand",
"of",
"MI",
",",
"an",
"INLINEASM",
"instruction",
",",
"using",
"the",
"specified",
"assembler",
"variant",
"as",
"an",
"address",
"."
] | [
"Mips",
"Mips",
"1",
"\"Insufficient operands\"",
"1",
"\"Unexpected base pointer for inline asm memory operand.\"",
"\"Unexpected offset for inline asm memory operand.\"",
"0",
"4",
"4",
"4",
"\"($\"",
"Mips",
"\")\""
] | MipsAsmPrinter (2)1 | PrintAsmMemoryOperand | Mips | CPU | LLVM | 17,615 | 182 | 1 | [] |
[
"<s>",
"void",
"X86ATTInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"StringRef",
"Annot",
")",
"{",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MII",
".",
"get",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";",
"uint64_t",
"TSFlags",
"=",
"Desc",
".",
"TSFlags",
";",
"if",
"(",
"CommentStream",
")",
"HasCustomInstComment",
"=",
"EmitAnyX86InstComments",
"(",
"MI",
",",
"*",
"CommentStream",
",",
"getRegisterName",
")",
";",
"if",
"(",
"TSFlags",
"&",
"X86II",
"::",
"LOCK",
")",
"OS",
"<<",
"\"\\tlock\\n\"",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"CALLpcrel32",
"&&",
"(",
"getAvailableFeatures",
"(",
")",
"&",
"X86",
"::",
"Mode64Bit",
")",
"!=",
"0",
")",
"{",
"OS",
"<<",
"\"\\tcallq\\t\"",
";",
"printPCRelImm",
"(",
"MI",
",",
"0",
",",
"OS",
")",
";",
"}",
"else",
"if",
"(",
"!",
"printAliasInstr",
"(",
"MI",
",",
"OS",
")",
")",
"printInstruction",
"(",
"MI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"X86",
"X86",
"X86",
"X86II::LOCK",
"\"\\tlock\\n\"",
"X86::CALLpcrel32",
"X86::Mode64Bit",
"0",
"\"\\tcallq\\t\"",
"0"
] | X86ATTInstPrinter23 | printInst | X86 | CPU | LLVM | 17,616 | 134 | 1 | [] |
[
"<s>",
"bool",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"override",
"{",
"if",
"(",
"skipFunction",
"(",
"F",
")",
")",
"return",
"false",
";",
"AliasAnalysis",
"&",
"AA",
"=",
"getAnalysis",
"<",
"AAResultsWrapperPass",
">",
"(",
")",
".",
"getAAResults",
"(",
")",
";",
"AssumptionCache",
"&",
"AC",
"=",
"getAnalysis",
"<",
"AssumptionCacheTracker",
">",
"(",
")",
".",
"getAssumptionCache",
"(",
"F",
")",
";",
"DominatorTree",
"&",
"DT",
"=",
"getAnalysis",
"<",
"DominatorTreeWrapperPass",
">",
"(",
")",
".",
"getDomTree",
"(",
")",
";",
"TargetLibraryInfo",
"&",
"TLI",
"=",
"getAnalysis",
"<",
"TargetLibraryInfoWrapperPass",
">",
"(",
")",
".",
"getTLI",
"(",
"F",
")",
";",
"auto",
"&",
"TM",
"=",
"getAnalysis",
"<",
"TargetPassConfig",
">",
"(",
")",
".",
"getTM",
"<",
"HexagonTargetMachine",
">",
"(",
")",
";",
"HexagonVectorCombine",
"HVC",
"(",
"F",
",",
"AA",
",",
"AC",
",",
"DT",
",",
"TLI",
",",
"TM",
")",
";",
"return",
"HVC",
".",
"run",
"(",
")",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonVectorCombine | runOnFunction | Hexagon | DSP | LLVM | 17,617 | 123 | 1 | [] |
[
"<s>",
"bool",
"SPUTargetMachine",
"::",
"addPreEmitPass",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"PM",
".",
"add",
"(",
"createSPUNopFillerPass",
"(",
"*",
"this",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"CellSPU",
"SPU",
"SPU"
] | SPUTargetMachine6 | addPreEmitPass | CellSPU | MPU | LLVM | 17,618 | 30 | 1 | [] |
[
"<s>",
"bool",
"MipsHazardSchedule",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"MipsSubtarget",
"*",
"STI",
"=",
"&",
"static_cast",
"<",
"const",
"MipsSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"!",
"STI",
"->",
"hasMips32r6",
"(",
")",
"||",
"STI",
"->",
"inMicroMipsMode",
"(",
")",
")",
"return",
"false",
";",
"bool",
"Changed",
"=",
"false",
";",
"const",
"MipsInstrInfo",
"*",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"FI",
"=",
"MF",
".",
"begin",
"(",
")",
";",
"FI",
"!=",
"MF",
".",
"end",
"(",
")",
";",
"++",
"FI",
")",
"{",
"for",
"(",
"Iter",
"I",
"=",
"FI",
"->",
"begin",
"(",
")",
";",
"I",
"!=",
"FI",
"->",
"end",
"(",
")",
";",
"++",
"I",
")",
"{",
"if",
"(",
"!",
"TII",
"->",
"HasForbiddenSlot",
"(",
"*",
"I",
")",
")",
"continue",
";",
"Iter",
"Inst",
";",
"bool",
"LastInstInFunction",
"=",
"std",
"::",
"next",
"(",
"I",
")",
"==",
"FI",
"->",
"end",
"(",
")",
"&&",
"std",
"::",
"next",
"(",
"FI",
")",
"==",
"MF",
".",
"end",
"(",
")",
";",
"if",
"(",
"!",
"LastInstInFunction",
")",
"{",
"Inst",
"=",
"getNextMachineInstr",
"(",
"std",
"::",
"next",
"(",
"I",
")",
",",
"&",
"*",
"FI",
")",
";",
"}",
"if",
"(",
"LastInstInFunction",
"||",
"!",
"TII",
"->",
"SafeInForbiddenSlot",
"(",
"*",
"Inst",
")",
")",
"{",
"Changed",
"=",
"true",
";",
"MIBundleBuilder",
"(",
"&",
"*",
"I",
")",
".",
"append",
"(",
"BuildMI",
"(",
"MF",
",",
"I",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"Mips",
"::",
"NOP",
")",
")",
")",
";",
"NumInsertedNops",
"++",
";",
"}",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips::NOP"
] | MipsHazardSchedule | runOnMachineFunction | Mips | CPU | LLVM | 17,619 | 238 | 1 | [] |
[
"<s>",
"void",
"advance",
"(",
")",
"{",
"assert",
"(",
"Current",
"!=",
"-",
"1",
")",
";",
"Current",
"=",
"Set",
".",
"V",
".",
"find_next",
"(",
"Current",
")",
";",
"}",
"</s>"
] | [
"Advance",
"across",
"the",
"current",
"instruction",
"."
] | [
"X86",
"1"
] | ImmutableGraph | advance | X86 | CPU | LLVM | 17,620 | 25 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Hexagon early if conversion\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Hexagon",
"\"Hexagon early if conversion\""
] | HexagonEarlyIfConv (2) | getPassName | Hexagon | DSP | LLVM | 17,621 | 13 | 1 | [] |
[
"<s>",
"ChangeStatus",
"updateImpl",
"(",
"Attributor",
"&",
"A",
")",
"override",
"{",
"Function",
"*",
"F",
"=",
"getAssociatedFunction",
"(",
")",
";",
"auto",
"OrigAssumed",
"=",
"getAssumed",
"(",
")",
";",
"const",
"AACallEdges",
"&",
"AAEdges",
"=",
"A",
".",
"getAAFor",
"<",
"AACallEdges",
">",
"(",
"*",
"this",
",",
"this",
"->",
"getIRPosition",
"(",
")",
",",
"DepClassTy",
"::",
"REQUIRED",
")",
";",
"if",
"(",
"AAEdges",
".",
"hasNonAsmUnknownCallee",
"(",
")",
")",
"return",
"indicatePessimisticFixpoint",
"(",
")",
";",
"bool",
"IsNonEntryFunc",
"=",
"!",
"AMDGPU",
"::",
"isEntryFunctionCC",
"(",
"F",
"->",
"getCallingConv",
"(",
")",
")",
";",
"bool",
"NeedsImplicit",
"=",
"false",
";",
"auto",
"&",
"InfoCache",
"=",
"static_cast",
"<",
"AMDGPUInformationCache",
"&",
">",
"(",
"A",
".",
"getInfoCache",
"(",
")",
")",
";",
"bool",
"HasApertureRegs",
"=",
"InfoCache",
".",
"hasApertureRegs",
"(",
"*",
"F",
")",
";",
"bool",
"SupportsGetDoorbellID",
"=",
"InfoCache",
".",
"supportsGetDoorbellID",
"(",
"*",
"F",
")",
";",
"for",
"(",
"Function",
"*",
"Callee",
":",
"AAEdges",
".",
"getOptimisticEdges",
"(",
")",
")",
"{",
"Intrinsic",
"::",
"ID",
"IID",
"=",
"Callee",
"->",
"getIntrinsicID",
"(",
")",
";",
"if",
"(",
"IID",
"==",
"Intrinsic",
"::",
"not_intrinsic",
")",
"{",
"const",
"AAAMDAttributes",
"&",
"AAAMD",
"=",
"A",
".",
"getAAFor",
"<",
"AAAMDAttributes",
">",
"(",
"*",
"this",
",",
"IRPosition",
"::",
"function",
"(",
"*",
"Callee",
")",
",",
"DepClassTy",
"::",
"REQUIRED",
")",
";",
"*",
"this",
"&=",
"AAAMD",
";",
"continue",
";",
"}",
"bool",
"NonKernelOnly",
"=",
"false",
";",
"ImplicitArgumentMask",
"AttrMask",
"=",
"intrinsicToAttrMask",
"(",
"IID",
",",
"NonKernelOnly",
",",
"NeedsImplicit",
",",
"HasApertureRegs",
",",
"SupportsGetDoorbellID",
")",
";",
"if",
"(",
"AttrMask",
"!=",
"NOT_IMPLICIT_INPUT",
")",
"{",
"if",
"(",
"(",
"IsNonEntryFunc",
"||",
"!",
"NonKernelOnly",
")",
")",
"removeAssumedBits",
"(",
"AttrMask",
")",
";",
"}",
"}",
"if",
"(",
"NeedsImplicit",
")",
"removeAssumedBits",
"(",
"IMPLICIT_ARG_PTR",
")",
";",
"if",
"(",
"isAssumed",
"(",
"QUEUE_PTR",
")",
"&&",
"checkForQueuePtr",
"(",
"A",
")",
")",
"{",
"if",
"(",
"AMDGPU",
"::",
"getAmdhsaCodeObjectVersion",
"(",
")",
"==",
"5",
")",
"removeAssumedBits",
"(",
"IMPLICIT_ARG_PTR",
")",
";",
"else",
"removeAssumedBits",
"(",
"QUEUE_PTR",
")",
";",
"}",
"if",
"(",
"funcRetrievesMultigridSyncArg",
"(",
"A",
")",
")",
"{",
"assert",
"(",
"!",
"isAssumed",
"(",
"IMPLICIT_ARG_PTR",
")",
"&&",
"\"multigrid_sync_arg needs implicitarg_ptr\"",
")",
";",
"removeAssumedBits",
"(",
"MULTIGRID_SYNC_ARG",
")",
";",
"}",
"if",
"(",
"funcRetrievesHostcallPtr",
"(",
"A",
")",
")",
"{",
"assert",
"(",
"!",
"isAssumed",
"(",
"IMPLICIT_ARG_PTR",
")",
"&&",
"\"hostcall needs implicitarg_ptr\"",
")",
";",
"removeAssumedBits",
"(",
"HOSTCALL_PTR",
")",
";",
"}",
"if",
"(",
"funcRetrievesHeapPtr",
"(",
"A",
")",
")",
"{",
"assert",
"(",
"!",
"isAssumed",
"(",
"IMPLICIT_ARG_PTR",
")",
"&&",
"\"heap_ptr needs implicitarg_ptr\"",
")",
";",
"removeAssumedBits",
"(",
"HEAP_PTR",
")",
";",
"}",
"if",
"(",
"isAssumed",
"(",
"QUEUE_PTR",
")",
"&&",
"funcRetrievesQueuePtr",
"(",
"A",
")",
")",
"{",
"assert",
"(",
"!",
"isAssumed",
"(",
"IMPLICIT_ARG_PTR",
")",
"&&",
"\"queue_ptr needs implicitarg_ptr\"",
")",
";",
"removeAssumedBits",
"(",
"QUEUE_PTR",
")",
";",
"}",
"return",
"getAssumed",
"(",
")",
"!=",
"OrigAssumed",
"?",
"ChangeStatus",
"::",
"CHANGED",
":",
"ChangeStatus",
"::",
"UNCHANGED",
";",
"}",
"</s>"
] | [
"The",
"actual",
"update/transfer",
"function",
"which",
"has",
"to",
"be",
"implemented",
"by",
"the",
"derived",
"classes",
"."
] | [
"AMDGPU",
"AMDGPU::isEntryFunctionCC",
"AMDGPU",
"Intrinsic::ID",
"Intrinsic::not_intrinsic",
"AMDGPU::getAmdhsaCodeObjectVersion",
"5",
"\"multigrid_sync_arg needs implicitarg_ptr\"",
"\"hostcall needs implicitarg_ptr\"",
"\"heap_ptr needs implicitarg_ptr\"",
"\"queue_ptr needs implicitarg_ptr\""
] | AMDGPUAttributor3 | updateImpl | AMDGPU | GPU | LLVM | 17,622 | 400 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"getSectionForConstant",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"SectionKind",
"Kind",
",",
"const",
"Constant",
"*",
"C",
",",
"unsigned",
"&",
"Align",
",",
"const",
"GlobalObject",
"*",
"GO",
")",
"const",
"override",
"{",
"return",
"ReadOnlySection",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constant",
"with",
"the",
"SectionKind",
",",
"return",
"a",
"section",
"that",
"it",
"should",
"be",
"placed",
"in",
"."
] | [
"NVPTX"
] | NVPTXTargetObjectFile18 | getSectionForConstant | NVPTX | GPU | LLVM | 17,623 | 33 | 1 | [] |
[
"<s>",
"SDValue",
"AlphaTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"unsigned",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"SDValue",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"Alpha",
"::",
"R26",
",",
"DAG",
".",
"getNode",
"(",
"AlphaISD",
"::",
"GlobalRetAddr",
",",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
",",
"MVT",
"::",
"i64",
")",
",",
"SDValue",
"(",
")",
")",
";",
"switch",
"(",
"Outs",
".",
"size",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Do not know how to return this many arguments!\"",
")",
";",
"case",
"0",
":",
"break",
";",
"case",
"1",
":",
"{",
"EVT",
"ArgVT",
"=",
"Outs",
"[",
"0",
"]",
".",
"Val",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"ArgReg",
";",
"if",
"(",
"ArgVT",
".",
"isInteger",
"(",
")",
")",
"ArgReg",
"=",
"Alpha",
"::",
"R0",
";",
"else",
"{",
"assert",
"(",
"ArgVT",
".",
"isFloatingPoint",
"(",
")",
")",
";",
"ArgReg",
"=",
"Alpha",
"::",
"F0",
";",
"}",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Copy",
",",
"dl",
",",
"ArgReg",
",",
"Outs",
"[",
"0",
"]",
".",
"Val",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"if",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_empty",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"ArgReg",
")",
";",
"break",
";",
"}",
"case",
"2",
":",
"{",
"EVT",
"ArgVT",
"=",
"Outs",
"[",
"0",
"]",
".",
"Val",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"ArgReg1",
",",
"ArgReg2",
";",
"if",
"(",
"ArgVT",
".",
"isInteger",
"(",
")",
")",
"{",
"ArgReg1",
"=",
"Alpha",
"::",
"R0",
";",
"ArgReg2",
"=",
"Alpha",
"::",
"R1",
";",
"}",
"else",
"{",
"assert",
"(",
"ArgVT",
".",
"isFloatingPoint",
"(",
")",
")",
";",
"ArgReg1",
"=",
"Alpha",
"::",
"F0",
";",
"ArgReg2",
"=",
"Alpha",
"::",
"F1",
";",
"}",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Copy",
",",
"dl",
",",
"ArgReg1",
",",
"Outs",
"[",
"0",
"]",
".",
"Val",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"if",
"(",
"std",
"::",
"find",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_begin",
"(",
")",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
",",
"ArgReg1",
")",
"==",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"ArgReg1",
")",
";",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Copy",
",",
"dl",
",",
"ArgReg2",
",",
"Outs",
"[",
"1",
"]",
".",
"Val",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"if",
"(",
"std",
"::",
"find",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_begin",
"(",
")",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
",",
"ArgReg2",
")",
"==",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"ArgReg2",
")",
";",
"break",
";",
"}",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"AlphaISD",
"::",
"RET_FLAG",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Copy",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"Alpha",
"Alpha",
"ISD::OutputArg",
"Alpha::R26",
"AlphaISD::GlobalRetAddr",
"MVT::i64",
"\"Do not know how to return this many arguments!\"",
"0",
"1",
"0",
"Alpha::R0",
"Alpha::F0",
"0",
"1",
"2",
"0",
"Alpha::R0",
"Alpha::R1",
"Alpha::F0",
"Alpha::F1",
"0",
"1",
"1",
"1",
"AlphaISD::RET_FLAG",
"MVT::Other",
"1"
] | AlphaISelLowering6 | LowerReturn | Alpha | MPU | LLVM | 17,624 | 491 | 1 | [] |
[
"<s>",
"bool",
"trackLivenessAfterRegAlloc",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"live-ins",
"should",
"be",
"tracked",
"after",
"register",
"allocation",
"."
] | [
"PowerPC"
] | PPCRegisterInfo (2)1 | trackLivenessAfterRegAlloc | PowerPC | CPU | LLVM | 17,625 | 15 | 1 | [] |
[
"<s>",
"bool",
"PPCInstrInfo",
"::",
"isBDNZ",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"return",
"(",
"Opcode",
"==",
"(",
"Subtarget",
".",
"isPPC64",
"(",
")",
"?",
"PPC",
"::",
"BDNZ8",
":",
"PPC",
"::",
"BDNZ",
")",
")",
";",
"}",
"</s>"
] | [
"Check",
"Opcode",
"is",
"BDNZ",
"(",
"Decrement",
"CTR",
"and",
"branch",
"if",
"it",
"is",
"still",
"nonzero",
")",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC::BDNZ8",
"PPC::BDNZ"
] | PPCInstrInfo | isBDNZ | PowerPC | CPU | LLVM | 17,626 | 32 | 1 | [] |
[
"<s>",
"static",
"void",
"riscv_emit_attribute",
"(",
")",
"{",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.attribute arch, \\\"%s\\\"\\n\"",
",",
"riscv_arch_str",
"(",
")",
".",
"c_str",
"(",
")",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.attribute unaligned_access, %d\\n\"",
",",
"TARGET_STRICT_ALIGN",
"?",
"0",
":",
"1",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.attribute stack_align, %d\\n\"",
",",
"riscv_stack_boundary",
"/",
"8",
")",
";",
"}",
"</s>"
] | [
"Auxiliary",
"function",
"to",
"emit",
"RISC-V",
"ELF",
"attribute",
"."
] | [
"riscv",
"\"\\t.attribute arch, \\\"%s\\\"\\n\"",
"\"\\t.attribute unaligned_access, %d\\n\"",
"0",
"1",
"\"\\t.attribute stack_align, %d\\n\"",
"8"
] | riscv | riscv_emit_attribute | riscv | CPU | GCC | 17,627 | 46 | 1 | [] |
[
"<s>",
"RISCVSubtarget",
"&",
"RISCVSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"bool",
"Is64Bit",
")",
"{",
"std",
"::",
"string",
"CPUName",
"=",
"CPU",
";",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"CPUName",
"=",
"Is64Bit",
"?",
"\"generic-rv64\"",
":",
"\"generic-rv32\"",
";",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FS",
")",
";",
"if",
"(",
"Is64Bit",
")",
"{",
"XLenVT",
"=",
"MVT",
"::",
"i64",
";",
"XLen",
"=",
"64",
";",
"}",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"\"generic-rv64\"",
"\"generic-rv32\"",
"MVT::i64",
"64"
] | RISCVSubtarget13 | initializeSubtargetDependencies | RISCV | CPU | LLVM | 17,628 | 67 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"breakPartialRegDependency",
"(",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"unsigned",
"Reg",
"=",
"MI",
".",
"getOperand",
"(",
"OpNum",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"MI",
".",
"killsRegister",
"(",
"Reg",
",",
"TRI",
")",
")",
"return",
";",
"if",
"(",
"X86",
"::",
"VR128RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"unsigned",
"Opc",
"=",
"Subtarget",
".",
"hasAVX",
"(",
")",
"?",
"X86",
"::",
"VXORPSrr",
":",
"X86",
"::",
"XORPSrr",
";",
"BuildMI",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"Opc",
")",
",",
"Reg",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Undef",
")",
";",
"MI",
".",
"addRegisterKilled",
"(",
"Reg",
",",
"TRI",
",",
"true",
")",
";",
"}",
"else",
"if",
"(",
"X86",
"::",
"VR256RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"unsigned",
"XReg",
"=",
"TRI",
"->",
"getSubReg",
"(",
"Reg",
",",
"X86",
"::",
"sub_xmm",
")",
";",
"BuildMI",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"VXORPSrr",
")",
",",
"XReg",
")",
".",
"addReg",
"(",
"XReg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"XReg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"MI",
".",
"addRegisterKilled",
"(",
"Reg",
",",
"TRI",
",",
"true",
")",
";",
"}",
"else",
"if",
"(",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"unsigned",
"XReg",
"=",
"TRI",
"->",
"getSubReg",
"(",
"Reg",
",",
"X86",
"::",
"sub_32bit",
")",
";",
"BuildMI",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"XOR32rr",
")",
",",
"XReg",
")",
".",
"addReg",
"(",
"XReg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"XReg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"MI",
".",
"addRegisterKilled",
"(",
"Reg",
",",
"TRI",
",",
"true",
")",
";",
"}",
"else",
"if",
"(",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"BuildMI",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"XOR32rr",
")",
",",
"Reg",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Undef",
")",
";",
"MI",
".",
"addRegisterKilled",
"(",
"Reg",
",",
"TRI",
",",
"true",
")",
";",
"}",
"}",
"</s>"
] | [
"Insert",
"a",
"dependency-breaking",
"instruction",
"before",
"MI",
"to",
"eliminate",
"an",
"unwanted",
"dependency",
"on",
"OpNum",
"."
] | [
"X86",
"X86",
"X86::VR128RegClass",
"X86::VXORPSrr",
"X86::XORPSrr",
"X86::VR256RegClass",
"X86::sub_xmm",
"X86::VXORPSrr",
"X86::GR64RegClass",
"X86::sub_32bit",
"X86::XOR32rr",
"X86::GR32RegClass",
"X86::XOR32rr"
] | X86InstrInfo | breakPartialRegDependency | X86 | CPU | LLVM | 17,629 | 387 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"SITargetLowering",
"::",
"legalizeTargetIndependentNode",
"(",
"SDNode",
"*",
"Node",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"Node",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"CopyToReg",
")",
"{",
"RegisterSDNode",
"*",
"DestReg",
"=",
"cast",
"<",
"RegisterSDNode",
">",
"(",
"Node",
"->",
"getOperand",
"(",
"1",
")",
")",
";",
"SDValue",
"SrcVal",
"=",
"Node",
"->",
"getOperand",
"(",
"2",
")",
";",
"if",
"(",
"SrcVal",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"i1",
"&&",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
"->",
"getReg",
"(",
")",
")",
")",
"{",
"SDLoc",
"SL",
"(",
"Node",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
";",
"SDValue",
"VReg",
"=",
"DAG",
".",
"getRegister",
"(",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VReg_1RegClass",
")",
",",
"MVT",
"::",
"i1",
")",
";",
"SDNode",
"*",
"Glued",
"=",
"Node",
"->",
"getGluedNode",
"(",
")",
";",
"SDValue",
"ToVReg",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Node",
"->",
"getOperand",
"(",
"0",
")",
",",
"SL",
",",
"VReg",
",",
"SrcVal",
",",
"SDValue",
"(",
"Glued",
",",
"Glued",
"?",
"Glued",
"->",
"getNumValues",
"(",
")",
"-",
"1",
":",
"0",
")",
")",
";",
"SDValue",
"ToResultReg",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"ToVReg",
",",
"SL",
",",
"SDValue",
"(",
"DestReg",
",",
"0",
")",
",",
"VReg",
",",
"ToVReg",
".",
"getValue",
"(",
"1",
")",
")",
";",
"DAG",
".",
"ReplaceAllUsesWith",
"(",
"Node",
",",
"ToResultReg",
".",
"getNode",
"(",
")",
")",
";",
"DAG",
".",
"RemoveDeadNode",
"(",
"Node",
")",
";",
"return",
"ToResultReg",
".",
"getNode",
"(",
")",
";",
"}",
"}",
"SmallVector",
"<",
"SDValue",
",",
"8",
">",
"Ops",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Node",
"->",
"getNumOperands",
"(",
")",
";",
"++",
"i",
")",
"{",
"if",
"(",
"!",
"isFrameIndexOp",
"(",
"Node",
"->",
"getOperand",
"(",
"i",
")",
")",
")",
"{",
"Ops",
".",
"push_back",
"(",
"Node",
"->",
"getOperand",
"(",
"i",
")",
")",
";",
"continue",
";",
"}",
"SDLoc",
"DL",
"(",
"Node",
")",
";",
"Ops",
".",
"push_back",
"(",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"AMDGPU",
"::",
"S_MOV_B32",
",",
"DL",
",",
"Node",
"->",
"getOperand",
"(",
"i",
")",
".",
"getValueType",
"(",
")",
",",
"Node",
"->",
"getOperand",
"(",
"i",
")",
")",
",",
"0",
")",
")",
";",
"}",
"DAG",
".",
"UpdateNodeOperands",
"(",
"Node",
",",
"Ops",
")",
";",
"return",
"Node",
";",
"}",
"</s>"
] | [
"Legalize",
"target",
"independent",
"instructions",
"(",
"e.g",
"."
] | [
"AMDGPU",
"SI",
"ISD::CopyToReg",
"1",
"2",
"MVT::i1",
"AMDGPU::VReg_1RegClass",
"MVT::i1",
"0",
"1",
"0",
"0",
"1",
"8",
"0",
"AMDGPU::S_MOV_B32",
"0"
] | SIISelLowering114 | legalizeTargetIndependentNode | AMDGPU | GPU | LLVM | 17,630 | 342 | 1 | [] |
[
"<s>",
"bool",
"P2FrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"&",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"return",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
"->",
"isFrameAddressTaken",
"(",
")",
"||",
"TRI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"P2",
"P2"
] | P2FrameLowering | hasFP | P2 | MPU | LLVM | 17,631 | 73 | 1 | [] |
[
"<s>",
"static",
"bool",
"s390_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
")",
"{",
"if",
"(",
"TARGET_TPF_PROFILING",
")",
"return",
"false",
";",
"if",
"(",
"!",
"TARGET_64BIT",
"&&",
"flag_pic",
"&&",
"decl",
"&&",
"!",
"targetm",
".",
"binds_local_p",
"(",
"decl",
")",
")",
"return",
"false",
";",
"return",
"!",
"s390_call_saved_register_used",
"(",
"exp",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"given",
"call",
"expression",
"can",
"be",
"turned",
"into",
"a",
"sibling",
"call",
".",
"DECL",
"holds",
"the",
"declaration",
"of",
"the",
"function",
"to",
"be",
"called",
"whereas",
"EXP",
"is",
"the",
"call",
"expression",
"itself",
"."
] | [
"s390"
] | s3904 | s390_function_ok_for_sibcall | s390 | MPU | GCC | 17,632 | 46 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addPreSched2",
"(",
")",
"{",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createSIShrinkInstructionsPass",
"(",
")",
")",
";",
"addPass",
"(",
"&",
"SIPostRABundlerID",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"prolog-epilog",
"insertion",
"and",
"before",
"the",
"second",
"instruction",
"scheduling",
"pass",
"."
] | [
"AMDGPU",
"SI",
"SI"
] | AMDGPUTargetMachine1 | addPreSched2 | AMDGPU | GPU | LLVM | 17,633 | 33 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_handle_attr_tune",
"(",
"const",
"char",
"*",
"str",
")",
"{",
"const",
"struct",
"processor",
"*",
"tmp_tune",
"=",
"NULL",
";",
"enum",
"aarch64_parse_opt_result",
"parse_res",
"=",
"aarch64_parse_tune",
"(",
"str",
",",
"&",
"tmp_tune",
")",
";",
"if",
"(",
"parse_res",
"==",
"AARCH64_PARSE_OK",
")",
"{",
"gcc_assert",
"(",
"tmp_tune",
")",
";",
"selected_tune",
"=",
"tmp_tune",
";",
"explicit_tune_core",
"=",
"selected_tune",
"->",
"ident",
";",
"return",
"true",
";",
"}",
"switch",
"(",
"parse_res",
")",
"{",
"case",
"AARCH64_PARSE_INVALID_ARG",
":",
"error",
"(",
"\"invalid name (\\\"%s\\\") in %<target(\\\"tune=\\\")%> pragma or attribute\"",
",",
"str",
")",
";",
"aarch64_print_hint_for_core",
"(",
"str",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Handle",
"the",
"argument",
"STR",
"to",
"the",
"tune=",
"target",
"attribute",
".",
"PRAGMA_OR_ATTR",
"is",
"used",
"in",
"potential",
"error",
"messages",
"."
] | [
"aarch64",
"\"invalid name (\\\"%s\\\") in %<target(\\\"tune=\\\")%> pragma or attribute\""
] | aarch64 | aarch64_handle_attr_tune | aarch64 | CPU | GCC | 17,634 | 89 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
"AllowModify",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"if",
"(",
"I",
"==",
"MBB",
".",
"end",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"AArch64",
"::",
"SpeculationBarrierISBDSBEndBB",
"||",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"AArch64",
"::",
"SpeculationBarrierSBEndBB",
")",
"{",
"--",
"I",
";",
"}",
"if",
"(",
"!",
"isUnpredicatedTerminator",
"(",
"*",
"I",
")",
")",
"return",
"false",
";",
"MachineInstr",
"*",
"LastInst",
"=",
"&",
"*",
"I",
";",
"unsigned",
"LastOpc",
"=",
"LastInst",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"I",
"==",
"MBB",
".",
"begin",
"(",
")",
"||",
"!",
"isUnpredicatedTerminator",
"(",
"*",
"--",
"I",
")",
")",
"{",
"if",
"(",
"isUncondBranchOpcode",
"(",
"LastOpc",
")",
")",
"{",
"TBB",
"=",
"LastInst",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"isCondBranchOpcode",
"(",
"LastOpc",
")",
")",
"{",
"parseCondBranch",
"(",
"LastInst",
",",
"TBB",
",",
"Cond",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"MachineInstr",
"*",
"SecondLastInst",
"=",
"&",
"*",
"I",
";",
"unsigned",
"SecondLastOpc",
"=",
"SecondLastInst",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"AllowModify",
"&&",
"isUncondBranchOpcode",
"(",
"LastOpc",
")",
")",
"{",
"while",
"(",
"isUncondBranchOpcode",
"(",
"SecondLastOpc",
")",
")",
"{",
"LastInst",
"->",
"eraseFromParent",
"(",
")",
";",
"LastInst",
"=",
"SecondLastInst",
";",
"LastOpc",
"=",
"LastInst",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"I",
"==",
"MBB",
".",
"begin",
"(",
")",
"||",
"!",
"isUnpredicatedTerminator",
"(",
"*",
"--",
"I",
")",
")",
"{",
"TBB",
"=",
"LastInst",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"return",
"false",
";",
"}",
"else",
"{",
"SecondLastInst",
"=",
"&",
"*",
"I",
";",
"SecondLastOpc",
"=",
"SecondLastInst",
"->",
"getOpcode",
"(",
")",
";",
"}",
"}",
"}",
"if",
"(",
"SecondLastInst",
"&&",
"I",
"!=",
"MBB",
".",
"begin",
"(",
")",
"&&",
"isUnpredicatedTerminator",
"(",
"*",
"--",
"I",
")",
")",
"return",
"true",
";",
"if",
"(",
"isCondBranchOpcode",
"(",
"SecondLastOpc",
")",
"&&",
"isUncondBranchOpcode",
"(",
"LastOpc",
")",
")",
"{",
"parseCondBranch",
"(",
"SecondLastInst",
",",
"TBB",
",",
"Cond",
")",
";",
"FBB",
"=",
"LastInst",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"isUncondBranchOpcode",
"(",
"SecondLastOpc",
")",
"&&",
"isUncondBranchOpcode",
"(",
"LastOpc",
")",
")",
"{",
"TBB",
"=",
"SecondLastInst",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"I",
"=",
"LastInst",
";",
"if",
"(",
"AllowModify",
")",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"isIndirectBranchOpcode",
"(",
"SecondLastOpc",
")",
"&&",
"isUncondBranchOpcode",
"(",
"LastOpc",
")",
")",
"{",
"I",
"=",
"LastInst",
";",
"if",
"(",
"AllowModify",
")",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"AArch64",
"AArch64",
"AArch64::SpeculationBarrierISBDSBEndBB",
"AArch64::SpeculationBarrierSBEndBB",
"0",
"0",
"0",
"0"
] | AArch64InstrInfo121 | analyzeBranch | AArch64 | CPU | LLVM | 17,635 | 428 | 1 | [] |
[
"<s>",
"void",
"MipsTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"SmallDataSection",
"=",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".sdata\"",
",",
"MCSectionELF",
"::",
"SHT_PROGBITS",
",",
"MCSectionELF",
"::",
"SHF_WRITE",
"|",
"MCSectionELF",
"::",
"SHF_ALLOC",
",",
"SectionKind",
"::",
"getDataRel",
"(",
")",
")",
";",
"SmallBSSSection",
"=",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".sbss\"",
",",
"MCSectionELF",
"::",
"SHT_NOBITS",
",",
"MCSectionELF",
"::",
"SHF_WRITE",
"|",
"MCSectionELF",
"::",
"SHF_ALLOC",
",",
"SectionKind",
"::",
"getBSS",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"Mips",
"Mips",
"\".sdata\"",
"\".sbss\""
] | MipsTargetObjectFile18 | Initialize | Mips | CPU | LLVM | 17,636 | 83 | 1 | [] |
[
"<s>",
"SDValue",
"HexagonTargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"Glue",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"SDValue",
"Callee",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"if",
"(",
"Subtarget",
".",
"useHVXOps",
"(",
")",
")",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_Hexagon_HVX",
")",
";",
"else",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_Hexagon",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"SDValue",
"RetVal",
";",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
"{",
"auto",
"&",
"MRI",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
";",
"SDValue",
"FR0",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
",",
"MVT",
"::",
"i32",
",",
"Glue",
")",
";",
"Register",
"PredR",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"Hexagon",
"::",
"PredRegsRegClass",
")",
";",
"SDValue",
"TPR",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"FR0",
".",
"getValue",
"(",
"1",
")",
",",
"dl",
",",
"PredR",
",",
"FR0",
".",
"getValue",
"(",
"0",
")",
",",
"FR0",
".",
"getValue",
"(",
"2",
")",
")",
";",
"RetVal",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"TPR",
".",
"getValue",
"(",
"0",
")",
",",
"dl",
",",
"PredR",
",",
"MVT",
"::",
"i1",
")",
";",
"Glue",
"=",
"TPR",
".",
"getValue",
"(",
"1",
")",
";",
"Chain",
"=",
"TPR",
".",
"getValue",
"(",
"0",
")",
";",
"}",
"else",
"{",
"RetVal",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
",",
"Glue",
")",
";",
"Glue",
"=",
"RetVal",
".",
"getValue",
"(",
"2",
")",
";",
"Chain",
"=",
"RetVal",
".",
"getValue",
"(",
"1",
")",
";",
"}",
"InVals",
".",
"push_back",
"(",
"RetVal",
".",
"getValue",
"(",
"0",
")",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"Hexagon",
"Hexagon",
"ISD::InputArg",
"16",
"Hexagon",
"Hexagon",
"0",
"MVT::i1",
"MVT::i32",
"Hexagon::PredRegsRegClass",
"1",
"0",
"2",
"0",
"MVT::i1",
"1",
"0",
"2",
"1",
"0"
] | HexagonISelLowering100 | LowerCallResult | Hexagon | DSP | LLVM | 17,637 | 351 | 1 | [] |
[
"<s>",
"SMLoc",
"getStartLoc",
"(",
")",
"const",
"override",
"{",
"return",
"StartLoc",
";",
"}",
"</s>"
] | [
"getStartLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"first",
"token",
"of",
"this",
"operand",
"."
] | [
"Hexagon"
] | HexagonAsmParser | getStartLoc | Hexagon | DSP | LLVM | 17,638 | 11 | 1 | [] |
[
"<s>",
"bool",
"ARCRegisterInfo",
"::",
"needsFrameMoves",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"{",
"return",
"MF",
".",
"getMMI",
"(",
")",
".",
"hasDebugInfo",
"(",
")",
"||",
"MF",
".",
"getFunction",
"(",
")",
"->",
"needsUnwindTableEntry",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"whether",
"to",
"emit",
"frame",
"moves",
"."
] | [
"ARC",
"ARC"
] | ARCRegisterInfo3 | needsFrameMoves | ARC | MPU | LLVM | 17,639 | 33 | 1 | [] |
[
"<s>",
"void",
"HexagonAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"MCInst",
"MCB",
";",
"MCB",
".",
"setOpcode",
"(",
"Hexagon",
"::",
"BUNDLE",
")",
";",
"MCB",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"0",
")",
")",
";",
"const",
"MCInstrInfo",
"&",
"MCII",
"=",
"*",
"Subtarget",
"->",
"getInstrInfo",
"(",
")",
";",
"if",
"(",
"MI",
"->",
"isBundle",
"(",
")",
")",
"{",
"assert",
"(",
"Subtarget",
"->",
"usePackets",
"(",
")",
"&&",
"\"Support for packets is disabled\"",
")",
";",
"const",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MI",
"->",
"getParent",
"(",
")",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"MII",
"=",
"MI",
"->",
"getIterator",
"(",
")",
";",
"for",
"(",
"++",
"MII",
";",
"MII",
"!=",
"MBB",
"->",
"instr_end",
"(",
")",
"&&",
"MII",
"->",
"isInsideBundle",
"(",
")",
";",
"++",
"MII",
")",
"if",
"(",
"!",
"MII",
"->",
"isDebugValue",
"(",
")",
"&&",
"!",
"MII",
"->",
"isImplicitDef",
"(",
")",
")",
"HexagonLowerToMC",
"(",
"MCII",
",",
"&",
"*",
"MII",
",",
"MCB",
",",
"*",
"this",
")",
";",
"}",
"else",
"{",
"HexagonLowerToMC",
"(",
"MCII",
",",
"MI",
",",
"MCB",
",",
"*",
"this",
")",
";",
"}",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"auto",
"&",
"HII",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"if",
"(",
"MI",
"->",
"isBundle",
"(",
")",
"&&",
"HII",
".",
"getBundleNoShuf",
"(",
"*",
"MI",
")",
")",
"HexagonMCInstrInfo",
"::",
"setMemReorderDisabled",
"(",
"MCB",
")",
";",
"MCContext",
"&",
"Ctx",
"=",
"OutStreamer",
"->",
"getContext",
"(",
")",
";",
"bool",
"Ok",
"=",
"HexagonMCInstrInfo",
"::",
"canonicalizePacket",
"(",
"MCII",
",",
"*",
"Subtarget",
",",
"Ctx",
",",
"MCB",
",",
"nullptr",
")",
";",
"assert",
"(",
"Ok",
")",
";",
"(",
"void",
")",
"Ok",
";",
"if",
"(",
"HexagonMCInstrInfo",
"::",
"bundleSize",
"(",
"MCB",
")",
"==",
"0",
")",
"return",
";",
"OutStreamer",
"->",
"EmitInstruction",
"(",
"MCB",
",",
"getSubtargetInfo",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::BUNDLE",
"0",
"\"Support for packets is disabled\"",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"0"
] | HexagonAsmPrinter42 | EmitInstruction | Hexagon | DSP | LLVM | 17,640 | 279 | 1 | [] |
[
"<s>",
"int",
"ia64_register_move_cost",
"(",
"enum",
"machine_mode",
"mode",
",",
"enum",
"reg_class",
"from",
",",
"enum",
"reg_class",
"to",
")",
"{",
"if",
"(",
"to",
"==",
"ADDL_REGS",
")",
"to",
"=",
"GR_REGS",
";",
"if",
"(",
"from",
"==",
"ADDL_REGS",
")",
"from",
"=",
"GR_REGS",
";",
"if",
"(",
"from",
"<",
"to",
")",
"{",
"enum",
"reg_class",
"tmp",
"=",
"to",
";",
"to",
"=",
"from",
",",
"from",
"=",
"tmp",
";",
"}",
"if",
"(",
"mode",
"==",
"XFmode",
"||",
"mode",
"==",
"RFmode",
")",
"{",
"if",
"(",
"to",
"!=",
"GR_REGS",
"||",
"from",
"!=",
"GR_REGS",
")",
"return",
"MEMORY_MOVE_COST",
"(",
"mode",
",",
"to",
",",
"0",
")",
";",
"else",
"return",
"3",
";",
"}",
"switch",
"(",
"to",
")",
"{",
"case",
"PR_REGS",
":",
"if",
"(",
"from",
"==",
"PR_REGS",
")",
"return",
"3",
";",
"if",
"(",
"from",
"!=",
"GR_REGS",
")",
"return",
"MEMORY_MOVE_COST",
"(",
"mode",
",",
"to",
",",
"0",
")",
";",
"break",
";",
"case",
"BR_REGS",
":",
"if",
"(",
"from",
"!=",
"GR_REGS",
"&&",
"from",
"!=",
"GR_AND_BR_REGS",
")",
"return",
"MEMORY_MOVE_COST",
"(",
"mode",
",",
"to",
",",
"0",
")",
";",
"break",
";",
"case",
"AR_I_REGS",
":",
"case",
"AR_M_REGS",
":",
"if",
"(",
"from",
"!=",
"GR_REGS",
")",
"return",
"MEMORY_MOVE_COST",
"(",
"mode",
",",
"to",
",",
"0",
")",
";",
"break",
";",
"case",
"GR_REGS",
":",
"case",
"FR_REGS",
":",
"case",
"FP_REGS",
":",
"case",
"GR_AND_FR_REGS",
":",
"case",
"GR_AND_BR_REGS",
":",
"case",
"ALL_REGS",
":",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"2",
";",
"}",
"</s>"
] | [
"Calulate",
"the",
"cost",
"of",
"moving",
"data",
"from",
"a",
"register",
"in",
"class",
"FROM",
"to",
"one",
"in",
"class",
"TO",
",",
"using",
"MODE",
"."
] | [
"ia64",
"0",
"3",
"3",
"0",
"0",
"0",
"2"
] | ia643 | ia64_register_move_cost | ia64 | CPU | GCC | 17,641 | 209 | 1 | [] |
[
"<s>",
"unsigned",
"X86AsmBackend",
"::",
"getMaximumNopSize",
"(",
")",
"const",
"{",
"if",
"(",
"!",
"STI",
".",
"hasFeature",
"(",
"X86",
"::",
"FeatureNOPL",
")",
"&&",
"!",
"STI",
".",
"hasFeature",
"(",
"X86",
"::",
"Mode64Bit",
")",
")",
"return",
"1",
";",
"if",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"X86",
"::",
"FeatureFast7ByteNOP",
"]",
")",
"return",
"7",
";",
"if",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"X86",
"::",
"FeatureFast15ByteNOP",
"]",
")",
"return",
"15",
";",
"if",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"X86",
"::",
"FeatureFast11ByteNOP",
"]",
")",
"return",
"11",
";",
"return",
"10",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"maximum",
"size",
"of",
"a",
"nop",
"in",
"bytes",
"on",
"this",
"target",
"."
] | [
"X86",
"X86",
"X86::FeatureNOPL",
"X86::Mode64Bit",
"1",
"X86::FeatureFast7ByteNOP",
"7",
"X86::FeatureFast15ByteNOP",
"15",
"X86::FeatureFast11ByteNOP",
"11",
"10"
] | X86AsmBackend14 | getMaximumNopSize | X86 | CPU | LLVM | 17,642 | 85 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"ix86_max_noce_ifcvt_seq_cost",
"(",
"edge",
"e",
")",
"{",
"bool",
"predictable_p",
"=",
"predictable_edge_p",
"(",
"e",
")",
";",
"if",
"(",
"predictable_p",
")",
"{",
"if",
"(",
"OPTION_SET_P",
"(",
"param_max_rtl_if_conversion_predictable_cost",
")",
")",
"return",
"param_max_rtl_if_conversion_predictable_cost",
";",
"}",
"else",
"{",
"if",
"(",
"OPTION_SET_P",
"(",
"param_max_rtl_if_conversion_unpredictable_cost",
")",
")",
"return",
"param_max_rtl_if_conversion_unpredictable_cost",
";",
"}",
"return",
"BRANCH_COST",
"(",
"true",
",",
"predictable_p",
")",
"*",
"COSTS_N_INSNS",
"(",
"2",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MAX_NOCE_IFCVT_SEQ_COST",
".",
"Like",
"the",
"default",
"implementation",
",",
"but",
"returns",
"a",
"lower",
"bound",
"."
] | [
"i386",
"2"
] | i386 | ix86_max_noce_ifcvt_seq_cost | i386 | CPU | GCC | 17,643 | 60 | 1 | [] |
[
"<s>",
"gimple",
"*",
"fold",
"(",
"gimple_folder",
"&",
"f",
")",
"const",
"override",
"{",
"if",
"(",
"tree",
"amount",
"=",
"uniform_integer_cst_p",
"(",
"gimple_call_arg",
"(",
"f",
".",
"call",
",",
"2",
")",
")",
")",
"{",
"if",
"(",
"wi",
"::",
"to_widest",
"(",
"amount",
")",
">=",
"0",
")",
"{",
"function_instance",
"instance",
"(",
"\"svlsl\"",
",",
"functions",
"::",
"svlsl",
",",
"shapes",
"::",
"binary_uint_opt_n",
",",
"MODE_n",
",",
"f",
".",
"type_suffix_ids",
",",
"f",
".",
"pred",
")",
";",
"gcall",
"*",
"call",
"=",
"as_a",
"<",
"gcall",
"*",
">",
"(",
"f",
".",
"redirect_call",
"(",
"instance",
")",
")",
";",
"gimple_call_set_arg",
"(",
"call",
",",
"2",
",",
"amount",
")",
";",
"return",
"call",
";",
"}",
"int",
"element_bits",
"=",
"f",
".",
"type_suffix",
"(",
"0",
")",
".",
"element_bits",
";",
"if",
"(",
"wi",
"::",
"to_widest",
"(",
"amount",
")",
">=",
"-",
"element_bits",
")",
"{",
"amount",
"=",
"wide_int_to_tree",
"(",
"TREE_TYPE",
"(",
"amount",
")",
",",
"-",
"wi",
"::",
"to_wide",
"(",
"amount",
")",
")",
";",
"function_instance",
"instance",
"(",
"\"svrshr\"",
",",
"functions",
"::",
"svrshr",
",",
"shapes",
"::",
"shift_right_imm",
",",
"MODE_n",
",",
"f",
".",
"type_suffix_ids",
",",
"f",
".",
"pred",
")",
";",
"gcall",
"*",
"call",
"=",
"as_a",
"<",
"gcall",
"*",
">",
"(",
"f",
".",
"redirect_call",
"(",
"instance",
")",
")",
";",
"gimple_call_set_arg",
"(",
"call",
",",
"2",
",",
"amount",
")",
";",
"return",
"call",
";",
"}",
"}",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Try",
"to",
"fold",
"the",
"call",
".",
"Return",
"the",
"new",
"statement",
"on",
"success",
"and",
"null",
"on",
"failure",
"."
] | [
"aarch64",
"2",
"0",
"\"svlsl\"",
"2",
"0",
"\"svrshr\"",
"2"
] | aarch64-sve-builtins-sve23 | fold | aarch64 | CPU | GCC | 17,644 | 199 | 1 | [] |
[
"<s>",
"static",
"int",
"frame_restore_reg",
"(",
"rtx",
"reg",
",",
"HOST_WIDE_INT",
"offset",
")",
"{",
"rtx",
"addr",
",",
"insn",
";",
"if",
"(",
"offset",
")",
"{",
"rtx",
"tmp",
"=",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"offset",
"+",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"reg",
")",
")",
")",
";",
"addr",
"=",
"gen_frame_mem",
"(",
"GET_MODE",
"(",
"reg",
")",
",",
"gen_rtx_POST_MODIFY",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"tmp",
")",
")",
";",
"}",
"else",
"addr",
"=",
"gen_frame_mem",
"(",
"GET_MODE",
"(",
"reg",
")",
",",
"gen_rtx_POST_INC",
"(",
"Pmode",
",",
"stack_pointer_rtx",
")",
")",
";",
"insn",
"=",
"frame_move_inc",
"(",
"reg",
",",
"addr",
",",
"stack_pointer_rtx",
",",
"0",
")",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_RESTORE",
",",
"reg",
")",
";",
"if",
"(",
"reg",
"==",
"hard_frame_pointer_rtx",
")",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_DEF_CFA",
",",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"reg",
")",
")",
"+",
"offset",
")",
")",
";",
"else",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_ADJUST_CFA",
",",
"gen_rtx_SET",
"(",
"stack_pointer_rtx",
",",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"reg",
")",
")",
"+",
"offset",
")",
")",
")",
";",
"return",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"reg",
")",
")",
"+",
"offset",
";",
"}",
"</s>"
] | [
"Helper",
"for",
"epilogue",
":",
"emit",
"frame",
"load",
"with",
"post_modify",
"or",
"post_inc",
"to",
"restore",
"register",
"REG",
"from",
"stack",
".",
"The",
"initial",
"offset",
"is",
"passed",
"via",
"OFFSET",
"."
] | [
"arc",
"0"
] | arc | frame_restore_reg | arc | MPU | GCC | 17,645 | 173 | 1 | [] |
[
"<s>",
"bool",
"ARMExpandPseudo",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"TargetMachine",
"&",
"TM",
"=",
"MF",
".",
"getTarget",
"(",
")",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"TM",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"TM",
".",
"getRegisterInfo",
"(",
")",
";",
"STI",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MFI",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"MFI",
"!=",
"E",
";",
"++",
"MFI",
")",
"Modified",
"|=",
"ExpandMBB",
"(",
"*",
"MFI",
")",
";",
"if",
"(",
"VerifyARMPseudo",
")",
"MF",
".",
"verify",
"(",
"this",
",",
"\"After expanding ARM pseudo instructions.\"",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"\"After expanding ARM pseudo instructions.\""
] | ARMExpandPseudoInsts | runOnMachineFunction | ARM | CPU | LLVM | 17,646 | 126 | 1 | [] |
[
"<s>",
"unsigned",
"SystemZInstrInfo",
"::",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"INLINEASM",
")",
"{",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"char",
"*",
"AsmStr",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSymbolName",
"(",
")",
";",
"return",
"getInlineAsmLength",
"(",
"AsmStr",
",",
"*",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
")",
";",
"}",
"return",
"MI",
".",
"getDesc",
"(",
")",
".",
"getSize",
"(",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"SystemZ",
"SystemZ",
"0"
] | SystemZInstrInfo (2)2 | getInstSizeInBytes | SystemZ | CPU | LLVM | 17,647 | 86 | 1 | [] |
[
"<s>",
"rtx",
"alpha_legitimize_reload_address",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"int",
"opnum",
",",
"int",
"type",
",",
"int",
"ind_levels",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"1",
")",
")",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"{",
"push_reload",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL_RTX",
",",
"&",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL",
",",
"BASE_REG_CLASS",
",",
"GET_MODE",
"(",
"x",
")",
",",
"VOIDmode",
",",
"0",
",",
"0",
",",
"opnum",
",",
"(",
"enum",
"reload_type",
")",
"type",
")",
";",
"return",
"x",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"&&",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"<",
"FIRST_PSEUDO_REGISTER",
"&&",
"REGNO_OK_FOR_BASE_P",
"(",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
")",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"{",
"HOST_WIDE_INT",
"val",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
";",
"HOST_WIDE_INT",
"low",
"=",
"(",
"(",
"val",
"&",
"0xffff",
")",
"^",
"0x8000",
")",
"-",
"0x8000",
";",
"HOST_WIDE_INT",
"high",
"=",
"(",
"(",
"(",
"val",
"-",
"low",
")",
"&",
"0xffffffff",
")",
"^",
"0x80000000",
")",
"-",
"0x80000000",
";",
"if",
"(",
"high",
"+",
"low",
"!=",
"val",
")",
"return",
"NULL_RTX",
";",
"x",
"=",
"gen_rtx_PLUS",
"(",
"GET_MODE",
"(",
"x",
")",
",",
"gen_rtx_PLUS",
"(",
"GET_MODE",
"(",
"x",
")",
",",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"GEN_INT",
"(",
"high",
")",
")",
",",
"GEN_INT",
"(",
"low",
")",
")",
";",
"push_reload",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL_RTX",
",",
"&",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL",
",",
"BASE_REG_CLASS",
",",
"GET_MODE",
"(",
"x",
")",
",",
"VOIDmode",
",",
"0",
",",
"0",
",",
"opnum",
",",
"(",
"enum",
"reload_type",
")",
"type",
")",
";",
"return",
"x",
";",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Try",
"a",
"machine-dependent",
"way",
"of",
"reloading",
"an",
"illegitimate",
"address",
"operand",
".",
"If",
"we",
"find",
"one",
",",
"push",
"the",
"reload",
"and",
"return",
"the",
"new",
"rtx",
"."
] | [
"alpha",
"0",
"0",
"0",
"0",
"1",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"1",
"0xffff",
"0x8000",
"0x8000",
"0xffffffff",
"0x80000000",
"0x80000000",
"0",
"0",
"0",
"0",
"0"
] | alpha | alpha_legitimize_reload_address | alpha | MPU | GCC | 17,648 | 329 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"getSectionForConstant",
"(",
"SectionKind",
"Kind",
",",
"const",
"Constant",
"*",
"C",
")",
"const",
"override",
"{",
"return",
"ReadOnlySection",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constant",
"with",
"the",
"SectionKind",
",",
"return",
"a",
"section",
"that",
"it",
"should",
"be",
"placed",
"in",
"."
] | [
"WebAssembly"
] | WebAssemblyTargetObjectFile7 | getSectionForConstant | WebAssembly | Virtual ISA | LLVM | 17,649 | 19 | 1 | [] |
[
"<s>",
"void",
"MipsTargetELFStreamer",
"::",
"emitAssignment",
"(",
"MCSymbol",
"*",
"S",
",",
"const",
"MCExpr",
"*",
"Value",
")",
"{",
"auto",
"*",
"Symbol",
"=",
"cast",
"<",
"MCSymbolELF",
">",
"(",
"S",
")",
";",
"if",
"(",
"Value",
"->",
"getKind",
"(",
")",
"!=",
"MCExpr",
"::",
"SymbolRef",
")",
"return",
";",
"const",
"auto",
"&",
"RhsSym",
"=",
"cast",
"<",
"MCSymbolELF",
">",
"(",
"static_cast",
"<",
"const",
"MCSymbolRefExpr",
"*",
">",
"(",
"Value",
")",
"->",
"getSymbol",
"(",
")",
")",
";",
"if",
"(",
"!",
"(",
"RhsSym",
".",
"getOther",
"(",
")",
"&",
"ELF",
"::",
"STO_MIPS_MICROMIPS",
")",
")",
"return",
";",
"Symbol",
"->",
"setOther",
"(",
"ELF",
"::",
"STO_MIPS_MICROMIPS",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"assignment",
"of",
"Value",
"to",
"Symbol",
"."
] | [
"Mips",
"Mips"
] | MipsTargetStreamer (2)1 | emitAssignment | Mips | CPU | LLVM | 17,650 | 93 | 1 | [] |
[
"<s>",
"static",
"inline",
"void",
"aarch64_sub_sp",
"(",
"rtx",
"temp1",
",",
"rtx",
"temp2",
",",
"poly_int64",
"delta",
",",
"bool",
"frame_related_p",
")",
"{",
"aarch64_add_offset",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"-",
"delta",
",",
"temp1",
",",
"temp2",
",",
"frame_related_p",
")",
";",
"}",
"</s>"
] | [
"Subtract",
"DELTA",
"from",
"the",
"stack",
"pointer",
",",
"marking",
"the",
"instructions",
"frame-related",
"if",
"FRAME_RELATED_P",
".",
"TEMP1",
"is",
"available",
"as",
"a",
"temporary",
"if",
"nonnull",
"."
] | [
"aarch64"
] | aarch645 | aarch64_sub_sp | aarch64 | CPU | GCC | 17,651 | 37 | 1 | [] |
[
"<s>",
"void",
"i386_pe_encode_section_info",
"(",
"tree",
"decl",
",",
"rtx",
"rtl",
",",
"int",
"first",
")",
"{",
"rtx",
"symbol",
";",
"int",
"flags",
";",
"default_encode_section_info",
"(",
"decl",
",",
"rtl",
",",
"first",
")",
";",
"if",
"(",
"!",
"MEM_P",
"(",
"rtl",
")",
")",
"return",
";",
"symbol",
"=",
"XEXP",
"(",
"rtl",
",",
"0",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"symbol",
")",
"==",
"SYMBOL_REF",
")",
";",
"switch",
"(",
"TREE_CODE",
"(",
"decl",
")",
")",
"{",
"case",
"FUNCTION_DECL",
":",
"case",
"VAR_DECL",
":",
"break",
";",
"default",
":",
"return",
";",
"}",
"flags",
"=",
"(",
"SYMBOL_REF_FLAGS",
"(",
"symbol",
")",
"&",
"~",
"(",
"SYMBOL_FLAG_DLLIMPORT",
"|",
"SYMBOL_FLAG_DLLEXPORT",
")",
")",
";",
"if",
"(",
"i386_pe_determine_dllexport_p",
"(",
"decl",
")",
")",
"flags",
"|=",
"SYMBOL_FLAG_DLLEXPORT",
";",
"else",
"if",
"(",
"i386_pe_determine_dllimport_p",
"(",
"decl",
")",
")",
"flags",
"|=",
"SYMBOL_FLAG_DLLIMPORT",
";",
"SYMBOL_REF_FLAGS",
"(",
"symbol",
")",
"=",
"flags",
";",
"}",
"</s>"
] | [
"Cover",
"function",
"to",
"implement",
"ENCODE_SECTION_INFO",
"."
] | [
"i386",
"0"
] | winnt | i386_pe_encode_section_info | i386 | CPU | GCC | 17,652 | 125 | 1 | [] |
[
"<s>",
"void",
"SparcCodeEmitter",
"::",
"emitInstruction",
"(",
"MachineBasicBlock",
"::",
"instr_iterator",
"MI",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"JIT: \"",
"<<",
"(",
"void",
"*",
")",
"MCE",
".",
"getCurrentPCValue",
"(",
")",
"<<",
"\":\\t\"",
"<<",
"*",
"MI",
")",
";",
"MCE",
".",
"processDebugLoc",
"(",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"true",
")",
";",
"++",
"NumEmitted",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"{",
"emitWord",
"(",
"getBinaryCodeForInstr",
"(",
"*",
"MI",
")",
")",
";",
"break",
";",
"}",
"case",
"TargetOpcode",
"::",
"INLINEASM",
":",
"{",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getSymbolName",
"(",
")",
"[",
"0",
"]",
")",
"{",
"report_fatal_error",
"(",
"\"JIT does not support inline asm!\"",
")",
";",
"}",
"break",
";",
"}",
"case",
"TargetOpcode",
"::",
"CFI_INSTRUCTION",
":",
"break",
";",
"case",
"TargetOpcode",
"::",
"EH_LABEL",
":",
"{",
"MCE",
".",
"emitLabel",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMCSymbol",
"(",
")",
")",
";",
"break",
";",
"}",
"case",
"TargetOpcode",
"::",
"IMPLICIT_DEF",
":",
"case",
"TargetOpcode",
"::",
"KILL",
":",
"{",
"break",
";",
"}",
"case",
"SP",
"::",
"GETPCX",
":",
"{",
"report_fatal_error",
"(",
"\"JIT does not support pseudo instruction GETPCX yet!\"",
")",
";",
"break",
";",
"}",
"}",
"MCE",
".",
"processDebugLoc",
"(",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"to",
"emit",
"instructions",
"."
] | [
"Sparc",
"Sparc",
"\"JIT: \"",
"\":\\t\"",
"0",
"0",
"\"JIT does not support inline asm!\"",
"0",
"SP::GETPCX",
"\"JIT does not support pseudo instruction GETPCX yet!\""
] | SparcCodeEmitter | emitInstruction | Sparc | CPU | LLVM | 17,653 | 186 | 1 | [] |
[
"<s>",
"static",
"rtx",
"mips_expand_builtin_bposge",
"(",
"enum",
"mips_builtin_type",
"builtin_type",
",",
"rtx",
"target",
")",
"{",
"rtx",
"label1",
",",
"label2",
",",
"if_then_else",
";",
"rtx",
"cmp_result",
";",
"int",
"cmp_value",
";",
"if",
"(",
"target",
"==",
"0",
"||",
"GET_MODE",
"(",
"target",
")",
"!=",
"SImode",
")",
"target",
"=",
"gen_reg_rtx",
"(",
"SImode",
")",
";",
"cmp_result",
"=",
"gen_rtx_REG",
"(",
"CCDSPmode",
",",
"CCDSP_PO_REGNUM",
")",
";",
"if",
"(",
"builtin_type",
"==",
"MIPS_BUILTIN_BPOSGE32",
")",
"cmp_value",
"=",
"32",
";",
"else",
"gcc_assert",
"(",
"0",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"const0_rtx",
")",
";",
"label1",
"=",
"gen_label_rtx",
"(",
")",
";",
"label2",
"=",
"gen_label_rtx",
"(",
")",
";",
"if_then_else",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"gen_rtx_fmt_ee",
"(",
"GE",
",",
"CCDSPmode",
",",
"cmp_result",
",",
"GEN_INT",
"(",
"cmp_value",
")",
")",
",",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"label1",
")",
",",
"pc_rtx",
")",
";",
"emit_jump_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"if_then_else",
")",
")",
";",
"emit_jump_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"label2",
")",
")",
")",
";",
"emit_barrier",
"(",
")",
";",
"emit_label",
"(",
"label1",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"const1_rtx",
")",
";",
"emit_label",
"(",
"label2",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"bposge",
"builtin",
"of",
"type",
"BUILTIN_TYPE",
".",
"TARGET",
",",
"if",
"nonnull",
",",
"suggests",
"a",
"good",
"place",
"to",
"put",
"the",
"boolean",
"result",
".",
"The",
"sequence",
"we",
"want",
"is",
"li",
"target",
",",
"0",
"bposge",
"*",
"label1",
"j",
"label2",
"label1",
":",
"li",
"target",
",",
"1",
"label2",
":"
] | [
"mips",
"0",
"32",
"0"
] | mips3 | mips_expand_builtin_bposge | mips | CPU | GCC | 17,654 | 173 | 1 | [] |
[
"<s>",
"static",
"inline",
"int",
"addsubcosts",
"(",
"rtx",
"x",
")",
"{",
"if",
"(",
"GET_MODE",
"(",
"x",
")",
"==",
"SImode",
")",
"{",
"rtx",
"op0",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"XEXP",
"(",
"x",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op0",
")",
"==",
"AND",
"&&",
"XEXP",
"(",
"op0",
",",
"1",
")",
"==",
"const1_rtx",
"&&",
"(",
"GET_CODE",
"(",
"op1",
")",
"==",
"PLUS",
"||",
"(",
"GET_CODE",
"(",
"op1",
")",
"==",
"MULT",
"&&",
"XEXP",
"(",
"op1",
",",
"1",
")",
"==",
"const2_rtx",
")",
")",
")",
"return",
"1",
";",
"if",
"(",
"GET_CODE",
"(",
"op0",
")",
"==",
"MULT",
"&&",
"XEXP",
"(",
"op0",
",",
"1",
")",
"==",
"const2_rtx",
"&&",
"GET_CODE",
"(",
"op1",
")",
"==",
"LSHIFTRT",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"op1",
",",
"1",
")",
")",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"op1",
",",
"1",
")",
")",
"==",
"31",
")",
"return",
"1",
";",
"}",
"if",
"(",
"treg_set_expr",
"(",
"op1",
",",
"SImode",
")",
")",
"return",
"1",
";",
"if",
"(",
"treg_set_expr",
"(",
"op0",
",",
"SImode",
")",
")",
"return",
"1",
";",
"}",
"const",
"int",
"cost_scale",
"=",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"x",
")",
")",
">",
"UNITS_PER_WORD",
"?",
"2",
":",
"1",
";",
"if",
"(",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"||",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"SUBREG",
")",
"return",
"1",
"*",
"cost_scale",
";",
"if",
"(",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"&&",
"CONST_OK_FOR_ADD",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
")",
"return",
"1",
"*",
"cost_scale",
";",
"return",
"3",
"*",
"cost_scale",
";",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"an",
"addition",
"or",
"a",
"subtraction",
"."
] | [
"sh",
"0",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"31",
"1",
"1",
"1",
"2",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"3"
] | sh | addsubcosts | sh | CPU | GCC | 17,655 | 256 | 1 | [] |
[
"<s>",
"bool",
"isImm",
"(",
")",
"const",
"{",
"return",
"Kind",
"==",
"MachineOperand",
"::",
"MO_Immediate",
";",
"}",
"</s>"
] | [
"isImm",
"-",
"Is",
"this",
"an",
"immediate",
"operand",
"?"
] | [
"AMDGPU"
] | SIFoldOperands | isImm | AMDGPU | GPU | LLVM | 17,656 | 14 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"Mips"
] | MipsOptimizePICCall | getAnalysisUsage | Mips | CPU | LLVM | 17,657 | 27 | 1 | [] |
[
"<s>",
"bool",
"M88kFrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"MutableArrayRef",
"<",
"CalleeSavedInfo",
">",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</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",
"(",
")",
"."
] | [
"M88k",
"M88k"
] | M88kFrameLowering | restoreCalleeSavedRegisters | M88k | MPU | LLVM | 17,658 | 31 | 1 | [] |
[
"<s>",
"void",
"BTFDebug",
"::",
"endModule",
"(",
")",
"{",
"if",
"(",
"MapDefNotCollected",
")",
"{",
"processGlobals",
"(",
"true",
")",
";",
"MapDefNotCollected",
"=",
"false",
";",
"}",
"processGlobals",
"(",
"false",
")",
";",
"for",
"(",
"auto",
"&",
"DataSec",
":",
"DataSecEntries",
")",
"addType",
"(",
"std",
"::",
"move",
"(",
"DataSec",
".",
"second",
")",
")",
";",
"for",
"(",
"auto",
"&",
"Fixup",
":",
"FixupDerivedTypes",
")",
"{",
"StringRef",
"TypeName",
"=",
"Fixup",
".",
"first",
";",
"bool",
"IsUnion",
"=",
"Fixup",
".",
"second",
".",
"first",
";",
"uint32_t",
"StructTypeId",
"=",
"0",
";",
"for",
"(",
"const",
"auto",
"&",
"StructType",
":",
"StructTypes",
")",
"{",
"if",
"(",
"StructType",
"->",
"getName",
"(",
")",
"==",
"TypeName",
")",
"{",
"StructTypeId",
"=",
"StructType",
"->",
"getId",
"(",
")",
";",
"break",
";",
"}",
"}",
"if",
"(",
"StructTypeId",
"==",
"0",
")",
"{",
"auto",
"FwdTypeEntry",
"=",
"std",
"::",
"make_unique",
"<",
"BTFTypeFwd",
">",
"(",
"TypeName",
",",
"IsUnion",
")",
";",
"StructTypeId",
"=",
"addType",
"(",
"std",
"::",
"move",
"(",
"FwdTypeEntry",
")",
")",
";",
"}",
"for",
"(",
"auto",
"&",
"DType",
":",
"Fixup",
".",
"second",
".",
"second",
")",
"{",
"DType",
"->",
"setPointeeType",
"(",
"StructTypeId",
")",
";",
"}",
"}",
"for",
"(",
"const",
"auto",
"&",
"TypeEntry",
":",
"TypeEntries",
")",
"TypeEntry",
"->",
"completeType",
"(",
"*",
"this",
")",
";",
"emitBTFSection",
"(",
")",
";",
"emitBTFExtSection",
"(",
")",
";",
"}",
"</s>"
] | [
"Emit",
"all",
"exception",
"information",
"that",
"should",
"come",
"after",
"the",
"content",
"."
] | [
"BPF",
"0",
"0"
] | BTFDebug1 | endModule | BPF | Virtual ISA | LLVM | 17,659 | 193 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_expand_vec_perm_const_1",
"(",
"rtx",
"target",
",",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"unsigned",
"char",
"perm0",
",",
"unsigned",
"char",
"perm1",
")",
"{",
"rtx",
"x",
";",
"if",
"(",
"(",
"perm0",
"&",
"2",
")",
"==",
"(",
"perm1",
"&",
"2",
")",
")",
"{",
"if",
"(",
"perm0",
"&",
"2",
")",
"op0",
"=",
"op1",
";",
"else",
"op1",
"=",
"op0",
";",
"}",
"if",
"(",
"rtx_equal_p",
"(",
"op0",
",",
"op1",
")",
")",
"{",
"perm0",
"=",
"perm0",
"&",
"1",
";",
"perm1",
"=",
"(",
"perm1",
"&",
"1",
")",
"+",
"2",
";",
"}",
"else",
"if",
"(",
"perm0",
"&",
"2",
")",
"{",
"if",
"(",
"perm1",
"&",
"2",
")",
"return",
"false",
";",
"perm0",
"-=",
"2",
";",
"perm1",
"+=",
"2",
";",
"std",
"::",
"swap",
"(",
"op0",
",",
"op1",
")",
";",
"}",
"else",
"if",
"(",
"(",
"perm1",
"&",
"2",
")",
"==",
"0",
")",
"return",
"false",
";",
"if",
"(",
"target",
"!=",
"NULL",
")",
"{",
"machine_mode",
"vmode",
",",
"dmode",
";",
"rtvec",
"v",
";",
"vmode",
"=",
"GET_MODE",
"(",
"target",
")",
";",
"gcc_assert",
"(",
"GET_MODE_NUNITS",
"(",
"vmode",
")",
"==",
"2",
")",
";",
"dmode",
"=",
"mode_for_vector",
"(",
"GET_MODE_INNER",
"(",
"vmode",
")",
",",
"4",
")",
";",
"x",
"=",
"gen_rtx_VEC_CONCAT",
"(",
"dmode",
",",
"op0",
",",
"op1",
")",
";",
"v",
"=",
"gen_rtvec",
"(",
"2",
",",
"GEN_INT",
"(",
"perm0",
")",
",",
"GEN_INT",
"(",
"perm1",
")",
")",
";",
"x",
"=",
"gen_rtx_VEC_SELECT",
"(",
"vmode",
",",
"x",
",",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"v",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"x",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"Paired",
"Single",
"or",
"VSX",
"Permute",
"Doubleword",
"constant",
"permutation",
".",
"Return",
"true",
"if",
"we",
"match",
"an",
"efficient",
"implementation",
"."
] | [
"rs6000",
"2",
"2",
"2",
"1",
"1",
"2",
"2",
"2",
"2",
"2",
"2",
"0",
"2",
"4",
"2"
] | rs60005 | rs6000_expand_vec_perm_const_1 | rs6000 | CPU | GCC | 17,660 | 235 | 1 | [] |
[
"<s>",
"void",
"MipsTargetLowering",
"::",
"computeKnownBitsForTargetNode",
"(",
"const",
"SDValue",
"Op",
",",
"KnownBits",
"&",
"Known",
",",
"const",
"APInt",
"&",
"DemandedElts",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"Known",
".",
"resetAll",
"(",
")",
";",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"{",
"switch",
"(",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
")",
"->",
"getZExtValue",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Intrinsic",
"::",
"cheri_round_representable_length",
":",
"if",
"(",
"Subtarget",
".",
"isCheri256",
"(",
")",
")",
"{",
"Known",
"=",
"DAG",
".",
"computeKnownBits",
"(",
"Op",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"}",
"else",
"if",
"(",
"Subtarget",
".",
"isCheri128",
"(",
")",
")",
"{",
"KnownBits",
"KnownLengthBits",
"=",
"DAG",
".",
"computeKnownBits",
"(",
"Op",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"uint64_t",
"MinLength",
"=",
"KnownLengthBits",
".",
"One",
".",
"getZExtValue",
"(",
")",
";",
"uint64_t",
"MaxLength",
"=",
"(",
"~",
"KnownLengthBits",
".",
"Zero",
")",
".",
"getZExtValue",
"(",
")",
";",
"uint64_t",
"MinMask",
"=",
"cc128_get_alignment_mask",
"(",
"MinLength",
")",
";",
"uint64_t",
"MaxMask",
"=",
"cc128_get_alignment_mask",
"(",
"MaxLength",
")",
";",
"uint64_t",
"MinRoundedLength",
"=",
"(",
"MinLength",
"+",
"~",
"MinMask",
")",
"&",
"MinMask",
";",
"uint64_t",
"MaxRoundedLength",
"=",
"(",
"MaxLength",
"+",
"~",
"MaxMask",
")",
"&",
"MaxMask",
";",
"bool",
"MinRoundedOverflow",
"=",
"MinRoundedLength",
"<",
"MinLength",
";",
"bool",
"MaxRoundedOverflow",
"=",
"MaxRoundedLength",
"<",
"MaxLength",
";",
"uint64_t",
"MinMaxRoundedAgreeMask",
"=",
"MinRoundedLength",
"^",
"~",
"MaxRoundedLength",
";",
"uint64_t",
"InputKnownMask",
"=",
"(",
"KnownLengthBits",
".",
"Zero",
"|",
"KnownLengthBits",
".",
"One",
")",
".",
"getZExtValue",
"(",
")",
";",
"uint64_t",
"LeadingKnownBits",
"=",
"countLeadingOnes",
"(",
"MinMaxRoundedAgreeMask",
")",
";",
"uint64_t",
"LeadingKnownMask",
"=",
"MinRoundedOverflow",
"==",
"MaxRoundedOverflow",
"?",
"maskLeadingOnes",
"<",
"uint64_t",
">",
"(",
"LeadingKnownBits",
")",
":",
"0",
";",
"uint64_t",
"TrailingKnownBits",
"=",
"countTrailingOnes",
"(",
"MinMaxRoundedAgreeMask",
")",
";",
"uint64_t",
"TrailingKnownMask",
"=",
"maskTrailingOnes",
"<",
"uint64_t",
">",
"(",
"TrailingKnownBits",
")",
"&",
"InputKnownMask",
";",
"uint64_t",
"KnownMask",
"=",
"LeadingKnownMask",
"|",
"TrailingKnownMask",
";",
"Known",
".",
"Zero",
"|=",
"~",
"MinRoundedLength",
"&",
"KnownMask",
";",
"Known",
".",
"One",
"|=",
"MinRoundedLength",
"&",
"KnownMask",
";",
"}",
"break",
";",
"case",
"Intrinsic",
"::",
"cheri_representable_alignment_mask",
":",
"if",
"(",
"Subtarget",
".",
"isCheri256",
"(",
")",
")",
"{",
"Known",
".",
"setAllOnes",
"(",
")",
";",
"}",
"else",
"if",
"(",
"Subtarget",
".",
"isCheri128",
"(",
")",
")",
"{",
"KnownBits",
"KnownLengthBits",
"=",
"DAG",
".",
"computeKnownBits",
"(",
"Op",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"uint64_t",
"MinLength",
"=",
"KnownLengthBits",
".",
"One",
".",
"getZExtValue",
"(",
")",
";",
"uint64_t",
"MaxLength",
"=",
"(",
"~",
"KnownLengthBits",
".",
"Zero",
")",
".",
"getZExtValue",
"(",
")",
";",
"Known",
".",
"Zero",
"|=",
"~",
"cc128_get_alignment_mask",
"(",
"MinLength",
")",
";",
"Known",
".",
"One",
"|=",
"cc128_get_alignment_mask",
"(",
"MaxLength",
")",
";",
"}",
"break",
";",
"}",
"}",
"}",
"}",
"</s>"
] | [
"Determine",
"which",
"of",
"the",
"bits",
"specified",
"in",
"Mask",
"are",
"known",
"to",
"be",
"either",
"zero",
"or",
"one",
"and",
"return",
"them",
"in",
"the",
"KnownZero/KnownOne",
"bitsets",
"."
] | [
"Mips",
"Mips",
"ISD::INTRINSIC_WO_CHAIN",
"0",
"Intrinsic::cheri_round_representable_length",
"1",
"1",
"0",
"Intrinsic::cheri_representable_alignment_mask",
"1"
] | MipsISelLowering66 | computeKnownBitsForTargetNode | Mips | CPU | LLVM | 17,661 | 405 | 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",
"NeedsPop",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"0",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"1",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
"==",
"ARM",
"::",
"LR",
")",
"{",
"if",
"(",
"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",
")",
";",
"}",
"else",
"continue",
";",
"}",
"MIB",
".",
"addReg",
"(",
"Reg",
",",
"getDefRegState",
"(",
"true",
")",
")",
";",
"NeedsPop",
"=",
"true",
";",
"}",
"if",
"(",
"NeedsPop",
")",
"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"
] | Thumb1FrameLowering2 | restoreCalleeSavedRegisters | ARM | CPU | LLVM | 17,662 | 306 | 1 | [] |
[
"<s>",
"SDValue",
"GBZ80TargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ADD",
":",
"return",
"PerformADDCombine",
"(",
"N",
",",
"DCI",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"GBZ80",
"GB",
"ISD::ADD"
] | GBZ80ISelLowering | PerformDAGCombine | GBZ80 | MPU | LLVM | 17,663 | 48 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"reMaterialize",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SubIdx",
",",
"const",
"MachineInstr",
"*",
"Orig",
",",
"const",
"TargetRegisterInfo",
"&",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"Orig",
"->",
"getDebugLoc",
"(",
")",
";",
"bool",
"Clone",
"=",
"true",
";",
"unsigned",
"Opc",
"=",
"Orig",
"->",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"break",
";",
"case",
"X86",
"::",
"MOV8r0",
":",
"case",
"X86",
"::",
"MOV16r0",
":",
"case",
"X86",
"::",
"MOV32r0",
":",
"case",
"X86",
"::",
"MOV64r0",
":",
"{",
"if",
"(",
"!",
"isSafeToClobberEFLAGS",
"(",
"MBB",
",",
"I",
")",
")",
"{",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"break",
";",
"case",
"X86",
"::",
"MOV8r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV8ri",
";",
"break",
";",
"case",
"X86",
"::",
"MOV16r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV16ri",
";",
"break",
";",
"case",
"X86",
"::",
"MOV32r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV32ri",
";",
"break",
";",
"case",
"X86",
"::",
"MOV64r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV64ri64i32",
";",
"break",
";",
"}",
"Clone",
"=",
"false",
";",
"}",
"break",
";",
"}",
"}",
"if",
"(",
"Clone",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"CloneMachineInstr",
"(",
"Orig",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"MI",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
".",
"addOperand",
"(",
"Orig",
"->",
"getOperand",
"(",
"0",
")",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"MachineInstr",
"*",
"NewMI",
"=",
"prior",
"(",
"I",
")",
";",
"NewMI",
"->",
"substituteRegister",
"(",
"Orig",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
",",
"DestReg",
",",
"SubIdx",
",",
"TRI",
")",
";",
"}",
"</s>"
] | [
"Re-issue",
"the",
"specified",
"'original",
"'",
"instruction",
"at",
"the",
"specific",
"location",
"targeting",
"a",
"new",
"destination",
"register",
"."
] | [
"X86",
"X86",
"X86::MOV8r0",
"X86::MOV16r0",
"X86::MOV32r0",
"X86::MOV64r0",
"X86::MOV8r0",
"X86::MOV8ri",
"X86::MOV16r0",
"X86::MOV16ri",
"X86::MOV32r0",
"X86::MOV32ri",
"X86::MOV64r0",
"X86::MOV64ri64i32",
"0",
"0",
"0"
] | X86InstrInfo12 | reMaterialize | X86 | CPU | LLVM | 17,664 | 261 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_lea_outperforms",
"(",
"rtx_insn",
"*",
"insn",
",",
"unsigned",
"int",
"regno0",
",",
"unsigned",
"int",
"regno1",
",",
"unsigned",
"int",
"regno2",
",",
"int",
"split_cost",
",",
"bool",
"has_scale",
")",
"{",
"int",
"dist_define",
",",
"dist_use",
";",
"if",
"(",
"TARGET_SILVERMONT",
"||",
"TARGET_GOLDMONT",
"||",
"TARGET_GOLDMONT_PLUS",
"||",
"TARGET_TREMONT",
"||",
"TARGET_INTEL",
")",
"{",
"if",
"(",
"has_scale",
")",
"return",
"true",
";",
"if",
"(",
"split_cost",
"<",
"1",
")",
"return",
"false",
";",
"if",
"(",
"regno0",
"==",
"regno1",
"||",
"regno0",
"==",
"regno2",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"dist_define",
"=",
"distance_non_agu_define",
"(",
"regno1",
",",
"regno2",
",",
"insn",
")",
";",
"dist_use",
"=",
"distance_agu_use",
"(",
"regno0",
",",
"insn",
")",
";",
"if",
"(",
"dist_define",
"<",
"0",
"||",
"dist_define",
">=",
"LEA_MAX_STALL",
")",
"{",
"if",
"(",
"dist_use",
"<",
"0",
"&&",
"split_cost",
"==",
"0",
")",
"return",
"TARGET_64BIT",
"||",
"IX86_LEA_PRIORITY",
";",
"else",
"return",
"true",
";",
"}",
"dist_define",
"+=",
"split_cost",
"+",
"IX86_LEA_PRIORITY",
";",
"if",
"(",
"dist_use",
"<",
"0",
")",
"return",
"dist_define",
">",
"LEA_MAX_STALL",
";",
"return",
"dist_define",
">=",
"dist_use",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"usage",
"of",
"lea",
"INSN",
"has",
"performance",
"advantage",
"over",
"a",
"sequence",
"of",
"instructions",
".",
"Instructions",
"sequence",
"has",
"SPLIT_COST",
"cycles",
"higher",
"latency",
"than",
"lea",
"latency",
"."
] | [
"i386",
"1",
"0",
"0",
"0",
"0"
] | i3868 | ix86_lea_outperforms | i386 | CPU | GCC | 17,665 | 152 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"s390_mangle_type",
"(",
"const_tree",
"type",
")",
"{",
"type",
"=",
"TYPE_MAIN_VARIANT",
"(",
"type",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"!=",
"VOID_TYPE",
"&&",
"TREE_CODE",
"(",
"type",
")",
"!=",
"BOOLEAN_TYPE",
"&&",
"TREE_CODE",
"(",
"type",
")",
"!=",
"INTEGER_TYPE",
"&&",
"TREE_CODE",
"(",
"type",
")",
"!=",
"REAL_TYPE",
")",
"return",
"NULL",
";",
"if",
"(",
"type",
"==",
"s390_builtin_types",
"[",
"BT_BV16QI",
"]",
")",
"return",
"\"U6__boolc\"",
";",
"if",
"(",
"type",
"==",
"s390_builtin_types",
"[",
"BT_BV8HI",
"]",
")",
"return",
"\"U6__bools\"",
";",
"if",
"(",
"type",
"==",
"s390_builtin_types",
"[",
"BT_BV4SI",
"]",
")",
"return",
"\"U6__booli\"",
";",
"if",
"(",
"type",
"==",
"s390_builtin_types",
"[",
"BT_BV2DI",
"]",
")",
"return",
"\"U6__booll\"",
";",
"if",
"(",
"type",
"==",
"long_double_type_node",
"&&",
"TARGET_LONG_DOUBLE_128",
")",
"return",
"\"g\"",
";",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MANGLE_TYPE",
"."
] | [
"s390",
"\"U6__boolc\"",
"\"U6__bools\"",
"\"U6__booli\"",
"\"U6__booll\"",
"\"g\""
] | s3901 | s390_mangle_type | s390 | MPU | GCC | 17,666 | 113 | 1 | [] |
[
"<s>",
"void",
"ARMBaseRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"unsigned",
"i",
"=",
"0",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"assert",
"(",
"!",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
"&&",
"\"This eliminateFrameIndex does not support Thumb1!\"",
")",
";",
"while",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
")",
"{",
"++",
"i",
";",
"assert",
"(",
"i",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
"&&",
"\"Instr doesn't have FrameIndex operand!\"",
")",
";",
"}",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"FrameReg",
";",
"int",
"Offset",
"=",
"ResolveFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"FrameReg",
",",
"SPAdj",
")",
";",
"if",
"(",
"MI",
".",
"isDebugValue",
"(",
")",
")",
"{",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"ChangeToRegister",
"(",
"FrameReg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"bool",
"Done",
"=",
"false",
";",
"if",
"(",
"!",
"AFI",
"->",
"isThumbFunction",
"(",
")",
")",
"Done",
"=",
"rewriteARMFrameIndex",
"(",
"MI",
",",
"i",
",",
"FrameReg",
",",
"Offset",
",",
"TII",
")",
";",
"else",
"{",
"assert",
"(",
"AFI",
"->",
"isThumb2Function",
"(",
")",
")",
";",
"Done",
"=",
"rewriteT2FrameIndex",
"(",
"MI",
",",
"i",
",",
"FrameReg",
",",
"Offset",
",",
"TII",
")",
";",
"}",
"if",
"(",
"Done",
")",
"return",
";",
"assert",
"(",
"(",
"Offset",
"||",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"TSFlags",
"&",
"ARMII",
"::",
"AddrModeMask",
")",
"==",
"ARMII",
"::",
"AddrMode4",
"||",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"TSFlags",
"&",
"ARMII",
"::",
"AddrModeMask",
")",
"==",
"ARMII",
"::",
"AddrMode6",
")",
"&&",
"\"This code isn't needed if offset already handled!\"",
")",
";",
"unsigned",
"ScratchReg",
"=",
"0",
";",
"int",
"PIdx",
"=",
"MI",
".",
"findFirstPredOperandIdx",
"(",
")",
";",
"ARMCC",
"::",
"CondCodes",
"Pred",
"=",
"(",
"PIdx",
"==",
"-",
"1",
")",
"?",
"ARMCC",
"::",
"AL",
":",
"(",
"ARMCC",
"::",
"CondCodes",
")",
"MI",
".",
"getOperand",
"(",
"PIdx",
")",
".",
"getImm",
"(",
")",
";",
"unsigned",
"PredReg",
"=",
"(",
"PIdx",
"==",
"-",
"1",
")",
"?",
"0",
":",
"MI",
".",
"getOperand",
"(",
"PIdx",
"+",
"1",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Offset",
"==",
"0",
")",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"ChangeToRegister",
"(",
"FrameReg",
",",
"false",
",",
"false",
",",
"false",
")",
";",
"else",
"{",
"ScratchReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"ARM",
"::",
"GPRRegisterClass",
")",
";",
"if",
"(",
"!",
"AFI",
"->",
"isThumbFunction",
"(",
")",
")",
"emitARMRegPlusImmediate",
"(",
"MBB",
",",
"II",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"ScratchReg",
",",
"FrameReg",
",",
"Offset",
",",
"Pred",
",",
"PredReg",
",",
"TII",
")",
";",
"else",
"{",
"assert",
"(",
"AFI",
"->",
"isThumb2Function",
"(",
")",
")",
";",
"emitT2RegPlusImmediate",
"(",
"MBB",
",",
"II",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"ScratchReg",
",",
"FrameReg",
",",
"Offset",
",",
"Pred",
",",
"PredReg",
",",
"TII",
")",
";",
"}",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"ChangeToRegister",
"(",
"ScratchReg",
",",
"false",
",",
"false",
",",
"true",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"ARM",
"ARM",
"0",
"ARM",
"ARM",
"\"This eliminateFrameIndex does not support Thumb1!\"",
"\"Instr doesn't have FrameIndex operand!\"",
"1",
"ARM",
"ARMII::AddrModeMask",
"ARMII::AddrMode4",
"ARMII::AddrModeMask",
"ARMII::AddrMode6",
"\"This code isn't needed if offset already handled!\"",
"0",
"ARMCC::CondCodes",
"1",
"ARMCC::AL",
"ARMCC::CondCodes",
"1",
"0",
"1",
"0",
"ARM::GPRRegisterClass",
"ARM"
] | ARMBaseRegisterInfo29 | eliminateFrameIndex | ARM | CPU | LLVM | 17,667 | 491 | 1 | [] |
[
"<s>",
"SMLoc",
"getStartLoc",
"(",
")",
"const",
"override",
"{",
"return",
"StartLoc",
";",
"}",
"</s>"
] | [
"getStartLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"first",
"token",
"of",
"this",
"operand",
"."
] | [
"AArch64"
] | AArch64AsmParser (2)1 | getStartLoc | AArch64 | CPU | LLVM | 17,668 | 11 | 1 | [] |
[
"<s>",
"virtual",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"PowerPC"
] | PPCInstrInfo (2) | getAnalysisUsage | PowerPC | CPU | LLVM | 17,669 | 18 | 1 | [] |
[
"<s>",
"static",
"bool",
"mn10300_handle_option",
"(",
"size_t",
"code",
",",
"const",
"char",
"*",
"arg",
"ATTRIBUTE_UNUSED",
",",
"int",
"value",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"OPT_mam33",
":",
"mn10300_processor",
"=",
"value",
"?",
"PROCESSOR_AM33",
":",
"PROCESSOR_MN10300",
";",
"return",
"true",
";",
"case",
"OPT_mam33_2",
":",
"mn10300_processor",
"=",
"(",
"value",
"?",
"PROCESSOR_AM33_2",
":",
"MIN",
"(",
"PROCESSOR_AM33",
",",
"PROCESSOR_DEFAULT",
")",
")",
";",
"return",
"true",
";",
"default",
":",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"TARGET_HANDLE_OPTION",
"."
] | [
"mn10300"
] | mn103003 | mn10300_handle_option | mn10300 | MPU | GCC | 17,670 | 64 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUTargetLowering",
"::",
"shouldReduceLoadWidth",
"(",
"SDNode",
"*",
"N",
",",
"ISD",
"::",
"LoadExtType",
",",
"EVT",
"NewVT",
")",
"const",
"{",
"unsigned",
"NewSize",
"=",
"NewVT",
".",
"getStoreSizeInBits",
"(",
")",
";",
"if",
"(",
"NewSize",
"==",
"32",
")",
"return",
"true",
";",
"EVT",
"OldVT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"unsigned",
"OldSize",
"=",
"OldVT",
".",
"getStoreSizeInBits",
"(",
")",
";",
"MemSDNode",
"*",
"MN",
"=",
"cast",
"<",
"MemSDNode",
">",
"(",
"N",
")",
";",
"unsigned",
"AS",
"=",
"MN",
"->",
"getAddressSpace",
"(",
")",
";",
"if",
"(",
"OldSize",
">=",
"32",
"&&",
"NewSize",
"<",
"32",
"&&",
"MN",
"->",
"getAlignment",
"(",
")",
">=",
"4",
"&&",
"(",
"AS",
"==",
"AMDGPUAS",
"::",
"CONSTANT_ADDRESS",
"||",
"AS",
"==",
"AMDGPUAS",
"::",
"CONSTANT_ADDRESS_32BIT",
"||",
"(",
"isa",
"<",
"LoadSDNode",
">",
"(",
"N",
")",
"&&",
"AS",
"==",
"AMDGPUAS",
"::",
"GLOBAL_ADDRESS",
"&&",
"MN",
"->",
"isInvariant",
"(",
")",
")",
")",
"&&",
"AMDGPUInstrInfo",
"::",
"isUniformMMO",
"(",
"MN",
"->",
"getMemOperand",
"(",
")",
")",
")",
"return",
"false",
";",
"return",
"(",
"OldSize",
"<",
"32",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"believe",
"it",
"is",
"correct",
"and",
"profitable",
"to",
"reduce",
"the",
"load",
"node",
"to",
"a",
"smaller",
"type",
"."
] | [
"AMDGPU",
"AMDGPU",
"ISD::LoadExtType",
"32",
"0",
"32",
"32",
"4",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"32"
] | AMDGPUISelLowering126 | shouldReduceLoadWidth | AMDGPU | GPU | LLVM | 17,671 | 152 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"TargetInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"MI",
",",
"MBB",
",",
"MF",
")",
"||",
"MI",
".",
"modifiesRegister",
"(",
"AMDGPU",
"::",
"EXEC",
",",
"&",
"RI",
")",
";",
"}",
"</s>"
] | [
"isSchedulingBoundary",
"-",
"Overrides",
"the",
"isSchedulingBoundary",
"from",
"Codegen/TargetInstrInfo.cpp",
"to",
"make",
"it",
"capable",
"of",
"identifying",
"ENDBR",
"intructions",
"and",
"prevent",
"it",
"from",
"being",
"re-scheduled",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::EXEC"
] | SIInstrInfo100 | isSchedulingBoundary | AMDGPU | GPU | LLVM | 17,672 | 47 | 1 | [] |
[
"<s>",
"void",
"m68hc11_notice_update_cc",
"(",
"rtx",
"exp",
",",
"rtx",
"insn",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"exp",
")",
"==",
"SET",
")",
"{",
"if",
"(",
"SET_DEST",
"(",
"exp",
")",
"==",
"pc_rtx",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"SET_SRC",
"(",
"exp",
")",
")",
"==",
"CALL",
")",
"{",
"CC_STATUS_INIT",
";",
"}",
"else",
"if",
"(",
"SET_DEST",
"(",
"exp",
")",
"==",
"cc0_rtx",
")",
"{",
"cc_status",
".",
"flags",
"=",
"0",
";",
"cc_status",
".",
"value1",
"=",
"XEXP",
"(",
"exp",
",",
"0",
")",
";",
"cc_status",
".",
"value2",
"=",
"XEXP",
"(",
"exp",
",",
"1",
")",
";",
"}",
"else",
"{",
"cc_status",
".",
"flags",
"=",
"0",
";",
"cc_status",
".",
"value1",
"=",
"XEXP",
"(",
"exp",
",",
"0",
")",
";",
"cc_status",
".",
"value2",
"=",
"XEXP",
"(",
"exp",
",",
"1",
")",
";",
"}",
"}",
"else",
"{",
"CC_STATUS_INIT",
";",
"}",
"if",
"(",
"cc_status",
".",
"value2",
"!=",
"0",
")",
"switch",
"(",
"GET_CODE",
"(",
"cc_status",
".",
"value2",
")",
")",
"{",
"case",
"IOR",
":",
"case",
"XOR",
":",
"case",
"AND",
":",
"break",
";",
"case",
"NOT",
":",
"if",
"(",
"GET_MODE",
"(",
"cc_status",
".",
"value2",
")",
"!=",
"QImode",
")",
"CC_STATUS_INIT",
";",
"break",
";",
"case",
"PLUS",
":",
"case",
"MINUS",
":",
"case",
"MULT",
":",
"case",
"DIV",
":",
"case",
"UDIV",
":",
"case",
"MOD",
":",
"case",
"UMOD",
":",
"case",
"NEG",
":",
"if",
"(",
"GET_MODE",
"(",
"cc_status",
".",
"value2",
")",
"!=",
"VOIDmode",
")",
"cc_status",
".",
"flags",
"|=",
"CC_NO_OVERFLOW",
";",
"break",
";",
"case",
"ASHIFT",
":",
"case",
"ROTATE",
":",
"case",
"ROTATERT",
":",
"if",
"(",
"GET_MODE",
"(",
"cc_status",
".",
"value2",
")",
"!=",
"VOIDmode",
")",
"cc_status",
".",
"flags",
"|=",
"CC_NO_OVERFLOW",
";",
"break",
";",
"case",
"MEM",
":",
"case",
"SYMBOL_REF",
":",
"case",
"REG",
":",
"case",
"CONST_INT",
":",
"cc_status",
".",
"flags",
"|=",
"CC_NO_OVERFLOW",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"if",
"(",
"cc_status",
".",
"value1",
"&&",
"GET_CODE",
"(",
"cc_status",
".",
"value1",
")",
"==",
"REG",
"&&",
"cc_status",
".",
"value2",
"&&",
"reg_overlap_mentioned_p",
"(",
"cc_status",
".",
"value1",
",",
"cc_status",
".",
"value2",
")",
")",
"cc_status",
".",
"value2",
"=",
"0",
";",
"else",
"if",
"(",
"cc_status",
".",
"value1",
"&&",
"side_effects_p",
"(",
"cc_status",
".",
"value1",
")",
")",
"cc_status",
".",
"value1",
"=",
"0",
";",
"else",
"if",
"(",
"cc_status",
".",
"value2",
"&&",
"side_effects_p",
"(",
"cc_status",
".",
"value2",
")",
")",
"cc_status",
".",
"value2",
"=",
"0",
";",
"}",
"</s>"
] | [
"Store",
"in",
"cc_status",
"the",
"expressions",
"that",
"the",
"condition",
"codes",
"will",
"describe",
"after",
"execution",
"of",
"an",
"instruction",
"whose",
"pattern",
"is",
"EXP",
".",
"Do",
"not",
"alter",
"them",
"if",
"the",
"instruction",
"would",
"not",
"alter",
"the",
"cc",
"'s",
"."
] | [
"m68hc11",
"0",
"0",
"1",
"0",
"0",
"1",
"0",
"0",
"0",
"0"
] | m68hc111 | m68hc11_notice_update_cc | m68hc11 | MPU | GCC | 17,673 | 345 | 1 | [] |
[
"<s>",
"void",
"FISCFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"computeStackSize",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"StackSize",
")",
"return",
";",
"unsigned",
"StackReg",
"=",
"FISC",
"::",
"SP",
";",
"unsigned",
"OffsetReg",
"=",
"materializeOffset",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"(",
"unsigned",
")",
"StackSize",
")",
";",
"if",
"(",
"OffsetReg",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"FISC",
"::",
"ADDrr",
")",
",",
"StackReg",
")",
".",
"addReg",
"(",
"StackReg",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"FISC",
"::",
"ADDri",
")",
",",
"StackReg",
")",
".",
"addReg",
"(",
"StackReg",
")",
".",
"addImm",
"(",
"StackSize",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"FISC",
"FISC",
"FISC::SP",
"FISC::ADDrr",
"FISC::ADDri"
] | FISCFrameLowering | emitEpilogue | FISC | CPU | LLVM | 17,674 | 174 | 1 | [] |
[
"<s>",
"bool",
"MipsAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
")",
"{",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"return",
"true",
";",
"printOperand",
"(",
"MI",
",",
"OpNo",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"Mips",
"Mips",
"0"
] | MipsAsmPrinter31 | PrintAsmOperand | Mips | CPU | LLVM | 17,675 | 45 | 1 | [] |
[
"<s>",
"const",
"UPTRegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"UPT",
"UPT"
] | UPTSubtarget | getRegisterInfo | UPT | CPU | LLVM | 17,676 | 18 | 1 | [] |
[
"<s>",
"void",
"SparcInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"uint64_t",
"Address",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"!",
"printAliasInstr",
"(",
"MI",
",",
"Address",
",",
"STI",
",",
"O",
")",
"&&",
"!",
"printSparcAliasInstr",
"(",
"MI",
",",
"STI",
",",
"O",
")",
")",
"printInstruction",
"(",
"MI",
",",
"Address",
",",
"STI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"Sparc",
"Sparc",
"Sparc"
] | SparcInstPrinter20 | printInst | Sparc | CPU | LLVM | 17,677 | 69 | 1 | [] |
[
"<s>",
"uint16_t",
"getDiscriminator",
"(",
")",
"const",
"{",
"return",
"Discriminator",
";",
"}",
"</s>"
] | [
"Get",
"the",
"Discriminator",
"of",
"this",
"MCDwarfLoc",
"."
] | [
"AArch64"
] | AArch64MCExpr16 | getDiscriminator | AArch64 | CPU | LLVM | 17,678 | 10 | 1 | [] |
[
"<s>",
"int",
"s390_label_align",
"(",
"rtx",
"label",
")",
"{",
"rtx_insn",
"*",
"prev_insn",
"=",
"prev_active_insn",
"(",
"label",
")",
";",
"rtx",
"set",
",",
"src",
";",
"if",
"(",
"prev_insn",
"==",
"NULL_RTX",
")",
"goto",
"old",
";",
"set",
"=",
"single_set",
"(",
"prev_insn",
")",
";",
"if",
"(",
"set",
"==",
"NULL_RTX",
")",
"goto",
"old",
";",
"src",
"=",
"SET_SRC",
"(",
"set",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"UNSPEC",
"&&",
"XINT",
"(",
"src",
",",
"1",
")",
"==",
"UNSPEC_MAIN_BASE",
")",
"return",
"0",
";",
"old",
":",
"return",
"align_labels_log",
";",
"}",
"</s>"
] | [
"Return",
"the",
"alignment",
"for",
"LABEL",
".",
"We",
"default",
"to",
"the",
"-falign-labels",
"value",
"except",
"for",
"the",
"literal",
"pool",
"base",
"label",
"."
] | [
"s390",
"1",
"0"
] | s3904 | s390_label_align | s390 | MPU | GCC | 17,679 | 80 | 1 | [] |
[
"<s>",
"static",
"void",
"replace_swapped_aligned_store",
"(",
"swap_web_entry",
"*",
"insn_entry",
",",
"rtx_insn",
"*",
"store_insn",
")",
"{",
"unsigned",
"uid",
"=",
"INSN_UID",
"(",
"store_insn",
")",
";",
"gcc_assert",
"(",
"insn_entry",
"[",
"uid",
"]",
".",
"is_swap",
"&&",
"insn_entry",
"[",
"uid",
"]",
".",
"is_store",
")",
";",
"rtx",
"body",
"=",
"PATTERN",
"(",
"store_insn",
")",
";",
"rtx",
"dest_address",
"=",
"XEXP",
"(",
"SET_DEST",
"(",
"body",
")",
",",
"0",
")",
";",
"rtx",
"swap_reg",
"=",
"XEXP",
"(",
"SET_SRC",
"(",
"body",
")",
",",
"0",
")",
";",
"gcc_assert",
"(",
"REG_P",
"(",
"dest_address",
")",
"||",
"rs6000_sum_of_two_registers_p",
"(",
"dest_address",
")",
")",
";",
"struct",
"df_insn_info",
"*",
"insn_info",
"=",
"DF_INSN_INFO_GET",
"(",
"store_insn",
")",
";",
"df_ref",
"use",
";",
"rtx_insn",
"*",
"swap_insn",
"=",
"NULL",
";",
"unsigned",
"uid2",
"=",
"0",
";",
"FOR_EACH_INSN_INFO_USE",
"(",
"use",
",",
"insn_info",
")",
"{",
"struct",
"df_link",
"*",
"def_link",
"=",
"DF_REF_CHAIN",
"(",
"use",
")",
";",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"DF_REF_REG",
"(",
"use",
")",
",",
"swap_reg",
")",
")",
"continue",
";",
"gcc_assert",
"(",
"def_link",
"&&",
"def_link",
"->",
"ref",
"&&",
"!",
"def_link",
"->",
"next",
"&&",
"!",
"DF_REF_IS_ARTIFICIAL",
"(",
"def_link",
"->",
"ref",
")",
")",
";",
"swap_insn",
"=",
"DF_REF_INSN",
"(",
"def_link",
"->",
"ref",
")",
";",
"uid2",
"=",
"INSN_UID",
"(",
"swap_insn",
")",
";",
"gcc_assert",
"(",
"insn_entry",
"[",
"uid2",
"]",
".",
"is_swap",
"&&",
"!",
"insn_entry",
"[",
"uid2",
"]",
".",
"is_load",
"&&",
"!",
"insn_entry",
"[",
"uid2",
"]",
".",
"is_store",
")",
";",
"break",
";",
"}",
"gcc_assert",
"(",
"swap_insn",
")",
";",
"rtx",
"set",
"=",
"single_set",
"(",
"store_insn",
")",
";",
"gcc_assert",
"(",
"set",
")",
";",
"rtx",
"dest_exp",
"=",
"SET_DEST",
"(",
"set",
")",
";",
"rtx",
"src_exp",
"=",
"XEXP",
"(",
"SET_SRC",
"(",
"body",
")",
",",
"0",
")",
";",
"enum",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"dest_exp",
")",
";",
"gcc_assert",
"(",
"MEM_P",
"(",
"dest_exp",
")",
")",
";",
"gcc_assert",
"(",
"MEM_ALIGN",
"(",
"dest_exp",
")",
">=",
"128",
")",
";",
"rtx",
"stvx",
";",
"stvx",
"=",
"rs6000_gen_stvx",
"(",
"mode",
",",
"dest_exp",
",",
"src_exp",
")",
";",
"rtx_insn",
"*",
"new_insn",
"=",
"emit_insn_before",
"(",
"stvx",
",",
"store_insn",
")",
";",
"rtx",
"new_body",
"=",
"PATTERN",
"(",
"new_insn",
")",
";",
"gcc_assert",
"(",
"(",
"GET_CODE",
"(",
"new_body",
")",
"==",
"SET",
")",
"&&",
"MEM_P",
"(",
"SET_DEST",
"(",
"new_body",
")",
")",
")",
";",
"basic_block",
"bb",
"=",
"BLOCK_FOR_INSN",
"(",
"store_insn",
")",
";",
"set_block_for_insn",
"(",
"new_insn",
",",
"bb",
")",
";",
"if",
"(",
"cfun",
"->",
"can_throw_non_call_exceptions",
"&&",
"BB_END",
"(",
"bb",
")",
"==",
"store_insn",
")",
"{",
"rtx",
"note",
"=",
"find_reg_note",
"(",
"store_insn",
",",
"REG_EH_REGION",
",",
"NULL_RTX",
")",
";",
"if",
"(",
"note",
")",
"add_reg_note",
"(",
"new_insn",
",",
"REG_EH_REGION",
",",
"XEXP",
"(",
"note",
",",
"0",
")",
")",
";",
"}",
"df_insn_rescan",
"(",
"new_insn",
")",
";",
"df_insn_delete",
"(",
"store_insn",
")",
";",
"remove_insn",
"(",
"store_insn",
")",
";",
"store_insn",
"->",
"set_deleted",
"(",
")",
";",
"uid2",
"=",
"INSN_UID",
"(",
"swap_insn",
")",
";",
"mark_swaps_for_removal",
"(",
"insn_entry",
",",
"uid2",
")",
";",
"replace_swap_with_copy",
"(",
"insn_entry",
",",
"uid2",
")",
";",
"}",
"</s>"
] | [
"Given",
"that",
"STORE_INSN",
"represents",
"an",
"aligned",
"store-with-swap",
"of",
"a",
"swapped",
"value",
",",
"replace",
"the",
"store",
"with",
"an",
"aligned",
"store",
"(",
"without",
"swap",
")",
"and",
"replace",
"the",
"swap",
"with",
"a",
"copy",
"insn",
"."
] | [
"rs6000",
"0",
"0",
"0",
"0",
"128",
"0"
] | rs6000-p8swap1 | replace_swapped_aligned_store | rs6000 | CPU | GCC | 17,680 | 430 | 1 | [] |
[
"<s>",
"static",
"tree",
"xstormy16_handle_below100_attribute",
"(",
"tree",
"*",
"node",
",",
"tree",
"name",
"ATTRIBUTE_UNUSED",
",",
"tree",
"args",
"ATTRIBUTE_UNUSED",
",",
"int",
"flags",
"ATTRIBUTE_UNUSED",
",",
"bool",
"*",
"no_add_attrs",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"*",
"node",
")",
"!=",
"VAR_DECL",
"&&",
"TREE_CODE",
"(",
"*",
"node",
")",
"!=",
"POINTER_TYPE",
"&&",
"TREE_CODE",
"(",
"*",
"node",
")",
"!=",
"TYPE_DECL",
")",
"{",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%<__BELOW100__%> attribute only applies to variables\"",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"args",
"==",
"NULL_TREE",
"&&",
"TREE_CODE",
"(",
"*",
"node",
")",
"==",
"VAR_DECL",
")",
"{",
"if",
"(",
"!",
"(",
"TREE_PUBLIC",
"(",
"*",
"node",
")",
"||",
"TREE_STATIC",
"(",
"*",
"node",
")",
")",
")",
"{",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%<__BELOW100__%> attribute not allowed \"",
"\"with auto storage class\"",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"}",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Handle",
"an",
"``",
"below",
"''",
"attribute",
";",
"arguments",
"as",
"in",
"struct",
"attribute_spec.handler",
"."
] | [
"stormy16",
"\"%<__BELOW100__%> attribute only applies to variables\"",
"\"%<__BELOW100__%> attribute not allowed \"",
"\"with auto storage class\""
] | stormy16 | xstormy16_handle_below100_attribute | stormy16 | CPU | GCC | 17,681 | 118 | 1 | [] |
[
"<s>",
"void",
"AArch64FrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"if",
"(",
"!",
"MF",
".",
"hasEHFunclets",
"(",
")",
")",
"return",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"WinEHFuncInfo",
"&",
"EHInfo",
"=",
"*",
"MF",
".",
"getWinEHFuncInfo",
"(",
")",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"auto",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"while",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"MBBI",
"->",
"getFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
")",
"++",
"MBBI",
";",
"if",
"(",
"MBBI",
"->",
"isTerminator",
"(",
")",
")",
"return",
";",
"int",
"UnwindHelpFI",
"=",
"MFI",
".",
"CreateStackObject",
"(",
"8",
",",
"16",
",",
"false",
")",
";",
"EHInfo",
".",
"UnwindHelpFrameIdx",
"=",
"UnwindHelpFI",
";",
"DebugLoc",
"DL",
";",
"RS",
"->",
"enterBasicBlock",
"(",
"MBB",
")",
";",
"unsigned",
"DstReg",
"=",
"RS",
"->",
"scavengeRegister",
"(",
"&",
"AArch64",
"::",
"GPR64RegClass",
",",
"MBBI",
",",
"0",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"AArch64",
"::",
"MOVi64imm",
")",
",",
"DstReg",
")",
".",
"addImm",
"(",
"-",
"2",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"AArch64",
"::",
"STURXi",
")",
")",
".",
"addReg",
"(",
"DstReg",
",",
"getKillRegState",
"(",
"true",
")",
")",
".",
"addFrameIndex",
"(",
"UnwindHelpFI",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"AArch64",
"AArch64",
"8",
"16",
"AArch64::GPR64RegClass",
"0",
"AArch64::MOVi64imm",
"2",
"AArch64::STURXi",
"0"
] | AArch64FrameLowering105 | processFunctionBeforeFrameFinalized | AArch64 | CPU | LLVM | 17,682 | 226 | 1 | [] |
[
"<s>",
"PPC",
"::",
"Predicate",
"PPC",
"::",
"getSwappedPredicate",
"(",
"PPC",
"::",
"Predicate",
"Opcode",
")",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"PPC",
"::",
"PRED_EQ",
":",
"return",
"PPC",
"::",
"PRED_EQ",
";",
"case",
"PPC",
"::",
"PRED_NE",
":",
"return",
"PPC",
"::",
"PRED_NE",
";",
"case",
"PPC",
"::",
"PRED_LT",
":",
"return",
"PPC",
"::",
"PRED_GT",
";",
"case",
"PPC",
"::",
"PRED_GE",
":",
"return",
"PPC",
"::",
"PRED_LE",
";",
"case",
"PPC",
"::",
"PRED_GT",
":",
"return",
"PPC",
"::",
"PRED_LT",
";",
"case",
"PPC",
"::",
"PRED_LE",
":",
"return",
"PPC",
"::",
"PRED_GE",
";",
"case",
"PPC",
"::",
"PRED_NU",
":",
"return",
"PPC",
"::",
"PRED_NU",
";",
"case",
"PPC",
"::",
"PRED_UN",
":",
"return",
"PPC",
"::",
"PRED_UN",
";",
"case",
"PPC",
"::",
"PRED_EQ_MINUS",
":",
"return",
"PPC",
"::",
"PRED_EQ_MINUS",
";",
"case",
"PPC",
"::",
"PRED_NE_MINUS",
":",
"return",
"PPC",
"::",
"PRED_NE_MINUS",
";",
"case",
"PPC",
"::",
"PRED_LT_MINUS",
":",
"return",
"PPC",
"::",
"PRED_GT_MINUS",
";",
"case",
"PPC",
"::",
"PRED_GE_MINUS",
":",
"return",
"PPC",
"::",
"PRED_LE_MINUS",
";",
"case",
"PPC",
"::",
"PRED_GT_MINUS",
":",
"return",
"PPC",
"::",
"PRED_LT_MINUS",
";",
"case",
"PPC",
"::",
"PRED_LE_MINUS",
":",
"return",
"PPC",
"::",
"PRED_GE_MINUS",
";",
"case",
"PPC",
"::",
"PRED_NU_MINUS",
":",
"return",
"PPC",
"::",
"PRED_NU_MINUS",
";",
"case",
"PPC",
"::",
"PRED_UN_MINUS",
":",
"return",
"PPC",
"::",
"PRED_UN_MINUS",
";",
"case",
"PPC",
"::",
"PRED_EQ_PLUS",
":",
"return",
"PPC",
"::",
"PRED_EQ_PLUS",
";",
"case",
"PPC",
"::",
"PRED_NE_PLUS",
":",
"return",
"PPC",
"::",
"PRED_NE_PLUS",
";",
"case",
"PPC",
"::",
"PRED_LT_PLUS",
":",
"return",
"PPC",
"::",
"PRED_GT_PLUS",
";",
"case",
"PPC",
"::",
"PRED_GE_PLUS",
":",
"return",
"PPC",
"::",
"PRED_LE_PLUS",
";",
"case",
"PPC",
"::",
"PRED_GT_PLUS",
":",
"return",
"PPC",
"::",
"PRED_LT_PLUS",
";",
"case",
"PPC",
"::",
"PRED_LE_PLUS",
":",
"return",
"PPC",
"::",
"PRED_GE_PLUS",
";",
"case",
"PPC",
"::",
"PRED_NU_PLUS",
":",
"return",
"PPC",
"::",
"PRED_NU_PLUS",
";",
"case",
"PPC",
"::",
"PRED_UN_PLUS",
":",
"return",
"PPC",
"::",
"PRED_UN_PLUS",
";",
"case",
"PPC",
"::",
"PRED_BIT_SET",
":",
"case",
"PPC",
"::",
"PRED_BIT_UNSET",
":",
"llvm_unreachable",
"(",
"\"Invalid use of bit predicate code\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Unknown PPC branch opcode!\"",
")",
";",
"}",
"</s>"
] | [
"This",
"is",
"a",
"static",
"version",
"that",
"you",
"can",
"use",
"without",
"an",
"instruction",
"available",
"."
] | [
"PowerPC",
"PPC::Predicate",
"PPC::getSwappedPredicate",
"PPC::Predicate",
"PPC::PRED_EQ",
"PPC::PRED_EQ",
"PPC::PRED_NE",
"PPC::PRED_NE",
"PPC::PRED_LT",
"PPC::PRED_GT",
"PPC::PRED_GE",
"PPC::PRED_LE",
"PPC::PRED_GT",
"PPC::PRED_LT",
"PPC::PRED_LE",
"PPC::PRED_GE",
"PPC::PRED_NU",
"PPC::PRED_NU",
"PPC::PRED_UN",
"PPC::PRED_UN",
"PPC::PRED_EQ_MINUS",
"PPC::PRED_EQ_MINUS",
"PPC::PRED_NE_MINUS",
"PPC::PRED_NE_MINUS",
"PPC::PRED_LT_MINUS",
"PPC::PRED_GT_MINUS",
"PPC::PRED_GE_MINUS",
"PPC::PRED_LE_MINUS",
"PPC::PRED_GT_MINUS",
"PPC::PRED_LT_MINUS",
"PPC::PRED_LE_MINUS",
"PPC::PRED_GE_MINUS",
"PPC::PRED_NU_MINUS",
"PPC::PRED_NU_MINUS",
"PPC::PRED_UN_MINUS",
"PPC::PRED_UN_MINUS",
"PPC::PRED_EQ_PLUS",
"PPC::PRED_EQ_PLUS",
"PPC::PRED_NE_PLUS",
"PPC::PRED_NE_PLUS",
"PPC::PRED_LT_PLUS",
"PPC::PRED_GT_PLUS",
"PPC::PRED_GE_PLUS",
"PPC::PRED_LE_PLUS",
"PPC::PRED_GT_PLUS",
"PPC::PRED_LT_PLUS",
"PPC::PRED_LE_PLUS",
"PPC::PRED_GE_PLUS",
"PPC::PRED_NU_PLUS",
"PPC::PRED_NU_PLUS",
"PPC::PRED_UN_PLUS",
"PPC::PRED_UN_PLUS",
"PPC::PRED_BIT_SET",
"PPC::PRED_BIT_UNSET",
"\"Invalid use of bit predicate code\"",
"\"Unknown PPC branch opcode!\""
] | PPCPredicates11 | getSwappedPredicate | PowerPC | CPU | LLVM | 17,683 | 280 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_evpc_neon_vuzp",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"unsigned",
"int",
"i",
",",
"odd",
",",
"mask",
",",
"nelt",
"=",
"d",
"->",
"perm",
".",
"length",
"(",
")",
";",
"rtx",
"out0",
",",
"out1",
",",
"in0",
",",
"in1",
";",
"int",
"first_elem",
";",
"int",
"swap_nelt",
";",
"if",
"(",
"GET_MODE_UNIT_SIZE",
"(",
"d",
"->",
"vmode",
")",
">=",
"8",
")",
"return",
"false",
";",
"swap_nelt",
"=",
"BYTES_BIG_ENDIAN",
"&&",
"!",
"d",
"->",
"one_vector_p",
"&&",
"GET_MODE_SIZE",
"(",
"d",
"->",
"vmode",
")",
"==",
"8",
"?",
"nelt",
":",
"0",
";",
"first_elem",
"=",
"d",
"->",
"perm",
"[",
"neon_endian_lane_map",
"(",
"d",
"->",
"vmode",
",",
"0",
")",
"]",
"^",
"swap_nelt",
";",
"if",
"(",
"first_elem",
"==",
"neon_endian_lane_map",
"(",
"d",
"->",
"vmode",
",",
"0",
")",
")",
"odd",
"=",
"0",
";",
"else",
"if",
"(",
"first_elem",
"==",
"neon_endian_lane_map",
"(",
"d",
"->",
"vmode",
",",
"1",
")",
")",
"odd",
"=",
"1",
";",
"else",
"return",
"false",
";",
"mask",
"=",
"(",
"d",
"->",
"one_vector_p",
"?",
"nelt",
"-",
"1",
":",
"2",
"*",
"nelt",
"-",
"1",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nelt",
";",
"i",
"++",
")",
"{",
"unsigned",
"elt",
"=",
"(",
"neon_pair_endian_lane_map",
"(",
"d",
"->",
"vmode",
",",
"i",
")",
"*",
"2",
"+",
"odd",
")",
"&",
"mask",
";",
"if",
"(",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"^",
"swap_nelt",
")",
"!=",
"neon_pair_endian_lane_map",
"(",
"d",
"->",
"vmode",
",",
"elt",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"d",
"->",
"testing_p",
")",
"return",
"true",
";",
"in0",
"=",
"d",
"->",
"op0",
";",
"in1",
"=",
"d",
"->",
"op1",
";",
"if",
"(",
"swap_nelt",
"!=",
"0",
")",
"std",
"::",
"swap",
"(",
"in0",
",",
"in1",
")",
";",
"out0",
"=",
"d",
"->",
"target",
";",
"out1",
"=",
"gen_reg_rtx",
"(",
"d",
"->",
"vmode",
")",
";",
"if",
"(",
"odd",
")",
"std",
"::",
"swap",
"(",
"out0",
",",
"out1",
")",
";",
"emit_insn",
"(",
"gen_neon_vuzp_internal",
"(",
"d",
"->",
"vmode",
",",
"out0",
",",
"in0",
",",
"in1",
",",
"out1",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Recognize",
"patterns",
"for",
"the",
"VUZP",
"insns",
"."
] | [
"arm",
"8",
"8",
"0",
"0",
"0",
"0",
"1",
"1",
"1",
"2",
"1",
"0",
"2",
"0"
] | arm | arm_evpc_neon_vuzp | arm | CPU | GCC | 17,684 | 300 | 1 | [] |
[
"<s>",
"Constant",
"*",
"AMDGPULibCalls",
"::",
"getFunction",
"(",
"Module",
"*",
"M",
",",
"const",
"FuncInfo",
"&",
"fInfo",
")",
"{",
"return",
"EnablePreLink",
"?",
"AMDGPULibFunc",
"::",
"getOrInsertFunction",
"(",
"M",
",",
"fInfo",
")",
":",
"AMDGPULibFunc",
"::",
"getFunction",
"(",
"M",
",",
"fInfo",
")",
";",
"}",
"</s>"
] | [
"getFunction",
"-",
"Return",
"this",
"trace",
"'s",
"parent",
"function",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPULibCalls10 | getFunction | AMDGPU | GPU | LLVM | 17,685 | 38 | 1 | [] |
[
"<s>",
"static",
"rtx",
"sh_function_arg",
"(",
"cumulative_args_t",
"ca_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"ca",
"=",
"get_cumulative_args",
"(",
"ca_v",
")",
";",
"machine_mode",
"mode",
"=",
"arg",
".",
"mode",
";",
"if",
"(",
"arg",
".",
"end_marker_p",
"(",
")",
")",
"return",
"ca",
"->",
"renesas_abi",
"?",
"const1_rtx",
":",
"const0_rtx",
";",
"if",
"(",
"sh_pass_in_reg_p",
"(",
"*",
"ca",
",",
"mode",
",",
"arg",
".",
"type",
")",
"&&",
"(",
"arg",
".",
"named",
"||",
"!",
"(",
"TARGET_HITACHI",
"||",
"ca",
"->",
"renesas_abi",
")",
")",
")",
"{",
"int",
"regno",
";",
"if",
"(",
"mode",
"==",
"SCmode",
"&&",
"TARGET_SH4",
"&&",
"TARGET_LITTLE_ENDIAN",
"&&",
"(",
"!",
"FUNCTION_ARG_SCmode_WART",
"||",
"(",
"sh_round_reg",
"(",
"*",
"ca",
",",
"mode",
")",
"&",
"1",
")",
")",
")",
"{",
"rtx",
"r1",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"SFmode",
",",
"BASE_ARG_REG",
"(",
"mode",
")",
"+",
"(",
"sh_round_reg",
"(",
"*",
"ca",
",",
"mode",
")",
"^",
"1",
")",
")",
",",
"const0_rtx",
")",
";",
"rtx",
"r2",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"SFmode",
",",
"BASE_ARG_REG",
"(",
"mode",
")",
"+",
"(",
"(",
"sh_round_reg",
"(",
"*",
"ca",
",",
"mode",
")",
"+",
"1",
")",
"^",
"1",
")",
")",
",",
"GEN_INT",
"(",
"4",
")",
")",
";",
"return",
"gen_rtx_PARALLEL",
"(",
"SCmode",
",",
"gen_rtvec",
"(",
"2",
",",
"r1",
",",
"r2",
")",
")",
";",
"}",
"if",
"(",
"(",
"TARGET_HITACHI",
"||",
"ca",
"->",
"renesas_abi",
")",
"&&",
"ca",
"->",
"free_single_fp_reg",
"&&",
"mode",
"==",
"SFmode",
")",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"ca",
"->",
"free_single_fp_reg",
")",
";",
"regno",
"=",
"(",
"BASE_ARG_REG",
"(",
"mode",
")",
"+",
"sh_round_reg",
"(",
"*",
"ca",
",",
"mode",
")",
")",
"^",
"(",
"mode",
"==",
"SFmode",
"&&",
"TARGET_SH4",
"&&",
"TARGET_LITTLE_ENDIAN",
"&&",
"!",
"TARGET_HITACHI",
"&&",
"!",
"ca",
"->",
"renesas_abi",
")",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Define",
"where",
"to",
"put",
"the",
"arguments",
"to",
"a",
"function",
".",
"Value",
"is",
"zero",
"to",
"push",
"the",
"argument",
"on",
"the",
"stack",
",",
"or",
"a",
"hard",
"register",
"in",
"which",
"to",
"store",
"the",
"argument",
".",
"MODE",
"is",
"the",
"argument",
"'s",
"machine",
"mode",
".",
"TYPE",
"is",
"the",
"data",
"type",
"of",
"the",
"argument",
"(",
"as",
"a",
"tree",
")",
".",
"This",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
".",
"CUM",
"is",
"a",
"variable",
"of",
"type",
"CUMULATIVE_ARGS",
"which",
"gives",
"info",
"about",
"the",
"preceding",
"args",
"and",
"about",
"the",
"function",
"being",
"called",
".",
"NAMED",
"is",
"nonzero",
"if",
"this",
"argument",
"is",
"a",
"named",
"parameter",
"(",
"otherwise",
"it",
"is",
"an",
"extra",
"parameter",
"matching",
"an",
"ellipsis",
")",
".",
"On",
"SH",
"the",
"first",
"args",
"are",
"normally",
"in",
"registers",
"and",
"the",
"rest",
"are",
"pushed",
".",
"Any",
"arg",
"that",
"starts",
"within",
"the",
"first",
"NPARM_REGS",
"words",
"is",
"at",
"least",
"partially",
"passed",
"in",
"a",
"register",
"unless",
"its",
"data",
"type",
"forbids",
"."
] | [
"sh",
"1",
"1",
"1",
"1",
"4",
"2"
] | sh | sh_function_arg | sh | CPU | GCC | 17,686 | 270 | 1 | [] |
[
"<s>",
"void",
"RISCVMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"verifyInstructionPredicates",
"(",
"MI",
",",
"computeAvailableFeatures",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
")",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"unsigned",
"Size",
"=",
"Desc",
".",
"getSize",
"(",
")",
";",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"RISCV",
"::",
"PseudoCALLReg",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"RISCV",
"::",
"PseudoCALL",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"RISCV",
"::",
"PseudoTAIL",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"RISCV",
"::",
"PseudoJump",
")",
"{",
"expandFunctionCall",
"(",
"MI",
",",
"OS",
",",
"Fixups",
",",
"STI",
")",
";",
"MCNumEmitted",
"+=",
"2",
";",
"return",
";",
"}",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"RISCV",
"::",
"PseudoAddTPRel",
")",
"{",
"expandAddTPRel",
"(",
"MI",
",",
"OS",
",",
"Fixups",
",",
"STI",
")",
";",
"MCNumEmitted",
"+=",
"1",
";",
"return",
";",
"}",
"switch",
"(",
"Size",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unhandled encodeInstruction length!\"",
")",
";",
"case",
"2",
":",
"{",
"uint16_t",
"Bits",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint16_t",
">",
"(",
"OS",
",",
"Bits",
",",
"support",
"::",
"little",
")",
";",
"break",
";",
"}",
"case",
"4",
":",
"{",
"uint32_t",
"Bits",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"support",
"::",
"endian",
"::",
"write",
"(",
"OS",
",",
"Bits",
",",
"support",
"::",
"little",
")",
";",
"break",
";",
"}",
"}",
"++",
"MCNumEmitted",
";",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"RISCV",
"RISCV",
"RISCV::PseudoCALLReg",
"RISCV::PseudoCALL",
"RISCV::PseudoTAIL",
"RISCV::PseudoJump",
"2",
"RISCV::PseudoAddTPRel",
"1",
"\"Unhandled encodeInstruction length!\"",
"2",
"support::endian",
"support::little",
"4",
"support::endian",
"support::little"
] | RISCVMCCodeEmitter1 | encodeInstruction | RISCV | CPU | LLVM | 17,687 | 247 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"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\"",
")",
";",
"if",
"(",
"Factor",
">",
"4",
")",
"return",
"false",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"LI",
"->",
"getModule",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"VectorType",
"*",
"VecTy",
"=",
"Shuffles",
"[",
"0",
"]",
"->",
"getType",
"(",
")",
";",
"unsigned",
"VecSize",
"=",
"DL",
".",
"getTypeSizeInBits",
"(",
"VecTy",
")",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"||",
"(",
"VecSize",
"!=",
"64",
"&&",
"VecSize",
"!=",
"128",
")",
")",
"return",
"false",
";",
"Type",
"*",
"EltTy",
"=",
"VecTy",
"->",
"getVectorElementType",
"(",
")",
";",
"if",
"(",
"EltTy",
"->",
"isPointerTy",
"(",
")",
")",
"VecTy",
"=",
"VectorType",
"::",
"get",
"(",
"DL",
".",
"getIntPtrType",
"(",
"EltTy",
")",
",",
"VecTy",
"->",
"getVectorNumElements",
"(",
")",
")",
";",
"Type",
"*",
"PtrTy",
"=",
"VecTy",
"->",
"getPointerTo",
"(",
"LI",
"->",
"getPointerAddressSpace",
"(",
")",
")",
";",
"Type",
"*",
"Tys",
"[",
"2",
"]",
"=",
"{",
"VecTy",
",",
"PtrTy",
"}",
";",
"static",
"const",
"Intrinsic",
"::",
"ID",
"LoadInts",
"[",
"3",
"]",
"=",
"{",
"Intrinsic",
"::",
"aarch64_neon_ld2",
",",
"Intrinsic",
"::",
"aarch64_neon_ld3",
",",
"Intrinsic",
"::",
"aarch64_neon_ld4",
"}",
";",
"Function",
"*",
"LdNFunc",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"LI",
"->",
"getModule",
"(",
")",
",",
"LoadInts",
"[",
"Factor",
"-",
"2",
"]",
",",
"Tys",
")",
";",
"IRBuilder",
"<",
">",
"Builder",
"(",
"LI",
")",
";",
"Value",
"*",
"Ptr",
"=",
"Builder",
".",
"CreateBitCast",
"(",
"LI",
"->",
"getPointerOperand",
"(",
")",
",",
"PtrTy",
")",
";",
"CallInst",
"*",
"LdN",
"=",
"Builder",
".",
"CreateCall",
"(",
"LdNFunc",
",",
"Ptr",
",",
"\"ldN\"",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Shuffles",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"ShuffleVectorInst",
"*",
"SVI",
"=",
"Shuffles",
"[",
"i",
"]",
";",
"unsigned",
"Index",
"=",
"Indices",
"[",
"i",
"]",
";",
"Value",
"*",
"SubVec",
"=",
"Builder",
".",
"CreateExtractValue",
"(",
"LdN",
",",
"Index",
")",
";",
"if",
"(",
"EltTy",
"->",
"isPointerTy",
"(",
")",
")",
"SubVec",
"=",
"Builder",
".",
"CreateIntToPtr",
"(",
"SubVec",
",",
"SVI",
"->",
"getType",
"(",
")",
")",
";",
"SVI",
"->",
"replaceAllUsesWith",
"(",
"SubVec",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Lower",
"interleaved",
"load",
"(",
"s",
")",
"into",
"target",
"specific",
"instructions/intrinsics",
"."
] | [
"AArch64",
"AArch64",
"2",
"\"Invalid interleave factor\"",
"\"Empty shufflevector input\"",
"\"Unmatched number of shufflevectors and indices\"",
"4",
"0",
"64",
"128",
"2",
"Intrinsic::ID",
"3",
"Intrinsic::aarch64_neon_ld2",
"Intrinsic::aarch64_neon_ld3",
"Intrinsic::aarch64_neon_ld4",
"Intrinsic::getDeclaration",
"2",
"\"ldN\"",
"0"
] | AArch64ISelLowering102 | lowerInterleavedLoad | AArch64 | CPU | LLVM | 17,688 | 378 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_float_exceptions_rounding_supported_p",
"(",
"void",
")",
"{",
"return",
"TARGET_80387",
"||",
"(",
"TARGET_SSE",
"&&",
"TARGET_SSE_MATH",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P",
"."
] | [
"i386"
] | i386 | ix86_float_exceptions_rounding_supported_p | i386 | CPU | GCC | 17,689 | 17 | 1 | [] |
[
"<s>",
"void",
"Mips16InstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"0",
";",
"if",
"(",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"DestReg",
")",
"&&",
"Mips",
"::",
"GPR32RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MoveR3216",
";",
"else",
"if",
"(",
"Mips",
"::",
"GPR32RegClass",
".",
"contains",
"(",
"DestReg",
")",
"&&",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"Move32R16",
";",
"else",
"if",
"(",
"(",
"SrcReg",
"==",
"Mips",
"::",
"HI0",
")",
"&&",
"(",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
")",
"Opc",
"=",
"Mips",
"::",
"Mfhi16",
",",
"SrcReg",
"=",
"0",
";",
"else",
"if",
"(",
"(",
"SrcReg",
"==",
"Mips",
"::",
"LO0",
")",
"&&",
"(",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
")",
"Opc",
"=",
"Mips",
"::",
"Mflo16",
",",
"SrcReg",
"=",
"0",
";",
"assert",
"(",
"Opc",
"&&",
"\"Cannot copy registers\"",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
";",
"if",
"(",
"DestReg",
")",
"MIB",
".",
"addReg",
"(",
"DestReg",
",",
"RegState",
"::",
"Define",
")",
";",
"if",
"(",
"SrcReg",
")",
"MIB",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"Mips",
"Mips",
"0",
"Mips::CPU16RegsRegClass",
"Mips::GPR32RegClass",
"Mips::MoveR3216",
"Mips::GPR32RegClass",
"Mips::CPU16RegsRegClass",
"Mips::Move32R16",
"Mips::HI0",
"Mips::CPU16RegsRegClass",
"Mips::Mfhi16",
"0",
"Mips::LO0",
"Mips::CPU16RegsRegClass",
"Mips::Mflo16",
"0",
"\"Cannot copy registers\""
] | Mips16InstrInfo13 | copyPhysReg | Mips | CPU | LLVM | 17,690 | 208 | 1 | [] |
[
"<s>",
"void",
"AArch64TargetStreamer",
"::",
"finish",
"(",
")",
"{",
"ConstantPools",
"->",
"emitAll",
"(",
"Streamer",
")",
";",
"if",
"(",
"MarkBTIProperty",
")",
"emitNoteSection",
"(",
"ELF",
"::",
"GNU_PROPERTY_AARCH64_FEATURE_1_BTI",
")",
";",
"}",
"</s>"
] | [
"finish",
"-",
"after",
"all",
"the",
"new",
"live",
"ranges",
"have",
"been",
"created",
",",
"compute",
"the",
"remaining",
"live",
"range",
",",
"and",
"rewrite",
"instructions",
"to",
"use",
"the",
"new",
"registers",
"."
] | [
"AArch64",
"AArch64"
] | AArch64TargetStreamer13 | finish | AArch64 | CPU | LLVM | 17,691 | 26 | 1 | [] |
[
"<s>",
"void",
"AArch64PassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"if",
"(",
"PACStack",
"::",
"doDummyPA",
"(",
")",
")",
"addPass",
"(",
"createAArch64DummyPA",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
">=",
"CodeGenOpt",
"::",
"Aggressive",
"&&",
"EnableLoadStoreOpt",
")",
"addPass",
"(",
"createAArch64LoadStoreOptimizationPass",
"(",
")",
")",
";",
"if",
"(",
"EnableA53Fix835769",
")",
"addPass",
"(",
"createAArch64A53Fix835769",
"(",
")",
")",
";",
"if",
"(",
"BranchRelaxation",
")",
"addPass",
"(",
"&",
"BranchRelaxationPassID",
")",
";",
"if",
"(",
"EnableBranchTargets",
")",
"addPass",
"(",
"createAArch64BranchTargetsPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableCompressJumpTables",
")",
"addPass",
"(",
"createAArch64CompressJumpTablesPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableCollectLOH",
"&&",
"TM",
"->",
"getTargetTriple",
"(",
")",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"addPass",
"(",
"createAArch64CollectLOHPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine81 | addPreEmitPass | AArch64 | CPU | LLVM | 17,692 | 128 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_modes_tieable_p",
"(",
"machine_mode",
"mode1",
",",
"machine_mode",
"mode2",
")",
"{",
"return",
"(",
"mode1",
"==",
"mode2",
"||",
"!",
"(",
"GET_MODE_CLASS",
"(",
"mode1",
")",
"==",
"MODE_FLOAT",
"&&",
"GET_MODE_CLASS",
"(",
"mode2",
")",
"==",
"MODE_FLOAT",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MODES_TIEABLE_P",
".",
"Do",
"n't",
"allow",
"floating-point",
"modes",
"to",
"be",
"tied",
",",
"since",
"type",
"punning",
"of",
"single-precision",
"and",
"double-precision",
"is",
"implementation",
"defined",
"."
] | [
"riscv"
] | riscv | riscv_modes_tieable_p | riscv | CPU | GCC | 17,693 | 36 | 1 | [] |
[
"<s>",
"void",
"createdInstr",
"(",
"MachineInstr",
"&",
"MI",
")",
"override",
"{",
"InstList",
".",
"insert",
"(",
"&",
"MI",
")",
";",
"}",
"</s>"
] | [
"An",
"instruction",
"has",
"been",
"created",
"and",
"inserted",
"into",
"the",
"function",
"."
] | [
"Mips"
] | MipsRegisterBankInfo10 | createdInstr | Mips | CPU | LLVM | 17,694 | 18 | 1 | [] |
[
"<s>",
"MCFragment",
"*",
"findAssociatedFragment",
"(",
")",
"const",
"override",
"{",
"return",
"getSubExpr",
"(",
")",
"->",
"findAssociatedFragment",
"(",
")",
";",
"}",
"</s>"
] | [
"Find",
"the",
"``",
"associated",
"section",
"''",
"for",
"this",
"expression",
",",
"which",
"is",
"currently",
"defined",
"as",
"the",
"absolute",
"section",
"for",
"constants",
",",
"or",
"otherwise",
"the",
"section",
"associated",
"with",
"the",
"first",
"defined",
"symbol",
"in",
"the",
"expression",
"."
] | [
"MOS"
] | MOSMCExpr | findAssociatedFragment | MOS | MPU | LLVM | 17,695 | 18 | 1 | [] |
[
"<s>",
"bool",
"VEAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"unsigned",
"MatchResult",
"=",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
";",
"switch",
"(",
"MatchResult",
")",
"{",
"case",
"Match_Success",
":",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"emitInstruction",
"(",
"Inst",
",",
"getSTI",
"(",
")",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction requires a CPU feature not currently enabled\"",
")",
";",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0ULL",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"VEOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"invalid instruction mnemonic\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Implement any new match types added!\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"VE",
"VE",
"\"instruction requires a CPU feature not currently enabled\"",
"0ULL",
"\"too few operands for instruction\"",
"VE",
"\"invalid operand for instruction\"",
"\"invalid instruction mnemonic\"",
"\"Implement any new match types added!\""
] | VEAsmParser (2) | MatchAndEmitInstruction | VE | CPU | LLVM | 17,696 | 178 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_legitimate_address_p",
"(",
"enum",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"bool",
"strict_p",
")",
"{",
"struct",
"riscv_address_info",
"addr",
";",
"return",
"riscv_classify_address",
"(",
"&",
"addr",
",",
"x",
",",
"mode",
",",
"strict_p",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMATE_ADDRESS_P",
"."
] | [
"riscv"
] | riscv2 | riscv_legitimate_address_p | riscv | CPU | GCC | 17,697 | 33 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isDebugInstr",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
".",
"isCall",
"(",
")",
")",
"{",
"if",
"(",
"doesNotReturn",
"(",
"MI",
")",
")",
"return",
"true",
";",
"for",
"(",
"auto",
"I",
":",
"MBB",
"->",
"successors",
"(",
")",
")",
"if",
"(",
"I",
"->",
"isEHPad",
"(",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"isTerminator",
"(",
")",
"||",
"MI",
".",
"isPosition",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"MI",
".",
"isInlineAsm",
"(",
")",
"&&",
"!",
"ScheduleInlineAsm",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"isSchedulingBoundary",
"-",
"Overrides",
"the",
"isSchedulingBoundary",
"from",
"Codegen/TargetInstrInfo.cpp",
"to",
"make",
"it",
"capable",
"of",
"identifying",
"ENDBR",
"intructions",
"and",
"prevent",
"it",
"from",
"being",
"re-scheduled",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonInstrInfo (2)2 | isSchedulingBoundary | Hexagon | DSP | LLVM | 17,698 | 114 | 1 | [] |
[
"<s>",
"int",
"memory_reload_operand",
"(",
"rtx",
"operand",
",",
"enum",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"GET_CODE",
"(",
"operand",
")",
"==",
"MEM",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"operand",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"(",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"operand",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"REG",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"operand",
",",
"0",
")",
",",
"1",
")",
")",
"==",
"CONST_INT",
")",
"||",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"operand",
",",
"0",
")",
",",
"1",
")",
")",
"==",
"REG",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"operand",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"CONST_INT",
")",
")",
";",
"}",
"</s>"
] | [
"Predicates",
"for",
"machine",
"description",
"."
] | [
"m68hc11",
"0",
"0",
"0",
"0",
"1",
"0",
"1",
"0",
"0"
] | m68hc111 | memory_reload_operand | m68hc11 | MPU | GCC | 17,699 | 107 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.