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>",
"StringRef",
"str",
"(",
")",
"{",
"return",
"OS",
".",
"str",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"twine",
"contents",
"as",
"a",
"std",
":",
":string",
"."
] | [
"HSAIL"
] | HSAILStoreInitializer | str | HSAIL | Virtual ISA | LLVM | 23,500 | 13 | 1 | [] |
[
"<s>",
"void",
"emitInst",
"(",
"uint32_t",
"Inst",
",",
"char",
"Suffix",
")",
"{",
"unsigned",
"Size",
";",
"char",
"Buffer",
"[",
"4",
"]",
";",
"const",
"bool",
"LittleEndian",
"=",
"getContext",
"(",
")",
".",
"getAsmInfo",
"(",
")",
"->",
"isLittleEndian",
"(",
")",
";",
"switch",
"(",
"Suffix",
")",
"{",
"case",
"'\\0'",
":",
"Size",
"=",
"4",
";",
"assert",
"(",
"!",
"IsThumb",
")",
";",
"EmitARMMappingSymbol",
"(",
")",
";",
"for",
"(",
"unsigned",
"II",
"=",
"0",
",",
"IE",
"=",
"Size",
";",
"II",
"!=",
"IE",
";",
"II",
"++",
")",
"{",
"const",
"unsigned",
"I",
"=",
"LittleEndian",
"?",
"(",
"Size",
"-",
"II",
"-",
"1",
")",
":",
"II",
";",
"Buffer",
"[",
"Size",
"-",
"II",
"-",
"1",
"]",
"=",
"uint8_t",
"(",
"Inst",
">>",
"I",
"*",
"CHAR_BIT",
")",
";",
"}",
"break",
";",
"case",
"'n'",
":",
"case",
"'w'",
":",
"Size",
"=",
"(",
"Suffix",
"==",
"'n'",
"?",
"2",
":",
"4",
")",
";",
"assert",
"(",
"IsThumb",
")",
";",
"EmitThumbMappingSymbol",
"(",
")",
";",
"for",
"(",
"unsigned",
"II",
"=",
"0",
",",
"IE",
"=",
"Size",
";",
"II",
"!=",
"IE",
";",
"II",
"=",
"II",
"+",
"2",
")",
"{",
"const",
"unsigned",
"I0",
"=",
"LittleEndian",
"?",
"II",
"+",
"0",
":",
"II",
"+",
"1",
";",
"const",
"unsigned",
"I1",
"=",
"LittleEndian",
"?",
"II",
"+",
"1",
":",
"II",
"+",
"0",
";",
"Buffer",
"[",
"Size",
"-",
"II",
"-",
"2",
"]",
"=",
"uint8_t",
"(",
"Inst",
">>",
"I0",
"*",
"CHAR_BIT",
")",
";",
"Buffer",
"[",
"Size",
"-",
"II",
"-",
"1",
"]",
"=",
"uint8_t",
"(",
"Inst",
">>",
"I1",
"*",
"CHAR_BIT",
")",
";",
"}",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Invalid Suffix\"",
")",
";",
"}",
"MCELFStreamer",
"::",
"EmitBytes",
"(",
"StringRef",
"(",
"Buffer",
",",
"Size",
")",
")",
";",
"}",
"</s>"
] | [
"Callback",
"used",
"to",
"implement",
"the",
".inst",
"directive",
"."
] | [
"ARM",
"4",
"4",
"ARM",
"0",
"1",
"1",
"2",
"4",
"0",
"2",
"0",
"1",
"1",
"0",
"2",
"1",
"\"Invalid Suffix\""
] | ARMELFStreamer14 | emitInst | ARM | CPU | LLVM | 23,501 | 250 | 1 | [] |
[
"<s>",
"bool",
"enableMachineScheduler",
"(",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Enable",
"the",
"MachineScheduler",
"pass",
"for",
"all",
"X86",
"subtargets",
"."
] | [
"TPC"
] | TPCSubtarget | enableMachineScheduler | TPC | Virtual ISA | LLVM | 23,502 | 11 | 1 | [] |
[
"<s>",
"SDValue",
"TeakTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"isVarArg",
")",
"{",
"report_fatal_error",
"(",
"\"VarArg not supported\"",
")",
";",
"}",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_Teak",
")",
";",
"SDValue",
"Flag",
";",
"SmallVector",
"<",
"SDValue",
",",
"4",
">",
"RetOps",
"(",
"1",
",",
"Chain",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RVLocs",
".",
"size",
"(",
")",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"OutVals",
"[",
"i",
"]",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"RetOps",
"[",
"0",
"]",
"=",
"Chain",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"{",
"RetOps",
".",
"push_back",
"(",
"Flag",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"TeakISD",
"::",
"RET_FLAG",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"RetOps",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"Teak",
"Teak",
"ISD::OutputArg",
"\"VarArg not supported\"",
"16",
"Teak",
"4",
"1",
"0",
"\"Can only return in registers!\"",
"1",
"0",
"TeakISD::RET_FLAG",
"MVT::Other"
] | TeakISelLowering | LowerReturn | Teak | DSP | LLVM | 23,503 | 254 | 1 | [] |
[
"<s>",
"void",
"AMDGPUInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"DestReg",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"Not Implemented\"",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"R600",
"\"Not Implemented\""
] | AMDGPUInstrInfo16 | loadRegFromStackSlot | R600 | GPU | LLVM | 23,504 | 38 | 1 | [] |
[
"<s>",
"bool",
"RISCVInstrInfo",
"::",
"isBranchOffsetInRange",
"(",
"unsigned",
"BranchOp",
",",
"int64_t",
"BrOffset",
")",
"const",
"{",
"unsigned",
"XLen",
"=",
"STI",
".",
"getXLen",
"(",
")",
";",
"switch",
"(",
"BranchOp",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected opcode!\"",
")",
";",
"case",
"RISCV",
"::",
"BEQ",
":",
"case",
"RISCV",
"::",
"BNE",
":",
"case",
"RISCV",
"::",
"BLT",
":",
"case",
"RISCV",
"::",
"BGE",
":",
"case",
"RISCV",
"::",
"BLTU",
":",
"case",
"RISCV",
"::",
"BGEU",
":",
"case",
"RISCV",
"::",
"CV_BEQIMM",
":",
"case",
"RISCV",
"::",
"CV_BNEIMM",
":",
"return",
"isIntN",
"(",
"13",
",",
"BrOffset",
")",
";",
"case",
"RISCV",
"::",
"JAL",
":",
"case",
"RISCV",
"::",
"PseudoBR",
":",
"return",
"isIntN",
"(",
"21",
",",
"BrOffset",
")",
";",
"case",
"RISCV",
"::",
"PseudoJump",
":",
"return",
"isIntN",
"(",
"32",
",",
"SignExtend64",
"(",
"BrOffset",
"+",
"0x800",
",",
"XLen",
")",
")",
";",
"case",
"RISCV",
"::",
"HwlpBranch",
":",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"Determine",
"if",
"the",
"branch",
"target",
"is",
"in",
"range",
"."
] | [
"RISCV",
"RISCV",
"\"Unexpected opcode!\"",
"RISCV::BEQ",
"RISCV::BNE",
"RISCV::BLT",
"RISCV::BGE",
"RISCV::BLTU",
"RISCV::BGEU",
"RISCV::CV_BEQIMM",
"RISCV::CV_BNEIMM",
"13",
"RISCV::JAL",
"RISCV::PseudoBR",
"21",
"RISCV::PseudoJump",
"32",
"0x800",
"RISCV::HwlpBranch"
] | RISCVInstrInfo2 | isBranchOffsetInRange | RISCV | CPU | LLVM | 23,505 | 130 | 1 | [] |
[
"<s>",
"static",
"const",
"TargetRegisterClass",
"*",
"getRegClass",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"Register",
"Reg",
")",
"{",
"if",
"(",
"MI",
".",
"getParent",
"(",
")",
"==",
"nullptr",
")",
"return",
"nullptr",
";",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"return",
"MF",
"?",
"MF",
"->",
"getRegInfo",
"(",
")",
".",
"getRegClassOrNull",
"(",
"Reg",
")",
":",
"nullptr",
";",
"}",
"</s>"
] | [
"Given",
"a",
"machine",
"instruction",
"descriptor",
",",
"returns",
"the",
"register",
"class",
"constraint",
"for",
"OpNum",
",",
"or",
"NULL",
"."
] | [
"AArch64"
] | AArch64InstrInfo51 | getRegClass | AArch64 | CPU | LLVM | 23,506 | 60 | 1 | [] |
[
"<s>",
"unsigned",
"AVRInstrInfo",
"::",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"{",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"get",
"(",
"Opcode",
")",
";",
"return",
"Desc",
".",
"getSize",
"(",
")",
";",
"}",
"case",
"TargetOpcode",
"::",
"EH_LABEL",
":",
"case",
"TargetOpcode",
"::",
"IMPLICIT_DEF",
":",
"case",
"TargetOpcode",
"::",
"KILL",
":",
"case",
"TargetOpcode",
"::",
"DBG_VALUE",
":",
"return",
"0",
";",
"case",
"TargetOpcode",
"::",
"INLINEASM",
":",
"{",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"AVRTargetMachine",
"&",
"TM",
"=",
"static_cast",
"<",
"const",
"AVRTargetMachine",
"&",
">",
"(",
"MF",
"->",
"getTarget",
"(",
")",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"TM",
".",
"getSubtargetImpl",
"(",
")",
"->",
"getInstrInfo",
"(",
")",
";",
"return",
"TII",
".",
"getInlineAsmLength",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSymbolName",
"(",
")",
",",
"*",
"TM",
".",
"getMCAsmInfo",
"(",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"AVR",
"AVR",
"0",
"AVR",
"AVR",
"0"
] | AVRInstrInfo23 | getInstSizeInBytes | AVR | MPU | LLVM | 23,507 | 153 | 1 | [] |
[
"<s>",
"bool",
"SystemZPassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"addPass",
"(",
"createSystemZISelDag",
"(",
"getSystemZTargetMachine",
"(",
")",
",",
"getOptLevel",
"(",
")",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createSystemZLDCleanupPass",
"(",
"getSystemZTargetMachine",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ"
] | SystemZTargetMachine10 | addInstSelector | SystemZ | CPU | LLVM | 23,508 | 45 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"uint64_t",
"StackSize",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"getStackSize",
"(",
")",
";",
"if",
"(",
"!",
"needsSP",
"(",
"MF",
")",
"||",
"!",
"needsSPWriteback",
"(",
"MF",
")",
")",
"return",
";",
"auto",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
";",
"const",
"auto",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"InsertPt",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"InsertPt",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"InsertPt",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"SPReg",
"=",
"0",
";",
"unsigned",
"SPFPReg",
"=",
"hasFP",
"(",
"MF",
")",
"?",
"getFPReg",
"(",
"MF",
")",
":",
"getSPReg",
"(",
"MF",
")",
";",
"if",
"(",
"hasBP",
"(",
"MF",
")",
")",
"{",
"auto",
"FI",
"=",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
";",
"SPReg",
"=",
"FI",
"->",
"getBasePointerVreg",
"(",
")",
";",
"}",
"else",
"if",
"(",
"StackSize",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"PtrRC",
"=",
"MRI",
".",
"getTargetRegisterInfo",
"(",
")",
"->",
"getPointerRegClass",
"(",
"MF",
")",
";",
"Register",
"OffsetReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"PtrRC",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"getOpcConst",
"(",
"MF",
")",
")",
",",
"OffsetReg",
")",
".",
"addImm",
"(",
"StackSize",
")",
";",
"SPReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"PtrRC",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"getOpcAdd",
"(",
"MF",
")",
")",
",",
"SPReg",
")",
".",
"addReg",
"(",
"SPFPReg",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
";",
"}",
"else",
"{",
"SPReg",
"=",
"SPFPReg",
";",
"}",
"writeSPToGlobal",
"(",
"SPReg",
",",
"MF",
",",
"MBB",
",",
"InsertPt",
",",
"DL",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"0",
"WebAssembly"
] | WebAssemblyFrameLowering11 | emitEpilogue | WebAssembly | Virtual ISA | LLVM | 23,509 | 280 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUTargetLowering",
"::",
"ComputeNumSignBitsForTargetNode",
"(",
"SDValue",
"Op",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPUISD",
"::",
"BFE_I32",
":",
"{",
"ConstantSDNode",
"*",
"Width",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
";",
"if",
"(",
"!",
"Width",
")",
"return",
"1",
";",
"unsigned",
"SignBits",
"=",
"32",
"-",
"Width",
"->",
"getZExtValue",
"(",
")",
"+",
"1",
";",
"if",
"(",
"!",
"isNullConstant",
"(",
"Op",
".",
"getOperand",
"(",
"1",
")",
")",
")",
"return",
"SignBits",
";",
"unsigned",
"Op0SignBits",
"=",
"DAG",
".",
"ComputeNumSignBits",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
",",
"Depth",
"+",
"1",
")",
";",
"return",
"std",
"::",
"max",
"(",
"SignBits",
",",
"Op0SignBits",
")",
";",
"}",
"case",
"AMDGPUISD",
"::",
"BFE_U32",
":",
"{",
"ConstantSDNode",
"*",
"Width",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
";",
"return",
"Width",
"?",
"32",
"-",
"(",
"Width",
"->",
"getZExtValue",
"(",
")",
"&",
"0x1f",
")",
":",
"1",
";",
"}",
"case",
"AMDGPUISD",
"::",
"CARRY",
":",
"case",
"AMDGPUISD",
"::",
"BORROW",
":",
"return",
"31",
";",
"default",
":",
"return",
"1",
";",
"}",
"}",
"</s>"
] | [
"Determine",
"the",
"number",
"of",
"bits",
"in",
"the",
"operation",
"that",
"are",
"sign",
"bits",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPUISD::BFE_I32",
"2",
"1",
"32",
"1",
"1",
"0",
"1",
"AMDGPUISD::BFE_U32",
"2",
"32",
"0x1f",
"1",
"AMDGPUISD::CARRY",
"AMDGPUISD::BORROW",
"31",
"1"
] | AMDGPUISelLowering (2) | ComputeNumSignBitsForTargetNode | AMDGPU | GPU | LLVM | 23,510 | 178 | 1 | [] |
[
"<s>",
"void",
"CJGInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"CJG",
"::",
"PUSH",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"CJG",
"CJG",
"CJG::PUSH"
] | CJGInstrInfo | storeRegToStackSlot | CJG | CPU | LLVM | 23,511 | 104 | 1 | [] |
[
"<s>",
"void",
"ix86_function_specific_restore",
"(",
"struct",
"gcc_options",
"*",
"opts",
",",
"struct",
"gcc_options",
"*",
",",
"struct",
"cl_target_option",
"*",
"ptr",
")",
"{",
"enum",
"processor_type",
"old_tune",
"=",
"ix86_tune",
";",
"enum",
"processor_type",
"old_arch",
"=",
"ix86_arch",
";",
"unsigned",
"HOST_WIDE_INT",
"ix86_arch_mask",
";",
"int",
"i",
";",
"opts",
"->",
"x_flag_pic",
"=",
"flag_pic",
";",
"ix86_arch",
"=",
"(",
"enum",
"processor_type",
")",
"ptr",
"->",
"arch",
";",
"ix86_schedule",
"=",
"(",
"enum",
"attr_cpu",
")",
"ptr",
"->",
"schedule",
";",
"ix86_tune",
"=",
"(",
"enum",
"processor_type",
")",
"ptr",
"->",
"tune",
";",
"ix86_prefetch_sse",
"=",
"ptr",
"->",
"prefetch_sse",
";",
"ix86_tune_defaulted",
"=",
"ptr",
"->",
"tune_defaulted",
";",
"ix86_arch_specified",
"=",
"ptr",
"->",
"arch_specified",
";",
"opts",
"->",
"x_ix86_isa_flags_explicit",
"=",
"ptr",
"->",
"x_ix86_isa_flags_explicit",
";",
"opts",
"->",
"x_ix86_isa_flags2_explicit",
"=",
"ptr",
"->",
"x_ix86_isa_flags2_explicit",
";",
"opts",
"->",
"x_recip_mask_explicit",
"=",
"ptr",
"->",
"x_recip_mask_explicit",
";",
"opts",
"->",
"x_ix86_arch_string",
"=",
"ptr",
"->",
"x_ix86_arch_string",
";",
"opts",
"->",
"x_ix86_tune_string",
"=",
"ptr",
"->",
"x_ix86_tune_string",
";",
"opts",
"->",
"x_ix86_asm_dialect",
"=",
"ptr",
"->",
"x_ix86_asm_dialect",
";",
"opts",
"->",
"x_ix86_branch_cost",
"=",
"ptr",
"->",
"x_ix86_branch_cost",
";",
"opts",
"->",
"x_ix86_dump_tunes",
"=",
"ptr",
"->",
"x_ix86_dump_tunes",
";",
"opts",
"->",
"x_ix86_force_align_arg_pointer",
"=",
"ptr",
"->",
"x_ix86_force_align_arg_pointer",
";",
"opts",
"->",
"x_ix86_force_drap",
"=",
"ptr",
"->",
"x_ix86_force_drap",
";",
"opts",
"->",
"x_ix86_recip_name",
"=",
"ptr",
"->",
"x_ix86_recip_name",
";",
"opts",
"->",
"x_ix86_section_threshold",
"=",
"ptr",
"->",
"x_ix86_section_threshold",
";",
"opts",
"->",
"x_ix86_sse2avx",
"=",
"ptr",
"->",
"x_ix86_sse2avx",
";",
"opts",
"->",
"x_ix86_stack_protector_guard",
"=",
"ptr",
"->",
"x_ix86_stack_protector_guard",
";",
"opts",
"->",
"x_ix86_stringop_alg",
"=",
"ptr",
"->",
"x_ix86_stringop_alg",
";",
"opts",
"->",
"x_ix86_tls_dialect",
"=",
"ptr",
"->",
"x_ix86_tls_dialect",
";",
"opts",
"->",
"x_ix86_tune_ctrl_string",
"=",
"ptr",
"->",
"x_ix86_tune_ctrl_string",
";",
"opts",
"->",
"x_ix86_tune_memcpy_strategy",
"=",
"ptr",
"->",
"x_ix86_tune_memcpy_strategy",
";",
"opts",
"->",
"x_ix86_tune_memset_strategy",
"=",
"ptr",
"->",
"x_ix86_tune_memset_strategy",
";",
"opts",
"->",
"x_ix86_tune_no_default",
"=",
"ptr",
"->",
"x_ix86_tune_no_default",
";",
"ix86_tune_cost",
"=",
"processor_cost_table",
"[",
"ix86_tune",
"]",
";",
"if",
"(",
"opts",
"->",
"x_optimize_size",
")",
"ix86_cost",
"=",
"&",
"ix86_size_cost",
";",
"else",
"ix86_cost",
"=",
"ix86_tune_cost",
";",
"if",
"(",
"old_arch",
"!=",
"ix86_arch",
")",
"{",
"ix86_arch_mask",
"=",
"HOST_WIDE_INT_1U",
"<<",
"ix86_arch",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"X86_ARCH_LAST",
";",
"++",
"i",
")",
"ix86_arch_features",
"[",
"i",
"]",
"=",
"!",
"!",
"(",
"initial_ix86_arch_features",
"[",
"i",
"]",
"&",
"ix86_arch_mask",
")",
";",
"}",
"if",
"(",
"old_tune",
"!=",
"ix86_tune",
")",
"set_ix86_tune_features",
"(",
"opts",
",",
"ix86_tune",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Restore",
"the",
"current",
"options"
] | [
"i386",
"0"
] | i386-options1 | ix86_function_specific_restore | i386 | CPU | GCC | 23,512 | 333 | 1 | [] |
[
"<s>",
"static",
"bool",
"s390_match_ccmode_set",
"(",
"rtx",
"set",
",",
"machine_mode",
"req_mode",
")",
"{",
"machine_mode",
"set_mode",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"set",
")",
"==",
"SET",
")",
";",
"gcc_assert",
"(",
"req_mode",
"!=",
"CCVIALLmode",
"&&",
"req_mode",
"!=",
"CCVIANYmode",
"&&",
"req_mode",
"!=",
"CCVFALLmode",
"&&",
"req_mode",
"!=",
"CCVFANYmode",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"SET_DEST",
"(",
"set",
")",
")",
"!=",
"REG",
"||",
"!",
"CC_REGNO_P",
"(",
"REGNO",
"(",
"SET_DEST",
"(",
"set",
")",
")",
")",
")",
"return",
"1",
";",
"set_mode",
"=",
"GET_MODE",
"(",
"SET_DEST",
"(",
"set",
")",
")",
";",
"switch",
"(",
"set_mode",
")",
"{",
"case",
"CCZ1mode",
":",
"case",
"CCSmode",
":",
"case",
"CCSRmode",
":",
"case",
"CCUmode",
":",
"case",
"CCURmode",
":",
"case",
"CCLmode",
":",
"case",
"CCL1mode",
":",
"case",
"CCL2mode",
":",
"case",
"CCL3mode",
":",
"case",
"CCT1mode",
":",
"case",
"CCT2mode",
":",
"case",
"CCT3mode",
":",
"case",
"CCVEQmode",
":",
"case",
"CCVIHmode",
":",
"case",
"CCVIHUmode",
":",
"case",
"CCVFHmode",
":",
"case",
"CCVFHEmode",
":",
"if",
"(",
"req_mode",
"!=",
"set_mode",
")",
"return",
"0",
";",
"break",
";",
"case",
"CCZmode",
":",
"if",
"(",
"req_mode",
"!=",
"CCSmode",
"&&",
"req_mode",
"!=",
"CCUmode",
"&&",
"req_mode",
"!=",
"CCTmode",
"&&",
"req_mode",
"!=",
"CCSRmode",
"&&",
"req_mode",
"!=",
"CCURmode",
"&&",
"req_mode",
"!=",
"CCZ1mode",
")",
"return",
"0",
";",
"break",
";",
"case",
"CCAPmode",
":",
"case",
"CCANmode",
":",
"if",
"(",
"req_mode",
"!=",
"CCAmode",
")",
"return",
"0",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"(",
"GET_MODE",
"(",
"SET_SRC",
"(",
"set",
")",
")",
"==",
"set_mode",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"SET",
"either",
"does",
"n't",
"set",
"the",
"CC",
"register",
",",
"or",
"else",
"the",
"source",
"and",
"destination",
"have",
"matching",
"CC",
"modes",
"and",
"that",
"CC",
"mode",
"is",
"at",
"least",
"as",
"constrained",
"as",
"REQ_MODE",
"."
] | [
"s390",
"1",
"0",
"0",
"0"
] | s3906 | s390_match_ccmode_set | s390 | MPU | GCC | 23,513 | 219 | 1 | [] |
[
"<s>",
"static",
"uint32_t",
"getBranchTargetOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpIdx",
",",
"unsigned",
"FixupKind",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpIdx",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"\"Unexpected branch target type!\"",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"MCFixupKind",
"Kind",
"=",
"MCFixupKind",
"(",
"FixupKind",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"Expr",
",",
"Kind",
",",
"MI",
".",
"getLoc",
"(",
")",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTargetOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"ARM",
"\"Unexpected branch target type!\"",
"0",
"0"
] | ARMMCCodeEmitter11 | getBranchTargetOpValue | ARM | CPU | LLVM | 23,514 | 111 | 1 | [] |
[
"<s>",
"size_t",
"size",
"(",
")",
"{",
"return",
"Q",
".",
"size",
"(",
")",
"+",
"HaveConst",
";",
"}",
"</s>"
] | [
"The",
"number",
"of",
"name/type",
"pairs",
"is",
"returned",
"."
] | [
"Hexagon"
] | HexagonISelDAGToDAG1 | size | Hexagon | DSP | LLVM | 23,515 | 15 | 1 | [] |
[
"<s>",
"rtx",
"legitimize_pic_address",
"(",
"rtx",
"orig",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"reg",
")",
"{",
"rtx",
"pic_ref",
"=",
"orig",
";",
"if",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"orig",
")",
"==",
"LABEL_REF",
")",
"{",
"gcc_assert",
"(",
"reg",
")",
";",
"pic_ref",
"=",
"m68k_wrap_symbol_into_got_ref",
"(",
"orig",
",",
"RELOC_GOT",
",",
"reg",
")",
";",
"pic_ref",
"=",
"m68k_move_to_reg",
"(",
"pic_ref",
",",
"orig",
",",
"reg",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"CONST",
")",
"{",
"rtx",
"base",
";",
"if",
"(",
"m68k_unwrap_symbol",
"(",
"orig",
",",
"true",
")",
"!=",
"orig",
")",
"return",
"orig",
";",
"gcc_assert",
"(",
"reg",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"orig",
",",
"0",
")",
")",
"==",
"PLUS",
")",
";",
"base",
"=",
"legitimize_pic_address",
"(",
"XEXP",
"(",
"XEXP",
"(",
"orig",
",",
"0",
")",
",",
"0",
")",
",",
"Pmode",
",",
"reg",
")",
";",
"orig",
"=",
"legitimize_pic_address",
"(",
"XEXP",
"(",
"XEXP",
"(",
"orig",
",",
"0",
")",
",",
"1",
")",
",",
"Pmode",
",",
"base",
"==",
"reg",
"?",
"0",
":",
"reg",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"CONST_INT",
")",
"pic_ref",
"=",
"plus_constant",
"(",
"Pmode",
",",
"base",
",",
"INTVAL",
"(",
"orig",
")",
")",
";",
"else",
"pic_ref",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"base",
",",
"orig",
")",
";",
"}",
"return",
"pic_ref",
";",
"}",
"</s>"
] | [
"Legitimize",
"PIC",
"addresses",
".",
"If",
"the",
"address",
"is",
"already",
"position-independent",
",",
"we",
"return",
"ORIG",
".",
"Newly",
"generated",
"position-independent",
"addresses",
"go",
"into",
"a",
"reg",
".",
"This",
"is",
"REG",
"if",
"nonzero",
",",
"otherwise",
"we",
"allocate",
"register",
"(",
"s",
")",
"as",
"necessary",
"."
] | [
"m68k",
"0",
"0",
"0",
"0",
"1",
"0"
] | m68k | legitimize_pic_address | m68k | MPU | GCC | 23,516 | 200 | 1 | [] |
[
"<s>",
"SDValue",
"XCoreTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"SDLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_XCore",
")",
";",
"SDValue",
"Flag",
";",
"SmallVector",
"<",
"SDValue",
",",
"4",
">",
"RetOps",
"(",
"1",
",",
"Chain",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"OutVals",
"[",
"i",
"]",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"RetOps",
"[",
"0",
"]",
"=",
"Chain",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"RetOps",
".",
"push_back",
"(",
"Flag",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"XCoreISD",
"::",
"RETSP",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"&",
"RetOps",
"[",
"0",
"]",
",",
"RetOps",
".",
"size",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"XCore",
"XCore",
"ISD::OutputArg",
"16",
"XCore",
"4",
"1",
"0",
"MVT::i32",
"0",
"\"Can only return in registers!\"",
"1",
"0",
"XCoreISD::RETSP",
"MVT::Other",
"0"
] | XCoreISelLowering (2) | LowerReturn | XCore | MPU | LLVM | 23,517 | 265 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_setup_reg_addr_masks",
"(",
"void",
")",
"{",
"ssize_t",
"rc",
",",
"reg",
",",
"m",
",",
"nregs",
";",
"addr_mask_type",
"any_addr_mask",
",",
"addr_mask",
";",
"for",
"(",
"m",
"=",
"0",
";",
"m",
"<",
"NUM_MACHINE_MODES",
";",
"++",
"m",
")",
"{",
"machine_mode",
"m2",
"=",
"(",
"machine_mode",
")",
"m",
";",
"bool",
"complex_p",
"=",
"false",
";",
"bool",
"small_int_p",
"=",
"(",
"m2",
"==",
"QImode",
"||",
"m2",
"==",
"HImode",
"||",
"m2",
"==",
"SImode",
")",
";",
"size_t",
"msize",
";",
"if",
"(",
"COMPLEX_MODE_P",
"(",
"m2",
")",
")",
"{",
"complex_p",
"=",
"true",
";",
"m2",
"=",
"GET_MODE_INNER",
"(",
"m2",
")",
";",
"}",
"msize",
"=",
"GET_MODE_SIZE",
"(",
"m2",
")",
";",
"bool",
"indexed_only_p",
"=",
"(",
"m",
"==",
"SDmode",
"&&",
"TARGET_NO_SDMODE_STACK",
")",
";",
"any_addr_mask",
"=",
"0",
";",
"for",
"(",
"rc",
"=",
"FIRST_RELOAD_REG_CLASS",
";",
"rc",
"<=",
"LAST_RELOAD_REG_CLASS",
";",
"rc",
"++",
")",
"{",
"addr_mask",
"=",
"0",
";",
"reg",
"=",
"reload_reg_map",
"[",
"rc",
"]",
".",
"reg",
";",
"if",
"(",
"reg",
">=",
"0",
"&&",
"rs6000_hard_regno_mode_ok_p",
"[",
"m",
"]",
"[",
"reg",
"]",
")",
"{",
"bool",
"small_int_vsx_p",
"=",
"(",
"small_int_p",
"&&",
"(",
"rc",
"==",
"RELOAD_REG_FPR",
"||",
"rc",
"==",
"RELOAD_REG_VMX",
")",
")",
";",
"nregs",
"=",
"rs6000_hard_regno_nregs",
"[",
"m",
"]",
"[",
"reg",
"]",
";",
"addr_mask",
"|=",
"RELOAD_REG_VALID",
";",
"if",
"(",
"small_int_vsx_p",
")",
"addr_mask",
"|=",
"RELOAD_REG_INDEXED",
";",
"else",
"if",
"(",
"nregs",
">",
"1",
"||",
"m",
"==",
"BLKmode",
"||",
"complex_p",
")",
"addr_mask",
"|=",
"RELOAD_REG_MULTIPLE",
";",
"else",
"addr_mask",
"|=",
"RELOAD_REG_INDEXED",
";",
"if",
"(",
"TARGET_UPDATE",
"&&",
"(",
"rc",
"==",
"RELOAD_REG_GPR",
"||",
"rc",
"==",
"RELOAD_REG_FPR",
")",
"&&",
"msize",
"<=",
"8",
"&&",
"!",
"VECTOR_MODE_P",
"(",
"m2",
")",
"&&",
"!",
"FLOAT128_VECTOR_P",
"(",
"m2",
")",
"&&",
"!",
"complex_p",
"&&",
"!",
"small_int_vsx_p",
"&&",
"(",
"m2",
"!=",
"DFmode",
"||",
"!",
"TARGET_UPPER_REGS_DF",
")",
"&&",
"(",
"m2",
"!=",
"SFmode",
"||",
"!",
"TARGET_UPPER_REGS_SF",
")",
"&&",
"!",
"(",
"TARGET_E500_DOUBLE",
"&&",
"msize",
"==",
"8",
")",
")",
"{",
"addr_mask",
"|=",
"RELOAD_REG_PRE_INCDEC",
";",
"switch",
"(",
"m",
")",
"{",
"default",
":",
"addr_mask",
"|=",
"RELOAD_REG_PRE_MODIFY",
";",
"break",
";",
"case",
"E_DImode",
":",
"if",
"(",
"TARGET_POWERPC64",
")",
"addr_mask",
"|=",
"RELOAD_REG_PRE_MODIFY",
";",
"break",
";",
"case",
"E_DFmode",
":",
"case",
"E_DDmode",
":",
"if",
"(",
"TARGET_DF_INSN",
")",
"addr_mask",
"|=",
"RELOAD_REG_PRE_MODIFY",
";",
"break",
";",
"}",
"}",
"}",
"if",
"(",
"(",
"addr_mask",
"!=",
"0",
")",
"&&",
"!",
"indexed_only_p",
"&&",
"msize",
"<=",
"8",
"&&",
"(",
"rc",
"==",
"RELOAD_REG_GPR",
"||",
"(",
"(",
"msize",
"==",
"8",
"||",
"m2",
"==",
"SFmode",
")",
"&&",
"(",
"rc",
"==",
"RELOAD_REG_FPR",
"||",
"(",
"rc",
"==",
"RELOAD_REG_VMX",
"&&",
"TARGET_P9_DFORM_SCALAR",
")",
")",
")",
")",
")",
"addr_mask",
"|=",
"RELOAD_REG_OFFSET",
";",
"else",
"if",
"(",
"(",
"addr_mask",
"!=",
"0",
")",
"&&",
"!",
"indexed_only_p",
"&&",
"msize",
"==",
"16",
"&&",
"TARGET_P9_DFORM_VECTOR",
"&&",
"(",
"ALTIVEC_OR_VSX_VECTOR_MODE",
"(",
"m2",
")",
"||",
"(",
"m2",
"==",
"TImode",
"&&",
"TARGET_VSX_TIMODE",
")",
")",
")",
"{",
"addr_mask",
"|=",
"RELOAD_REG_OFFSET",
";",
"if",
"(",
"rc",
"==",
"RELOAD_REG_FPR",
"||",
"rc",
"==",
"RELOAD_REG_VMX",
")",
"addr_mask",
"|=",
"RELOAD_REG_QUAD_OFFSET",
";",
"}",
"if",
"(",
"rc",
"==",
"RELOAD_REG_VMX",
"&&",
"msize",
"==",
"16",
"&&",
"(",
"addr_mask",
"&",
"RELOAD_REG_VALID",
")",
"!=",
"0",
")",
"addr_mask",
"|=",
"RELOAD_REG_AND_M16",
";",
"reg_addr",
"[",
"m",
"]",
".",
"addr_mask",
"[",
"rc",
"]",
"=",
"addr_mask",
";",
"any_addr_mask",
"|=",
"addr_mask",
";",
"}",
"reg_addr",
"[",
"m",
"]",
".",
"addr_mask",
"[",
"RELOAD_REG_ANY",
"]",
"=",
"any_addr_mask",
";",
"}",
"}",
"</s>"
] | [
"Update",
"the",
"addr",
"mask",
"bits",
"in",
"reg_addr",
"to",
"help",
"secondary",
"reload",
"and",
"go",
"if",
"legitimate",
"address",
"support",
"to",
"figure",
"out",
"the",
"appropriate",
"addressing",
"to",
"use",
"."
] | [
"powerpcspe",
"0",
"0",
"0",
"0",
"1",
"8",
"8",
"0",
"8",
"8",
"0",
"16",
"16",
"0"
] | powerpcspe | rs6000_setup_reg_addr_masks | powerpcspe | CPU | GCC | 23,518 | 483 | 1 | [] |
[
"<s>",
"void",
"rx_split_cbranch",
"(",
"machine_mode",
"cc_mode",
",",
"enum",
"rtx_code",
"cmp1",
",",
"rtx",
"c1",
",",
"rtx",
"c2",
",",
"rtx",
"label",
")",
"{",
"rtx",
"flags",
",",
"x",
";",
"flags",
"=",
"gen_rtx_REG",
"(",
"cc_mode",
",",
"CC_REG",
")",
";",
"x",
"=",
"gen_rtx_COMPARE",
"(",
"cc_mode",
",",
"c1",
",",
"c2",
")",
";",
"x",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"flags",
",",
"x",
")",
";",
"emit_insn",
"(",
"x",
")",
";",
"x",
"=",
"gen_rtx_fmt_ee",
"(",
"cmp1",
",",
"VOIDmode",
",",
"flags",
",",
"const0_rtx",
")",
";",
"x",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"x",
",",
"label",
",",
"pc_rtx",
")",
";",
"x",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"x",
")",
";",
"emit_jump_insn",
"(",
"x",
")",
";",
"}",
"</s>"
] | [
"Split",
"the",
"conditional",
"branch",
".",
"Emit",
"(",
"COMPARE",
"C1",
"C2",
")",
"into",
"CC_REG",
"with",
"CC_MODE",
",",
"and",
"use",
"that",
"in",
"branches",
"based",
"on",
"that",
"compare",
"."
] | [
"rx"
] | rx2 | rx_split_cbranch | rx | CPU | GCC | 23,519 | 104 | 1 | [] |
[
"<s>",
"bool",
"PPCPassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"if",
"(",
"!",
"DisableInstrFormPrep",
"&&",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createPPCLoopInstrFormPrepPass",
"(",
"getPPCTargetMachine",
"(",
")",
")",
")",
";",
"if",
"(",
"!",
"DisableCTRLoops",
"&&",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createHardwareLoopsPass",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"PowerPC",
"PPC",
"PPC",
"PPC"
] | PPCTargetMachine11 | addPreISel | PowerPC | CPU | LLVM | 23,520 | 54 | 1 | [] |
[
"<s>",
"bool",
"arc_need_delay",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx_insn",
"*",
"next",
";",
"if",
"(",
"!",
"flag_delayed_branch",
")",
"return",
"false",
";",
"if",
"(",
"NONJUMP_INSN_P",
"(",
"insn",
")",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"USE",
"&&",
"(",
"!",
"(",
"next",
"=",
"next_active_insn",
"(",
"insn",
")",
")",
"||",
"(",
"(",
"!",
"NONJUMP_INSN_P",
"(",
"next",
")",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"next",
")",
")",
"!=",
"SEQUENCE",
")",
"&&",
"arc_attr_type",
"(",
"next",
")",
"==",
"TYPE_RETURN",
")",
")",
"&&",
"(",
"!",
"TARGET_PAD_RETURN",
"||",
"(",
"prev_active_insn",
"(",
"insn",
")",
"&&",
"prev_active_insn",
"(",
"prev_active_insn",
"(",
"insn",
")",
")",
"&&",
"prev_active_insn",
"(",
"prev_active_insn",
"(",
"prev_active_insn",
"(",
"insn",
")",
")",
")",
")",
")",
")",
"return",
"true",
";",
"if",
"(",
"NONJUMP_INSN_P",
"(",
"insn",
")",
"?",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"USE",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"CLOBBER",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"SEQUENCE",
")",
":",
"JUMP_P",
"(",
"insn",
")",
"?",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"ADDR_VEC",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"ADDR_DIFF_VEC",
")",
":",
"!",
"CALL_P",
"(",
"insn",
")",
")",
"return",
"false",
";",
"return",
"num_delay_slots",
"(",
"insn",
")",
"!=",
"0",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"INSN",
"is",
"an",
"instruction",
"with",
"a",
"delay",
"slot",
"we",
"may",
"want",
"to",
"fill",
"."
] | [
"arc",
"0"
] | arc | arc_need_delay | arc | MPU | GCC | 23,521 | 194 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SI Lower i1 Copies\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU",
"\"SI Lower i1 Copies\""
] | SILowerI1Copies18 | getPassName | AMDGPU | GPU | LLVM | 23,522 | 13 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyAsmPrinter",
"::",
"PrintAsmMemoryOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"OS",
")",
"{",
"return",
"AsmPrinter",
"::",
"PrintAsmMemoryOperand",
"(",
"MI",
",",
"OpNo",
",",
"ExtraCode",
",",
"OS",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"operand",
"of",
"MI",
",",
"an",
"INLINEASM",
"instruction",
",",
"using",
"the",
"specified",
"assembler",
"variant",
"as",
"an",
"address",
"."
] | [
"WebAssembly",
"WebAssembly"
] | WebAssemblyAsmPrinter (2)1 | PrintAsmMemoryOperand | WebAssembly | Virtual ISA | LLVM | 23,523 | 38 | 1 | [] |
[
"<s>",
"bool",
"aarch64_gimple_fold_builtin",
"(",
"gimple_stmt_iterator",
"*",
"gsi",
")",
"{",
"bool",
"changed",
"=",
"false",
";",
"gimple",
"stmt",
"=",
"gsi_stmt",
"(",
"*",
"gsi",
")",
";",
"tree",
"call",
"=",
"gimple_call_fn",
"(",
"stmt",
")",
";",
"tree",
"fndecl",
";",
"gimple",
"new_stmt",
"=",
"NULL",
";",
"if",
"(",
"call",
")",
"{",
"fndecl",
"=",
"gimple_call_fndecl",
"(",
"stmt",
")",
";",
"if",
"(",
"fndecl",
")",
"{",
"int",
"fcode",
"=",
"DECL_FUNCTION_CODE",
"(",
"fndecl",
")",
";",
"int",
"nargs",
"=",
"gimple_call_num_args",
"(",
"stmt",
")",
";",
"tree",
"*",
"args",
"=",
"(",
"nargs",
">",
"0",
"?",
"gimple_call_arg_ptr",
"(",
"stmt",
",",
"0",
")",
":",
"&",
"error_mark_node",
")",
";",
"switch",
"(",
"fcode",
")",
"{",
"BUILTIN_VALL",
"(",
"UNOP",
",",
"reduc_plus_scal_",
",",
"10",
")",
"new_stmt",
"=",
"gimple_build_assign",
"(",
"gimple_call_lhs",
"(",
"stmt",
")",
",",
"REDUC_PLUS_EXPR",
",",
"args",
"[",
"0",
"]",
")",
";",
"break",
";",
"BUILTIN_VDQIF",
"(",
"UNOP",
",",
"reduc_smax_scal_",
",",
"10",
")",
"BUILTIN_VDQ_BHSI",
"(",
"UNOPU",
",",
"reduc_umax_scal_",
",",
"10",
")",
"new_stmt",
"=",
"gimple_build_assign",
"(",
"gimple_call_lhs",
"(",
"stmt",
")",
",",
"REDUC_MAX_EXPR",
",",
"args",
"[",
"0",
"]",
")",
";",
"break",
";",
"BUILTIN_VDQIF",
"(",
"UNOP",
",",
"reduc_smin_scal_",
",",
"10",
")",
"BUILTIN_VDQ_BHSI",
"(",
"UNOPU",
",",
"reduc_umin_scal_",
",",
"10",
")",
"new_stmt",
"=",
"gimple_build_assign",
"(",
"gimple_call_lhs",
"(",
"stmt",
")",
",",
"REDUC_MIN_EXPR",
",",
"args",
"[",
"0",
"]",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"}",
"if",
"(",
"new_stmt",
")",
"{",
"gsi_replace",
"(",
"gsi",
",",
"new_stmt",
",",
"true",
")",
";",
"changed",
"=",
"true",
";",
"}",
"return",
"changed",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_GIMPLE_FOLD_BUILTIN",
"."
] | [
"aarch64",
"0",
"0",
"10",
"0",
"10",
"10",
"0",
"10",
"10",
"0"
] | aarch64-builtins2 | aarch64_gimple_fold_builtin | aarch64 | CPU | GCC | 23,524 | 223 | 1 | [] |
[
"<s>",
"bool",
"MSP430PassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"PM",
".",
"add",
"(",
"createMSP430BranchSelectionPass",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"MSP430",
"MSP430",
"MSP430"
] | MSP430TargetMachine5 | addPreEmitPass | MSP430 | MPU | LLVM | 23,525 | 20 | 1 | [] |
[
"<s>",
"unsigned",
"RISCVInstrInfo",
"::",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"{",
"return",
"get",
"(",
"Opcode",
")",
".",
"getSize",
"(",
")",
";",
"}",
"case",
"TargetOpcode",
"::",
"EH_LABEL",
":",
"case",
"TargetOpcode",
"::",
"IMPLICIT_DEF",
":",
"case",
"TargetOpcode",
"::",
"KILL",
":",
"case",
"TargetOpcode",
"::",
"DBG_VALUE",
":",
"return",
"0",
";",
"case",
"TargetOpcode",
"::",
"INLINEASM",
":",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"auto",
"&",
"TM",
"=",
"static_cast",
"<",
"const",
"RISCVTargetMachine",
"&",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"return",
"getInlineAsmLength",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSymbolName",
"(",
")",
",",
"*",
"TM",
".",
"getMCAsmInfo",
"(",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"RISCV",
"RISCV",
"0",
"RISCV",
"0"
] | RISCVInstrInfo17 | getInstSizeInBytes | RISCV | CPU | LLVM | 23,526 | 129 | 1 | [] |
[
"<s>",
"static",
"bool",
"s390_function_arg_vector",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
")",
"{",
"if",
"(",
"!",
"TARGET_VX_ABI",
")",
"return",
"false",
";",
"if",
"(",
"s390_function_arg_size",
"(",
"mode",
",",
"type",
")",
">",
"16",
")",
"return",
"false",
";",
"if",
"(",
"!",
"type",
")",
"return",
"VECTOR_MODE_P",
"(",
"mode",
")",
";",
"if",
"(",
"!",
"s390_single_field_struct_p",
"(",
"VECTOR_TYPE",
",",
"type",
",",
"true",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"a",
"function",
"argument",
"of",
"type",
"TYPE",
"and",
"mode",
"MODE",
"is",
"to",
"be",
"passed",
"in",
"a",
"vector",
"register",
",",
"if",
"available",
"."
] | [
"s390",
"16"
] | s390 | s390_function_arg_vector | s390 | MPU | GCC | 23,527 | 63 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"getSubExpr",
"(",
")",
"const",
"{",
"return",
"Expr",
";",
"}",
"</s>"
] | [
"getSubExpr",
"-",
"Get",
"the",
"child",
"of",
"this",
"expression",
"."
] | [
"RI5CY"
] | RISCVMCExpr | getSubExpr | RI5CY | CPU | LLVM | 23,528 | 12 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"FISC"
] | FISCTargetMachine | getObjFileLowering | FISC | CPU | LLVM | 23,529 | 16 | 1 | [] |
[
"<s>",
"unsigned",
"char",
"M680x0Subtarget",
"::",
"classifyBlockAddressReference",
"(",
")",
"const",
"{",
"return",
"M680x0II",
"::",
"MO_PC_RELATIVE_ADDRESS",
";",
"}",
"</s>"
] | [
"Classify",
"a",
"blockaddress",
"reference",
"for",
"the",
"current",
"subtarget",
"according",
"to",
"how",
"we",
"should",
"reference",
"it",
"in",
"a",
"non-pcrel",
"context",
"."
] | [
"M680x0",
"M680x0",
"M680x0II::MO_PC_RELATIVE_ADDRESS"
] | M680x0Subtarget | classifyBlockAddressReference | M680x0 | MPU | LLVM | 23,530 | 15 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"MipsAsmPrinter",
"::",
"getCurrentABIString",
"(",
")",
"const",
"{",
"switch",
"(",
"Subtarget",
"->",
"getTargetABI",
"(",
")",
")",
"{",
"case",
"MipsSubtarget",
"::",
"O32",
":",
"return",
"\"abi32\"",
";",
"case",
"MipsSubtarget",
"::",
"O64",
":",
"return",
"\"abiO64\"",
";",
"case",
"MipsSubtarget",
"::",
"N32",
":",
"return",
"\"abiN32\"",
";",
"case",
"MipsSubtarget",
"::",
"N64",
":",
"return",
"\"abi64\"",
";",
"case",
"MipsSubtarget",
"::",
"EABI",
":",
"return",
"\"eabi32\"",
";",
"default",
":",
"break",
";",
"}",
"llvm_unreachable",
"(",
"\"Unknown Mips ABI\"",
")",
";",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Emit",
"Set",
"directives",
"."
] | [
"Mips",
"Mips",
"Mips",
"\"abi32\"",
"Mips",
"\"abiO64\"",
"Mips",
"\"abiN32\"",
"Mips",
"\"abi64\"",
"Mips",
"\"eabi32\"",
"\"Unknown Mips ABI\""
] | MipsAsmPrinter19 | getCurrentABIString | Mips | CPU | LLVM | 23,531 | 73 | 1 | [] |
[
"<s>",
"static",
"void",
"output_init_frag",
"(",
"rtx",
"sym",
")",
"{",
"fprintf",
"(",
"asm_out_file",
",",
"init_frag",
".",
"started",
"?",
"\", \"",
":",
"\" = { \"",
")",
";",
"unsigned",
"HOST_WIDE_INT",
"val",
"=",
"init_frag",
".",
"val",
";",
"init_frag",
".",
"started",
"=",
"true",
";",
"init_frag",
".",
"val",
"=",
"0",
";",
"init_frag",
".",
"offset",
"=",
"0",
";",
"init_frag",
".",
"remaining",
"--",
";",
"if",
"(",
"sym",
")",
"{",
"fprintf",
"(",
"asm_out_file",
",",
"\"generic(\"",
")",
";",
"output_address",
"(",
"VOIDmode",
",",
"sym",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"val",
"?",
"\") + \"",
":",
"\")\"",
")",
";",
"}",
"if",
"(",
"!",
"sym",
"||",
"val",
")",
"fprintf",
"(",
"asm_out_file",
",",
"HOST_WIDE_INT_PRINT_DEC",
",",
"val",
")",
";",
"}",
"</s>"
] | [
"The",
"current",
"fragment",
"is",
"full",
",",
"write",
"it",
"out",
".",
"SYM",
"may",
"provide",
"a",
"symbolic",
"reference",
"we",
"should",
"output",
",",
"in",
"which",
"case",
"the",
"fragment",
"value",
"is",
"the",
"addend",
"."
] | [
"nvptx",
"\", \"",
"\" = { \"",
"0",
"0",
"\"generic(\"",
"\") + \"",
"\")\""
] | nvptx3 | output_init_frag | nvptx | GPU | GCC | 23,532 | 100 | 1 | [] |
[
"<s>",
"void",
"SystemZInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZInstPrinter14 | printInst | SystemZ | CPU | LLVM | 23,533 | 38 | 1 | [] |
[
"<s>",
"SDValue",
"XCoreTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"DebugLoc",
"dl",
"=",
"N",
"->",
"getDebugLoc",
"(",
")",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"STORE",
":",
"{",
"StoreSDNode",
"*",
"ST",
"=",
"cast",
"<",
"StoreSDNode",
">",
"(",
"N",
")",
";",
"if",
"(",
"!",
"DCI",
".",
"isBeforeLegalize",
"(",
")",
"||",
"allowsUnalignedMemoryAccesses",
"(",
"ST",
"->",
"getMemoryVT",
"(",
")",
")",
"||",
"ST",
"->",
"isVolatile",
"(",
")",
"||",
"ST",
"->",
"isIndexed",
"(",
")",
")",
"{",
"break",
";",
"}",
"SDValue",
"Chain",
"=",
"ST",
"->",
"getChain",
"(",
")",
";",
"unsigned",
"StoreBits",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
".",
"getStoreSizeInBits",
"(",
")",
";",
"if",
"(",
"StoreBits",
"%",
"8",
")",
"{",
"break",
";",
"}",
"unsigned",
"ABIAlignment",
"=",
"getTargetData",
"(",
")",
"->",
"getABITypeAlignment",
"(",
"ST",
"->",
"getMemoryVT",
"(",
")",
".",
"getTypeForEVT",
"(",
"*",
"DCI",
".",
"DAG",
".",
"getContext",
"(",
")",
")",
")",
";",
"unsigned",
"Alignment",
"=",
"ST",
"->",
"getAlignment",
"(",
")",
";",
"if",
"(",
"Alignment",
">=",
"ABIAlignment",
")",
"{",
"break",
";",
"}",
"if",
"(",
"LoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"ST",
"->",
"getValue",
"(",
")",
")",
")",
"{",
"if",
"(",
"LD",
"->",
"hasNUsesOfValue",
"(",
"1",
",",
"0",
")",
"&&",
"ST",
"->",
"getMemoryVT",
"(",
")",
"==",
"LD",
"->",
"getMemoryVT",
"(",
")",
"&&",
"LD",
"->",
"getAlignment",
"(",
")",
"==",
"Alignment",
"&&",
"!",
"LD",
"->",
"isVolatile",
"(",
")",
"&&",
"!",
"LD",
"->",
"isIndexed",
"(",
")",
"&&",
"Chain",
".",
"reachesChainWithoutSideEffects",
"(",
"SDValue",
"(",
"LD",
",",
"1",
")",
")",
")",
"{",
"return",
"DAG",
".",
"getMemmove",
"(",
"Chain",
",",
"dl",
",",
"ST",
"->",
"getBasePtr",
"(",
")",
",",
"LD",
"->",
"getBasePtr",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"StoreBits",
"/",
"8",
",",
"MVT",
"::",
"i32",
")",
",",
"Alignment",
",",
"ST",
"->",
"getSrcValue",
"(",
")",
",",
"ST",
"->",
"getSrcValueOffset",
"(",
")",
",",
"LD",
"->",
"getSrcValue",
"(",
")",
",",
"LD",
"->",
"getSrcValueOffset",
"(",
")",
")",
";",
"}",
"}",
"break",
";",
"}",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"XCore",
"XCore",
"ISD::STORE",
"8",
"1",
"0",
"1",
"8",
"MVT::i32"
] | XCoreISelLowering43 | PerformDAGCombine | XCore | MPU | LLVM | 23,534 | 326 | 1 | [] |
[
"<s>",
"virtual",
"unsigned",
"getByValTypeAlignment",
"(",
"Type",
"*",
"Ty",
")",
"const",
"LLVM_OVERRIDE",
"{",
"return",
"4",
";",
"}",
"</s>"
] | [
"Return",
"the",
"desired",
"alignment",
"for",
"ByVal",
"aggregate",
"function",
"arguments",
"in",
"the",
"caller",
"parameter",
"area",
"."
] | [
"Patmos",
"4"
] | PatmosISelLowering | getByValTypeAlignment | Patmos | VLIW | LLVM | 23,535 | 15 | 1 | [] |
[
"<s>",
"void",
"HexagonFrameLowering",
"::",
"determineFrameLayout",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"unsigned",
"FrameSize",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"unsigned",
"TargetAlign",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
";",
"unsigned",
"maxCallFrameSize",
"=",
"MFI",
"->",
"getMaxCallFrameSize",
"(",
")",
";",
"if",
"(",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
")",
"maxCallFrameSize",
"=",
"RoundUpToAlignment",
"(",
"maxCallFrameSize",
",",
"TargetAlign",
")",
";",
"MFI",
"->",
"setMaxCallFrameSize",
"(",
"maxCallFrameSize",
")",
";",
"FrameSize",
"+=",
"maxCallFrameSize",
";",
"FrameSize",
"=",
"RoundUpToAlignment",
"(",
"FrameSize",
",",
"TargetAlign",
")",
";",
"MFI",
"->",
"setStackSize",
"(",
"FrameSize",
")",
";",
"}",
"</s>"
] | [
"Determine",
"the",
"frame",
"layout",
"but",
"do",
"not",
"update",
"the",
"machine",
"function",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonFrameLowering18 | determineFrameLayout | Hexagon | DSP | LLVM | 23,536 | 101 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_darwin64_record_arg_flush",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"HOST_WIDE_INT",
"bitpos",
",",
"rtx",
"rvec",
"[",
"]",
",",
"int",
"*",
"k",
")",
"{",
"machine_mode",
"mode",
";",
"unsigned",
"int",
"regno",
";",
"unsigned",
"int",
"startbit",
",",
"endbit",
";",
"int",
"this_regno",
",",
"intregs",
",",
"intoffset",
";",
"rtx",
"reg",
";",
"if",
"(",
"cum",
"->",
"intoffset",
"==",
"-",
"1",
")",
"return",
";",
"intoffset",
"=",
"cum",
"->",
"intoffset",
";",
"cum",
"->",
"intoffset",
"=",
"-",
"1",
";",
"if",
"(",
"intoffset",
"%",
"BITS_PER_WORD",
"!=",
"0",
")",
"{",
"unsigned",
"int",
"bits",
"=",
"BITS_PER_WORD",
"-",
"intoffset",
"%",
"BITS_PER_WORD",
";",
"if",
"(",
"!",
"int_mode_for_size",
"(",
"bits",
",",
"0",
")",
".",
"exists",
"(",
"&",
"mode",
")",
")",
"{",
"intoffset",
"=",
"ROUND_DOWN",
"(",
"intoffset",
",",
"BITS_PER_WORD",
")",
";",
"mode",
"=",
"word_mode",
";",
"}",
"}",
"else",
"mode",
"=",
"word_mode",
";",
"startbit",
"=",
"ROUND_DOWN",
"(",
"intoffset",
",",
"BITS_PER_WORD",
")",
";",
"endbit",
"=",
"ROUND_UP",
"(",
"bitpos",
",",
"BITS_PER_WORD",
")",
";",
"intregs",
"=",
"(",
"endbit",
"-",
"startbit",
")",
"/",
"BITS_PER_WORD",
";",
"this_regno",
"=",
"cum",
"->",
"words",
"+",
"intoffset",
"/",
"BITS_PER_WORD",
";",
"if",
"(",
"intregs",
">",
"0",
"&&",
"intregs",
">",
"GP_ARG_NUM_REG",
"-",
"this_regno",
")",
"cum",
"->",
"use_stack",
"=",
"1",
";",
"intregs",
"=",
"MIN",
"(",
"intregs",
",",
"GP_ARG_NUM_REG",
"-",
"this_regno",
")",
";",
"if",
"(",
"intregs",
"<=",
"0",
")",
"return",
";",
"intoffset",
"/=",
"BITS_PER_UNIT",
";",
"do",
"{",
"regno",
"=",
"GP_ARG_MIN_REG",
"+",
"this_regno",
";",
"reg",
"=",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"rvec",
"[",
"(",
"*",
"k",
")",
"++",
"]",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"reg",
",",
"GEN_INT",
"(",
"intoffset",
")",
")",
";",
"this_regno",
"+=",
"1",
";",
"intoffset",
"=",
"(",
"intoffset",
"|",
"(",
"UNITS_PER_WORD",
"-",
"1",
")",
")",
"+",
"1",
";",
"mode",
"=",
"word_mode",
";",
"intregs",
"-=",
"1",
";",
"}",
"while",
"(",
"intregs",
">",
"0",
")",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"rs6000_darwin64_record_arg",
".",
"Assign",
"the",
"bits",
"of",
"the",
"structure",
"between",
"cum-",
">",
"intoffset",
"and",
"bitpos",
"to",
"integer",
"registers",
"."
] | [
"rs6000",
"1",
"1",
"0",
"0",
"0",
"1",
"0",
"1",
"1",
"1",
"1",
"0"
] | rs6000-call | rs6000_darwin64_record_arg_flush | rs6000 | CPU | GCC | 23,537 | 276 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"emitLeadingFence",
"(",
"IRBuilder",
"<",
">",
"&",
"Builder",
",",
"AtomicOrdering",
"Ord",
",",
"bool",
"IsStore",
",",
"bool",
"IsLoad",
")",
"const",
"{",
"if",
"(",
"!",
"getInsertFencesForAtomic",
"(",
")",
")",
"return",
";",
"switch",
"(",
"Ord",
")",
"{",
"case",
"NotAtomic",
":",
"case",
"Unordered",
":",
"llvm_unreachable",
"(",
"\"Invalid fence: unordered/non-atomic\"",
")",
";",
"case",
"Monotonic",
":",
"case",
"Acquire",
":",
"return",
";",
"case",
"SequentiallyConsistent",
":",
"if",
"(",
"!",
"IsStore",
")",
"return",
";",
"case",
"Release",
":",
"case",
"AcquireRelease",
":",
"if",
"(",
"Subtarget",
"->",
"isSwift",
"(",
")",
")",
"makeDMB",
"(",
"Builder",
",",
"ARM_MB",
"::",
"ISHST",
")",
";",
"else",
"makeDMB",
"(",
"Builder",
",",
"ARM_MB",
"::",
"ISH",
")",
";",
"return",
";",
"}",
"}",
"</s>"
] | [
"Custom",
"Lower",
"{",
"."
] | [
"ARM",
"ARM",
"\"Invalid fence: unordered/non-atomic\"",
"ARM_MB::ISHST",
"ARM_MB::ISH"
] | ARMISelLowering149 | emitLeadingFence | ARM | CPU | LLVM | 23,538 | 102 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"isFPRCopy",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"TargetOpcode",
"::",
"COPY",
":",
"{",
"unsigned",
"DstReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"return",
"(",
"AArch64",
"::",
"FPR64RegClass",
".",
"contains",
"(",
"DstReg",
")",
"||",
"AArch64",
"::",
"FPR128RegClass",
".",
"contains",
"(",
"DstReg",
")",
")",
";",
"}",
"case",
"AArch64",
"::",
"ORRv16i8",
":",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
")",
"{",
"assert",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumOperands",
"(",
")",
"==",
"3",
"&&",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isReg",
"(",
")",
"&&",
"\"invalid ORRv16i8 operands\"",
")",
";",
"return",
"true",
";",
"}",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Does",
"this",
"instruction",
"rename",
"an",
"FPR",
"without",
"modifying",
"bits",
"?"
] | [
"AArch64",
"AArch64",
"0",
"AArch64::FPR64RegClass",
"AArch64::FPR128RegClass",
"AArch64::ORRv16i8",
"1",
"2",
"3",
"0",
"\"invalid ORRv16i8 operands\""
] | AArch64InstrInfo (2)1 | isFPRCopy | AArch64 | CPU | LLVM | 23,539 | 135 | 1 | [] |
[
"<s>",
"bool",
"arc_is_shortcall_p",
"(",
"rtx",
"sym_ref",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"sym_ref",
")",
"!=",
"SYMBOL_REF",
")",
"return",
"false",
";",
"return",
"(",
"SYMBOL_REF_SHORT_CALL_P",
"(",
"sym_ref",
")",
"||",
"(",
"!",
"TARGET_LONG_CALLS_SET",
"&&",
"!",
"TARGET_MEDIUM_CALLS",
"&&",
"!",
"SYMBOL_REF_LONG_CALL_P",
"(",
"sym_ref",
")",
"&&",
"!",
"SYMBOL_REF_MEDIUM_CALL_P",
"(",
"sym_ref",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Likewise",
"for",
"short",
"calls",
"."
] | [
"arc"
] | arc | arc_is_shortcall_p | arc | MPU | GCC | 23,540 | 48 | 1 | [] |
[
"<s>",
"void",
"arc_print_operand_address",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"addr",
")",
"{",
"rtx",
"base",
",",
"index",
"=",
"0",
";",
"switch",
"(",
"GET_CODE",
"(",
"addr",
")",
")",
"{",
"case",
"REG",
":",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"addr",
")",
"]",
",",
"file",
")",
";",
"break",
";",
"case",
"SYMBOL_REF",
":",
"if",
"(",
"output_sdata",
")",
"fputs",
"(",
"\"gp,\"",
",",
"file",
")",
";",
"output_addr_const",
"(",
"file",
",",
"addr",
")",
";",
"if",
"(",
"output_sdata",
")",
"fputs",
"(",
"\"@sda\"",
",",
"file",
")",
";",
"output_sdata",
"=",
"0",
";",
"break",
";",
"case",
"PLUS",
":",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"==",
"MULT",
")",
"index",
"=",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
",",
"base",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"else",
"if",
"(",
"CONST_INT_P",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
")",
"index",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"base",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"else",
"base",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"index",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"gcc_assert",
"(",
"OBJECT_P",
"(",
"base",
")",
")",
";",
"arc_print_operand_address",
"(",
"file",
",",
"base",
")",
";",
"if",
"(",
"CONSTANT_P",
"(",
"base",
")",
"&&",
"CONST_INT_P",
"(",
"index",
")",
")",
"fputc",
"(",
"'+'",
",",
"file",
")",
";",
"else",
"fputc",
"(",
"','",
",",
"file",
")",
";",
"gcc_assert",
"(",
"OBJECT_P",
"(",
"index",
")",
")",
";",
"arc_print_operand_address",
"(",
"file",
",",
"index",
")",
";",
"break",
";",
"case",
"CONST",
":",
"{",
"rtx",
"c",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"c",
")",
"==",
"UNSPEC",
"&&",
"(",
"XINT",
"(",
"c",
",",
"1",
")",
"==",
"UNSPEC_TLS_OFF",
"||",
"XINT",
"(",
"c",
",",
"1",
")",
"==",
"UNSPEC_TLS_IE",
")",
")",
"||",
"(",
"GET_CODE",
"(",
"c",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"c",
",",
"0",
")",
")",
"==",
"UNSPEC",
"&&",
"(",
"XINT",
"(",
"XEXP",
"(",
"c",
",",
"0",
")",
",",
"1",
")",
"==",
"UNSPEC_TLS_OFF",
"||",
"XINT",
"(",
"XEXP",
"(",
"c",
",",
"0",
")",
",",
"1",
")",
"==",
"ARC_UNSPEC_GOTOFFPC",
")",
")",
")",
"{",
"arc_output_pic_addr_const",
"(",
"file",
",",
"c",
",",
"0",
")",
";",
"break",
";",
"}",
"gcc_assert",
"(",
"GET_CODE",
"(",
"c",
")",
"==",
"PLUS",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"c",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"c",
",",
"1",
")",
")",
"==",
"CONST_INT",
")",
";",
"output_address",
"(",
"VOIDmode",
",",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
";",
"break",
";",
"}",
"case",
"PRE_INC",
":",
"case",
"PRE_DEC",
":",
"gcc_unreachable",
"(",
")",
";",
"break",
";",
"default",
":",
"if",
"(",
"flag_pic",
")",
"arc_output_pic_addr_const",
"(",
"file",
",",
"addr",
",",
"0",
")",
";",
"else",
"output_addr_const",
"(",
"file",
",",
"addr",
")",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"Print",
"a",
"memory",
"address",
"as",
"an",
"operand",
"to",
"reference",
"that",
"memory",
"location",
"."
] | [
"arc",
"0",
"\"gp,\"",
"\"@sda\"",
"0",
"0",
"0",
"0",
"1",
"0",
"0",
"1",
"0",
"1",
"0",
"1",
"1",
"0",
"0",
"1",
"0",
"1",
"0",
"0",
"1",
"0",
"0"
] | arc | arc_print_operand_address | arc | MPU | GCC | 23,541 | 434 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyExceptionInfo",
"::",
"releaseMemory",
"(",
")",
"{",
"BBMap",
".",
"clear",
"(",
")",
";",
"DeleteContainerPointers",
"(",
"TopLevelExceptions",
")",
";",
"TopLevelExceptions",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"releaseMemory",
"(",
")",
"-",
"This",
"member",
"can",
"be",
"implemented",
"by",
"a",
"pass",
"if",
"it",
"wants",
"to",
"be",
"able",
"to",
"release",
"its",
"memory",
"when",
"it",
"is",
"no",
"longer",
"needed",
"."
] | [
"WebAssembly",
"WebAssembly"
] | WebAssemblyExceptionInfo | releaseMemory | WebAssembly | Virtual ISA | LLVM | 23,542 | 25 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"getPreIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
")",
"return",
"false",
";",
"EVT",
"VT",
";",
"SDValue",
"Ptr",
";",
"unsigned",
"Align",
";",
"bool",
"isSEXTLoad",
"=",
"false",
";",
"bool",
"IsMasked",
"=",
"false",
";",
"if",
"(",
"LoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"LD",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"Align",
"=",
"LD",
"->",
"getAlignment",
"(",
")",
";",
"isSEXTLoad",
"=",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"SEXTLOAD",
";",
"}",
"else",
"if",
"(",
"StoreSDNode",
"*",
"ST",
"=",
"dyn_cast",
"<",
"StoreSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"ST",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
";",
"Align",
"=",
"ST",
"->",
"getAlignment",
"(",
")",
";",
"}",
"else",
"if",
"(",
"MaskedLoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"MaskedLoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"LD",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"Align",
"=",
"LD",
"->",
"getAlignment",
"(",
")",
";",
"isSEXTLoad",
"=",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"SEXTLOAD",
";",
"IsMasked",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"MaskedStoreSDNode",
"*",
"ST",
"=",
"dyn_cast",
"<",
"MaskedStoreSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"ST",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
";",
"Align",
"=",
"ST",
"->",
"getAlignment",
"(",
")",
";",
"IsMasked",
"=",
"true",
";",
"}",
"else",
"return",
"false",
";",
"bool",
"isInc",
";",
"bool",
"isLegal",
"=",
"false",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
")",
"isLegal",
"=",
"Subtarget",
"->",
"hasMVEIntegerOps",
"(",
")",
"&&",
"getMVEIndexedAddressParts",
"(",
"Ptr",
".",
"getNode",
"(",
")",
",",
"VT",
",",
"Align",
",",
"isSEXTLoad",
",",
"IsMasked",
",",
"Subtarget",
"->",
"isLittle",
"(",
")",
",",
"Base",
",",
"Offset",
",",
"isInc",
",",
"DAG",
")",
";",
"else",
"{",
"if",
"(",
"Subtarget",
"->",
"isThumb2",
"(",
")",
")",
"isLegal",
"=",
"getT2IndexedAddressParts",
"(",
"Ptr",
".",
"getNode",
"(",
")",
",",
"VT",
",",
"isSEXTLoad",
",",
"Base",
",",
"Offset",
",",
"isInc",
",",
"DAG",
")",
";",
"else",
"isLegal",
"=",
"getARMIndexedAddressParts",
"(",
"Ptr",
".",
"getNode",
"(",
")",
",",
"VT",
",",
"isSEXTLoad",
",",
"Base",
",",
"Offset",
",",
"isInc",
",",
"DAG",
")",
";",
"}",
"if",
"(",
"!",
"isLegal",
")",
"return",
"false",
";",
"AM",
"=",
"isInc",
"?",
"ISD",
"::",
"PRE_INC",
":",
"ISD",
"::",
"PRE_DEC",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"by",
"value",
",",
"base",
"pointer",
"and",
"offset",
"pointer",
"and",
"addressing",
"mode",
"by",
"reference",
"if",
"the",
"node",
"'s",
"address",
"can",
"be",
"legally",
"represented",
"as",
"pre-indexed",
"load",
"/",
"store",
"address",
"."
] | [
"ARM",
"ARM",
"ISD::MemIndexedMode",
"ISD::SEXTLOAD",
"ISD::SEXTLOAD",
"ARM",
"ISD::PRE_INC",
"ISD::PRE_DEC"
] | ARMISelLowering (2)6 | getPreIndexedAddressParts | ARM | CPU | LLVM | 23,543 | 395 | 1 | [] |
[
"<s>",
"bool",
"isImm",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"k_Immediate",
";",
"}",
"</s>"
] | [
"isImm",
"-",
"Is",
"this",
"an",
"immediate",
"operand",
"?"
] | [
"OR1K"
] | OR1KAsmParser1 | isImm | OR1K | CPU | LLVM | 23,544 | 13 | 1 | [] |
[
"<s>",
"void",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCInst",
"&",
"Res",
")",
"const",
"override",
"{",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"SIC"
] | SICAsmBackend | relaxInstruction | SIC | CPU | LLVM | 23,545 | 21 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_init_builtins",
"(",
"void",
")",
"{",
"const",
"struct",
"mips_builtin_description",
"*",
"d",
";",
"unsigned",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"mips_builtins",
")",
";",
"i",
"++",
")",
"{",
"d",
"=",
"&",
"mips_builtins",
"[",
"i",
"]",
";",
"if",
"(",
"d",
"->",
"avail",
"(",
")",
")",
"{",
"mips_builtin_decls",
"[",
"i",
"]",
"=",
"add_builtin_function",
"(",
"d",
"->",
"name",
",",
"mips_build_function_type",
"(",
"d",
"->",
"function_type",
")",
",",
"i",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL",
")",
";",
"mips_get_builtin_decl_index",
"[",
"d",
"->",
"icode",
"]",
"=",
"i",
";",
"}",
"}",
"}",
"</s>"
] | [
"Init",
"builtin",
"functions",
".",
"This",
"is",
"called",
"from",
"TARGET_INIT_BUILTIN",
"."
] | [
"mips",
"0"
] | mips6 | mips_init_builtins | mips | CPU | GCC | 23,546 | 90 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Imm",
".",
"isPosZero",
"(",
")",
"&&",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"||",
"VT",
"==",
"MVT",
"::",
"f32",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
"&&",
"Subtarget",
"->",
"hasFullFP16",
"(",
")",
")",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Legal fp imm: materialize 0 using the zero register\\n\"",
")",
";",
"return",
"true",
";",
"}",
"StringRef",
"FPType",
";",
"bool",
"IsLegal",
"=",
"false",
";",
"SmallString",
"<",
"128",
">",
"ImmStrVal",
";",
"Imm",
".",
"toString",
"(",
"ImmStrVal",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
")",
"{",
"FPType",
"=",
"\"f64\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP64Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"{",
"FPType",
"=",
"\"f32\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP32Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
"&&",
"Subtarget",
"->",
"hasFullFP16",
"(",
")",
")",
"{",
"FPType",
"=",
"\"f16\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP16Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"if",
"(",
"IsLegal",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Legal \"",
"<<",
"FPType",
"<<",
"\" imm value: \"",
"<<",
"ImmStrVal",
"<<",
"\"\\n\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"FPType",
".",
"empty",
"(",
")",
")",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Illegal \"",
"<<",
"FPType",
"<<",
"\" imm value: \"",
"<<",
"ImmStrVal",
"<<",
"\"\\n\"",
")",
";",
"else",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Illegal fp imm \"",
"<<",
"ImmStrVal",
"<<",
"\": unsupported fp type\\n\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"AArch64",
"AArch64",
"MVT::f64",
"MVT::f32",
"MVT::f16",
"\"Legal fp imm: materialize 0 using the zero register\\n\"",
"128",
"MVT::f64",
"\"f64\"",
"AArch64_AM::getFP64Imm",
"1",
"MVT::f32",
"\"f32\"",
"AArch64_AM::getFP32Imm",
"1",
"MVT::f16",
"\"f16\"",
"AArch64_AM::getFP16Imm",
"1",
"\"Legal \"",
"\" imm value: \"",
"\"\\n\"",
"\"Illegal \"",
"\" imm value: \"",
"\"\\n\"",
"\"Illegal fp imm \"",
"\": unsupported fp type\\n\""
] | AArch64ISelLowering | isFPImmLegal | AArch64 | CPU | LLVM | 23,547 | 242 | 1 | [] |
[
"<s>",
"bool",
"MipsLongBranch",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"F",
")",
"{",
"const",
"MipsSubtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"MipsSubtarget",
"&",
">",
"(",
"F",
".",
"getSubtarget",
"(",
")",
")",
";",
"const",
"MipsInstrInfo",
"*",
"TII",
"=",
"static_cast",
"<",
"const",
"MipsInstrInfo",
"*",
">",
"(",
"STI",
".",
"getInstrInfo",
"(",
")",
")",
";",
"LongBranchSeqSize",
"=",
"!",
"IsPIC",
"?",
"2",
":",
"(",
"ABI",
".",
"IsN64",
"(",
")",
"?",
"10",
":",
"(",
"!",
"STI",
".",
"isTargetNaCl",
"(",
")",
"?",
"9",
":",
"10",
")",
")",
";",
"if",
"(",
"STI",
".",
"inMips16Mode",
"(",
")",
"||",
"!",
"STI",
".",
"enableLongBranchPass",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"IsPIC",
"&&",
"static_cast",
"<",
"const",
"MipsTargetMachine",
"&",
">",
"(",
"TM",
")",
".",
"getABI",
"(",
")",
".",
"IsO32",
"(",
")",
"&&",
"F",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
"->",
"globalBaseRegSet",
"(",
")",
")",
"emitGPDisp",
"(",
"F",
",",
"TII",
")",
";",
"if",
"(",
"SkipLongBranch",
")",
"return",
"true",
";",
"MF",
"=",
"&",
"F",
";",
"initMBBInfo",
"(",
")",
";",
"SmallVectorImpl",
"<",
"MBBInfo",
">",
"::",
"iterator",
"I",
",",
"E",
"=",
"MBBInfos",
".",
"end",
"(",
")",
";",
"bool",
"EverMadeChange",
"=",
"false",
",",
"MadeChange",
"=",
"true",
";",
"while",
"(",
"MadeChange",
")",
"{",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"I",
"=",
"MBBInfos",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"!",
"I",
"->",
"Br",
"||",
"I",
"->",
"HasLongBranch",
")",
"continue",
";",
"int",
"ShVal",
"=",
"STI",
".",
"inMicroMipsMode",
"(",
")",
"?",
"2",
":",
"4",
";",
"int64_t",
"Offset",
"=",
"computeOffset",
"(",
"I",
"->",
"Br",
")",
"/",
"ShVal",
";",
"if",
"(",
"STI",
".",
"isTargetNaCl",
"(",
")",
")",
"{",
"Offset",
"*=",
"2",
";",
"}",
"if",
"(",
"!",
"ForceLongBranch",
"&&",
"isInt",
"<",
"16",
">",
"(",
"Offset",
")",
")",
"continue",
";",
"I",
"->",
"HasLongBranch",
"=",
"true",
";",
"I",
"->",
"Size",
"+=",
"LongBranchSeqSize",
"*",
"4",
";",
"++",
"LongBranches",
";",
"EverMadeChange",
"=",
"MadeChange",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"!",
"EverMadeChange",
")",
"return",
"true",
";",
"if",
"(",
"IsPIC",
")",
"{",
"uint64_t",
"Address",
"=",
"0",
";",
"for",
"(",
"I",
"=",
"MBBInfos",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"E",
";",
"Address",
"+=",
"I",
"->",
"Size",
",",
"++",
"I",
")",
"I",
"->",
"Address",
"=",
"Address",
";",
"}",
"for",
"(",
"I",
"=",
"MBBInfos",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"if",
"(",
"I",
"->",
"HasLongBranch",
")",
"expandToLongBranch",
"(",
"*",
"I",
")",
";",
"MF",
"->",
"RenumberBlocks",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"2",
"10",
"9",
"10",
"Mips",
"Mips",
"Mips",
"Mips",
"2",
"4",
"2",
"16",
"4",
"0"
] | MipsLongBranch10 | runOnMachineFunction | Mips | CPU | LLVM | 23,548 | 385 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_print_condition",
"(",
"FILE",
"*",
"stream",
")",
"{",
"if",
"(",
"arm_ccfsm_state",
"==",
"3",
"||",
"arm_ccfsm_state",
"==",
"4",
")",
"{",
"if",
"(",
"TARGET_THUMB",
")",
"{",
"output_operand_lossage",
"(",
"\"predicated Thumb instruction\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"current_insn_predicate",
"!=",
"NULL",
")",
"{",
"output_operand_lossage",
"(",
"\"predicated instruction in conditional sequence\"",
")",
";",
"return",
";",
"}",
"fputs",
"(",
"arm_condition_codes",
"[",
"arm_current_cc",
"]",
",",
"stream",
")",
";",
"}",
"else",
"if",
"(",
"current_insn_predicate",
")",
"{",
"enum",
"arm_cond_code",
"code",
";",
"if",
"(",
"TARGET_THUMB1",
")",
"{",
"output_operand_lossage",
"(",
"\"predicated Thumb instruction\"",
")",
";",
"return",
";",
"}",
"code",
"=",
"get_arm_condition_code",
"(",
"current_insn_predicate",
")",
";",
"fputs",
"(",
"arm_condition_codes",
"[",
"code",
"]",
",",
"stream",
")",
";",
"}",
"}",
"</s>"
] | [
"Print",
"condition",
"code",
"to",
"STREAM",
".",
"Helper",
"function",
"for",
"arm_print_operand",
"."
] | [
"arm",
"3",
"4",
"\"predicated Thumb instruction\"",
"\"predicated instruction in conditional sequence\"",
"\"predicated Thumb instruction\""
] | arm | arm_print_condition | arm | CPU | GCC | 23,549 | 101 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_output_barrier",
"(",
"rtx",
"*",
"mem_operand",
",",
"int",
"memmodel",
",",
"bool",
"pre_p",
")",
"{",
"bool",
"post_p",
"=",
"!",
"pre_p",
";",
"switch",
"(",
"memmodel",
")",
"{",
"case",
"MEMMODEL_RELAXED",
":",
"return",
";",
"case",
"MEMMODEL_CONSUME",
":",
"case",
"MEMMODEL_ACQUIRE",
":",
"case",
"MEMMODEL_SYNC_ACQUIRE",
":",
"if",
"(",
"post_p",
")",
"break",
";",
"return",
";",
"case",
"MEMMODEL_RELEASE",
":",
"case",
"MEMMODEL_SYNC_RELEASE",
":",
"if",
"(",
"pre_p",
")",
"break",
";",
"return",
";",
"case",
"MEMMODEL_ACQ_REL",
":",
"case",
"MEMMODEL_SEQ_CST",
":",
"case",
"MEMMODEL_SYNC_SEQ_CST",
":",
"if",
"(",
"pre_p",
"||",
"post_p",
")",
"break",
";",
"return",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"output_asm_insn",
"(",
"\"%.\\tmembar%B0;\"",
",",
"mem_operand",
")",
";",
"}",
"</s>"
] | [
"Output",
"a",
"pre/post",
"barrier",
"for",
"MEM_OPERAND",
"according",
"to",
"MEMMODEL",
"."
] | [
"nvptx",
"\"%.\\tmembar%B0;\""
] | nvptx | nvptx_output_barrier | nvptx | GPU | GCC | 23,550 | 96 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_conditional_register_usage",
"(",
"void",
")",
"{",
"int",
"i",
";",
"if",
"(",
"flag_pic",
")",
"fixed_regs",
"[",
"PIC_OFFSET_TABLE_REGNUM",
"]",
"=",
"1",
";",
"fixed_regs",
"[",
"BASE_REGNUM",
"]",
"=",
"0",
";",
"fixed_regs",
"[",
"RETURN_REGNUM",
"]",
"=",
"0",
";",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"for",
"(",
"i",
"=",
"FPR8_REGNUM",
";",
"i",
"<=",
"FPR15_REGNUM",
";",
"i",
"++",
")",
"call_used_regs",
"[",
"i",
"]",
"=",
"0",
";",
"}",
"else",
"{",
"call_used_regs",
"[",
"FPR4_REGNUM",
"]",
"=",
"0",
";",
"call_used_regs",
"[",
"FPR6_REGNUM",
"]",
"=",
"0",
";",
"}",
"if",
"(",
"TARGET_SOFT_FLOAT",
")",
"{",
"for",
"(",
"i",
"=",
"FPR0_REGNUM",
";",
"i",
"<=",
"FPR15_REGNUM",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"1",
";",
"}",
"if",
"(",
"!",
"TARGET_VX",
")",
"{",
"for",
"(",
"i",
"=",
"VR16_REGNUM",
";",
"i",
"<=",
"VR31_REGNUM",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"CONDITIONAL_REGISTER_USAGE",
"."
] | [
"s390",
"1",
"0",
"0",
"0",
"0",
"0",
"1",
"1"
] | s390 | s390_conditional_register_usage | s390 | MPU | GCC | 23,551 | 137 | 1 | [] |
[
"<s>",
"void",
"mips_expand_vec_reduc",
"(",
"rtx",
"target",
",",
"rtx",
"in",
",",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
")",
"{",
"machine_mode",
"vmode",
"=",
"GET_MODE",
"(",
"in",
")",
";",
"unsigned",
"char",
"perm2",
"[",
"2",
"]",
";",
"rtx",
"last",
",",
"next",
",",
"fold",
",",
"x",
";",
"bool",
"ok",
";",
"last",
"=",
"in",
";",
"fold",
"=",
"gen_reg_rtx",
"(",
"vmode",
")",
";",
"switch",
"(",
"vmode",
")",
"{",
"case",
"E_V2SFmode",
":",
"perm2",
"[",
"0",
"]",
"=",
"1",
";",
"perm2",
"[",
"1",
"]",
"=",
"2",
";",
"ok",
"=",
"mips_expand_vselect_vconcat",
"(",
"fold",
",",
"last",
",",
"last",
",",
"perm2",
",",
"2",
")",
";",
"gcc_assert",
"(",
"ok",
")",
";",
"break",
";",
"case",
"E_V2SImode",
":",
"emit_insn",
"(",
"gen_loongson_punpckhwd",
"(",
"fold",
",",
"last",
",",
"last",
")",
")",
";",
"break",
";",
"case",
"E_V4HImode",
":",
"emit_insn",
"(",
"gen_loongson_punpckhwd_hi",
"(",
"fold",
",",
"last",
",",
"last",
")",
")",
";",
"next",
"=",
"gen_reg_rtx",
"(",
"vmode",
")",
";",
"emit_insn",
"(",
"gen",
"(",
"next",
",",
"last",
",",
"fold",
")",
")",
";",
"last",
"=",
"next",
";",
"fold",
"=",
"gen_reg_rtx",
"(",
"vmode",
")",
";",
"x",
"=",
"force_reg",
"(",
"SImode",
",",
"GEN_INT",
"(",
"16",
")",
")",
";",
"emit_insn",
"(",
"gen_vec_shr_v4hi",
"(",
"fold",
",",
"last",
",",
"x",
")",
")",
";",
"break",
";",
"case",
"E_V8QImode",
":",
"emit_insn",
"(",
"gen_loongson_punpckhwd_qi",
"(",
"fold",
",",
"last",
",",
"last",
")",
")",
";",
"next",
"=",
"gen_reg_rtx",
"(",
"vmode",
")",
";",
"emit_insn",
"(",
"gen",
"(",
"next",
",",
"last",
",",
"fold",
")",
")",
";",
"last",
"=",
"next",
";",
"fold",
"=",
"gen_reg_rtx",
"(",
"vmode",
")",
";",
"x",
"=",
"force_reg",
"(",
"SImode",
",",
"GEN_INT",
"(",
"16",
")",
")",
";",
"emit_insn",
"(",
"gen_vec_shr_v8qi",
"(",
"fold",
",",
"last",
",",
"x",
")",
")",
";",
"next",
"=",
"gen_reg_rtx",
"(",
"vmode",
")",
";",
"emit_insn",
"(",
"gen",
"(",
"next",
",",
"last",
",",
"fold",
")",
")",
";",
"last",
"=",
"next",
";",
"fold",
"=",
"gen_reg_rtx",
"(",
"vmode",
")",
";",
"x",
"=",
"force_reg",
"(",
"SImode",
",",
"GEN_INT",
"(",
"8",
")",
")",
";",
"emit_insn",
"(",
"gen_vec_shr_v8qi",
"(",
"fold",
",",
"last",
",",
"x",
")",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"emit_insn",
"(",
"gen",
"(",
"target",
",",
"last",
",",
"fold",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"vector",
"reduction",
"."
] | [
"mips",
"2",
"0",
"1",
"1",
"2",
"2",
"16",
"16",
"8"
] | mips | mips_expand_vec_reduc | mips | CPU | GCC | 23,552 | 338 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_emit_restore_regs_using_mov",
"(",
"HOST_WIDE_INT",
"cfa_offset",
",",
"bool",
"maybe_eh_return",
")",
"{",
"struct",
"machine_function",
"*",
"m",
"=",
"cfun",
"->",
"machine",
";",
"unsigned",
"int",
"regno",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"!",
"SSE_REGNO_P",
"(",
"regno",
")",
"&&",
"ix86_save_reg",
"(",
"regno",
",",
"maybe_eh_return",
")",
")",
"{",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"word_mode",
",",
"regno",
")",
";",
"rtx",
"insn",
",",
"mem",
";",
"mem",
"=",
"choose_baseaddr",
"(",
"cfa_offset",
")",
";",
"mem",
"=",
"gen_frame_mem",
"(",
"word_mode",
",",
"mem",
")",
";",
"insn",
"=",
"emit_move_insn",
"(",
"reg",
",",
"mem",
")",
";",
"if",
"(",
"m",
"->",
"fs",
".",
"cfa_reg",
"==",
"crtl",
"->",
"drap_reg",
"&&",
"regno",
"==",
"REGNO",
"(",
"crtl",
"->",
"drap_reg",
")",
")",
"{",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_DEF_CFA",
",",
"reg",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"m",
"->",
"fs",
".",
"drap_valid",
"=",
"true",
";",
"}",
"else",
"ix86_add_cfa_restore_note",
"(",
"NULL_RTX",
",",
"reg",
",",
"cfa_offset",
")",
";",
"cfa_offset",
"-=",
"UNITS_PER_WORD",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"restore",
"saved",
"registers",
"using",
"MOV",
"insns",
".",
"First",
"register",
"is",
"restored",
"from",
"POINTER",
"+",
"OFFSET",
"."
] | [
"i386",
"0",
"1"
] | i3864 | ix86_emit_restore_regs_using_mov | i386 | CPU | GCC | 23,553 | 156 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_function_regparm",
"(",
"const_tree",
"type",
",",
"const_tree",
"decl",
")",
"{",
"tree",
"attr",
";",
"int",
"regparm",
";",
"unsigned",
"int",
"ccvt",
";",
"if",
"(",
"TARGET_64BIT",
")",
"return",
"(",
"ix86_function_type_abi",
"(",
"type",
")",
"==",
"SYSV_ABI",
"?",
"X86_64_REGPARM_MAX",
":",
"X86_64_MS_REGPARM_MAX",
")",
";",
"ccvt",
"=",
"ix86_get_callcvt",
"(",
"type",
")",
";",
"regparm",
"=",
"ix86_regparm",
";",
"if",
"(",
"(",
"ccvt",
"&",
"IX86_CALLCVT_REGPARM",
")",
"!=",
"0",
")",
"{",
"attr",
"=",
"lookup_attribute",
"(",
"\"regparm\"",
",",
"TYPE_ATTRIBUTES",
"(",
"type",
")",
")",
";",
"if",
"(",
"attr",
")",
"{",
"regparm",
"=",
"TREE_INT_CST_LOW",
"(",
"TREE_VALUE",
"(",
"TREE_VALUE",
"(",
"attr",
")",
")",
")",
";",
"return",
"regparm",
";",
"}",
"}",
"else",
"if",
"(",
"(",
"ccvt",
"&",
"IX86_CALLCVT_FASTCALL",
")",
"!=",
"0",
")",
"return",
"2",
";",
"else",
"if",
"(",
"(",
"ccvt",
"&",
"IX86_CALLCVT_THISCALL",
")",
"!=",
"0",
")",
"return",
"1",
";",
"if",
"(",
"decl",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"{",
"cgraph_node",
"*",
"target",
"=",
"cgraph_node",
"::",
"get",
"(",
"decl",
")",
";",
"if",
"(",
"target",
")",
"target",
"=",
"target",
"->",
"function_symbol",
"(",
")",
";",
"if",
"(",
"target",
"&&",
"opt_for_fn",
"(",
"target",
"->",
"decl",
",",
"optimize",
")",
"&&",
"!",
"(",
"profile_flag",
"&&",
"!",
"flag_fentry",
")",
")",
"{",
"cgraph_local_info",
"*",
"i",
"=",
"&",
"target",
"->",
"local",
";",
"if",
"(",
"i",
"&&",
"i",
"->",
"local",
"&&",
"i",
"->",
"can_change_signature",
")",
"{",
"int",
"local_regparm",
",",
"globals",
"=",
"0",
",",
"regno",
";",
"for",
"(",
"local_regparm",
"=",
"0",
";",
"local_regparm",
"<",
"REGPARM_MAX",
";",
"local_regparm",
"++",
")",
"if",
"(",
"fixed_regs",
"[",
"local_regparm",
"]",
")",
"break",
";",
"if",
"(",
"local_regparm",
"==",
"3",
"&&",
"DECL_STATIC_CHAIN",
"(",
"target",
"->",
"decl",
")",
")",
"local_regparm",
"=",
"2",
";",
"if",
"(",
"flag_split_stack",
")",
"{",
"if",
"(",
"local_regparm",
"==",
"3",
")",
"local_regparm",
"=",
"2",
";",
"else",
"if",
"(",
"local_regparm",
"==",
"2",
"&&",
"DECL_STATIC_CHAIN",
"(",
"target",
"->",
"decl",
")",
")",
"local_regparm",
"=",
"1",
";",
"}",
"for",
"(",
"regno",
"=",
"AX_REG",
";",
"regno",
"<=",
"DI_REG",
";",
"regno",
"++",
")",
"if",
"(",
"fixed_regs",
"[",
"regno",
"]",
")",
"globals",
"++",
";",
"local_regparm",
"=",
"globals",
"<",
"local_regparm",
"?",
"local_regparm",
"-",
"globals",
":",
"0",
";",
"if",
"(",
"local_regparm",
">",
"regparm",
")",
"regparm",
"=",
"local_regparm",
";",
"}",
"}",
"}",
"return",
"regparm",
";",
"}",
"</s>"
] | [
"Return",
"the",
"regparm",
"value",
"for",
"a",
"function",
"with",
"the",
"indicated",
"TYPE",
"and",
"DECL",
".",
"DECL",
"may",
"be",
"NULL",
"when",
"calling",
"function",
"indirectly",
"or",
"considering",
"a",
"libcall",
"."
] | [
"i386",
"0",
"\"regparm\"",
"0",
"2",
"0",
"1",
"0",
"0",
"3",
"2",
"3",
"2",
"2",
"1",
"0"
] | i3866 | ix86_function_regparm | i386 | CPU | GCC | 23,554 | 337 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"EVT",
",",
"EVT",
">",
"AMDGPUTargetLowering",
"::",
"getSplitDestVTs",
"(",
"const",
"EVT",
"&",
"VT",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"EVT",
"LoVT",
",",
"HiVT",
";",
"EVT",
"EltVT",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"unsigned",
"NumElts",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"unsigned",
"LoNumElts",
"=",
"PowerOf2Ceil",
"(",
"(",
"NumElts",
"+",
"1",
")",
"/",
"2",
")",
";",
"LoVT",
"=",
"EVT",
"::",
"getVectorVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"EltVT",
",",
"LoNumElts",
")",
";",
"HiVT",
"=",
"NumElts",
"-",
"LoNumElts",
"==",
"1",
"?",
"EltVT",
":",
"EVT",
"::",
"getVectorVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"EltVT",
",",
"NumElts",
"-",
"LoNumElts",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"LoVT",
",",
"HiVT",
")",
";",
"}",
"</s>"
] | [
"Split",
"a",
"vector",
"type",
"into",
"two",
"parts",
"."
] | [
"AMDGPU",
"AMDGPU",
"1",
"2",
"1"
] | AMDGPUISelLowering (2)1 | getSplitDestVTs | AMDGPU | GPU | LLVM | 23,555 | 117 | 1 | [] |
[
"<s>",
"ScheduleHazardRecognizer",
"::",
"HazardType",
"GCNHazardRecognizer",
"::",
"getHazardType",
"(",
"SUnit",
"*",
"SU",
",",
"int",
"Stalls",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"SU",
"->",
"getInstr",
"(",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isSMRD",
"(",
"*",
"MI",
")",
"&&",
"checkSMRDHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isVMEM",
"(",
"*",
"MI",
")",
"&&",
"checkVMEMHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isVALU",
"(",
"*",
"MI",
")",
"&&",
"checkVALUHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isDPP",
"(",
"*",
"MI",
")",
"&&",
"checkDPPHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"isDivFMas",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkDivFMasHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"isRWLane",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkRWLaneHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"isSGetReg",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkGetRegHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"isSSetReg",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkSetRegHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"isRFE",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkRFEHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"NoopHazard",
";",
"return",
"NoHazard",
";",
"}",
"</s>"
] | [
"getHazardType",
"-",
"Return",
"the",
"hazard",
"type",
"of",
"emitting",
"this",
"node",
"."
] | [
"AMDGPU",
"SI",
"0",
"SI",
"0",
"SI",
"0",
"SI",
"0",
"0",
"0",
"0",
"0",
"0"
] | GCNHazardRecognizer33 | getHazardType | AMDGPU | GPU | LLVM | 23,556 | 214 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"isProfitableToIfCvt",
"(",
"MachineBasicBlock",
"&",
"TMBB",
",",
"unsigned",
"NumCyclesT",
",",
"unsigned",
"ExtraPredCyclesT",
",",
"MachineBasicBlock",
"&",
"FMBB",
",",
"unsigned",
"NumCyclesF",
",",
"unsigned",
"ExtraPredCyclesF",
",",
"BranchProbability",
"Probability",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Second",
"variant",
"of",
"isProfitableToIfCvt",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZInstrInfo (2)2 | isProfitableToIfCvt | SystemZ | CPU | LLVM | 23,557 | 34 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Dead register definitions\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AArch64",
"\"Dead register definitions\""
] | AArch64DeadRegisterDefinitionsPass1 | getPassName | AArch64 | CPU | LLVM | 23,558 | 13 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"HexagonTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"StringRef",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"bool",
"UseHVX",
"=",
"Subtarget",
".",
"useHVXOps",
"(",
")",
",",
"UseHVXDbl",
"=",
"Subtarget",
".",
"useHVXDblOps",
"(",
")",
";",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"switch",
"(",
"VT",
".",
"SimpleTy",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"getRegForInlineAsmConstraint Unhandled data type\"",
")",
";",
"case",
"MVT",
"::",
"i1",
":",
"case",
"MVT",
"::",
"i8",
":",
"case",
"MVT",
"::",
"i16",
":",
"case",
"MVT",
"::",
"i32",
":",
"case",
"MVT",
"::",
"f32",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"IntRegsRegClass",
")",
";",
"case",
"MVT",
"::",
"i64",
":",
"case",
"MVT",
"::",
"f64",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"DoubleRegsRegClass",
")",
";",
"}",
"break",
";",
"case",
"'a'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"ModRegsRegClass",
")",
";",
"case",
"'q'",
":",
"switch",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"getRegForInlineAsmConstraint Unhandled vector size\"",
")",
";",
"case",
"512",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"HvxQRRegClass",
")",
";",
"case",
"1024",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"HvxQRRegClass",
")",
";",
"}",
"break",
";",
"case",
"'v'",
":",
"switch",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"getRegForInlineAsmConstraint Unhandled vector size\"",
")",
";",
"case",
"512",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"HvxVRRegClass",
")",
";",
"case",
"1024",
":",
"if",
"(",
"Subtarget",
".",
"hasV60TOps",
"(",
")",
"&&",
"UseHVX",
"&&",
"UseHVXDbl",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"HvxVRRegClass",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"HvxWRRegClass",
")",
";",
"case",
"2048",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Hexagon",
"::",
"HvxWRRegClass",
")",
";",
"}",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown asm register class\"",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"Hexagon",
"Hexagon",
"1",
"0",
"\"getRegForInlineAsmConstraint Unhandled data type\"",
"MVT::i1",
"MVT::i8",
"MVT::i16",
"MVT::i32",
"MVT::f32",
"0U",
"Hexagon::IntRegsRegClass",
"MVT::i64",
"MVT::f64",
"0U",
"Hexagon::DoubleRegsRegClass",
"0U",
"Hexagon::ModRegsRegClass",
"\"getRegForInlineAsmConstraint Unhandled vector size\"",
"512",
"0U",
"Hexagon::HvxQRRegClass",
"1024",
"0U",
"Hexagon::HvxQRRegClass",
"\"getRegForInlineAsmConstraint Unhandled vector size\"",
"512",
"0U",
"Hexagon::HvxVRRegClass",
"1024",
"0U",
"Hexagon::HvxVRRegClass",
"0U",
"Hexagon::HvxWRRegClass",
"2048",
"0U",
"Hexagon::HvxWRRegClass",
"\"Unknown asm register class\""
] | HexagonISelLowering27 | getRegForInlineAsmConstraint | Hexagon | DSP | LLVM | 23,559 | 331 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_register_move_cost",
"(",
"machine_mode",
"mode",
",",
"reg_class_t",
"class1_i",
",",
"reg_class_t",
"class2_i",
")",
"{",
"enum",
"reg_class",
"class1",
"=",
"(",
"enum",
"reg_class",
")",
"class1_i",
";",
"enum",
"reg_class",
"class2",
"=",
"(",
"enum",
"reg_class",
")",
"class2_i",
";",
"if",
"(",
"inline_secondary_memory_needed",
"(",
"mode",
",",
"class1",
",",
"class2",
",",
"false",
")",
")",
"{",
"int",
"cost",
"=",
"1",
";",
"cost",
"+=",
"inline_memory_move_cost",
"(",
"mode",
",",
"class1",
",",
"2",
")",
";",
"cost",
"+=",
"inline_memory_move_cost",
"(",
"mode",
",",
"class2",
",",
"2",
")",
";",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
">",
"BITS_PER_WORD",
"&&",
"TARGET_MEMORY_MISMATCH_STALL",
"&&",
"targetm",
".",
"class_max_nregs",
"(",
"class1",
",",
"mode",
")",
">",
"targetm",
".",
"class_max_nregs",
"(",
"class2",
",",
"mode",
")",
")",
"cost",
"+=",
"20",
";",
"if",
"(",
"(",
"MMX_CLASS_P",
"(",
"class1",
")",
"&&",
"MAYBE_FLOAT_CLASS_P",
"(",
"class2",
")",
")",
"||",
"(",
"MMX_CLASS_P",
"(",
"class2",
")",
"&&",
"MAYBE_FLOAT_CLASS_P",
"(",
"class1",
")",
")",
")",
"cost",
"+=",
"20",
";",
"return",
"cost",
";",
"}",
"if",
"(",
"MMX_CLASS_P",
"(",
"class1",
")",
"!=",
"MMX_CLASS_P",
"(",
"class2",
")",
")",
"gcc_unreachable",
"(",
")",
";",
"if",
"(",
"SSE_CLASS_P",
"(",
"class1",
")",
"!=",
"SSE_CLASS_P",
"(",
"class2",
")",
")",
"return",
"(",
"SSE_CLASS_P",
"(",
"class1",
")",
"?",
"ix86_cost",
"->",
"hard_register",
".",
"sse_to_integer",
":",
"ix86_cost",
"->",
"hard_register",
".",
"integer_to_sse",
")",
";",
"if",
"(",
"MASK_CLASS_P",
"(",
"class1",
")",
"!=",
"MASK_CLASS_P",
"(",
"class2",
")",
")",
"{",
"return",
"(",
"MASK_CLASS_P",
"(",
"class1",
")",
"?",
"ix86_cost",
"->",
"hard_register",
".",
"mask_to_integer",
":",
"ix86_cost",
"->",
"hard_register",
".",
"integer_to_mask",
")",
";",
"}",
"if",
"(",
"MASK_CLASS_P",
"(",
"class1",
")",
"&&",
"MASK_CLASS_P",
"(",
"class2",
")",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"mask_move",
";",
"if",
"(",
"MAYBE_FLOAT_CLASS_P",
"(",
"class1",
")",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"fp_move",
";",
"if",
"(",
"MAYBE_SSE_CLASS_P",
"(",
"class1",
")",
")",
"{",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"<=",
"128",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"xmm_move",
";",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"<=",
"256",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"ymm_move",
";",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"zmm_move",
";",
"}",
"if",
"(",
"MAYBE_MMX_CLASS_P",
"(",
"class1",
")",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"mmx_move",
";",
"return",
"2",
";",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"moving",
"data",
"from",
"a",
"register",
"in",
"class",
"CLASS1",
"to",
"one",
"in",
"class",
"CLASS2",
".",
"It",
"is",
"not",
"required",
"that",
"the",
"cost",
"always",
"equal",
"2",
"when",
"FROM",
"is",
"the",
"same",
"as",
"TO",
";",
"on",
"some",
"machines",
"it",
"is",
"expensive",
"to",
"move",
"between",
"registers",
"if",
"they",
"are",
"not",
"general",
"registers",
"."
] | [
"i386",
"1",
"2",
"2",
"20",
"20",
"128",
"256",
"2"
] | i386 | ix86_register_move_cost | i386 | CPU | GCC | 23,560 | 323 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_output_addr_const_extra",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"UNSPEC",
")",
"switch",
"(",
"XINT",
"(",
"x",
",",
"1",
")",
")",
"{",
"case",
"UNSPEC_TOCREL",
":",
"gcc_checking_assert",
"(",
"SYMBOL_REF_P",
"(",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
"&&",
"REG_P",
"(",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"1",
")",
")",
"&&",
"REGNO",
"(",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"1",
")",
")",
"==",
"TOC_REGISTER",
")",
";",
"output_addr_const",
"(",
"file",
",",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
";",
"if",
"(",
"x",
"==",
"tocrel_base_oac",
"&&",
"tocrel_offset_oac",
"!=",
"const0_rtx",
")",
"{",
"if",
"(",
"INTVAL",
"(",
"tocrel_offset_oac",
")",
">=",
"0",
")",
"fprintf",
"(",
"file",
",",
"\"+\"",
")",
";",
"output_addr_const",
"(",
"file",
",",
"CONST_CAST_RTX",
"(",
"tocrel_offset_oac",
")",
")",
";",
"}",
"if",
"(",
"!",
"TARGET_AIX",
"||",
"(",
"TARGET_ELF",
"&&",
"TARGET_MINIMAL_TOC",
")",
")",
"{",
"putc",
"(",
"'-'",
",",
"file",
")",
";",
"assemble_name",
"(",
"file",
",",
"toc_label_name",
")",
";",
"need_toc_init",
"=",
"1",
";",
"}",
"else",
"if",
"(",
"TARGET_ELF",
")",
"fputs",
"(",
"\"@toc\"",
",",
"file",
")",
";",
"return",
"true",
";",
"case",
"UNSPEC_MACHOPIC_OFFSET",
":",
"output_addr_const",
"(",
"file",
",",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
";",
"putc",
"(",
"'-'",
",",
"file",
")",
";",
"machopic_output_function_base_name",
"(",
"file",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA",
"."
] | [
"rs6000",
"1",
"0",
"0",
"0",
"1",
"0",
"1",
"0",
"0",
"0",
"\"+\"",
"1",
"\"@toc\"",
"0",
"0"
] | rs60008 | rs6000_output_addr_const_extra | rs6000 | CPU | GCC | 23,561 | 210 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isExtended",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"const",
"uint64_t",
"F",
"=",
"MI",
"->",
"getDesc",
"(",
")",
".",
"TSFlags",
";",
"if",
"(",
"(",
"F",
">>",
"HexagonII",
"::",
"ExtendedPos",
")",
"&",
"HexagonII",
"::",
"ExtendedMask",
")",
"return",
"true",
";",
"for",
"(",
"MachineInstr",
"::",
"const_mop_iterator",
"I",
"=",
"MI",
"->",
"operands_begin",
"(",
")",
",",
"E",
"=",
"MI",
"->",
"operands_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"getTargetFlags",
"(",
")",
"&&",
"HexagonII",
"::",
"HMOTF_ConstExtended",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Test",
"if",
"the",
"given",
"EVT",
"is",
"extended",
"(",
"as",
"opposed",
"to",
"being",
"simple",
")",
"."
] | [
"Hexagon",
"Hexagon",
"HexagonII::ExtendedPos",
"HexagonII::ExtendedMask",
"HexagonII::HMOTF_ConstExtended"
] | HexagonInstrInfo (2) | isExtended | Hexagon | DSP | LLVM | 23,562 | 90 | 1 | [] |
[
"<s>",
"void",
"cr16_expand_prologue",
"(",
"void",
")",
"{",
"rtx",
"insn",
";",
"cr16_compute_frame",
"(",
")",
";",
"cr16_compute_save_regs",
"(",
")",
";",
"if",
"(",
"(",
"current_frame_info",
".",
"total_size",
"+",
"current_frame_info",
".",
"reg_size",
")",
"==",
"0",
")",
"return",
";",
"if",
"(",
"current_frame_info",
".",
"last_reg_to_save",
"!=",
"-",
"1",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"gen_push_for_prologue",
"(",
"GEN_INT",
"(",
"current_frame_info",
".",
"reg_size",
")",
")",
")",
";",
"cr16_create_dwarf_for_multi_push",
"(",
"insn",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"if",
"(",
"current_frame_info",
".",
"total_size",
">",
"0",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"current_frame_info",
".",
"total_size",
")",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"{",
"insn",
"=",
"emit_move_insn",
"(",
"frame_pointer_rtx",
",",
"stack_pointer_rtx",
")",
";",
"}",
"}",
"</s>"
] | [
"CompactRISC",
"CR16",
"Architecture",
"stack",
"layout",
":",
"0",
"+",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"-",
"|",
".",
".",
"|",
"+====================",
"Sp",
"(",
"x",
")",
"=",
"Ap",
"(",
"x+1",
")",
"A",
"|",
"Args",
"for",
"functions",
"|",
"|",
"called",
"by",
"X",
"and",
"Dynamically",
"|",
"|",
"Dynamic",
"allocations",
"allocated",
"and",
"|",
"|",
"(",
"alloca",
",",
"variable",
"deallocated",
"Stack",
"|",
"length",
"arrays",
")",
".",
"grows",
"+",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"Fp",
"(",
"x",
")",
"down|",
"|",
"Local",
"variables",
"of",
"X",
"ward|",
"+",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"|",
"|",
"Regs",
"saved",
"for",
"X-1",
"|",
"+====================",
"Sp",
"(",
"x-1",
")",
"=",
"Ap",
"(",
"x",
")",
"|",
"Args",
"for",
"func",
"X",
"|",
"pushed",
"by",
"X-1",
"+",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"--",
"Fp",
"(",
"x-1",
")",
"|",
"|",
"V"
] | [
"cr16",
"0",
"1",
"1",
"0",
"1"
] | cr16 | cr16_expand_prologue | cr16 | MPU | GCC | 23,563 | 124 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"isPredicable",
"(",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"STI",
".",
"hasLoadStoreOnCond",
"(",
")",
"&&",
"getConditionalMove",
"(",
"Opcode",
")",
")",
"return",
"true",
";",
"if",
"(",
"Opcode",
"==",
"SystemZ",
"::",
"Return",
"||",
"Opcode",
"==",
"SystemZ",
"::",
"Trap",
"||",
"Opcode",
"==",
"SystemZ",
"::",
"CallJG",
"||",
"Opcode",
"==",
"SystemZ",
"::",
"CallBR",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"instruction",
"can",
"be",
"predicated",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ::Return",
"SystemZ::Trap",
"SystemZ::CallJG",
"SystemZ::CallBR"
] | SystemZInstrInfo74 | isPredicable | SystemZ | CPU | LLVM | 23,564 | 69 | 1 | [] |
[
"<s>",
"static",
"void",
"iq2000_option_override",
"(",
"void",
")",
"{",
"target_flags",
"&=",
"~",
"MASK_GPOPT",
";",
"iq2000_isa",
"=",
"IQ2000_ISA_DEFAULT",
";",
"iq2000_print_operand_punct",
"[",
"'?'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'#'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'&'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'!'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'*'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'@'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'.'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'('",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"')'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'['",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"']'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'<'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'>'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'{'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'}'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'^'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'$'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'+'",
"]",
"=",
"1",
";",
"iq2000_print_operand_punct",
"[",
"'~'",
"]",
"=",
"1",
";",
"gpr_mode",
"=",
"SImode",
";",
"init_machine_status",
"=",
"iq2000_init_machine_status",
";",
"}",
"</s>"
] | [
"Detect",
"any",
"conflicts",
"in",
"the",
"switches",
"."
] | [
"iq2000",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1"
] | iq2000 | iq2000_option_override | iq2000 | CPU | GCC | 23,565 | 158 | 1 | [] |
[
"<s>",
"static",
"void",
"expand_block_set_2",
"(",
"rtx",
"dst",
",",
"rtx",
"dst_reg",
",",
"rtx",
"value_rtx",
",",
"rtx",
"bytes_rtx",
")",
"{",
"const",
"rtx",
"sym",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"\"__wrd_memset\"",
")",
";",
"unsigned",
"HOST_WIDE_INT",
"bytes",
"=",
"UINTVAL",
"(",
"bytes_rtx",
")",
";",
"unsigned",
"int",
"rem",
"=",
"bytes",
"%",
"2",
";",
"value_rtx",
"=",
"convert_to_mode",
"(",
"Pmode",
",",
"value_rtx",
",",
"1",
")",
";",
"emit_library_call",
"(",
"sym",
",",
"LCT_NORMAL",
",",
"VOIDmode",
",",
"3",
",",
"dst_reg",
",",
"Pmode",
",",
"value_rtx",
",",
"Pmode",
",",
"convert_to_mode",
"(",
"TYPE_MODE",
"(",
"sizetype",
")",
",",
"GEN_INT",
"(",
"bytes",
">>",
"1",
")",
",",
"TYPE_UNSIGNED",
"(",
"sizetype",
")",
")",
",",
"TYPE_MODE",
"(",
"sizetype",
")",
")",
";",
"if",
"(",
"rem",
"==",
"0",
")",
"return",
";",
"dst",
"=",
"replace_equiv_address_nv",
"(",
"dst",
",",
"dst_reg",
")",
";",
"bytes",
"-=",
"rem",
";",
"emit_move_insn",
"(",
"adjust_address_nv",
"(",
"dst",
",",
"QImode",
",",
"bytes",
")",
",",
"convert_to_mode",
"(",
"QImode",
",",
"value_rtx",
",",
"1",
")",
")",
";",
"}",
"</s>"
] | [
"Generate",
"a",
"call",
"to",
"a",
"library",
"function",
"to",
"set",
"BYTES_RTX",
"bytes",
"of",
"DST",
"with",
"address",
"DST_REG",
"to",
"VALUE_RTX",
"in",
"2-byte",
"chunks",
"."
] | [
"visium",
"\"__wrd_memset\"",
"2",
"1",
"3",
"1",
"0",
"1"
] | visium2 | expand_block_set_2 | visium | Virtual ISA | GCC | 23,566 | 143 | 1 | [] |
[
"<s>",
"bool",
"useMachineCombiner",
"(",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"when",
"a",
"target",
"supports",
"MachineCombiner",
"."
] | [
"X86"
] | X86InstrInfo (2) | useMachineCombiner | X86 | CPU | LLVM | 23,567 | 11 | 1 | [] |
[
"<s>",
"size_t",
"Mips64GOT",
"::",
"getEntrySize",
"(",
")",
"const",
"{",
"return",
"Mips64GOTEntry",
"::",
"EntrySize",
";",
"}",
"</s>"
] | [
"getEntrySize",
"-",
"Return",
"the",
"size",
"of",
"each",
"entry",
"in",
"the",
"jump",
"table",
"."
] | [
"Mips",
"Mips",
"Mips64GOTEntry::EntrySize"
] | MipsGOT | getEntrySize | Mips | CPU | LLVM | 23,568 | 14 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"X86RegisterInfo",
"::",
"getPointerRegClass",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"unsigned",
"Kind",
")",
"const",
"{",
"switch",
"(",
"Kind",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected Kind in getPointerRegClass!\"",
")",
";",
"case",
"0",
":",
"if",
"(",
"Subtarget",
".",
"isTarget64BitLP64",
"(",
")",
")",
"return",
"&",
"X86",
"::",
"GR64RegClass",
";",
"return",
"&",
"X86",
"::",
"GR32RegClass",
";",
"case",
"1",
":",
"if",
"(",
"Subtarget",
".",
"isTarget64BitLP64",
"(",
")",
")",
"return",
"&",
"X86",
"::",
"GR64_NOSPRegClass",
";",
"return",
"&",
"X86",
"::",
"GR32_NOSPRegClass",
";",
"case",
"2",
":",
"if",
"(",
"Subtarget",
".",
"isTargetWin64",
"(",
")",
")",
"return",
"&",
"X86",
"::",
"GR64_TCW64RegClass",
";",
"else",
"if",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
")",
"return",
"&",
"X86",
"::",
"GR64_TCRegClass",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"bool",
"hasHipeCC",
"=",
"(",
"F",
"?",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"HiPE",
":",
"false",
")",
";",
"if",
"(",
"hasHipeCC",
")",
"return",
"&",
"X86",
"::",
"GR32RegClass",
";",
"return",
"&",
"X86",
"::",
"GR32_TCRegClass",
";",
"}",
"}",
"</s>"
] | [
"getPointerRegClass",
"-",
"Returns",
"a",
"TargetRegisterClass",
"used",
"for",
"pointer",
"values",
"."
] | [
"X86",
"X86",
"\"Unexpected Kind in getPointerRegClass!\"",
"0",
"X86::GR64RegClass",
"X86::GR32RegClass",
"1",
"X86::GR64_NOSPRegClass",
"X86::GR32_NOSPRegClass",
"2",
"X86::GR64_TCW64RegClass",
"X86::GR64_TCRegClass",
"X86::GR32RegClass",
"X86::GR32_TCRegClass"
] | X86RegisterInfo2 | getPointerRegClass | X86 | CPU | LLVM | 23,569 | 155 | 1 | [] |
[
"<s>",
"unsigned",
"AVRInstrInfo",
"::",
"removeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"int",
"*",
"BytesRemoved",
")",
"const",
"{",
"assert",
"(",
"!",
"BytesRemoved",
"&&",
"\"code size not handled\"",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"unsigned",
"Count",
"=",
"0",
";",
"while",
"(",
"I",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"--",
"I",
";",
"if",
"(",
"I",
"->",
"isDebugValue",
"(",
")",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"!=",
"AVR",
"::",
"RJMPk",
"&&",
"getCondFromBranchOpc",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"==",
"AVRCC",
"::",
"COND_INVALID",
")",
"{",
"break",
";",
"}",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"++",
"Count",
";",
"}",
"return",
"Count",
";",
"}",
"</s>"
] | [
"Remove",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"the",
"specific",
"MBB",
"."
] | [
"AVR",
"AVR",
"\"code size not handled\"",
"0",
"AVR::RJMPk",
"AVRCC::COND_INVALID"
] | AVRInstrInfo19 | removeBranch | AVR | MPU | LLVM | 23,570 | 116 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_nsaved_regs",
"(",
"void",
")",
"{",
"int",
"nregs",
"=",
"0",
";",
"int",
"regno",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"!",
"SSE_REGNO_P",
"(",
"regno",
")",
"&&",
"ix86_save_reg",
"(",
"regno",
",",
"true",
")",
")",
"nregs",
"++",
";",
"return",
"nregs",
";",
"}",
"</s>"
] | [
"Return",
"number",
"of",
"registers",
"to",
"be",
"saved",
"on",
"the",
"stack",
"."
] | [
"i386",
"0",
"0"
] | i3864 | ix86_nsaved_regs | i386 | CPU | GCC | 23,571 | 50 | 1 | [] |
[
"<s>",
"static",
"void",
"*",
"rs6000_alloc_sched_context",
"(",
"void",
")",
"{",
"return",
"xmalloc",
"(",
"sizeof",
"(",
"rs6000_sched_context_def",
")",
")",
";",
"}",
"</s>"
] | [
"Allocate",
"store",
"for",
"new",
"scheduling",
"context",
"."
] | [
"powerpcspe"
] | powerpcspe | rs6000_alloc_sched_context | powerpcspe | CPU | GCC | 23,572 | 18 | 1 | [] |
[
"<s>",
"static",
"void",
"nds32_asm_trampoline_template",
"(",
"FILE",
"*",
"f",
")",
"{",
"if",
"(",
"TARGET_REDUCED_REGS",
")",
"{",
"sorry",
"(",
"\"a nested function is not supported for reduced registers\"",
")",
";",
"}",
"else",
"{",
"asm_fprintf",
"(",
"f",
",",
"\"\\t! Trampoline code template\\n\"",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\t! This code fragment will be copied \"",
"\"into stack on demand\\n\"",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\tmfusr\\t$r16,$pc\\n\"",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\tlwi\\t$r15,[$r16 + 20] \"",
"\"! load nested function address\\n\"",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\tlwi\\t$r16,[$r16 + 16] \"",
"\"! load chain_value\\n\"",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\tjr\\t$r15\\n\"",
")",
";",
"}",
"asm_fprintf",
"(",
"f",
",",
"\"\\t! space for saving chain_value\\n\"",
")",
";",
"assemble_aligned_integer",
"(",
"UNITS_PER_WORD",
",",
"const0_rtx",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\t! space for saving nested function address\\n\"",
")",
";",
"assemble_aligned_integer",
"(",
"UNITS_PER_WORD",
",",
"const0_rtx",
")",
";",
"}",
"</s>"
] | [
"Trampolines",
"for",
"Nested",
"Functions",
"."
] | [
"nds32",
"\"a nested function is not supported for reduced registers\"",
"\"\\t! Trampoline code template\\n\"",
"\"\\t! This code fragment will be copied \"",
"\"into stack on demand\\n\"",
"\"\\tmfusr\\t$r16,$pc\\n\"",
"\"\\tlwi\\t$r15,[$r16 + 20] \"",
"\"! load nested function address\\n\"",
"\"\\tlwi\\t$r16,[$r16 + 16] \"",
"\"! load chain_value\\n\"",
"\"\\tjr\\t$r15\\n\"",
"\"\\t! space for saving chain_value\\n\"",
"\"\\t! space for saving nested function address\\n\""
] | nds32 | nds32_asm_trampoline_template | nds32 | CPU | GCC | 23,573 | 97 | 1 | [] |
[
"<s>",
"EVT",
"SystemZTargetLowering",
"::",
"getSetCCResultType",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"LLVMContext",
"&",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"MVT",
"::",
"i32",
";",
"return",
"VT",
".",
"changeVectorElementTypeToInteger",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"SystemZ",
"SystemZ",
"MVT::i32"
] | SystemZISelLowering (2)1 | getSetCCResultType | SystemZ | CPU | LLVM | 23,574 | 40 | 1 | [] |
[
"<s>",
"static",
"std",
"::",
"string",
"toString",
"(",
"const",
"APFloat",
"&",
"FP",
")",
"{",
"if",
"(",
"FP",
".",
"isNaN",
"(",
")",
"&&",
"!",
"FP",
".",
"bitwiseIsEqual",
"(",
"APFloat",
"::",
"getQNaN",
"(",
"FP",
".",
"getSemantics",
"(",
")",
")",
")",
"&&",
"!",
"FP",
".",
"bitwiseIsEqual",
"(",
"APFloat",
"::",
"getQNaN",
"(",
"FP",
".",
"getSemantics",
"(",
")",
",",
"true",
")",
")",
")",
"{",
"APInt",
"AI",
"=",
"FP",
".",
"bitcastToAPInt",
"(",
")",
";",
"return",
"std",
"::",
"string",
"(",
"AI",
".",
"isNegative",
"(",
")",
"?",
"\"-\"",
":",
"\"\"",
")",
"+",
"\"nan:0x\"",
"+",
"utohexstr",
"(",
"AI",
".",
"getZExtValue",
"(",
")",
"&",
"(",
"AI",
".",
"getBitWidth",
"(",
")",
"==",
"32",
"?",
"INT64_C",
"(",
"0x007fffff",
")",
":",
"INT64_C",
"(",
"0x000fffffffffffff",
")",
")",
",",
"true",
")",
";",
"}",
"static",
"const",
"size_t",
"BufBytes",
"=",
"128",
";",
"char",
"buf",
"[",
"BufBytes",
"]",
";",
"auto",
"Written",
"=",
"FP",
".",
"convertToHexString",
"(",
"buf",
",",
"0",
",",
"false",
",",
"APFloat",
"::",
"rmNearestTiesToEven",
")",
";",
"(",
"void",
")",
"Written",
";",
"assert",
"(",
"Written",
"!=",
"0",
")",
";",
"assert",
"(",
"Written",
"<",
"BufBytes",
")",
";",
"return",
"buf",
";",
"}",
"</s>"
] | [
"Convert",
"to",
"a",
"decimal",
"representation",
"in",
"a",
"string",
"."
] | [
"WebAssembly",
"\"-\"",
"\"\"",
"\"nan:0x\"",
"32",
"0x007fffff",
"0x000fffffffffffff",
"128",
"0",
"0"
] | WebAssemblyInstPrinter31 | toString | WebAssembly | Virtual ISA | LLVM | 23,575 | 170 | 1 | [] |
[
"<s>",
"int",
"pru_can_use_return_insn",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"reload_completed",
"||",
"crtl",
"->",
"profile",
")",
"return",
"0",
";",
"return",
"cfun",
"->",
"machine",
"->",
"total_size",
"==",
"0",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"this",
"function",
"is",
"known",
"to",
"have",
"a",
"null",
"epilogue",
".",
"This",
"allows",
"the",
"optimizer",
"to",
"omit",
"jumps",
"to",
"jumps",
"if",
"no",
"stack",
"was",
"created",
"."
] | [
"pru",
"0",
"0"
] | pru | pru_can_use_return_insn | pru | CPU | GCC | 23,576 | 28 | 1 | [] |
[
"<s>",
"static",
"inline",
"bool",
"mode_supports_pre_incdec_p",
"(",
"machine_mode",
"mode",
")",
"{",
"return",
"(",
"(",
"reg_addr",
"[",
"mode",
"]",
".",
"addr_mask",
"[",
"RELOAD_REG_ANY",
"]",
"&",
"RELOAD_REG_PRE_INCDEC",
")",
"!=",
"0",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"to",
"say",
"whether",
"a",
"mode",
"supports",
"PRE_INC",
"or",
"PRE_DEC",
"."
] | [
"rs6000",
"0"
] | rs6000 | mode_supports_pre_incdec_p | rs6000 | CPU | GCC | 23,577 | 29 | 1 | [] |
[
"<s>",
"bool",
"X86FrameLowering",
"::",
"has128ByteRedZone",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"assert",
"(",
"&",
"STI",
"==",
"&",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
"&&",
"\"MF used frame lowering for wrong subtarget\"",
")",
";",
"const",
"Function",
"&",
"Fn",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"const",
"bool",
"IsWin64CC",
"=",
"STI",
".",
"isCallingConvWin64",
"(",
"Fn",
".",
"getCallingConv",
"(",
")",
")",
";",
"return",
"Is64Bit",
"&&",
"!",
"IsWin64CC",
"&&",
"!",
"Fn",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoRedZone",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"function",
"has",
"a",
"redzone",
"(",
"accessible",
"bytes",
"past",
"the",
"frame",
"of",
"the",
"top",
"of",
"stack",
"function",
")",
"as",
"part",
"of",
"it",
"'s",
"ABI",
"."
] | [
"X86",
"X86",
"X86",
"\"MF used frame lowering for wrong subtarget\""
] | X86FrameLowering (2)3 | has128ByteRedZone | X86 | CPU | LLVM | 23,578 | 73 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"isVectorLoadExtDesirable",
"(",
"SDValue",
"ExtVal",
")",
"const",
"{",
"return",
"ExtVal",
".",
"getValueType",
"(",
")",
".",
"isScalableVector",
"(",
")",
"||",
"useSVEForFixedLengthVectorVT",
"(",
"ExtVal",
".",
"getValueType",
"(",
")",
",",
"Subtarget",
"->",
"useSVEForFixedLengthVectors",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"folding",
"a",
"vector",
"load",
"into",
"ExtVal",
"(",
"a",
"sign",
",",
"zero",
",",
"or",
"any",
"extend",
"node",
")",
"is",
"profitable",
"."
] | [
"AArch64",
"AArch64"
] | AArch64ISelLowering69 | isVectorLoadExtDesirable | AArch64 | CPU | LLVM | 23,579 | 37 | 1 | [] |
[
"<s>",
"unsigned",
"size",
"(",
")",
"const",
"{",
"return",
"(",
"Packet",
".",
"size",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"The",
"number",
"of",
"name/type",
"pairs",
"is",
"returned",
"."
] | [
"Hexagon"
] | HexagonShuffler | size | Hexagon | DSP | LLVM | 23,580 | 16 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"AArch64TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"StringRef",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"AArch64",
"::",
"GPR64commonRegClass",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"AArch64",
"::",
"GPR32commonRegClass",
")",
";",
"case",
"'w'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"AArch64",
"::",
"FPR32RegClass",
")",
";",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"AArch64",
"::",
"FPR64RegClass",
")",
";",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"128",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"AArch64",
"::",
"FPR128RegClass",
")",
";",
"break",
";",
"case",
"'x'",
":",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"128",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"AArch64",
"::",
"FPR128_loRegClass",
")",
";",
"break",
";",
"}",
"}",
"if",
"(",
"StringRef",
"(",
"\"{cc}\"",
")",
".",
"equals_lower",
"(",
"Constraint",
")",
")",
"return",
"std",
"::",
"make_pair",
"(",
"unsigned",
"(",
"AArch64",
"::",
"NZCV",
")",
",",
"&",
"AArch64",
"::",
"CCRRegClass",
")",
";",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"Res",
";",
"Res",
"=",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"if",
"(",
"!",
"Res",
".",
"second",
")",
"{",
"unsigned",
"Size",
"=",
"Constraint",
".",
"size",
"(",
")",
";",
"if",
"(",
"(",
"Size",
"==",
"4",
"||",
"Size",
"==",
"5",
")",
"&&",
"Constraint",
"[",
"0",
"]",
"==",
"'{'",
"&&",
"tolower",
"(",
"Constraint",
"[",
"1",
"]",
")",
"==",
"'v'",
"&&",
"Constraint",
"[",
"Size",
"-",
"1",
"]",
"==",
"'}'",
")",
"{",
"int",
"RegNo",
";",
"bool",
"Failed",
"=",
"Constraint",
".",
"slice",
"(",
"2",
",",
"Size",
"-",
"1",
")",
".",
"getAsInteger",
"(",
"10",
",",
"RegNo",
")",
";",
"if",
"(",
"!",
"Failed",
"&&",
"RegNo",
">=",
"0",
"&&",
"RegNo",
"<=",
"31",
")",
"{",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"Other",
"&&",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"{",
"Res",
".",
"first",
"=",
"AArch64",
"::",
"FPR64RegClass",
".",
"getRegister",
"(",
"RegNo",
")",
";",
"Res",
".",
"second",
"=",
"&",
"AArch64",
"::",
"FPR64RegClass",
";",
"}",
"else",
"{",
"Res",
".",
"first",
"=",
"AArch64",
"::",
"FPR128RegClass",
".",
"getRegister",
"(",
"RegNo",
")",
";",
"Res",
".",
"second",
"=",
"&",
"AArch64",
"::",
"FPR128RegClass",
";",
"}",
"}",
"}",
"}",
"return",
"Res",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"AArch64",
"AArch64",
"1",
"0",
"64",
"0U",
"AArch64::GPR64commonRegClass",
"0U",
"AArch64::GPR32commonRegClass",
"MVT::f32",
"0U",
"AArch64::FPR32RegClass",
"64",
"0U",
"AArch64::FPR64RegClass",
"128",
"0U",
"AArch64::FPR128RegClass",
"128",
"0U",
"AArch64::FPR128_loRegClass",
"\"{cc}\"",
"AArch64::NZCV",
"AArch64::CCRRegClass",
"4",
"5",
"0",
"1",
"1",
"2",
"1",
"10",
"0",
"31",
"MVT::Other",
"64",
"AArch64::FPR64RegClass",
"AArch64::FPR64RegClass",
"AArch64::FPR128RegClass",
"AArch64::FPR128RegClass"
] | AArch64ISelLowering149 | getRegForInlineAsmConstraint | AArch64 | CPU | LLVM | 23,581 | 408 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"SparcRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"return",
"CSR_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"Sparc",
"Sparc"
] | SparcRegisterInfo (2) | getCallPreservedMask | Sparc | CPU | LLVM | 23,582 | 23 | 1 | [] |
[
"<s>",
"virtual",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"{",
"return",
"&",
"InstrItins",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"CellSPU"
] | SPUTargetMachine1 | getInstrItineraryData | CellSPU | MPU | LLVM | 23,583 | 14 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isReallyTriviallyReMaterializable",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"AAResults",
"*",
"AA",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPU",
"::",
"V_MOV_B32_e32",
":",
"case",
"AMDGPU",
"::",
"V_MOV_B32_e64",
":",
"case",
"AMDGPU",
"::",
"V_MOV_B64_PSEUDO",
":",
"case",
"AMDGPU",
"::",
"V_ACCVGPR_READ_B32_e64",
":",
"case",
"AMDGPU",
"::",
"V_ACCVGPR_WRITE_B32_e64",
":",
"return",
"MI",
".",
"getNumOperands",
"(",
")",
"==",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumOperands",
"(",
")",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"For",
"instructions",
"with",
"opcodes",
"for",
"which",
"the",
"M_REMATERIALIZABLE",
"flag",
"is",
"set",
",",
"this",
"hook",
"lets",
"the",
"target",
"specify",
"whether",
"the",
"instruction",
"is",
"actually",
"trivially",
"rematerializable",
",",
"taking",
"into",
"consideration",
"its",
"operands",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::V_MOV_B32_e32",
"AMDGPU::V_MOV_B32_e64",
"AMDGPU::V_MOV_B64_PSEUDO",
"AMDGPU::V_ACCVGPR_READ_B32_e64",
"AMDGPU::V_ACCVGPR_WRITE_B32_e64"
] | SIInstrInfo99 | isReallyTriviallyReMaterializable | AMDGPU | GPU | LLVM | 23,584 | 74 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"LC3RegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"return",
"CC_Save_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"LC3",
"LC3"
] | LC3RegisterInfo | getCallPreservedMask | LC3 | CPU | LLVM | 23,585 | 22 | 1 | [] |
[
"<s>",
"void",
"NVPTXTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"report_fatal_error",
"(",
"\"Unhandled custom legalization\"",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"ReplaceLoadVector",
"(",
"N",
",",
"DAG",
",",
"Results",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
":",
"ReplaceINTRINSIC_W_CHAIN",
"(",
"N",
",",
"DAG",
",",
"Results",
")",
";",
"return",
";",
"}",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"NVPTX",
"NVPTX",
"\"Unhandled custom legalization\"",
"ISD::LOAD",
"ISD::INTRINSIC_W_CHAIN"
] | NVPTXISelLowering48 | ReplaceNodeResults | NVPTX | GPU | LLVM | 23,586 | 72 | 1 | [] |
[
"<s>",
"bool",
"arc_legitimate_pc_offset_p",
"(",
"rtx",
"addr",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"!=",
"CONST",
")",
"return",
"false",
";",
"return",
"arc_needs_pcl_p",
"(",
"addr",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"ADDR",
"is",
"an",
"address",
"that",
"needs",
"to",
"be",
"expressed",
"as",
"an",
"explicit",
"sum",
"of",
"pcl",
"+",
"offset",
"."
] | [
"arc"
] | arc6 | arc_legitimate_pc_offset_p | arc | MPU | GCC | 23,587 | 26 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"R600 Packetizer\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"R600",
"\"R600 Packetizer\""
] | R600Packetizer18 | getPassName | R600 | GPU | LLVM | 23,588 | 13 | 1 | [] |
[
"<s>",
"static",
"inline",
"ChildIteratorType",
"child_begin",
"(",
"NodeRef",
"N",
")",
"{",
"return",
"N",
"->",
"G",
"->",
"Edges",
".",
"lower_bound",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"nodes_iterator/begin/end",
"-",
"Allow",
"iteration",
"over",
"all",
"nodes",
"in",
"the",
"graph"
] | [
"Patmos"
] | PatmosFunctionSplitter1 | child_begin | Patmos | VLIW | LLVM | 23,589 | 22 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"X86"
] | X86DomainReassignment | getAnalysisUsage | X86 | CPU | LLVM | 23,590 | 24 | 1 | [] |
[
"<s>",
"void",
"X86AsmPrinter",
"::",
"emitStartOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
".",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatELF",
"(",
")",
")",
"{",
"unsigned",
"FeatureFlagsAnd",
"=",
"0",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-branch\"",
")",
")",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_IBT",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-return\"",
")",
")",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_SHSTK",
";",
"if",
"(",
"FeatureFlagsAnd",
")",
"{",
"if",
"(",
"!",
"TT",
".",
"isArch32Bit",
"(",
")",
"&&",
"!",
"TT",
".",
"isArch64Bit",
"(",
")",
")",
"llvm_unreachable",
"(",
"\"CFProtection used on invalid architecture!\"",
")",
";",
"MCSection",
"*",
"Cur",
"=",
"OutStreamer",
"->",
"getCurrentSectionOnly",
"(",
")",
";",
"MCSection",
"*",
"Nt",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".note.gnu.property\"",
",",
"ELF",
"::",
"SHT_NOTE",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Nt",
")",
";",
"int",
"WordSize",
"=",
"TT",
".",
"isArch64Bit",
"(",
")",
"?",
"8",
":",
"4",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"4",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"8",
"+",
"WordSize",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"ELF",
"::",
"NT_GNU_PROPERTY_TYPE_0",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitBytes",
"(",
"StringRef",
"(",
"\"GNU\"",
",",
"4",
")",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_AND",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"4",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"FeatureFlagsAnd",
",",
"4",
")",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"endSection",
"(",
"Nt",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Cur",
")",
";",
"}",
"}",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"OutStreamer",
"->",
"SwitchSection",
"(",
"getObjFileLowering",
"(",
")",
".",
"getTextSection",
"(",
")",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatCOFF",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"S",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"StringRef",
"(",
"\"@feat.00\"",
")",
")",
";",
"OutStreamer",
"->",
"BeginCOFFSymbolDef",
"(",
"S",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolStorageClass",
"(",
"COFF",
"::",
"IMAGE_SYM_CLASS_STATIC",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolType",
"(",
"COFF",
"::",
"IMAGE_SYM_DTYPE_NULL",
")",
";",
"OutStreamer",
"->",
"EndCOFFSymbolDef",
"(",
")",
";",
"int64_t",
"Feat00Flags",
"=",
"0",
";",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86",
")",
"{",
"Feat00Flags",
"|=",
"1",
";",
"}",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cfguard\"",
")",
")",
"Feat00Flags",
"|=",
"0x800",
";",
"OutStreamer",
"->",
"emitSymbolAttribute",
"(",
"S",
",",
"MCSA_Global",
")",
";",
"OutStreamer",
"->",
"emitAssignment",
"(",
"S",
",",
"MCConstantExpr",
"::",
"create",
"(",
"Feat00Flags",
",",
"MMI",
"->",
"getContext",
"(",
")",
")",
")",
";",
"}",
"OutStreamer",
"->",
"emitSyntaxDirective",
"(",
")",
";",
"bool",
"is16",
"=",
"TT",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"CODE16",
";",
"if",
"(",
"M",
".",
"getModuleInlineAsm",
"(",
")",
".",
"empty",
"(",
")",
"&&",
"is16",
")",
"OutStreamer",
"->",
"emitAssemblerFlag",
"(",
"MCAF_Code16",
")",
";",
"}",
"</s>"
] | [
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"start",
"of",
"their",
"file",
"."
] | [
"X86",
"X86",
"0",
"\"cf-protection-branch\"",
"X86",
"\"cf-protection-return\"",
"X86",
"\"CFProtection used on invalid architecture!\"",
"\".note.gnu.property\"",
"8",
"4",
"4",
"4",
"8",
"4",
"4",
"8",
"4",
"4",
"\"GNU\"",
"4",
"X86",
"4",
"4",
"4",
"4",
"4",
"4",
"8",
"\"@feat.00\"",
"0",
"1",
"\"cfguard\"",
"0x800"
] | X86AsmPrinter74 | emitStartOfAsmFile | X86 | CPU | LLVM | 23,591 | 452 | 1 | [] |
[
"<s>",
"static",
"base_reg_disp",
"sh_find_base_reg_disp",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"x",
",",
"disp_t",
"disp",
"=",
"0",
",",
"rtx",
"base_reg",
"=",
"NULL",
")",
"{",
"if",
"(",
"REG_P",
"(",
"x",
")",
")",
"{",
"if",
"(",
"REGNO",
"(",
"x",
")",
"==",
"GBR_REG",
")",
"return",
"base_reg_disp",
"(",
"x",
",",
"disp",
")",
";",
"if",
"(",
"REGNO",
"(",
"x",
")",
"<",
"FIRST_PSEUDO_REGISTER",
")",
"return",
"base_reg_disp",
"(",
"base_reg",
"!=",
"NULL",
"?",
"base_reg",
":",
"x",
",",
"disp",
")",
";",
"rtx_insn",
"*",
"last_i",
"=",
"NULL",
";",
"rtx",
"last_set",
"=",
"NULL",
";",
"for",
"(",
"df_ref",
"d",
"=",
"DF_REG_DEF_CHAIN",
"(",
"REGNO",
"(",
"x",
")",
")",
";",
"d",
"!=",
"NULL",
";",
"d",
"=",
"DF_REF_NEXT_REG",
"(",
"d",
")",
")",
"{",
"rtx",
"set",
"=",
"const_cast",
"<",
"rtx",
">",
"(",
"set_of",
"(",
"x",
",",
"DF_REF_INSN",
"(",
"d",
")",
")",
")",
";",
"if",
"(",
"last_set",
"==",
"NULL",
"||",
"rtx_equal_p",
"(",
"last_set",
",",
"set",
")",
")",
"{",
"last_i",
"=",
"DF_REF_INSN",
"(",
"d",
")",
";",
"last_set",
"=",
"set",
";",
"}",
"else",
"{",
"last_i",
"=",
"NULL",
";",
"last_set",
"=",
"NULL",
";",
"break",
";",
"}",
"}",
"if",
"(",
"last_set",
"!=",
"NULL",
"&&",
"last_i",
"!=",
"NULL",
")",
"return",
"sh_find_base_reg_disp",
"(",
"last_i",
",",
"XEXP",
"(",
"last_set",
",",
"1",
")",
",",
"disp",
",",
"XEXP",
"(",
"last_set",
",",
"0",
")",
")",
";",
"return",
"base_reg_disp",
"(",
"x",
",",
"disp",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
")",
"{",
"base_reg_disp",
"left_val",
"=",
"sh_find_base_reg_disp",
"(",
"insn",
",",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"base_reg_disp",
"right_val",
"=",
"sh_find_base_reg_disp",
"(",
"insn",
",",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
";",
"if",
"(",
"left_val",
".",
"is_reg",
"(",
")",
"&&",
"right_val",
".",
"is_disp",
"(",
")",
")",
"return",
"base_reg_disp",
"(",
"left_val",
".",
"reg",
"(",
")",
",",
"left_val",
".",
"disp",
"(",
")",
"+",
"right_val",
".",
"disp",
"(",
")",
"+",
"disp",
")",
";",
"else",
"if",
"(",
"right_val",
".",
"is_reg",
"(",
")",
"&&",
"left_val",
".",
"is_disp",
"(",
")",
")",
"return",
"base_reg_disp",
"(",
"right_val",
".",
"reg",
"(",
")",
",",
"right_val",
".",
"disp",
"(",
")",
"+",
"left_val",
".",
"disp",
"(",
")",
"+",
"disp",
")",
";",
"else",
"return",
"base_reg_disp",
"(",
"base_reg",
",",
"disp",
")",
";",
"}",
"else",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
")",
"return",
"base_reg_disp",
"(",
"NULL",
",",
"disp",
"+",
"INTVAL",
"(",
"x",
")",
")",
";",
"return",
"base_reg_disp",
"(",
"base_reg",
",",
"disp",
")",
";",
"}",
"</s>"
] | [
"Find",
"the",
"base",
"register",
"and",
"calculate",
"the",
"displacement",
"for",
"a",
"given",
"address",
"rtx",
"'",
"x",
"'",
"."
] | [
"sh",
"0",
"1",
"0",
"0",
"1"
] | sh | sh_find_base_reg_disp | sh | CPU | GCC | 23,592 | 364 | 1 | [] |
[
"<s>",
"unsigned",
"TPCInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"TPC",
"::",
"SPILL_ARF_SAVE",
":",
"case",
"TPC",
"::",
"SPILL_DRF_SAVE",
":",
"case",
"TPC",
"::",
"SPILL_VRF_SAVE",
":",
"case",
"TPC",
"::",
"SPILL_VPRF_SAVE",
":",
"case",
"TPC",
"::",
"SPILL_IRF_SAVE",
":",
"case",
"TPC",
"::",
"SPILL_SRF_SAVE",
":",
"case",
"TPC",
"::",
"SPILL_ZRF_SAVE",
":",
"case",
"TPC",
"::",
"SPILL_SPRF_SAVE",
":",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"TPC",
"TPC",
"TPC::SPILL_ARF_SAVE",
"TPC::SPILL_DRF_SAVE",
"TPC::SPILL_VRF_SAVE",
"TPC::SPILL_VPRF_SAVE",
"TPC::SPILL_IRF_SAVE",
"TPC::SPILL_SRF_SAVE",
"TPC::SPILL_ZRF_SAVE",
"TPC::SPILL_SPRF_SAVE",
"0",
"1",
"0"
] | TPCInstrInfo | isStoreToStackSlot | TPC | Virtual ISA | LLVM | 23,593 | 95 | 1 | [] |
[
"<s>",
"bool",
"MipsSEInstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
";",
"switch",
"(",
"MI",
"->",
"getDesc",
"(",
")",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"Mips",
"::",
"RetRA",
":",
"expandRetRA",
"(",
"MBB",
",",
"MI",
")",
";",
"break",
";",
"case",
"Mips",
"::",
"BuildPairF64",
":",
"expandBuildPairF64",
"(",
"MBB",
",",
"MI",
",",
"false",
")",
";",
"break",
";",
"case",
"Mips",
"::",
"ExtractElementF64",
":",
"expandExtractElementF64",
"(",
"MBB",
",",
"MI",
",",
"false",
")",
";",
"break",
";",
"case",
"Mips",
"::",
"MIPSeh_return32",
":",
"case",
"Mips",
"::",
"MIPSeh_return64",
":",
"expandEhReturn",
"(",
"MBB",
",",
"MI",
")",
";",
"break",
";",
"}",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
] | [
"Mips",
"Mips",
"Mips::RetRA",
"Mips::BuildPairF64",
"Mips::ExtractElementF64",
"Mips::MIPSeh_return32",
"Mips::MIPSeh_return64"
] | MipsSEInstrInfo25 | expandPostRAPseudo | Mips | CPU | LLVM | 23,594 | 118 | 1 | [] |
[
"<s>",
"static",
"bool",
"read_vl_insn_p",
"(",
"rtx_insn",
"*",
"rinsn",
")",
"{",
"return",
"recog_memoized",
"(",
"rinsn",
")",
">=",
"0",
"&&",
"get_attr_type",
"(",
"rinsn",
")",
"==",
"TYPE_RDVL",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"instruction",
"is",
"read",
"vl",
"instruction",
"."
] | [
"riscv",
"0"
] | riscv-vsetvl | read_vl_insn_p | riscv | CPU | GCC | 23,595 | 25 | 1 | [] |
[
"<s>",
"void",
"ARMConstantPoolValue",
"::",
"dump",
"(",
")",
"const",
"{",
"cerr",
"<<",
"\" \"",
"<<",
"*",
"this",
";",
"}",
"</s>"
] | [
"Dump",
"the",
"plan",
"to",
"stderr",
"(",
"for",
"debugging",
")",
"."
] | [
"ARM",
"ARM",
"\" \""
] | ARMConstantPoolValue25 | dump | ARM | CPU | LLVM | 23,596 | 16 | 1 | [] |
[
"<s>",
"static",
"bool",
"mmix_function_value_regno_p",
"(",
"const",
"unsigned",
"int",
"regno",
")",
"{",
"return",
"regno",
"==",
"MMIX_RETURN_VALUE_REGNUM",
";",
"}",
"</s>"
] | [
"FUNCTION_VALUE_REGNO_P",
"."
] | [
"mmix"
] | mmix | mmix_function_value_regno_p | mmix | CPU | GCC | 23,597 | 16 | 1 | [] |
[
"<s>",
"static",
"reg_class_t",
"aarch64_ira_change_pseudo_allocno_class",
"(",
"int",
"regno",
",",
"reg_class_t",
"allocno_class",
",",
"reg_class_t",
"best_class",
")",
"{",
"enum",
"machine_mode",
"mode",
";",
"if",
"(",
"allocno_class",
"!=",
"ALL_REGS",
")",
"return",
"allocno_class",
";",
"if",
"(",
"best_class",
"!=",
"ALL_REGS",
")",
"return",
"best_class",
";",
"mode",
"=",
"PSEUDO_REGNO_MODE",
"(",
"regno",
")",
";",
"return",
"FLOAT_MODE_P",
"(",
"mode",
")",
"||",
"VECTOR_MODE_P",
"(",
"mode",
")",
"?",
"FP_REGS",
":",
"GENERAL_REGS",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS",
".",
"The",
"register",
"allocator",
"chooses",
"ALL_REGS",
"if",
"FP_REGS",
"and",
"GENERAL_REGS",
"have",
"the",
"same",
"cost",
"even",
"if",
"ALL_REGS",
"has",
"a",
"much",
"larger",
"cost",
".",
"ALL_REGS",
"is",
"also",
"used",
"if",
"the",
"cost",
"of",
"both",
"FP_REGS",
"and",
"GENERAL_REGS",
"is",
"lower",
"than",
"the",
"memory",
"cost",
"(",
"in",
"this",
"case",
"the",
"best",
"class",
"is",
"the",
"lowest",
"cost",
"one",
")",
".",
"Using",
"ALL_REGS",
"irrespectively",
"of",
"its",
"cost",
"results",
"in",
"bad",
"allocations",
"with",
"many",
"redundant",
"int",
"<",
"-",
">",
"FP",
"moves",
"which",
"are",
"expensive",
"on",
"various",
"cores",
".",
"To",
"avoid",
"this",
"we",
"do",
"n't",
"allow",
"ALL_REGS",
"as",
"the",
"allocno",
"class",
",",
"but",
"force",
"a",
"decision",
"between",
"FP_REGS",
"and",
"GENERAL_REGS",
".",
"We",
"use",
"the",
"allocno",
"class",
"if",
"it",
"is",
"n't",
"ALL_REGS",
".",
"Similarly",
",",
"use",
"the",
"best",
"class",
"if",
"it",
"is",
"n't",
"ALL_REGS",
".",
"Otherwise",
"set",
"the",
"allocno",
"class",
"depending",
"on",
"the",
"mode",
".",
"The",
"result",
"of",
"this",
"is",
"that",
"it",
"is",
"no",
"longer",
"inefficient",
"to",
"have",
"a",
"higher",
"memory",
"move",
"cost",
"than",
"the",
"register",
"move",
"cost",
"."
] | [
"aarch64"
] | aarch643 | aarch64_ira_change_pseudo_allocno_class | aarch64 | CPU | GCC | 23,598 | 59 | 1 | [] |
[
"<s>",
"static",
"void",
"set_ix86_tune_features",
"(",
"enum",
"processor_type",
"ix86_tune",
",",
"bool",
"dump",
")",
"{",
"unsigned",
"int",
"ix86_tune_mask",
"=",
"1u",
"<<",
"ix86_tune",
";",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"X86_TUNE_LAST",
";",
"++",
"i",
")",
"{",
"if",
"(",
"ix86_tune_no_default",
")",
"ix86_tune_features",
"[",
"i",
"]",
"=",
"0",
";",
"else",
"ix86_tune_features",
"[",
"i",
"]",
"=",
"!",
"!",
"(",
"initial_ix86_tune_features",
"[",
"i",
"]",
"&",
"ix86_tune_mask",
")",
";",
"}",
"if",
"(",
"dump",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"List of x86 specific tuning parameter names:\\n\"",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"X86_TUNE_LAST",
";",
"i",
"++",
")",
"fprintf",
"(",
"stderr",
",",
"\"%s : %s\\n\"",
",",
"ix86_tune_feature_names",
"[",
"i",
"]",
",",
"ix86_tune_features",
"[",
"i",
"]",
"?",
"\"on\"",
":",
"\"off\"",
")",
";",
"}",
"parse_mtune_ctrl_str",
"(",
"dump",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"to",
"set",
"ix86_tune_features",
".",
"IX86_TUNE",
"is",
"the",
"processor",
"type",
"."
] | [
"i386",
"1u",
"0",
"0",
"\"List of x86 specific tuning parameter names:\\n\"",
"0",
"\"%s : %s\\n\"",
"\"on\"",
"\"off\""
] | i3864 | set_ix86_tune_features | i386 | CPU | GCC | 23,599 | 119 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.