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>",
"bool",
"isBlockAddress",
"(",
")",
"const",
"{",
"return",
"Kind",
"==",
"CSKYCP",
"::",
"CPBlockAddress",
";",
"}",
"</s>"
] | [
"isBlockAddress",
"-",
"Tests",
"if",
"this",
"is",
"a",
"MO_BlockAddress",
"operand",
"."
] | [
"CSKY",
"CSKYCP::CPBlockAddress"
] | CSKYConstantPoolValue | isBlockAddress | CSKY | CPU | LLVM | 11,800 | 14 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_ubranch",
"(",
"rtx",
"dest",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"static",
"char",
"string",
"[",
"64",
"]",
";",
"bool",
"v9_form",
"=",
"false",
";",
"int",
"delta",
";",
"char",
"*",
"p",
";",
"delta",
"=",
"5000000",
";",
"if",
"(",
"!",
"CROSSING_JUMP_P",
"(",
"insn",
")",
"&&",
"INSN_ADDRESSES_SET_P",
"(",
")",
")",
"delta",
"=",
"(",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"dest",
")",
")",
"-",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"insn",
")",
")",
")",
";",
"if",
"(",
"TARGET_V9",
"&&",
"delta",
">=",
"-",
"260000",
"&&",
"delta",
"<",
"260000",
")",
"v9_form",
"=",
"true",
";",
"if",
"(",
"TARGET_CBCOND",
")",
"{",
"bool",
"emit_nop",
"=",
"emit_cbcond_nop",
"(",
"insn",
")",
";",
"bool",
"far",
"=",
"false",
";",
"const",
"char",
"*",
"rval",
";",
"if",
"(",
"delta",
"<",
"-",
"500",
"||",
"delta",
">",
"500",
")",
"far",
"=",
"true",
";",
"if",
"(",
"far",
")",
"{",
"if",
"(",
"v9_form",
")",
"rval",
"=",
"\"ba,a,pt\\t%%xcc, %l0\"",
";",
"else",
"rval",
"=",
"\"b,a\\t%l0\"",
";",
"}",
"else",
"{",
"if",
"(",
"emit_nop",
")",
"rval",
"=",
"\"cwbe\\t%%g0, %%g0, %l0\\n\\tnop\"",
";",
"else",
"rval",
"=",
"\"cwbe\\t%%g0, %%g0, %l0\"",
";",
"}",
"return",
"rval",
";",
"}",
"if",
"(",
"v9_form",
")",
"strcpy",
"(",
"string",
",",
"\"ba%*,pt\\t%%xcc, \"",
")",
";",
"else",
"strcpy",
"(",
"string",
",",
"\"b%*\\t\"",
")",
";",
"p",
"=",
"strchr",
"(",
"string",
",",
"'\\0'",
")",
";",
"*",
"p",
"++",
"=",
"'%'",
";",
"*",
"p",
"++",
"=",
"'l'",
";",
"*",
"p",
"++",
"=",
"'0'",
";",
"*",
"p",
"++",
"=",
"'%'",
";",
"*",
"p",
"++",
"=",
"'('",
";",
"*",
"p",
"=",
"'\\0'",
";",
"return",
"string",
";",
"}",
"</s>"
] | [
"Output",
"an",
"unconditional",
"branch",
"to",
"LABEL",
".",
"INSN",
"is",
"the",
"instruction",
"."
] | [
"sparc",
"64",
"5000000",
"260000",
"260000",
"500",
"500",
"\"ba,a,pt\\t%%xcc, %l0\"",
"\"b,a\\t%l0\"",
"\"cwbe\\t%%g0, %%g0, %l0\\n\\tnop\"",
"\"cwbe\\t%%g0, %%g0, %l0\"",
"\"ba%*,pt\\t%%xcc, \"",
"\"b%*\\t\""
] | sparc | output_ubranch | sparc | CPU | GCC | 11,801 | 229 | 1 | [] |
[
"<s>",
"static",
"int",
"compute_movmem_length",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"unsigned",
"int",
"align",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"7",
")",
",",
"0",
")",
")",
";",
"unsigned",
"long",
"n_bytes",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"6",
")",
",",
"0",
")",
")",
";",
"unsigned",
"int",
"n_insns",
"=",
"0",
";",
"if",
"(",
"align",
">",
"(",
"TARGET_64BIT",
"?",
"8",
":",
"4",
")",
")",
"align",
"=",
"(",
"TARGET_64BIT",
"?",
"8",
":",
"4",
")",
";",
"n_insns",
"=",
"6",
";",
"if",
"(",
"n_bytes",
"%",
"(",
"2",
"*",
"align",
")",
"!=",
"0",
")",
"{",
"if",
"(",
"(",
"n_bytes",
"%",
"(",
"2",
"*",
"align",
")",
")",
">=",
"align",
")",
"n_insns",
"+=",
"2",
";",
"if",
"(",
"(",
"n_bytes",
"%",
"align",
")",
"!=",
"0",
")",
"n_insns",
"+=",
"2",
";",
"}",
"return",
"n_insns",
"*",
"4",
";",
"}",
"</s>"
] | [
"Count",
"the",
"number",
"of",
"insns",
"necessary",
"to",
"handle",
"this",
"block",
"move",
".",
"Basic",
"structure",
"is",
"the",
"same",
"as",
"emit_block_move",
",",
"except",
"that",
"we",
"count",
"insns",
"rather",
"than",
"emit",
"them",
"."
] | [
"pa",
"0",
"7",
"0",
"0",
"6",
"0",
"0",
"8",
"4",
"8",
"4",
"6",
"2",
"0",
"2",
"2",
"0",
"2",
"4"
] | pa4 | compute_movmem_length | pa | CPU | GCC | 11,802 | 143 | 1 | [] |
[
"<s>",
"void",
"XtensaFrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"false",
"&&",
"\"XtensaFrameLowering::processFunctionBeforeFrameFinalized\"",
"\" not implemented\"",
")",
";",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"Xtensa",
"Xtensa",
"\"XtensaFrameLowering::processFunctionBeforeFrameFinalized\"",
"\" not implemented\""
] | XtensaFrameLowering1 | processFunctionBeforeFrameFinalized | Xtensa | MPU | LLVM | 11,803 | 24 | 1 | [] |
[
"<s>",
"static",
"bool",
"IsDef",
"(",
"const",
"NodeAddr",
"<",
"NodeBase",
"*",
">",
"BA",
")",
"{",
"return",
"BA",
".",
"Addr",
"->",
"getType",
"(",
")",
"==",
"NodeAttrs",
"::",
"Ref",
"&&",
"BA",
".",
"Addr",
"->",
"getKind",
"(",
")",
"==",
"NodeAttrs",
"::",
"Def",
";",
"}",
"</s>"
] | [
"Tests",
"if",
"this",
"MemDepResult",
"represents",
"a",
"query",
"that",
"is",
"an",
"instruction",
"definition",
"dependency",
"."
] | [
"Hexagon"
] | RDFGraph | isDef | Hexagon | DSP | LLVM | 11,804 | 39 | 1 | [] |
[
"<s>",
"bool",
"MachineConstPropagator",
"::",
"run",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"DEBUG",
"(",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
"<<",
"\"Starting MachineConstPropagator\\n\"",
",",
"0",
")",
")",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"Cells",
".",
"clear",
"(",
")",
";",
"EdgeExec",
".",
"clear",
"(",
")",
";",
"InstrExec",
".",
"clear",
"(",
")",
";",
"assert",
"(",
"FlowQ",
".",
"empty",
"(",
")",
")",
";",
"propagate",
"(",
"MF",
")",
";",
"bool",
"Changed",
"=",
"rewrite",
"(",
"MF",
")",
";",
"DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"End of MachineConstPropagator (Changed=\"",
"<<",
"Changed",
"<<",
"\")\\n\"",
";",
"if",
"(",
"Changed",
")",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
",",
"0",
")",
";",
"}",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"Run",
"the",
"analysis",
"pass",
"over",
"a",
"function",
"and",
"produce",
"a",
"dominator",
"tree",
"."
] | [
"Hexagon",
"\"Starting MachineConstPropagator\\n\"",
"0",
"\"End of MachineConstPropagator (Changed=\"",
"\")\\n\"",
"0"
] | HexagonConstPropagation | run | Hexagon | DSP | LLVM | 11,805 | 110 | 1 | [] |
[
"<s>",
"unsigned",
"char",
"M68kSubtarget",
"::",
"classifyBlockAddressReference",
"(",
")",
"const",
"{",
"return",
"M68kII",
"::",
"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",
"."
] | [
"M68k",
"M68k",
"M68kII::MO_PC_RELATIVE_ADDRESS"
] | M68kSubtarget | classifyBlockAddressReference | M68k | MPU | LLVM | 11,806 | 15 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUPropagateAttributesEarly",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"!",
"TM",
")",
"{",
"auto",
"*",
"TPC",
"=",
"getAnalysisIfAvailable",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"TM",
"=",
"&",
"TPC",
"->",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"}",
"if",
"(",
"!",
"AMDGPU",
"::",
"isEntryFunctionCC",
"(",
"F",
".",
"getCallingConv",
"(",
")",
")",
")",
"return",
"false",
";",
"return",
"AMDGPUPropagateAttributes",
"(",
"TM",
",",
"false",
")",
".",
"process",
"(",
"F",
")",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::isEntryFunctionCC",
"AMDGPU"
] | AMDGPUPropagateAttributes | runOnFunction | AMDGPU | GPU | LLVM | 11,807 | 79 | 1 | [] |
[
"<s>",
"SDValue",
"SHUXITargetLowering",
"::",
"LowerFormalArguments",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"switch",
"(",
"CallConv",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unsupported calling convention\"",
")",
";",
"case",
"CallingConv",
"::",
"C",
":",
"break",
";",
"}",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RegInfo",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"if",
"(",
"IsVarArg",
")",
"{",
"llvm_unreachable",
"(",
"\"VarArg not supported\"",
")",
";",
"}",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"ArgLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"ArgLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeFormalArguments",
"(",
"Ins",
",",
"CC_SHUXI",
")",
";",
"for",
"(",
"auto",
"&",
"VA",
":",
"ArgLocs",
")",
"{",
"if",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
")",
"{",
"EVT",
"RegVT",
"=",
"VA",
".",
"getLocVT",
"(",
")",
";",
"switch",
"(",
"RegVT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"case",
"MVT",
"::",
"i32",
":",
"{",
"const",
"unsigned",
"VReg",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"&",
"SHUXI",
"::",
"GPRegsRegClass",
")",
";",
"RegInfo",
".",
"addLiveIn",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VReg",
")",
";",
"SDValue",
"ArgIn",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"VReg",
",",
"RegVT",
")",
";",
"InVals",
".",
"push_back",
"(",
"ArgIn",
")",
";",
"break",
";",
"}",
"default",
":",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"LowerFormalArguments Unhandled argument type: \"",
"<<",
"RegVT",
".",
"getEVTString",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"llvm_unreachable",
"(",
"\"unhandled argument type\"",
")",
";",
"}",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Defined with too many args\"",
")",
";",
"}",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"the",
"Ins",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"SHUXI",
"SHUXI",
"ISD::InputArg",
"\"Unsupported calling convention\"",
"\"VarArg not supported\"",
"16",
"SHUXI",
"MVT::i32",
"SHUXI::GPRegsRegClass",
"\"LowerFormalArguments Unhandled argument type: \"",
"\"\\n\"",
"\"unhandled argument type\"",
"\"Defined with too many args\""
] | SHUXIISelLowering | LowerFormalArguments | SHUXI | CPU | LLVM | 11,808 | 267 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"X86 DAG->DAG Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"X86 DAG->DAG Instruction Selection\""
] | X86ISelDAGToDAG103 | getPassName | X86 | CPU | LLVM | 11,809 | 13 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"AMDGPUTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"AMDGPUISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"AMDGPUISD",
"::",
"FIRST_NUMBER",
":",
"break",
";",
"NODE_NAME_CASE",
"(",
"UMUL",
")",
";",
"NODE_NAME_CASE",
"(",
"BRANCH_COND",
")",
";",
"NODE_NAME_CASE",
"(",
"IF",
")",
"NODE_NAME_CASE",
"(",
"ELSE",
")",
"NODE_NAME_CASE",
"(",
"LOOP",
")",
"NODE_NAME_CASE",
"(",
"CALL",
")",
"NODE_NAME_CASE",
"(",
"TRAP",
")",
"NODE_NAME_CASE",
"(",
"RET_FLAG",
")",
"NODE_NAME_CASE",
"(",
"RETURN_TO_EPILOG",
")",
"NODE_NAME_CASE",
"(",
"ENDPGM",
")",
"NODE_NAME_CASE",
"(",
"DWORDADDR",
")",
"NODE_NAME_CASE",
"(",
"FRACT",
")",
"NODE_NAME_CASE",
"(",
"SETCC",
")",
"NODE_NAME_CASE",
"(",
"SETREG",
")",
"NODE_NAME_CASE",
"(",
"FMA_W_CHAIN",
")",
"NODE_NAME_CASE",
"(",
"FMUL_W_CHAIN",
")",
"NODE_NAME_CASE",
"(",
"CLAMP",
")",
"NODE_NAME_CASE",
"(",
"COS_HW",
")",
"NODE_NAME_CASE",
"(",
"SIN_HW",
")",
"NODE_NAME_CASE",
"(",
"FMAX_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"FMIN_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"FMAX3",
")",
"NODE_NAME_CASE",
"(",
"SMAX3",
")",
"NODE_NAME_CASE",
"(",
"UMAX3",
")",
"NODE_NAME_CASE",
"(",
"FMIN3",
")",
"NODE_NAME_CASE",
"(",
"SMIN3",
")",
"NODE_NAME_CASE",
"(",
"UMIN3",
")",
"NODE_NAME_CASE",
"(",
"FMED3",
")",
"NODE_NAME_CASE",
"(",
"SMED3",
")",
"NODE_NAME_CASE",
"(",
"UMED3",
")",
"NODE_NAME_CASE",
"(",
"URECIP",
")",
"NODE_NAME_CASE",
"(",
"DIV_SCALE",
")",
"NODE_NAME_CASE",
"(",
"DIV_FMAS",
")",
"NODE_NAME_CASE",
"(",
"DIV_FIXUP",
")",
"NODE_NAME_CASE",
"(",
"FMAD_FTZ",
")",
"NODE_NAME_CASE",
"(",
"TRIG_PREOP",
")",
"NODE_NAME_CASE",
"(",
"RCP",
")",
"NODE_NAME_CASE",
"(",
"RSQ",
")",
"NODE_NAME_CASE",
"(",
"RCP_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"RSQ_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"FMUL_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"RSQ_CLAMP",
")",
"NODE_NAME_CASE",
"(",
"LDEXP",
")",
"NODE_NAME_CASE",
"(",
"FP_CLASS",
")",
"NODE_NAME_CASE",
"(",
"DOT4",
")",
"NODE_NAME_CASE",
"(",
"CARRY",
")",
"NODE_NAME_CASE",
"(",
"BORROW",
")",
"NODE_NAME_CASE",
"(",
"BFE_U32",
")",
"NODE_NAME_CASE",
"(",
"BFE_I32",
")",
"NODE_NAME_CASE",
"(",
"BFI",
")",
"NODE_NAME_CASE",
"(",
"BFM",
")",
"NODE_NAME_CASE",
"(",
"FFBH_U32",
")",
"NODE_NAME_CASE",
"(",
"FFBH_I32",
")",
"NODE_NAME_CASE",
"(",
"MUL_U24",
")",
"NODE_NAME_CASE",
"(",
"MUL_I24",
")",
"NODE_NAME_CASE",
"(",
"MULHI_U24",
")",
"NODE_NAME_CASE",
"(",
"MULHI_I24",
")",
"NODE_NAME_CASE",
"(",
"MUL_LOHI_U24",
")",
"NODE_NAME_CASE",
"(",
"MUL_LOHI_I24",
")",
"NODE_NAME_CASE",
"(",
"MAD_U24",
")",
"NODE_NAME_CASE",
"(",
"MAD_I24",
")",
"NODE_NAME_CASE",
"(",
"TEXTURE_FETCH",
")",
"NODE_NAME_CASE",
"(",
"EXPORT",
")",
"NODE_NAME_CASE",
"(",
"EXPORT_DONE",
")",
"NODE_NAME_CASE",
"(",
"R600_EXPORT",
")",
"NODE_NAME_CASE",
"(",
"CONST_ADDRESS",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_LOAD",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_STORE",
")",
"NODE_NAME_CASE",
"(",
"SAMPLE",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEB",
")",
"NODE_NAME_CASE",
"(",
"SAMPLED",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEL",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE0",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE1",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE2",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE3",
")",
"NODE_NAME_CASE",
"(",
"CVT_PKRTZ_F16_F32",
")",
"NODE_NAME_CASE",
"(",
"FP_TO_FP16",
")",
"NODE_NAME_CASE",
"(",
"FP16_ZEXT",
")",
"NODE_NAME_CASE",
"(",
"BUILD_VERTICAL_VECTOR",
")",
"NODE_NAME_CASE",
"(",
"CONST_DATA_PTR",
")",
"NODE_NAME_CASE",
"(",
"PC_ADD_REL_OFFSET",
")",
"NODE_NAME_CASE",
"(",
"KILL",
")",
"NODE_NAME_CASE",
"(",
"DUMMY_CHAIN",
")",
"case",
"AMDGPUISD",
"::",
"FIRST_MEM_OPCODE_NUMBER",
":",
"break",
";",
"NODE_NAME_CASE",
"(",
"SENDMSG",
")",
"NODE_NAME_CASE",
"(",
"SENDMSGHALT",
")",
"NODE_NAME_CASE",
"(",
"INTERP_MOV",
")",
"NODE_NAME_CASE",
"(",
"INTERP_P1",
")",
"NODE_NAME_CASE",
"(",
"INTERP_P2",
")",
"NODE_NAME_CASE",
"(",
"STORE_MSKOR",
")",
"NODE_NAME_CASE",
"(",
"LOAD_CONSTANT",
")",
"NODE_NAME_CASE",
"(",
"TBUFFER_STORE_FORMAT",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_CMP_SWAP",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_INC",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_DEC",
")",
"NODE_NAME_CASE",
"(",
"BUFFER_LOAD",
")",
"NODE_NAME_CASE",
"(",
"BUFFER_LOAD_FORMAT",
")",
"case",
"AMDGPUISD",
"::",
"LAST_AMDGPU_ISD_NUMBER",
":",
"break",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"AMDGPU",
"AMDGPU",
"AMDGPUISD::NodeType",
"AMDGPUISD::FIRST_NUMBER",
"SI",
"R600",
"AMDGPUISD::FIRST_MEM_OPCODE_NUMBER",
"AMDGPUISD::LAST_AMDGPU_ISD_NUMBER"
] | AMDGPUISelLowering38 | getTargetNodeName | AMDGPU | GPU | LLVM | 11,810 | 438 | 1 | [] |
[
"<s>",
"unsigned",
"NyuziRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"return",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"Nyuzi",
"::",
"FP_REG",
":",
"Nyuzi",
"::",
"SP_REG",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"Nyuzi",
"Nyuzi",
"Nyuzi::FP_REG",
"Nyuzi::SP_REG"
] | NyuziRegisterInfo | getFrameRegister | Nyuzi | GPU | LLVM | 11,811 | 44 | 1 | [] |
[
"<s>",
"unsigned",
"AllocateStack",
"(",
"unsigned",
"Size",
",",
"unsigned",
"Align",
")",
"{",
"assert",
"(",
"Align",
"&&",
"(",
"(",
"Align",
"-",
"1",
")",
"&",
"Align",
")",
"==",
"0",
")",
";",
"StackOffset",
"=",
"(",
"(",
"StackOffset",
"+",
"Align",
"-",
"1",
")",
"&",
"~",
"(",
"Align",
"-",
"1",
")",
")",
";",
"unsigned",
"Result",
"=",
"StackOffset",
";",
"StackOffset",
"+=",
"Size",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Version",
"of",
"AllocateStack",
"with",
"list",
"of",
"extra",
"registers",
"to",
"be",
"shadowed",
"."
] | [
"Hexagon",
"1",
"0",
"1",
"1"
] | HexagonCallingConvLower | AllocateStack | Hexagon | DSP | LLVM | 11,812 | 59 | 1 | [] |
[
"<s>",
"bool",
"X86PassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"bool",
"ShouldPrint",
"=",
"false",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"getX86Subtarget",
"(",
")",
".",
"hasSSE2",
"(",
")",
")",
"{",
"PM",
"->",
"add",
"(",
"createExecutionDependencyFixPass",
"(",
"&",
"X86",
"::",
"VR128RegClass",
")",
")",
";",
"ShouldPrint",
"=",
"true",
";",
"}",
"if",
"(",
"getX86Subtarget",
"(",
")",
".",
"hasAVX",
"(",
")",
"&&",
"UseVZeroUpper",
")",
"{",
"PM",
"->",
"add",
"(",
"createX86IssueVZeroUpperPass",
"(",
")",
")",
";",
"ShouldPrint",
"=",
"true",
";",
"}",
"return",
"ShouldPrint",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"X86",
"X86",
"X86",
"X86::VR128RegClass",
"X86",
"X86"
] | X86TargetMachine87 | addPreEmitPass | X86 | CPU | LLVM | 11,813 | 80 | 1 | [] |
[
"<s>",
"static",
"void",
"pru_insert_attributes",
"(",
"tree",
"node",
",",
"tree",
"*",
"attributes",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"VAR_P",
"(",
"node",
")",
")",
"{",
"const",
"char",
"*",
"name",
"=",
"DECL_NAME",
"(",
"node",
")",
"?",
"IDENTIFIER_POINTER",
"(",
"DECL_NAME",
"(",
"node",
")",
")",
":",
"\"<unknown>\"",
";",
"tree",
"typ",
"=",
"TREE_TYPE",
"(",
"node",
")",
";",
"addr_space_t",
"as",
"=",
"TYPE_ADDR_SPACE",
"(",
"typ",
")",
";",
"if",
"(",
"as",
"==",
"ADDR_SPACE_GENERIC",
")",
"return",
";",
"if",
"(",
"AGGREGATE_TYPE_P",
"(",
"typ",
")",
")",
"{",
"error",
"(",
"\"aggregate types are prohibited in \"",
"\"%<__regio_symbol%> address space\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"DECL_INITIAL",
"(",
"node",
")",
"!=",
"NULL_TREE",
")",
"error",
"(",
"\"variables in %<__regio_symbol%> address space \"",
"\"cannot have initial value\"",
")",
";",
"if",
"(",
"DECL_REGISTER",
"(",
"node",
")",
")",
"error",
"(",
"\"variables in %<__regio_symbol%> address space \"",
"\"cannot be declared %<register%>\"",
")",
";",
"if",
"(",
"!",
"TYPE_VOLATILE",
"(",
"typ",
")",
")",
"error",
"(",
"\"variables in %<__regio_symbol%> address space \"",
"\"must be declared %<volatile%>\"",
")",
";",
"if",
"(",
"!",
"DECL_EXTERNAL",
"(",
"node",
")",
")",
"error",
"(",
"\"variables in %<__regio_symbol%> address space \"",
"\"must be declared %<extern%>\"",
")",
";",
"if",
"(",
"TYPE_MODE",
"(",
"typ",
")",
"!=",
"SImode",
")",
"error",
"(",
"\"only 32-bit access is supported \"",
"\"for %<__regio_symbol%> address space\"",
")",
";",
"if",
"(",
"strcmp",
"(",
"name",
",",
"\"__R30\"",
")",
"!=",
"0",
"&&",
"strcmp",
"(",
"name",
",",
"\"__R31\"",
")",
"!=",
"0",
")",
"error",
"(",
"\"register name %<%s%> not recognized \"",
"\"in %<__regio_symbol%> address space\"",
",",
"name",
")",
";",
"}",
"tree",
"typ",
"=",
"NULL_TREE",
";",
"switch",
"(",
"TREE_CODE",
"(",
"node",
")",
")",
"{",
"case",
"FUNCTION_DECL",
":",
"typ",
"=",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"node",
")",
")",
";",
"break",
";",
"case",
"TYPE_DECL",
":",
"case",
"RESULT_DECL",
":",
"case",
"VAR_DECL",
":",
"case",
"FIELD_DECL",
":",
"case",
"PARM_DECL",
":",
"typ",
"=",
"TREE_TYPE",
"(",
"node",
")",
";",
"break",
";",
"case",
"POINTER_TYPE",
":",
"typ",
"=",
"node",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"if",
"(",
"typ",
"!=",
"NULL_TREE",
"&&",
"pru_nongeneric_pointer_addrspace",
"(",
"typ",
")",
")",
"error",
"(",
"\"pointers to %<__regio_symbol%> address space are prohibited\"",
")",
";",
"}",
"</s>"
] | [
"Implement",
"`",
"TARGET_INSERT_ATTRIBUTES",
"'",
".",
"For",
"PRU",
"it",
"'s",
"used",
"as",
"a",
"hook",
"to",
"provide",
"better",
"diagnostics",
"for",
"some",
"invalid",
"usages",
"of",
"the",
"__regio_symbol",
"address",
"space",
".",
"Any",
"escapes",
"of",
"the",
"following",
"checks",
"are",
"supposed",
"to",
"be",
"caught",
"during",
"the",
"``",
"mov",
"<",
"mode",
">",
"''",
"pattern",
"expansion",
"."
] | [
"pru",
"\"<unknown>\"",
"\"aggregate types are prohibited in \"",
"\"%<__regio_symbol%> address space\"",
"\"variables in %<__regio_symbol%> address space \"",
"\"cannot have initial value\"",
"\"variables in %<__regio_symbol%> address space \"",
"\"cannot be declared %<register%>\"",
"\"variables in %<__regio_symbol%> address space \"",
"\"must be declared %<volatile%>\"",
"\"variables in %<__regio_symbol%> address space \"",
"\"must be declared %<extern%>\"",
"\"only 32-bit access is supported \"",
"\"for %<__regio_symbol%> address space\"",
"\"__R30\"",
"0",
"\"__R31\"",
"0",
"\"register name %<%s%> not recognized \"",
"\"in %<__regio_symbol%> address space\"",
"\"pointers to %<__regio_symbol%> address space are prohibited\""
] | pru | pru_insert_attributes | pru | CPU | GCC | 11,814 | 265 | 1 | [] |
[
"<s>",
"static",
"int",
"rs6000_cpu_name_lookup",
"(",
"const",
"char",
"*",
"name",
")",
"{",
"size_t",
"i",
";",
"if",
"(",
"name",
"!=",
"NULL",
")",
"{",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"processor_target_table",
")",
";",
"i",
"++",
")",
"if",
"(",
"!",
"strcmp",
"(",
"name",
",",
"processor_target_table",
"[",
"i",
"]",
".",
"name",
")",
")",
"return",
"(",
"int",
")",
"i",
";",
"}",
"return",
"-",
"1",
";",
"}",
"</s>"
] | [
"Look",
"up",
"a",
"processor",
"name",
"for",
"-mcpu=xxx",
"and",
"-mtune=xxx",
".",
"Return",
"-1",
"if",
"the",
"name",
"is",
"invalid",
"."
] | [
"powerpcspe",
"0",
"1"
] | powerpcspe | rs6000_cpu_name_lookup | powerpcspe | CPU | GCC | 11,815 | 63 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUInstructionSelector",
"::",
"select",
"(",
"MachineInstr",
"&",
"I",
")",
"{",
"if",
"(",
"I",
".",
"isPHI",
"(",
")",
")",
"return",
"selectPHI",
"(",
"I",
")",
";",
"if",
"(",
"!",
"I",
".",
"isPreISelOpcode",
"(",
")",
")",
"{",
"if",
"(",
"I",
".",
"isCopy",
"(",
")",
")",
"return",
"selectCOPY",
"(",
"I",
")",
";",
"return",
"true",
";",
"}",
"switch",
"(",
"I",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"TargetOpcode",
"::",
"G_AND",
":",
"case",
"TargetOpcode",
"::",
"G_OR",
":",
"case",
"TargetOpcode",
"::",
"G_XOR",
":",
"if",
"(",
"selectG_AND_OR_XOR",
"(",
"I",
")",
")",
"return",
"true",
";",
"return",
"selectImpl",
"(",
"I",
",",
"*",
"CoverageInfo",
")",
";",
"case",
"TargetOpcode",
"::",
"G_ADD",
":",
"case",
"TargetOpcode",
"::",
"G_SUB",
":",
"if",
"(",
"selectImpl",
"(",
"I",
",",
"*",
"CoverageInfo",
")",
")",
"return",
"true",
";",
"return",
"selectG_ADD_SUB",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_UADDO",
":",
"case",
"TargetOpcode",
"::",
"G_USUBO",
":",
"return",
"selectG_UADDO_USUBO",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_INTTOPTR",
":",
"case",
"TargetOpcode",
"::",
"G_BITCAST",
":",
"case",
"TargetOpcode",
"::",
"G_PTRTOINT",
":",
"return",
"selectCOPY",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_CONSTANT",
":",
"case",
"TargetOpcode",
"::",
"G_FCONSTANT",
":",
"return",
"selectG_CONSTANT",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_EXTRACT",
":",
"return",
"selectG_EXTRACT",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_MERGE_VALUES",
":",
"case",
"TargetOpcode",
"::",
"G_BUILD_VECTOR",
":",
"case",
"TargetOpcode",
"::",
"G_CONCAT_VECTORS",
":",
"return",
"selectG_MERGE_VALUES",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_UNMERGE_VALUES",
":",
"return",
"selectG_UNMERGE_VALUES",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_PTR_ADD",
":",
"return",
"selectG_PTR_ADD",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_IMPLICIT_DEF",
":",
"return",
"selectG_IMPLICIT_DEF",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_INSERT",
":",
"return",
"selectG_INSERT",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_INTRINSIC",
":",
"return",
"selectG_INTRINSIC",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_INTRINSIC_W_SIDE_EFFECTS",
":",
"return",
"selectG_INTRINSIC_W_SIDE_EFFECTS",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_ICMP",
":",
"if",
"(",
"selectG_ICMP",
"(",
"I",
")",
")",
"return",
"true",
";",
"return",
"selectImpl",
"(",
"I",
",",
"*",
"CoverageInfo",
")",
";",
"case",
"TargetOpcode",
"::",
"G_LOAD",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMIC_CMPXCHG",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_XCHG",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_ADD",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_SUB",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_AND",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_OR",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_XOR",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_MIN",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_MAX",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_UMIN",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_UMAX",
":",
"case",
"TargetOpcode",
"::",
"G_ATOMICRMW_FADD",
":",
"return",
"selectG_LOAD_ATOMICRMW",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_SELECT",
":",
"return",
"selectG_SELECT",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_STORE",
":",
"return",
"selectG_STORE",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_TRUNC",
":",
"return",
"selectG_TRUNC",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_SEXT",
":",
"case",
"TargetOpcode",
"::",
"G_ZEXT",
":",
"case",
"TargetOpcode",
"::",
"G_ANYEXT",
":",
"return",
"selectG_SZA_EXT",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_BRCOND",
":",
"return",
"selectG_BRCOND",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_FRAME_INDEX",
":",
"return",
"selectG_FRAME_INDEX",
"(",
"I",
")",
";",
"case",
"TargetOpcode",
"::",
"G_FENCE",
":",
"I",
".",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"AMDGPU",
"::",
"ATOMIC_FENCE",
")",
")",
";",
"return",
"true",
";",
"case",
"TargetOpcode",
"::",
"G_PTR_MASK",
":",
"return",
"selectG_PTR_MASK",
"(",
"I",
")",
";",
"default",
":",
"return",
"selectImpl",
"(",
"I",
",",
"*",
"CoverageInfo",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Select",
"the",
"(",
"possibly",
"generic",
")",
"instruction",
"I",
"to",
"only",
"use",
"target-specific",
"opcodes",
"."
] | [
"AMDGPU",
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"AMDGPU::ATOMIC_FENCE"
] | AMDGPUInstructionSelector25 | select | AMDGPU | GPU | LLVM | 11,816 | 495 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"PatmosDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"NULL",
";",
"switch",
"(",
"Node",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"}",
"return",
"SelectCode",
"(",
"Node",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Patmos",
"Patmos"
] | PatmosISelDAGToDAG | Select | Patmos | VLIW | LLVM | 11,817 | 43 | 1 | [] |
[
"<s>",
"static",
"void",
"function_arg_record_value_3",
"(",
"HOST_WIDE_INT",
"bitpos",
",",
"struct",
"function_arg_record_value_parms",
"*",
"parms",
")",
"{",
"enum",
"machine_mode",
"mode",
";",
"unsigned",
"int",
"regno",
";",
"unsigned",
"int",
"startbit",
",",
"endbit",
";",
"int",
"this_slotno",
",",
"intslots",
",",
"intoffset",
";",
"rtx",
"reg",
";",
"if",
"(",
"parms",
"->",
"intoffset",
"==",
"-",
"1",
")",
"return",
";",
"intoffset",
"=",
"parms",
"->",
"intoffset",
";",
"parms",
"->",
"intoffset",
"=",
"-",
"1",
";",
"startbit",
"=",
"intoffset",
"&",
"-",
"BITS_PER_WORD",
";",
"endbit",
"=",
"(",
"bitpos",
"+",
"BITS_PER_WORD",
"-",
"1",
")",
"&",
"-",
"BITS_PER_WORD",
";",
"intslots",
"=",
"(",
"endbit",
"-",
"startbit",
")",
"/",
"BITS_PER_WORD",
";",
"this_slotno",
"=",
"parms",
"->",
"slotno",
"+",
"intoffset",
"/",
"BITS_PER_WORD",
";",
"intslots",
"=",
"MIN",
"(",
"intslots",
",",
"SPARC_INT_ARG_MAX",
"-",
"this_slotno",
")",
";",
"if",
"(",
"intslots",
"<=",
"0",
")",
"return",
";",
"if",
"(",
"intoffset",
"%",
"BITS_PER_WORD",
"!=",
"0",
")",
"mode",
"=",
"smallest_mode_for_size",
"(",
"BITS_PER_WORD",
"-",
"intoffset",
"%",
"BITS_PER_WORD",
",",
"MODE_INT",
")",
";",
"else",
"mode",
"=",
"word_mode",
";",
"intoffset",
"/=",
"BITS_PER_UNIT",
";",
"do",
"{",
"regno",
"=",
"parms",
"->",
"regbase",
"+",
"this_slotno",
";",
"reg",
"=",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"XVECEXP",
"(",
"parms",
"->",
"ret",
",",
"0",
",",
"parms",
"->",
"stack",
"+",
"parms",
"->",
"nregs",
")",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"reg",
",",
"GEN_INT",
"(",
"intoffset",
")",
")",
";",
"this_slotno",
"+=",
"1",
";",
"intoffset",
"=",
"(",
"intoffset",
"|",
"(",
"UNITS_PER_WORD",
"-",
"1",
")",
")",
"+",
"1",
";",
"mode",
"=",
"word_mode",
";",
"parms",
"->",
"nregs",
"+=",
"1",
";",
"intslots",
"-=",
"1",
";",
"}",
"while",
"(",
"intslots",
">",
"0",
")",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"function_arg_record_value",
".",
"Assign",
"the",
"bits",
"of",
"the",
"structure",
"between",
"parms-",
">",
"intoffset",
"and",
"bitpos",
"to",
"integer",
"registers",
"."
] | [
"sparc",
"1",
"1",
"1",
"0",
"0",
"0",
"1",
"1",
"1",
"1",
"1",
"0"
] | sparc3 | function_arg_record_value_3 | sparc | CPU | GCC | 11,818 | 239 | 1 | [] |
[
"<s>",
"bool",
"aarch64_float_const_rtx_p",
"(",
"rtx",
"x",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"x",
")",
";",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"return",
"false",
";",
"unsigned",
"HOST_WIDE_INT",
"ival",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_DOUBLE",
"&&",
"SCALAR_FLOAT_MODE_P",
"(",
"mode",
")",
"&&",
"aarch64_reinterpret_float_as_int",
"(",
"x",
",",
"&",
"ival",
")",
")",
"{",
"scalar_int_mode",
"imode",
"=",
"(",
"mode",
"==",
"HFmode",
"?",
"SImode",
":",
"int_mode_for_mode",
"(",
"mode",
")",
".",
"require",
"(",
")",
")",
";",
"int",
"num_instr",
"=",
"aarch64_internal_mov_immediate",
"(",
"NULL_RTX",
",",
"gen_int_mode",
"(",
"ival",
",",
"imode",
")",
",",
"false",
",",
"imode",
")",
";",
"return",
"num_instr",
"<",
"3",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"rtx",
"X",
"is",
"an",
"immediate",
"constant",
"that",
"can",
"be",
"moved",
"using",
"a",
"single",
"MOV",
"(",
"+MOVK",
")",
"followed",
"by",
"an",
"FMOV",
"."
] | [
"aarch64",
"3"
] | aarch64 | aarch64_float_const_rtx_p | aarch64 | CPU | GCC | 11,819 | 100 | 1 | [] |
[
"<s>",
"PPCSubtarget",
"::",
"PPCSubtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"bool",
"is64Bit",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
":",
"PPCGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"IsPPC64",
"(",
"is64Bit",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"OptLevel",
"(",
"OptLevel",
")",
"{",
"initializeEnvironment",
"(",
")",
";",
"resetSubtargetFeatures",
"(",
"CPU",
",",
"FS",
")",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"PPC"
] | PPCSubtarget33 | PPCSubtarget | PowerPC | CPU | LLVM | 11,820 | 70 | 1 | [] |
[
"<s>",
"static",
"bool",
"ia64_skip_rtx_p",
"(",
"const_rtx",
"x",
")",
"{",
"return",
"get_spec_unspec_code",
"(",
"x",
")",
"!=",
"-",
"1",
";",
"}",
"</s>"
] | [
"Implement",
"skip_rtx_p",
"hook",
"."
] | [
"ia64",
"1"
] | ia64 | ia64_skip_rtx_p | ia64 | CPU | GCC | 11,821 | 18 | 1 | [] |
[
"<s>",
"void",
"reset",
"(",
")",
"{",
"loc",
"=",
"RC",
"->",
"begin",
"(",
")",
";",
"}",
"</s>"
] | [
"Reset",
"an",
"existing",
"scalar",
"value",
"for",
"Def",
"and",
"a",
"given",
"Instance",
"."
] | [
"PTX"
] | PTXISelLowering1 | reset | PTX | GPU | LLVM | 11,822 | 14 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"AArch64TargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"AArch64ISD",
"::",
"BR_CC",
":",
"return",
"\"AArch64ISD::BR_CC\"",
";",
"case",
"AArch64ISD",
"::",
"Call",
":",
"return",
"\"AArch64ISD::Call\"",
";",
"case",
"AArch64ISD",
"::",
"FPMOV",
":",
"return",
"\"AArch64ISD::FPMOV\"",
";",
"case",
"AArch64ISD",
"::",
"GOTLoad",
":",
"return",
"\"AArch64ISD::GOTLoad\"",
";",
"case",
"AArch64ISD",
"::",
"BFI",
":",
"return",
"\"AArch64ISD::BFI\"",
";",
"case",
"AArch64ISD",
"::",
"EXTR",
":",
"return",
"\"AArch64ISD::EXTR\"",
";",
"case",
"AArch64ISD",
"::",
"Ret",
":",
"return",
"\"AArch64ISD::Ret\"",
";",
"case",
"AArch64ISD",
"::",
"SBFX",
":",
"return",
"\"AArch64ISD::SBFX\"",
";",
"case",
"AArch64ISD",
"::",
"SELECT_CC",
":",
"return",
"\"AArch64ISD::SELECT_CC\"",
";",
"case",
"AArch64ISD",
"::",
"SETCC",
":",
"return",
"\"AArch64ISD::SETCC\"",
";",
"case",
"AArch64ISD",
"::",
"TC_RETURN",
":",
"return",
"\"AArch64ISD::TC_RETURN\"",
";",
"case",
"AArch64ISD",
"::",
"THREAD_POINTER",
":",
"return",
"\"AArch64ISD::THREAD_POINTER\"",
";",
"case",
"AArch64ISD",
"::",
"TLSDESCCALL",
":",
"return",
"\"AArch64ISD::TLSDESCCALL\"",
";",
"case",
"AArch64ISD",
"::",
"WrapperLarge",
":",
"return",
"\"AArch64ISD::WrapperLarge\"",
";",
"case",
"AArch64ISD",
"::",
"WrapperSmall",
":",
"return",
"\"AArch64ISD::WrapperSmall\"",
";",
"default",
":",
"return",
"NULL",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"AArch64",
"AArch64",
"AArch64ISD::BR_CC",
"\"AArch64ISD::BR_CC\"",
"AArch64ISD::Call",
"\"AArch64ISD::Call\"",
"AArch64ISD::FPMOV",
"\"AArch64ISD::FPMOV\"",
"AArch64ISD::GOTLoad",
"\"AArch64ISD::GOTLoad\"",
"AArch64ISD::BFI",
"\"AArch64ISD::BFI\"",
"AArch64ISD::EXTR",
"\"AArch64ISD::EXTR\"",
"AArch64ISD::Ret",
"\"AArch64ISD::Ret\"",
"AArch64ISD::SBFX",
"\"AArch64ISD::SBFX\"",
"AArch64ISD::SELECT_CC",
"\"AArch64ISD::SELECT_CC\"",
"AArch64ISD::SETCC",
"\"AArch64ISD::SETCC\"",
"AArch64ISD::TC_RETURN",
"\"AArch64ISD::TC_RETURN\"",
"AArch64ISD::THREAD_POINTER",
"\"AArch64ISD::THREAD_POINTER\"",
"AArch64ISD::TLSDESCCALL",
"\"AArch64ISD::TLSDESCCALL\"",
"AArch64ISD::WrapperLarge",
"\"AArch64ISD::WrapperLarge\"",
"AArch64ISD::WrapperSmall",
"\"AArch64ISD::WrapperSmall\""
] | AArch64ISelLowering123 | getTargetNodeName | AArch64 | CPU | LLVM | 11,823 | 144 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"ARMBaseRegisterInfo",
"::",
"getCrossCopyRegClass",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"if",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"CCRRegClass",
")",
"return",
"&",
"ARM",
"::",
"rGPRRegClass",
";",
"return",
"RC",
";",
"}",
"</s>"
] | [
"getCrossCopyRegClass",
"-",
"Returns",
"a",
"legal",
"register",
"class",
"to",
"copy",
"a",
"register",
"in",
"the",
"specified",
"class",
"to",
"or",
"from",
"."
] | [
"ARM",
"ARM",
"ARM::CCRRegClass",
"ARM::rGPRRegClass"
] | ARMBaseRegisterInfo | getCrossCopyRegClass | ARM | CPU | LLVM | 11,824 | 33 | 1 | [] |
[
"<s>",
"void",
"ix86_d_target_versions",
"(",
"void",
")",
"{",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"d_add_builtin_version",
"(",
"\"X86_64\"",
")",
";",
"if",
"(",
"TARGET_X32",
")",
"d_add_builtin_version",
"(",
"\"D_X32\"",
")",
";",
"}",
"else",
"d_add_builtin_version",
"(",
"\"X86\"",
")",
";",
"if",
"(",
"TARGET_80387",
")",
"d_add_builtin_version",
"(",
"\"D_HardFloat\"",
")",
";",
"else",
"d_add_builtin_version",
"(",
"\"D_SoftFloat\"",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_D_CPU_VERSIONS",
"for",
"x86",
"targets",
"."
] | [
"i386",
"\"X86_64\"",
"\"D_X32\"",
"\"X86\"",
"\"D_HardFloat\"",
"\"D_SoftFloat\""
] | i386-d | ix86_d_target_versions | i386 | CPU | GCC | 11,825 | 48 | 1 | [] |
[
"<s>",
"int",
"X86TTIImpl",
"::",
"getIntImmCost",
"(",
"unsigned",
"Opcode",
",",
"unsigned",
"Idx",
",",
"const",
"APInt",
"&",
"Imm",
",",
"Type",
"*",
"Ty",
")",
"{",
"assert",
"(",
"Ty",
"->",
"isIntegerTy",
"(",
")",
")",
";",
"unsigned",
"BitSize",
"=",
"Ty",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"BitSize",
"==",
"0",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"unsigned",
"ImmIdx",
"=",
"~",
"0U",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"TTI",
"::",
"TCC_Free",
";",
"case",
"Instruction",
"::",
"GetElementPtr",
":",
"if",
"(",
"Idx",
"==",
"0",
")",
"return",
"2",
"*",
"TTI",
"::",
"TCC_Basic",
";",
"return",
"TTI",
"::",
"TCC_Free",
";",
"case",
"Instruction",
"::",
"Store",
":",
"ImmIdx",
"=",
"0",
";",
"break",
";",
"case",
"Instruction",
"::",
"Add",
":",
"case",
"Instruction",
"::",
"Sub",
":",
"case",
"Instruction",
"::",
"Mul",
":",
"case",
"Instruction",
"::",
"UDiv",
":",
"case",
"Instruction",
"::",
"SDiv",
":",
"case",
"Instruction",
"::",
"URem",
":",
"case",
"Instruction",
"::",
"SRem",
":",
"case",
"Instruction",
"::",
"And",
":",
"case",
"Instruction",
"::",
"Or",
":",
"case",
"Instruction",
"::",
"Xor",
":",
"case",
"Instruction",
"::",
"ICmp",
":",
"ImmIdx",
"=",
"1",
";",
"break",
";",
"case",
"Instruction",
"::",
"Shl",
":",
"case",
"Instruction",
"::",
"LShr",
":",
"case",
"Instruction",
"::",
"AShr",
":",
"if",
"(",
"Idx",
"==",
"1",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"break",
";",
"case",
"Instruction",
"::",
"Trunc",
":",
"case",
"Instruction",
"::",
"ZExt",
":",
"case",
"Instruction",
"::",
"SExt",
":",
"case",
"Instruction",
"::",
"IntToPtr",
":",
"case",
"Instruction",
"::",
"PtrToInt",
":",
"case",
"Instruction",
"::",
"BitCast",
":",
"case",
"Instruction",
"::",
"PHI",
":",
"case",
"Instruction",
"::",
"Call",
":",
"case",
"Instruction",
"::",
"Select",
":",
"case",
"Instruction",
"::",
"Ret",
":",
"case",
"Instruction",
"::",
"Load",
":",
"break",
";",
"}",
"if",
"(",
"Idx",
"==",
"ImmIdx",
")",
"{",
"int",
"NumConstants",
"=",
"(",
"BitSize",
"+",
"63",
")",
"/",
"64",
";",
"int",
"Cost",
"=",
"X86TTIImpl",
"::",
"getIntImmCost",
"(",
"Imm",
",",
"Ty",
")",
";",
"return",
"(",
"Cost",
"<=",
"NumConstants",
"*",
"TTI",
"::",
"TCC_Basic",
")",
"?",
"static_cast",
"<",
"int",
">",
"(",
"TTI",
"::",
"TCC_Free",
")",
":",
"Cost",
";",
"}",
"return",
"X86TTIImpl",
"::",
"getIntImmCost",
"(",
"Imm",
",",
"Ty",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"materializing",
"a",
"64-bit",
"value",
"."
] | [
"X86",
"X86",
"0",
"0U",
"0",
"2",
"0",
"1",
"1",
"63",
"64",
"X86",
"X86"
] | X86TargetTransformInfo96 | getIntImmCost | X86 | CPU | LLVM | 11,826 | 314 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"getSectionForConstant",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"SectionKind",
"Kind",
",",
"const",
"Constant",
"*",
"C",
",",
"Align",
"&",
"Alignment",
")",
"const",
"override",
"{",
"return",
"ReadOnlySection",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constant",
"with",
"the",
"SectionKind",
",",
"return",
"a",
"section",
"that",
"it",
"should",
"be",
"placed",
"in",
"."
] | [
"NVPTX"
] | NVPTXTargetObjectFile11 | getSectionForConstant | NVPTX | GPU | LLVM | 11,827 | 28 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_output_function_prologue",
"(",
"FILE",
"*",
"file",
",",
"HOST_WIDE_INT",
"size",
"ATTRIBUTE_UNUSED",
")",
"{",
"const",
"char",
"*",
"fnname",
";",
"if",
"(",
"TARGET_MIPS16",
"&&",
"TARGET_HARD_FLOAT_ABI",
"&&",
"crtl",
"->",
"args",
".",
"info",
".",
"fp_code",
"!=",
"0",
")",
"mips16_build_function_stub",
"(",
")",
";",
"fnname",
"=",
"XSTR",
"(",
"XEXP",
"(",
"DECL_RTL",
"(",
"current_function_decl",
")",
",",
"0",
")",
",",
"0",
")",
";",
"mips_start_function_definition",
"(",
"fnname",
",",
"TARGET_MIPS16",
")",
";",
"if",
"(",
"!",
"flag_inhibit_size_directive",
")",
"{",
"const",
"struct",
"mips_frame_info",
"*",
"frame",
";",
"frame",
"=",
"&",
"cfun",
"->",
"machine",
"->",
"frame",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.frame\\t%s,\"",
"HOST_WIDE_INT_PRINT_DEC",
"\",%s\\t\\t\"",
"\"# vars= \"",
"HOST_WIDE_INT_PRINT_DEC",
"\", regs= %d/%d\"",
"\", args= \"",
"HOST_WIDE_INT_PRINT_DEC",
"\", gp= \"",
"HOST_WIDE_INT_PRINT_DEC",
"\"\\n\"",
",",
"reg_names",
"[",
"frame_pointer_needed",
"?",
"HARD_FRAME_POINTER_REGNUM",
":",
"STACK_POINTER_REGNUM",
"]",
",",
"(",
"frame_pointer_needed",
"?",
"frame",
"->",
"total_size",
"-",
"frame",
"->",
"hard_frame_pointer_offset",
":",
"frame",
"->",
"total_size",
")",
",",
"reg_names",
"[",
"RETURN_ADDR_REGNUM",
"]",
",",
"frame",
"->",
"var_size",
",",
"frame",
"->",
"num_gp",
",",
"frame",
"->",
"num_fp",
",",
"frame",
"->",
"args_size",
",",
"frame",
"->",
"cprestore_size",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.mask\\t0x%08x,\"",
"HOST_WIDE_INT_PRINT_DEC",
"\"\\n\"",
",",
"frame",
"->",
"mask",
",",
"frame",
"->",
"gp_save_offset",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.fmask\\t0x%08x,\"",
"HOST_WIDE_INT_PRINT_DEC",
"\"\\n\"",
",",
"frame",
"->",
"fmask",
",",
"frame",
"->",
"fp_save_offset",
")",
";",
"}",
"if",
"(",
"mips_must_initialize_gp_p",
"(",
")",
"&&",
"mips_current_loadgp_style",
"(",
")",
"==",
"LOADGP_OLDABI",
")",
"{",
"if",
"(",
"TARGET_MIPS16",
")",
"{",
"output_asm_insn",
"(",
"\"li\\t$2,%%hi(_gp_disp)\"",
",",
"0",
")",
";",
"output_asm_insn",
"(",
"\"addiu\\t$3,$pc,%%lo(_gp_disp)\"",
",",
"0",
")",
";",
"output_asm_insn",
"(",
"\"sll\\t$2,16\"",
",",
"0",
")",
";",
"output_asm_insn",
"(",
"\"addu\\t$2,$3\"",
",",
"0",
")",
";",
"}",
"else",
"{",
"mips_push_asm_switch",
"(",
"&",
"mips_noreorder",
")",
";",
"output_asm_insn",
"(",
"\".cpload\\t%^\"",
",",
"0",
")",
";",
"if",
"(",
"!",
"cfun",
"->",
"machine",
"->",
"all_noreorder_p",
")",
"mips_pop_asm_switch",
"(",
"&",
"mips_noreorder",
")",
";",
"else",
"mips_push_asm_switch",
"(",
"&",
"mips_nomacro",
")",
";",
"}",
"}",
"else",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"all_noreorder_p",
")",
"{",
"mips_push_asm_switch",
"(",
"&",
"mips_noreorder",
")",
";",
"mips_push_asm_switch",
"(",
"&",
"mips_nomacro",
")",
";",
"}",
"mips_output_cplocal",
"(",
")",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"stack",
"and",
"frame",
"(",
"if",
"desired",
")",
"for",
"the",
"function",
"."
] | [
"mips",
"0",
"0",
"0",
"\"\\t.frame\\t%s,\"",
"\",%s\\t\\t\"",
"\"# vars= \"",
"\", regs= %d/%d\"",
"\", args= \"",
"\", gp= \"",
"\"\\n\"",
"\"\\t.mask\\t0x%08x,\"",
"\"\\n\"",
"\"\\t.fmask\\t0x%08x,\"",
"\"\\n\"",
"\"li\\t$2,%%hi(_gp_disp)\"",
"0",
"\"addiu\\t$3,$pc,%%lo(_gp_disp)\"",
"0",
"\"sll\\t$2,16\"",
"0",
"\"addu\\t$2,$3\"",
"0",
"\".cpload\\t%^\"",
"0"
] | mips4 | mips_output_function_prologue | mips | CPU | GCC | 11,828 | 299 | 1 | [] |
[
"<s>",
"static",
"void",
"aarch64_update_cpp_builtins",
"(",
"cpp_reader",
"*",
"pfile",
")",
"{",
"aarch64_def_or_undef",
"(",
"flag_unsafe_math_optimizations",
",",
"\"__ARM_FP_FAST\"",
",",
"pfile",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__ARM_ARCH\"",
",",
"aarch64_architecture_version",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__ARM_SIZEOF_MINIMAL_ENUM\"",
",",
"flag_short_enums",
"?",
"1",
":",
"4",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_BIG_END",
",",
"\"__AARCH64EB__\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_BIG_END",
",",
"\"__ARM_BIG_ENDIAN\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"!",
"TARGET_BIG_END",
",",
"\"__AARCH64EL__\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_FLOAT",
",",
"\"__ARM_FEATURE_FMA\"",
",",
"pfile",
")",
";",
"if",
"(",
"TARGET_FLOAT",
"||",
"TARGET_SIMD",
")",
"{",
"builtin_define_with_int_value",
"(",
"\"__ARM_FP\"",
",",
"0x0E",
")",
";",
"builtin_define",
"(",
"\"__ARM_FP16_FORMAT_IEEE\"",
")",
";",
"builtin_define",
"(",
"\"__ARM_FP16_ARGS\"",
")",
";",
"}",
"else",
"cpp_undef",
"(",
"pfile",
",",
"\"__ARM_FP\"",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_FP_F16INST",
",",
"\"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_SIMD_F16INST",
",",
"\"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_SIMD",
",",
"\"__ARM_FEATURE_NUMERIC_MAXMIN\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_SIMD",
",",
"\"__ARM_NEON\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_CRC32",
",",
"\"__ARM_FEATURE_CRC32\"",
",",
"pfile",
")",
";",
"cpp_undef",
"(",
"pfile",
",",
"\"__AARCH64_CMODEL_TINY__\"",
")",
";",
"cpp_undef",
"(",
"pfile",
",",
"\"__AARCH64_CMODEL_SMALL__\"",
")",
";",
"cpp_undef",
"(",
"pfile",
",",
"\"__AARCH64_CMODEL_LARGE__\"",
")",
";",
"switch",
"(",
"aarch64_cmodel",
")",
"{",
"case",
"AARCH64_CMODEL_TINY",
":",
"case",
"AARCH64_CMODEL_TINY_PIC",
":",
"builtin_define",
"(",
"\"__AARCH64_CMODEL_TINY__\"",
")",
";",
"break",
";",
"case",
"AARCH64_CMODEL_SMALL",
":",
"case",
"AARCH64_CMODEL_SMALL_PIC",
":",
"builtin_define",
"(",
"\"__AARCH64_CMODEL_SMALL__\"",
")",
";",
"break",
";",
"case",
"AARCH64_CMODEL_LARGE",
":",
"builtin_define",
"(",
"\"__AARCH64_CMODEL_LARGE__\"",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"aarch64_def_or_undef",
"(",
"TARGET_ILP32",
",",
"\"_ILP32\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_ILP32",
",",
"\"__ILP32__\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_CRYPTO",
",",
"\"__ARM_FEATURE_CRYPTO\"",
",",
"pfile",
")",
";",
"aarch64_def_or_undef",
"(",
"TARGET_SIMD_RDMA",
",",
"\"__ARM_FEATURE_QRDMX\"",
",",
"pfile",
")",
";",
"cpp_undef",
"(",
"pfile",
",",
"\"__FLT_EVAL_METHOD__\"",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__FLT_EVAL_METHOD__\"",
",",
"c_flt_eval_method",
"(",
"true",
")",
")",
";",
"cpp_undef",
"(",
"pfile",
",",
"\"__FLT_EVAL_METHOD_C99__\"",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__FLT_EVAL_METHOD_C99__\"",
",",
"c_flt_eval_method",
"(",
"false",
")",
")",
";",
"}",
"</s>"
] | [
"Undefine/redefine",
"macros",
"that",
"depend",
"on",
"the",
"current",
"backend",
"state",
"and",
"may",
"need",
"to",
"change",
"when",
"a",
"target",
"pragma",
"modifies",
"the",
"backend",
"state",
"."
] | [
"aarch64",
"\"__ARM_FP_FAST\"",
"\"__ARM_ARCH\"",
"\"__ARM_SIZEOF_MINIMAL_ENUM\"",
"1",
"4",
"\"__AARCH64EB__\"",
"\"__ARM_BIG_ENDIAN\"",
"\"__AARCH64EL__\"",
"\"__ARM_FEATURE_FMA\"",
"\"__ARM_FP\"",
"0x0E",
"\"__ARM_FP16_FORMAT_IEEE\"",
"\"__ARM_FP16_ARGS\"",
"\"__ARM_FP\"",
"\"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC\"",
"\"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC\"",
"\"__ARM_FEATURE_NUMERIC_MAXMIN\"",
"\"__ARM_NEON\"",
"\"__ARM_FEATURE_CRC32\"",
"\"__AARCH64_CMODEL_TINY__\"",
"\"__AARCH64_CMODEL_SMALL__\"",
"\"__AARCH64_CMODEL_LARGE__\"",
"\"__AARCH64_CMODEL_TINY__\"",
"\"__AARCH64_CMODEL_SMALL__\"",
"\"__AARCH64_CMODEL_LARGE__\"",
"\"_ILP32\"",
"\"__ILP32__\"",
"\"__ARM_FEATURE_CRYPTO\"",
"\"__ARM_FEATURE_QRDMX\"",
"\"__FLT_EVAL_METHOD__\"",
"\"__FLT_EVAL_METHOD__\"",
"\"__FLT_EVAL_METHOD_C99__\"",
"\"__FLT_EVAL_METHOD_C99__\""
] | aarch64-c3 | aarch64_update_cpp_builtins | aarch64 | CPU | GCC | 11,829 | 289 | 1 | [] |
[
"<s>",
"static",
"void",
"sh_emit_storehi",
"(",
"rtx",
"addr",
",",
"HOST_WIDE_INT",
"offset",
",",
"uint16_t",
"w0",
",",
"uint16_t",
"w1",
")",
"{",
"sh_emit_storesi",
"(",
"addr",
",",
"offset",
",",
"gen_int_mode",
"(",
"TARGET_LITTLE_ENDIAN",
"?",
"(",
"w0",
"|",
"(",
"w1",
"<<",
"16",
")",
")",
":",
"(",
"w1",
"|",
"(",
"w0",
"<<",
"16",
")",
")",
",",
"SImode",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"insns",
"to",
"store",
"w0",
"at",
"addr",
"+",
"offset",
"and",
"w1",
"at",
"addr",
"+",
"offset",
"+",
"2",
"."
] | [
"sh",
"16",
"16"
] | sh | sh_emit_storehi | sh | CPU | GCC | 11,830 | 52 | 1 | [] |
[
"<s>",
"void",
"PatmosSinglePathInfo",
"::",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"AU",
".",
"addRequired",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"Patmos",
"Patmos"
] | PatmosSinglePathInfo | getAnalysisUsage | Patmos | VLIW | LLVM | 11,831 | 43 | 1 | [] |
[
"<s>",
"unsigned",
"epiphany_adjust_field_align",
"(",
"tree",
"type",
",",
"unsigned",
"computed",
")",
"{",
"if",
"(",
"computed",
"==",
"32",
"&&",
"TREE_CODE",
"(",
"type",
")",
"==",
"ARRAY_TYPE",
")",
"{",
"tree",
"elmsz",
"=",
"TYPE_SIZE",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
";",
"if",
"(",
"!",
"tree_fits_uhwi_p",
"(",
"elmsz",
")",
"||",
"tree_to_uhwi",
"(",
"elmsz",
")",
">=",
"32",
")",
"return",
"64",
";",
"}",
"return",
"computed",
";",
"}",
"</s>"
] | [
"Upping",
"the",
"alignment",
"of",
"arrays",
"in",
"structs",
"is",
"not",
"only",
"a",
"performance",
"enhancement",
",",
"it",
"also",
"helps",
"preserve",
"assumptions",
"about",
"how",
"arrays-at-the-end-of-structs",
"work",
",",
"like",
"for",
"struct",
"gcov_fn_info",
"in",
"libgcov.c",
"."
] | [
"epiphany",
"32",
"32",
"64"
] | epiphany | epiphany_adjust_field_align | epiphany | MPU | GCC | 11,832 | 58 | 1 | [] |
[
"<s>",
"static",
"tree",
"parse_type",
"(",
"const",
"function_instance",
"&",
"instance",
",",
"const",
"char",
"*",
"&",
"format",
")",
"{",
"int",
"ch",
"=",
"*",
"format",
"++",
";",
"if",
"(",
"ch",
"==",
"'_'",
")",
"return",
"void_type_node",
";",
"if",
"(",
"ch",
"==",
"'a'",
")",
"{",
"ch",
"=",
"*",
"format",
"++",
";",
"if",
"(",
"ch",
"==",
"'l'",
")",
"return",
"build_const_pointer",
"(",
"instance",
".",
"memory_scalar_type",
"(",
")",
")",
";",
"if",
"(",
"ch",
"==",
"'p'",
")",
"return",
"const_ptr_type_node",
";",
"if",
"(",
"ch",
"==",
"'s'",
")",
"return",
"build_pointer_type",
"(",
"instance",
".",
"memory_scalar_type",
"(",
")",
")",
";",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"ch",
"==",
"'b'",
")",
"return",
"instance",
".",
"base_vector_type",
"(",
")",
";",
"if",
"(",
"ch",
"==",
"'d'",
")",
"return",
"instance",
".",
"displacement_vector_type",
"(",
")",
";",
"if",
"(",
"ch",
"==",
"'e'",
")",
"{",
"if",
"(",
"strncmp",
"(",
"format",
",",
"\"pattern\"",
",",
"7",
")",
"==",
"0",
")",
"{",
"format",
"+=",
"7",
";",
"return",
"acle_svpattern",
";",
"}",
"if",
"(",
"strncmp",
"(",
"format",
",",
"\"prfop\"",
",",
"5",
")",
"==",
"0",
")",
"{",
"format",
"+=",
"5",
";",
"return",
"acle_svprfop",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"ch",
"==",
"'s'",
")",
"{",
"type_suffix_index",
"suffix",
"=",
"parse_element_type",
"(",
"instance",
",",
"format",
")",
";",
"return",
"scalar_types",
"[",
"type_suffixes",
"[",
"suffix",
"]",
".",
"vector_type",
"]",
";",
"}",
"if",
"(",
"ch",
"==",
"'t'",
")",
"{",
"type_suffix_index",
"suffix",
"=",
"parse_element_type",
"(",
"instance",
",",
"format",
")",
";",
"vector_type_index",
"vector_type",
"=",
"type_suffixes",
"[",
"suffix",
"]",
".",
"vector_type",
";",
"unsigned",
"int",
"num_vectors",
"=",
"instance",
".",
"vectors_per_tuple",
"(",
")",
";",
"return",
"acle_vector_types",
"[",
"num_vectors",
"-",
"1",
"]",
"[",
"vector_type",
"]",
";",
"}",
"if",
"(",
"ch",
"==",
"'v'",
")",
"{",
"type_suffix_index",
"suffix",
"=",
"parse_element_type",
"(",
"instance",
",",
"format",
")",
";",
"return",
"acle_vector_types",
"[",
"0",
"]",
"[",
"type_suffixes",
"[",
"suffix",
"]",
".",
"vector_type",
"]",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Read",
"and",
"return",
"a",
"type",
"from",
"FORMAT",
"for",
"function",
"INSTANCE",
".",
"Advance",
"FORMAT",
"beyond",
"the",
"type",
"string",
".",
"The",
"format",
"is",
":",
"_",
"-",
"void",
"al",
"-",
"array",
"pointer",
"for",
"loads",
"ap",
"-",
"array",
"pointer",
"for",
"prefetches",
"as",
"-",
"array",
"pointer",
"for",
"stores",
"b",
"-",
"base",
"vector",
"type",
"(",
"from",
"a",
"_",
"<",
"m0",
">",
"base",
"suffix",
")",
"d",
"-",
"displacement",
"vector",
"type",
"(",
"from",
"a",
"_",
"<",
"m1",
">",
"index",
"or",
"_",
"<",
"m1",
">",
"offset",
"suffix",
")",
"e",
"<",
"name",
">",
"-",
"an",
"enum",
"with",
"the",
"given",
"name",
"s",
"<",
"elt",
">",
"-",
"a",
"scalar",
"type",
"with",
"the",
"given",
"element",
"suffix",
"t",
"<",
"elt",
">",
"-",
"a",
"vector",
"or",
"tuple",
"type",
"with",
"given",
"element",
"suffix",
"[",
"*",
"1",
"]",
"v",
"<",
"elt",
">",
"-",
"a",
"vector",
"with",
"the",
"given",
"element",
"suffix",
"where",
"<",
"elt",
">",
"has",
"the",
"format",
"described",
"above",
"parse_element_type",
"[",
"*",
"1",
"]",
"the",
"vectors_per_tuple",
"function",
"indicates",
"whether",
"the",
"type",
"should",
"be",
"a",
"tuple",
",",
"and",
"if",
"so",
",",
"how",
"many",
"vectors",
"it",
"should",
"contain",
"."
] | [
"aarch64",
"\"pattern\"",
"7",
"0",
"7",
"\"prfop\"",
"5",
"0",
"5",
"1",
"0"
] | aarch64-sve-builtins-shapes | parse_type | aarch64 | CPU | GCC | 11,833 | 288 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"AVR DAG->DAG Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AVR",
"\"AVR DAG->DAG Instruction Selection\""
] | AVRISelDAGToDAG | getPassName | AVR | MPU | LLVM | 11,834 | 11 | 1 | [] |
[
"<s>",
"static",
"rtx",
"neon_vdup_constant",
"(",
"rtx",
"vals",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"vals",
")",
";",
"machine_mode",
"inner_mode",
"=",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"int",
"n_elts",
"=",
"GET_MODE_NUNITS",
"(",
"mode",
")",
";",
"bool",
"all_same",
"=",
"true",
";",
"rtx",
"x",
";",
"int",
"i",
";",
"if",
"(",
"GET_CODE",
"(",
"vals",
")",
"!=",
"CONST_VECTOR",
"||",
"GET_MODE_SIZE",
"(",
"inner_mode",
")",
">",
"4",
")",
"return",
"NULL_RTX",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"n_elts",
";",
"++",
"i",
")",
"{",
"x",
"=",
"XVECEXP",
"(",
"vals",
",",
"0",
",",
"i",
")",
";",
"if",
"(",
"i",
">",
"0",
"&&",
"!",
"rtx_equal_p",
"(",
"x",
",",
"XVECEXP",
"(",
"vals",
",",
"0",
",",
"0",
")",
")",
")",
"all_same",
"=",
"false",
";",
"}",
"if",
"(",
"!",
"all_same",
")",
"return",
"NULL_RTX",
";",
"x",
"=",
"copy_to_mode_reg",
"(",
"inner_mode",
",",
"XVECEXP",
"(",
"vals",
",",
"0",
",",
"0",
")",
")",
";",
"return",
"gen_rtx_VEC_DUPLICATE",
"(",
"mode",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"non-NULL",
"RTX",
"iff",
"VALS",
"is",
"a",
"vector",
"constant",
"that",
"can",
"be",
"loaded",
"into",
"a",
"register",
"using",
"VDUP",
".",
"If",
"this",
"is",
"the",
"case",
",",
"and",
"GENERATE",
"is",
"set",
",",
"we",
"also",
"generate",
"instructions",
"to",
"do",
"this",
"and",
"return",
"an",
"RTX",
"to",
"assign",
"to",
"the",
"register",
"."
] | [
"arm",
"4",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] | arm4 | neon_vdup_constant | arm | CPU | GCC | 11,835 | 146 | 1 | [] |
[
"<s>",
"rtx",
"mmix_eh_return_handler_rtx",
"(",
"void",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"Pmode",
",",
"MMIX_INCOMING_RETURN_ADDRESS_REGNUM",
")",
";",
"}",
"</s>"
] | [
"EH_RETURN_HANDLER_RTX",
"."
] | [
"mmix"
] | mmix | mmix_eh_return_handler_rtx | mmix | CPU | GCC | 11,836 | 15 | 1 | [] |
[
"<s>",
"unsigned",
"char",
"M680x0Subtarget",
"::",
"classifyGlobalFunctionReference",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"const",
"Module",
"&",
"M",
")",
"const",
"{",
"if",
"(",
"TM",
".",
"shouldAssumeDSOLocal",
"(",
"M",
",",
"GV",
")",
")",
"return",
"M680x0II",
"::",
"MO_NO_FLAG",
";",
"auto",
"*",
"F",
"=",
"dyn_cast_or_null",
"<",
"Function",
">",
"(",
"GV",
")",
";",
"if",
"(",
"F",
"&&",
"F",
"->",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NonLazyBind",
")",
")",
"{",
"return",
"M680x0II",
"::",
"MO_GOTPCREL",
";",
"}",
"return",
"M680x0II",
"::",
"MO_PLT",
";",
"}",
"</s>"
] | [
"Classify",
"a",
"global",
"function",
"reference",
"for",
"the",
"current",
"subtarget",
"."
] | [
"M680x0",
"M680x0",
"M680x0II::MO_NO_FLAG",
"M680x0II::MO_GOTPCREL",
"M680x0II::MO_PLT"
] | M680x0Subtarget | classifyGlobalFunctionReference | M680x0 | MPU | LLVM | 11,837 | 72 | 1 | [] |
[
"<s>",
"void",
"Cpu0AsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"const",
"{",
"MCFixupKind",
"Kind",
"=",
"Fixup",
".",
"getKind",
"(",
")",
";",
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
",",
"Value",
")",
";",
"if",
"(",
"!",
"Value",
")",
"return",
";",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"unsigned",
"NumBytes",
"=",
"(",
"getFixupKindInfo",
"(",
"Kind",
")",
".",
"TargetSize",
"+",
"7",
")",
"/",
"8",
";",
"unsigned",
"FullSize",
";",
"switch",
"(",
"(",
"unsigned",
")",
"Kind",
")",
"{",
"default",
":",
"FullSize",
"=",
"4",
";",
"break",
";",
"}",
"uint64_t",
"CurVal",
"=",
"0",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"unsigned",
"Idx",
"=",
"Endian",
"==",
"support",
"::",
"little",
"?",
"i",
":",
"(",
"FullSize",
"-",
"1",
"-",
"i",
")",
";",
"CurVal",
"|=",
"(",
"uint64_t",
")",
"(",
"(",
"uint8_t",
")",
"Data",
"[",
"Offset",
"+",
"Idx",
"]",
")",
"<<",
"(",
"i",
"*",
"8",
")",
";",
"}",
"uint64_t",
"Mask",
"=",
"(",
"(",
"uint64_t",
")",
"(",
"-",
"1",
")",
">>",
"(",
"64",
"-",
"getFixupKindInfo",
"(",
"Kind",
")",
".",
"TargetSize",
")",
")",
";",
"CurVal",
"|=",
"Value",
"&",
"Mask",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"unsigned",
"Idx",
"=",
"Endian",
"==",
"support",
"::",
"little",
"?",
"i",
":",
"(",
"FullSize",
"-",
"1",
"-",
"i",
")",
";",
"Data",
"[",
"Offset",
"+",
"Idx",
"]",
"=",
"(",
"uint8_t",
")",
"(",
"(",
"CurVal",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"Cpu0",
"Cpu0",
"7",
"8",
"4",
"0",
"0",
"support::little",
"1",
"8",
"1",
"64",
"0",
"support::little",
"1",
"8",
"0xff"
] | Cpu0AsmBackend3 | applyFixup | Cpu0 | CPU | LLVM | 11,838 | 262 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips_pass_by_reference",
"(",
"cumulative_args_t",
"cum",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"bool",
"named",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"mips_abi",
"==",
"ABI_EABI",
")",
"{",
"int",
"size",
";",
"if",
"(",
"mode",
"==",
"DImode",
"||",
"mode",
"==",
"DFmode",
"||",
"mode",
"==",
"DQmode",
"||",
"mode",
"==",
"UDQmode",
"||",
"mode",
"==",
"DAmode",
"||",
"mode",
"==",
"UDAmode",
")",
"return",
"0",
";",
"size",
"=",
"type",
"?",
"int_size_in_bytes",
"(",
"type",
")",
":",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"return",
"size",
"==",
"-",
"1",
"||",
"size",
">",
"UNITS_PER_WORD",
";",
"}",
"else",
"{",
"return",
"targetm",
".",
"calls",
".",
"must_pass_in_stack",
"(",
"mode",
",",
"type",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"nonzero",
"when",
"an",
"argument",
"must",
"be",
"passed",
"by",
"reference",
"."
] | [
"mips",
"0",
"1"
] | mips4 | mips_pass_by_reference | mips | CPU | GCC | 11,839 | 99 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"isGPRZero",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"AArch64",
"::",
"MOVZWi",
":",
"case",
"AArch64",
"::",
"MOVZXi",
":",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"assert",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumOperands",
"(",
")",
"==",
"3",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
"&&",
"\"invalid MOVZi operands\"",
")",
";",
"return",
"true",
";",
"}",
"break",
";",
"case",
"AArch64",
"::",
"ANDWri",
":",
"return",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"AArch64",
"::",
"WZR",
";",
"case",
"AArch64",
"::",
"ANDXri",
":",
"return",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"AArch64",
"::",
"XZR",
";",
"case",
"TargetOpcode",
"::",
"COPY",
":",
"return",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"AArch64",
"::",
"WZR",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Does",
"this",
"instruction",
"set",
"its",
"full",
"destination",
"register",
"to",
"zero",
"?"
] | [
"AArch64",
"AArch64",
"AArch64::MOVZWi",
"AArch64::MOVZXi",
"1",
"1",
"0",
"3",
"2",
"0",
"\"invalid MOVZi operands\"",
"AArch64::ANDWri",
"1",
"AArch64::WZR",
"AArch64::ANDXri",
"1",
"AArch64::XZR",
"1",
"AArch64::WZR"
] | AArch64InstrInfo (2) | isGPRZero | AArch64 | CPU | LLVM | 11,840 | 166 | 1 | [] |
[
"<s>",
"bool",
"mep_use_post_modify_p",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"reg",
",",
"rtx",
"offset",
")",
"{",
"bool",
"result",
"=",
"mep_use_post_modify_p_1",
"(",
"insn",
",",
"reg",
",",
"offset",
")",
";",
"extract_insn",
"(",
"insn",
")",
";",
"return",
"result",
";",
"}",
"</s>"
] | [
"A",
"wrapper",
"around",
"mep_use_post_modify_p_1",
"that",
"preserves",
"recog_data",
"."
] | [
"mep"
] | mep | mep_use_post_modify_p | mep | CPU | GCC | 11,841 | 35 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyPassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"addPass",
"(",
"createWebAssemblyCFGStackify",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly"
] | WebAssemblyTargetMachine36 | addPreEmitPass | WebAssembly | Virtual ISA | LLVM | 11,842 | 15 | 1 | [] |
[
"<s>",
"bool",
"SIInsertSkips",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"GCNSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"&",
"TII",
"->",
"getRegisterInfo",
"(",
")",
";",
"MDT",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"SkipThreshold",
"=",
"SkipThresholdFlag",
";",
"MachineBasicBlock",
"*",
"EmptyMBBAtEnd",
"=",
"nullptr",
";",
"SmallVector",
"<",
"MachineInstr",
"*",
",",
"4",
">",
"KillInstrs",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"Next",
";",
"for",
"(",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"=",
"Next",
")",
"{",
"Next",
"=",
"std",
"::",
"next",
"(",
"I",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"I",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPU",
"::",
"SI_MASK_BRANCH",
":",
"MadeChange",
"|=",
"skipMaskBranch",
"(",
"MI",
",",
"MBB",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"S_BRANCH",
":",
"if",
"(",
"MBB",
".",
"isLayoutSuccessor",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
")",
")",
"{",
"assert",
"(",
"&",
"MI",
"==",
"&",
"MBB",
".",
"back",
"(",
")",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"MadeChange",
"=",
"true",
";",
"}",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_KILL_F32_COND_IMM_TERMINATOR",
":",
"case",
"AMDGPU",
"::",
"SI_KILL_I1_TERMINATOR",
":",
"{",
"MadeChange",
"=",
"true",
";",
"bool",
"CanKill",
"=",
"kill",
"(",
"MI",
")",
";",
"if",
"(",
"CanKill",
"&&",
"MF",
".",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"AMDGPU_PS",
"&&",
"dominatesAllReachable",
"(",
"MBB",
")",
")",
"{",
"KillInstrs",
".",
"push_back",
"(",
"&",
"MI",
")",
";",
"}",
"else",
"{",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"}",
"break",
";",
"}",
"case",
"AMDGPU",
"::",
"SI_RETURN_TO_EPILOG",
":",
"assert",
"(",
"!",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
"->",
"returnsVoid",
"(",
")",
")",
";",
"if",
"(",
"&",
"MBB",
"!=",
"&",
"MF",
".",
"back",
"(",
")",
"||",
"&",
"MI",
"!=",
"&",
"MBB",
".",
"back",
"(",
")",
")",
"{",
"if",
"(",
"!",
"EmptyMBBAtEnd",
")",
"{",
"EmptyMBBAtEnd",
"=",
"MF",
".",
"CreateMachineBasicBlock",
"(",
")",
";",
"MF",
".",
"insert",
"(",
"MF",
".",
"end",
"(",
")",
",",
"EmptyMBBAtEnd",
")",
";",
"}",
"MBB",
".",
"addSuccessor",
"(",
"EmptyMBBAtEnd",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"&",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_BRANCH",
")",
")",
".",
"addMBB",
"(",
"EmptyMBBAtEnd",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"MDT",
"->",
"getBase",
"(",
")",
".",
"insertEdge",
"(",
"&",
"MBB",
",",
"EmptyMBBAtEnd",
")",
";",
"}",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"}",
"for",
"(",
"MachineInstr",
"*",
"Kill",
":",
"KillInstrs",
")",
"{",
"skipIfDead",
"(",
"*",
"Kill",
"->",
"getParent",
"(",
")",
",",
"std",
"::",
"next",
"(",
"Kill",
"->",
"getIterator",
"(",
")",
")",
",",
"Kill",
"->",
"getDebugLoc",
"(",
")",
")",
";",
"Kill",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"KillInstrs",
".",
"clear",
"(",
")",
";",
"return",
"MadeChange",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AMDGPU",
"SI",
"4",
"AMDGPU::SI_MASK_BRANCH",
"AMDGPU::S_BRANCH",
"0",
"AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR",
"AMDGPU::SI_KILL_I1_TERMINATOR",
"AMDGPU",
"AMDGPU::SI_RETURN_TO_EPILOG",
"SI",
"AMDGPU::S_BRANCH"
] | SIInsertSkips1 | runOnMachineFunction | AMDGPU | GPU | LLVM | 11,843 | 464 | 1 | [] |
[
"<s>",
"bool",
"aarch64_simd_shift_imm_p",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
",",
"bool",
"left",
")",
"{",
"int",
"bit_width",
"=",
"GET_MODE_UNIT_SIZE",
"(",
"mode",
")",
"*",
"BITS_PER_UNIT",
";",
"if",
"(",
"left",
")",
"return",
"aarch64_const_vec_all_same_in_range_p",
"(",
"x",
",",
"0",
",",
"bit_width",
"-",
"1",
")",
";",
"else",
"return",
"aarch64_const_vec_all_same_in_range_p",
"(",
"x",
",",
"1",
",",
"bit_width",
")",
";",
"}",
"</s>"
] | [
"Check",
"of",
"immediate",
"shift",
"constants",
"are",
"within",
"range",
"."
] | [
"aarch64",
"0",
"1",
"1"
] | aarch642 | aarch64_simd_shift_imm_p | aarch64 | CPU | GCC | 11,844 | 51 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"X86FrameLowering",
"::",
"restoreWin32EHStackPointers",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"bool",
"RestoreSP",
")",
"const",
"{",
"assert",
"(",
"STI",
".",
"isTargetWindowsMSVC",
"(",
")",
"&&",
"\"funclets only supported in MSVC env\"",
")",
";",
"assert",
"(",
"STI",
".",
"isTargetWin32",
"(",
")",
"&&",
"\"EBP/ESI restoration only required on win32\"",
")",
";",
"assert",
"(",
"STI",
".",
"is32Bit",
"(",
")",
"&&",
"!",
"Uses64BitFramePtr",
"&&",
"\"restoring EBP/ESI on non-32-bit target\"",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"Register",
"FramePtr",
"=",
"TRI",
"->",
"getFrameRegister",
"(",
"MF",
")",
";",
"Register",
"BasePtr",
"=",
"TRI",
"->",
"getBaseRegister",
"(",
")",
";",
"WinEHFuncInfo",
"&",
"FuncInfo",
"=",
"*",
"MF",
".",
"getWinEHFuncInfo",
"(",
")",
";",
"X86MachineFunctionInfo",
"*",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"int",
"FI",
"=",
"FuncInfo",
".",
"EHRegNodeFrameIndex",
";",
"int",
"EHRegSize",
"=",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
";",
"if",
"(",
"RestoreSP",
")",
"{",
"addRegOffset",
"(",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"X86",
"::",
"MOV32rm",
")",
",",
"X86",
"::",
"ESP",
")",
",",
"X86",
"::",
"EBP",
",",
"true",
",",
"-",
"EHRegSize",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"Register",
"UsedReg",
";",
"int",
"EHRegOffset",
"=",
"getFrameIndexReference",
"(",
"MF",
",",
"FI",
",",
"UsedReg",
")",
".",
"getFixed",
"(",
")",
";",
"int",
"EndOffset",
"=",
"-",
"EHRegOffset",
"-",
"EHRegSize",
";",
"FuncInfo",
".",
"EHRegNodeEndOffset",
"=",
"EndOffset",
";",
"if",
"(",
"UsedReg",
"==",
"FramePtr",
")",
"{",
"unsigned",
"ADDri",
"=",
"getADDriOpcode",
"(",
"false",
",",
"EndOffset",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"ADDri",
")",
",",
"FramePtr",
")",
".",
"addReg",
"(",
"FramePtr",
")",
".",
"addImm",
"(",
"EndOffset",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"assert",
"(",
"EndOffset",
">=",
"0",
"&&",
"\"end of registration object above normal EBP position!\"",
")",
";",
"}",
"else",
"if",
"(",
"UsedReg",
"==",
"BasePtr",
")",
"{",
"addRegOffset",
"(",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"X86",
"::",
"LEA32r",
")",
",",
"BasePtr",
")",
",",
"FramePtr",
",",
"false",
",",
"EndOffset",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"assert",
"(",
"X86FI",
"->",
"getHasSEHFramePtrSave",
"(",
")",
")",
";",
"int",
"Offset",
"=",
"getFrameIndexReference",
"(",
"MF",
",",
"X86FI",
"->",
"getSEHFramePtrSaveIndex",
"(",
")",
",",
"UsedReg",
")",
".",
"getFixed",
"(",
")",
";",
"assert",
"(",
"UsedReg",
"==",
"BasePtr",
")",
";",
"addRegOffset",
"(",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"X86",
"::",
"MOV32rm",
")",
",",
"FramePtr",
")",
",",
"UsedReg",
",",
"true",
",",
"Offset",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"32-bit frames with WinEH must use FramePtr or BasePtr\"",
")",
";",
"}",
"return",
"MBBI",
";",
"}",
"</s>"
] | [
"Sets",
"up",
"EBP",
"and",
"optionally",
"ESI",
"based",
"on",
"the",
"incoming",
"EBP",
"value",
"."
] | [
"X86",
"X86",
"\"funclets only supported in MSVC env\"",
"\"EBP/ESI restoration only required on win32\"",
"\"restoring EBP/ESI on non-32-bit target\"",
"X86",
"X86",
"X86",
"X86::MOV32rm",
"X86::ESP",
"X86::EBP",
"3",
"0",
"\"end of registration object above normal EBP position!\"",
"X86::LEA32r",
"X86",
"X86",
"X86::MOV32rm",
"\"32-bit frames with WinEH must use FramePtr or BasePtr\""
] | X86FrameLowering (2)3 | restoreWin32EHStackPointers | X86 | CPU | LLVM | 11,845 | 423 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addFastRegAlloc",
"(",
"FunctionPass",
"*",
"RegAllocPass",
")",
"{",
"insertPass",
"(",
"&",
"TwoAddressInstructionPassID",
",",
"&",
"SILowerControlFlowID",
",",
"false",
")",
";",
"TargetPassConfig",
"::",
"addFastRegAlloc",
"(",
"RegAllocPass",
")",
";",
"}",
"</s>"
] | [
"addFastRegAlloc",
"-",
"Add",
"the",
"minimum",
"set",
"of",
"target-independent",
"passes",
"that",
"are",
"required",
"for",
"fast",
"register",
"allocation",
"."
] | [
"AMDGPU",
"SI"
] | AMDGPUTargetMachine84 | addFastRegAlloc | AMDGPU | GPU | LLVM | 11,846 | 29 | 1 | [] |
[
"<s>",
"SDValue",
"MipsTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"unsigned",
"opc",
"=",
"N",
"->",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"opc",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ADDE",
":",
"return",
"PerformADDECombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SUBE",
":",
"return",
"PerformSUBECombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SDIVREM",
":",
"case",
"ISD",
"::",
"UDIVREM",
":",
"return",
"PerformDivRemCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"PerformSELECTCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"AND",
":",
"return",
"PerformANDCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"OR",
":",
"return",
"PerformORCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"}",
"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",
"."
] | [
"Mips",
"Mips",
"ISD::ADDE",
"ISD::SUBE",
"ISD::SDIVREM",
"ISD::UDIVREM",
"ISD::SELECT",
"ISD::AND",
"ISD::OR"
] | MipsISelLowering (2)3 | PerformDAGCombine | Mips | CPU | LLVM | 11,847 | 155 | 1 | [] |
[
"<s>",
"static",
"rtx",
"ix86_expand_sse_cmp",
"(",
"rtx",
"dest",
",",
"enum",
"rtx_code",
"code",
",",
"rtx",
"cmp_op0",
",",
"rtx",
"cmp_op1",
",",
"rtx",
"op_true",
",",
"rtx",
"op_false",
")",
"{",
"enum",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"dest",
")",
";",
"rtx",
"x",
";",
"cmp_op0",
"=",
"force_reg",
"(",
"mode",
",",
"cmp_op0",
")",
";",
"if",
"(",
"!",
"nonimmediate_operand",
"(",
"cmp_op1",
",",
"mode",
")",
")",
"cmp_op1",
"=",
"force_reg",
"(",
"mode",
",",
"cmp_op1",
")",
";",
"if",
"(",
"optimize",
"||",
"reg_overlap_mentioned_p",
"(",
"dest",
",",
"op_true",
")",
"||",
"reg_overlap_mentioned_p",
"(",
"dest",
",",
"op_false",
")",
")",
"dest",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"x",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"mode",
",",
"cmp_op0",
",",
"cmp_op1",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"dest",
",",
"x",
")",
")",
";",
"return",
"dest",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"sse",
"vector",
"comparison",
".",
"Return",
"the",
"register",
"with",
"the",
"result",
"."
] | [
"i386"
] | i3863 | ix86_expand_sse_cmp | i386 | CPU | GCC | 11,848 | 118 | 1 | [] |
[
"<s>",
"unsigned",
"WebAssemblyInstrInfo",
"::",
"insertBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"TBB",
",",
"MachineBasicBlock",
"*",
"FBB",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"int",
"*",
"BytesAdded",
")",
"const",
"{",
"assert",
"(",
"!",
"BytesAdded",
"&&",
"\"code size not handled\"",
")",
";",
"if",
"(",
"Cond",
".",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"!",
"TBB",
")",
"return",
"0",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"WebAssembly",
"::",
"BR",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"return",
"1",
";",
"}",
"assert",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"2",
"&&",
"\"Expected a flag and a successor block\"",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"bool",
"IsBrOnExn",
"=",
"Cond",
"[",
"1",
"]",
".",
"isReg",
"(",
")",
"&&",
"MRI",
".",
"getRegClass",
"(",
"Cond",
"[",
"1",
"]",
".",
"getReg",
"(",
")",
")",
"==",
"&",
"WebAssembly",
"::",
"EXCEPT_REFRegClass",
";",
"if",
"(",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
"{",
"if",
"(",
"IsBrOnExn",
")",
"{",
"const",
"char",
"*",
"CPPExnSymbol",
"=",
"MF",
".",
"createExternalSymbolName",
"(",
"\"__cpp_exception\"",
")",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"WebAssembly",
"::",
"BR_ON_EXN",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
".",
"addExternalSymbol",
"(",
"CPPExnSymbol",
",",
"WebAssemblyII",
"::",
"MO_SYMBOL_EVENT",
")",
".",
"add",
"(",
"Cond",
"[",
"1",
"]",
")",
";",
"}",
"else",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"WebAssembly",
"::",
"BR_IF",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
".",
"add",
"(",
"Cond",
"[",
"1",
"]",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"!",
"IsBrOnExn",
"&&",
"\"br_on_exn does not have a reversed condition\"",
")",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"WebAssembly",
"::",
"BR_UNLESS",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
".",
"add",
"(",
"Cond",
"[",
"1",
"]",
")",
";",
"}",
"if",
"(",
"!",
"FBB",
")",
"return",
"1",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"WebAssembly",
"::",
"BR",
")",
")",
".",
"addMBB",
"(",
"FBB",
")",
";",
"return",
"2",
";",
"}",
"</s>"
] | [
"Insert",
"branch",
"code",
"into",
"the",
"end",
"of",
"the",
"specified",
"MachineBasicBlock",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"code size not handled\"",
"0",
"WebAssembly::BR",
"1",
"2",
"\"Expected a flag and a successor block\"",
"1",
"1",
"WebAssembly::EXCEPT_REFRegClass",
"0",
"\"__cpp_exception\"",
"WebAssembly::BR_ON_EXN",
"WebAssemblyII::MO_SYMBOL_EVENT",
"1",
"WebAssembly::BR_IF",
"1",
"\"br_on_exn does not have a reversed condition\"",
"WebAssembly::BR_UNLESS",
"1",
"1",
"WebAssembly::BR",
"2"
] | WebAssemblyInstrInfo17 | insertBranch | WebAssembly | Virtual ISA | LLVM | 11,849 | 316 | 1 | [] |
[
"<s>",
"void",
"write",
"(",
"unsigned",
"int",
"i",
")",
"{",
"std",
"::",
"stringstream",
"s",
";",
"s",
"<<",
"MF",
"->",
"getFunction",
"(",
")",
".",
"getName",
"(",
")",
".",
"str",
"(",
")",
"<<",
"\"-\"",
"<<",
"i",
"<<",
"\".dot\"",
";",
"std",
"::",
"error_code",
"err",
";",
"raw_fd_ostream",
"f",
"(",
"s",
".",
"str",
"(",
")",
".",
"c_str",
"(",
")",
",",
"err",
")",
";",
"WriteGraph",
"(",
"f",
",",
"*",
"this",
")",
";",
"f",
".",
"close",
"(",
")",
";",
"}",
"</s>"
] | [
"Write",
"the",
"profile",
"to",
"a",
"string",
"output",
"stream",
"OS",
"."
] | [
"Patmos",
"\"-\"",
"\".dot\""
] | PatmosFunctionSplitter1 | write | Patmos | VLIW | LLVM | 11,850 | 71 | 1 | [] |
[
"<s>",
"static",
"int",
"riscv_issue_rate",
"(",
"void",
")",
"{",
"return",
"tune_param",
"->",
"issue_rate",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"instructions",
"that",
"can",
"be",
"issued",
"per",
"cycle",
"."
] | [
"riscv"
] | riscv | riscv_issue_rate | riscv | CPU | GCC | 11,851 | 13 | 1 | [] |
[
"<s>",
"static",
"void",
"setup_incoming_varargs_64",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
")",
"{",
"rtx",
"save_area",
",",
"mem",
";",
"alias_set_type",
"set",
";",
"int",
"i",
",",
"max",
";",
"if",
"(",
"cfun",
"->",
"va_list_gpr_size",
")",
"ix86_varargs_gpr_size",
"=",
"X86_64_REGPARM_MAX",
"*",
"UNITS_PER_WORD",
";",
"else",
"ix86_varargs_gpr_size",
"=",
"0",
";",
"if",
"(",
"TARGET_SSE",
"&&",
"cfun",
"->",
"va_list_fpr_size",
")",
"ix86_varargs_fpr_size",
"=",
"X86_64_SSE_REGPARM_MAX",
"*",
"16",
";",
"else",
"ix86_varargs_fpr_size",
"=",
"0",
";",
"if",
"(",
"!",
"ix86_varargs_gpr_size",
"&&",
"!",
"ix86_varargs_fpr_size",
")",
"return",
";",
"save_area",
"=",
"frame_pointer_rtx",
";",
"set",
"=",
"get_varargs_alias_set",
"(",
")",
";",
"max",
"=",
"cum",
"->",
"regno",
"+",
"cfun",
"->",
"va_list_gpr_size",
"/",
"UNITS_PER_WORD",
";",
"if",
"(",
"max",
">",
"X86_64_REGPARM_MAX",
")",
"max",
"=",
"X86_64_REGPARM_MAX",
";",
"for",
"(",
"i",
"=",
"cum",
"->",
"regno",
";",
"i",
"<",
"max",
";",
"i",
"++",
")",
"{",
"mem",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"plus_constant",
"(",
"Pmode",
",",
"save_area",
",",
"i",
"*",
"UNITS_PER_WORD",
")",
")",
";",
"MEM_NOTRAP_P",
"(",
"mem",
")",
"=",
"1",
";",
"set_mem_alias_set",
"(",
"mem",
",",
"set",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"gen_rtx_REG",
"(",
"word_mode",
",",
"x86_64_int_parameter_registers",
"[",
"i",
"]",
")",
")",
";",
"}",
"if",
"(",
"ix86_varargs_fpr_size",
")",
"{",
"machine_mode",
"smode",
";",
"rtx_code_label",
"*",
"label",
";",
"rtx",
"test",
";",
"label",
"=",
"gen_label_rtx",
"(",
")",
";",
"test",
"=",
"gen_rtx_EQ",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"QImode",
",",
"AX_REG",
")",
",",
"const0_rtx",
")",
";",
"emit_jump_insn",
"(",
"gen_cbranchqi4",
"(",
"test",
",",
"XEXP",
"(",
"test",
",",
"0",
")",
",",
"XEXP",
"(",
"test",
",",
"1",
")",
",",
"label",
")",
")",
";",
"smode",
"=",
"V4SFmode",
";",
"if",
"(",
"crtl",
"->",
"stack_alignment_needed",
"<",
"GET_MODE_ALIGNMENT",
"(",
"smode",
")",
")",
"crtl",
"->",
"stack_alignment_needed",
"=",
"GET_MODE_ALIGNMENT",
"(",
"smode",
")",
";",
"max",
"=",
"cum",
"->",
"sse_regno",
"+",
"cfun",
"->",
"va_list_fpr_size",
"/",
"16",
";",
"if",
"(",
"max",
">",
"X86_64_SSE_REGPARM_MAX",
")",
"max",
"=",
"X86_64_SSE_REGPARM_MAX",
";",
"for",
"(",
"i",
"=",
"cum",
"->",
"sse_regno",
";",
"i",
"<",
"max",
";",
"++",
"i",
")",
"{",
"mem",
"=",
"plus_constant",
"(",
"Pmode",
",",
"save_area",
",",
"i",
"*",
"16",
"+",
"ix86_varargs_gpr_size",
")",
";",
"mem",
"=",
"gen_rtx_MEM",
"(",
"smode",
",",
"mem",
")",
";",
"MEM_NOTRAP_P",
"(",
"mem",
")",
"=",
"1",
";",
"set_mem_alias_set",
"(",
"mem",
",",
"set",
")",
";",
"set_mem_align",
"(",
"mem",
",",
"GET_MODE_ALIGNMENT",
"(",
"smode",
")",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"gen_rtx_REG",
"(",
"smode",
",",
"SSE_REGNO",
"(",
"i",
")",
")",
")",
";",
"}",
"emit_label",
"(",
"label",
")",
";",
"}",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_SETUP_INCOMING_VARARGS",
"."
] | [
"i386",
"0",
"16",
"0",
"1",
"0",
"1",
"16",
"16",
"1"
] | i3864 | setup_incoming_varargs_64 | i386 | CPU | GCC | 11,852 | 358 | 1 | [] |
[
"<s>",
"static",
"rtx",
"arm_expand_acle_builtin",
"(",
"int",
"fcode",
",",
"tree",
"exp",
",",
"rtx",
"target",
")",
"{",
"arm_builtin_datum",
"*",
"d",
"=",
"&",
"acle_builtin_data",
"[",
"fcode",
"-",
"ARM_BUILTIN_ACLE_PATTERN_START",
"]",
";",
"return",
"arm_expand_builtin_1",
"(",
"fcode",
",",
"exp",
",",
"target",
",",
"d",
")",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"ACLE",
"builtin",
",",
"i.e",
".",
"those",
"registered",
"only",
"if",
"their",
"respective",
"target",
"constraints",
"are",
"met",
".",
"This",
"check",
"happens",
"within",
"arm_expand_builtin_args",
"."
] | [
"arm"
] | arm-builtins4 | arm_expand_acle_builtin | arm | CPU | GCC | 11,853 | 39 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64TargetLowering",
"::",
"BuildSDIVPow2",
"(",
"SDNode",
"*",
"N",
",",
"const",
"APInt",
"&",
"Divisor",
",",
"SelectionDAG",
"&",
"DAG",
",",
"std",
"::",
"vector",
"<",
"SDNode",
"*",
">",
"*",
"Created",
")",
"const",
"{",
"AttributeList",
"Attr",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getFunction",
"(",
")",
".",
"getAttributes",
"(",
")",
";",
"if",
"(",
"isIntDivCheap",
"(",
"N",
"->",
"getValueType",
"(",
"0",
")",
",",
"Attr",
")",
")",
"return",
"SDValue",
"(",
"N",
",",
"0",
")",
";",
"EVT",
"VT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"if",
"(",
"(",
"VT",
"!=",
"MVT",
"::",
"i32",
"&&",
"VT",
"!=",
"MVT",
"::",
"i64",
")",
"||",
"!",
"(",
"Divisor",
".",
"isPowerOf2",
"(",
")",
"||",
"(",
"-",
"Divisor",
")",
".",
"isPowerOf2",
"(",
")",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"SDValue",
"N0",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"unsigned",
"Lg2",
"=",
"Divisor",
".",
"countTrailingZeros",
"(",
")",
";",
"SDValue",
"Zero",
"=",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"VT",
")",
";",
"SDValue",
"Pow2MinusOne",
"=",
"DAG",
".",
"getConstant",
"(",
"(",
"1ULL",
"<<",
"Lg2",
")",
"-",
"1",
",",
"DL",
",",
"VT",
")",
";",
"SDValue",
"CCVal",
";",
"SDValue",
"Cmp",
"=",
"getAArch64Cmp",
"(",
"N0",
",",
"Zero",
",",
"ISD",
"::",
"SETLT",
",",
"CCVal",
",",
"DAG",
",",
"DL",
")",
";",
"SDValue",
"Add",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"VT",
",",
"N0",
",",
"Pow2MinusOne",
")",
";",
"SDValue",
"CSel",
"=",
"DAG",
".",
"getNode",
"(",
"AArch64ISD",
"::",
"CSEL",
",",
"DL",
",",
"VT",
",",
"Add",
",",
"N0",
",",
"CCVal",
",",
"Cmp",
")",
";",
"if",
"(",
"Created",
")",
"{",
"Created",
"->",
"push_back",
"(",
"Cmp",
".",
"getNode",
"(",
")",
")",
";",
"Created",
"->",
"push_back",
"(",
"Add",
".",
"getNode",
"(",
")",
")",
";",
"Created",
"->",
"push_back",
"(",
"CSel",
".",
"getNode",
"(",
")",
")",
";",
"}",
"SDValue",
"SRA",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SRA",
",",
"DL",
",",
"VT",
",",
"CSel",
",",
"DAG",
".",
"getConstant",
"(",
"Lg2",
",",
"DL",
",",
"MVT",
"::",
"i64",
")",
")",
";",
"if",
"(",
"Divisor",
".",
"isNonNegative",
"(",
")",
")",
"return",
"SRA",
";",
"if",
"(",
"Created",
")",
"Created",
"->",
"push_back",
"(",
"SRA",
".",
"getNode",
"(",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SUB",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"VT",
")",
",",
"SRA",
")",
";",
"}",
"</s>"
] | [
"Targets",
"may",
"override",
"this",
"function",
"to",
"provide",
"custom",
"SDIV",
"lowering",
"for",
"power-of-2",
"denominators",
"."
] | [
"AArch64",
"AArch64",
"0",
"0",
"0",
"MVT::i32",
"MVT::i64",
"0",
"0",
"1ULL",
"1",
"AArch64",
"ISD::SETLT",
"ISD::ADD",
"AArch64ISD::CSEL",
"ISD::SRA",
"MVT::i64",
"ISD::SUB",
"0"
] | AArch64ISelLowering106 | BuildSDIVPow2 | AArch64 | CPU | LLVM | 11,854 | 368 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isVectorClearMaskLegal",
"(",
"const",
"SmallVectorImpl",
"<",
"int",
">",
"&",
"Mask",
",",
"EVT",
"VT",
")",
"const",
"{",
"unsigned",
"NumElts",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"if",
"(",
"NumElts",
"==",
"2",
")",
"return",
"true",
";",
"if",
"(",
"NumElts",
"==",
"4",
"&&",
"VT",
".",
"is128BitVector",
"(",
")",
")",
"{",
"return",
"(",
"isMOVLMask",
"(",
"Mask",
",",
"VT",
")",
"||",
"isCommutedMOVLMask",
"(",
"Mask",
",",
"VT",
",",
"true",
")",
"||",
"isSHUFPMask",
"(",
"Mask",
",",
"VT",
",",
"Subtarget",
"->",
"hasAVX",
"(",
")",
")",
"||",
"isSHUFPMask",
"(",
"Mask",
",",
"VT",
",",
"Subtarget",
"->",
"hasAVX",
"(",
")",
",",
"true",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Similar",
"to",
"isShuffleMaskLegal",
"."
] | [
"X86",
"X86",
"2",
"4"
] | X86ISelLowering117 | isVectorClearMaskLegal | X86 | CPU | LLVM | 11,855 | 101 | 1 | [] |
[
"<s>",
"SDValue",
"BPFTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"BR_CC",
":",
"return",
"LowerBR_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"unimplemented operand\"",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"BPF",
"BPF",
"ISD::BR_CC",
"ISD::GlobalAddress",
"ISD::SELECT_CC",
"\"unimplemented operand\""
] | BPFISelLowering (2) | LowerOperation | BPF | Virtual ISA | LLVM | 11,856 | 71 | 1 | [] |
[
"<s>",
"unsigned",
"SparcInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"LDri",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"LDXri",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"LDFri",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"LDDFri",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"LDQFri",
")",
"{",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"Sparc",
"Sparc",
"SP::LDri",
"SP::LDXri",
"SP::LDFri",
"SP::LDDFri",
"SP::LDQFri",
"1",
"2",
"2",
"0",
"1",
"0",
"0"
] | SparcInstrInfo1 | isLoadFromStackSlot | Sparc | CPU | LLVM | 11,857 | 138 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips_legitimate_constant_p",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"x",
")",
"{",
"return",
"mips_const_insns",
"(",
"x",
")",
">",
"0",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMATE_CONSTANT_P",
"."
] | [
"mips",
"0"
] | mips | mips_legitimate_constant_p | mips | CPU | GCC | 11,858 | 21 | 1 | [] |
[
"<s>",
"static",
"int",
"rs6000_issue_rate",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"reload_completed",
"&&",
"!",
"flag_sched_pressure",
")",
"return",
"1",
";",
"switch",
"(",
"rs6000_cpu_attr",
")",
"{",
"case",
"CPU_RS64A",
":",
"case",
"CPU_PPC601",
":",
"case",
"CPU_PPC7450",
":",
"return",
"3",
";",
"case",
"CPU_PPC440",
":",
"case",
"CPU_PPC603",
":",
"case",
"CPU_PPC750",
":",
"case",
"CPU_PPC7400",
":",
"case",
"CPU_PPC8540",
":",
"case",
"CPU_PPC8548",
":",
"case",
"CPU_CELL",
":",
"case",
"CPU_PPCE300C2",
":",
"case",
"CPU_PPCE300C3",
":",
"case",
"CPU_PPCE500MC",
":",
"case",
"CPU_PPCE500MC64",
":",
"case",
"CPU_PPCE5500",
":",
"case",
"CPU_PPCE6500",
":",
"case",
"CPU_TITAN",
":",
"return",
"2",
";",
"case",
"CPU_PPC476",
":",
"case",
"CPU_PPC604",
":",
"case",
"CPU_PPC604E",
":",
"case",
"CPU_PPC620",
":",
"case",
"CPU_PPC630",
":",
"return",
"4",
";",
"case",
"CPU_POWER4",
":",
"case",
"CPU_POWER5",
":",
"case",
"CPU_POWER6",
":",
"case",
"CPU_POWER7",
":",
"return",
"5",
";",
"case",
"CPU_POWER8",
":",
"return",
"7",
";",
"default",
":",
"return",
"1",
";",
"}",
"}",
"</s>"
] | [
"Return",
"how",
"many",
"instructions",
"the",
"machine",
"can",
"issue",
"per",
"cycle",
"."
] | [
"rs6000",
"1",
"3",
"2",
"4",
"5",
"7",
"1"
] | rs60004 | rs6000_issue_rate | rs6000 | CPU | GCC | 11,859 | 126 | 1 | [] |
[
"<s>",
"static",
"SDValue",
"WidenVector",
"(",
"SDValue",
"V64Reg",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"EVT",
"VT",
"=",
"V64Reg",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"NarrowSize",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"MVT",
"EltTy",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
".",
"getSimpleVT",
"(",
")",
";",
"MVT",
"WideTy",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"EltTy",
",",
"2",
"*",
"NarrowSize",
")",
";",
"SDLoc",
"DL",
"(",
"V64Reg",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"INSERT_SUBVECTOR",
",",
"DL",
",",
"WideTy",
",",
"DAG",
".",
"getUNDEF",
"(",
"WideTy",
")",
",",
"V64Reg",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"</s>"
] | [
"Widen",
"the",
"vector",
"up",
"to",
"the",
"next",
"power",
"of",
"two",
"using",
"INSERT_SUBVECTOR",
"."
] | [
"AArch64",
"MVT::getVectorVT",
"2",
"ISD::INSERT_SUBVECTOR",
"0",
"MVT::i32"
] | AArch64ISelLowering117 | WidenVector | AArch64 | CPU | LLVM | 11,860 | 98 | 1 | [] |
[
"<s>",
"bool",
"MipsAsmParser",
"::",
"processInstruction",
"(",
"MCInst",
"&",
"Inst",
",",
"SMLoc",
"IDLoc",
",",
"SmallVectorImpl",
"<",
"MCInst",
">",
"&",
"Instructions",
")",
"{",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"getInstDesc",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
";",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"if",
"(",
"MCID",
".",
"hasDelaySlot",
"(",
")",
"&&",
"Options",
".",
"isReorder",
"(",
")",
")",
"{",
"Instructions",
".",
"push_back",
"(",
"Inst",
")",
";",
"MCInst",
"NopInst",
";",
"NopInst",
".",
"setOpcode",
"(",
"Mips",
"::",
"SLL",
")",
";",
"NopInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"Mips",
"::",
"ZERO",
")",
")",
";",
"NopInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"Mips",
"::",
"ZERO",
")",
")",
";",
"NopInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateImm",
"(",
"0",
")",
")",
";",
"Instructions",
".",
"push_back",
"(",
"NopInst",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"MCID",
".",
"mayLoad",
"(",
")",
"||",
"MCID",
".",
"mayStore",
"(",
")",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"MCID",
".",
"getNumOperands",
"(",
")",
";",
"i",
"++",
")",
"{",
"const",
"MCOperandInfo",
"&",
"OpInfo",
"=",
"MCID",
".",
"OpInfo",
"[",
"i",
"]",
";",
"if",
"(",
"(",
"OpInfo",
".",
"OperandType",
"==",
"MCOI",
"::",
"OPERAND_MEMORY",
")",
"||",
"(",
"OpInfo",
".",
"OperandType",
"==",
"MCOI",
"::",
"OPERAND_UNKNOWN",
")",
")",
"{",
"MCOperand",
"&",
"Op",
"=",
"Inst",
".",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"Op",
".",
"isImm",
"(",
")",
")",
"{",
"int",
"MemOffset",
"=",
"Op",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"MemOffset",
"<",
"-",
"32768",
"||",
"MemOffset",
">",
"32767",
")",
"{",
"expandMemInst",
"(",
"Inst",
",",
"IDLoc",
",",
"Instructions",
",",
"MCID",
".",
"mayLoad",
"(",
")",
",",
"true",
")",
";",
"return",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"Op",
".",
"isExpr",
"(",
")",
")",
"{",
"const",
"MCExpr",
"*",
"Expr",
"=",
"Op",
".",
"getExpr",
"(",
")",
";",
"if",
"(",
"Expr",
"->",
"getKind",
"(",
")",
"==",
"MCExpr",
"::",
"SymbolRef",
")",
"{",
"const",
"MCSymbolRefExpr",
"*",
"SR",
"=",
"static_cast",
"<",
"const",
"MCSymbolRefExpr",
"*",
">",
"(",
"Expr",
")",
";",
"if",
"(",
"SR",
"->",
"getKind",
"(",
")",
"==",
"MCSymbolRefExpr",
"::",
"VK_None",
")",
"{",
"expandMemInst",
"(",
"Inst",
",",
"IDLoc",
",",
"Instructions",
",",
"MCID",
".",
"mayLoad",
"(",
")",
",",
"false",
")",
";",
"return",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"!",
"isEvaluated",
"(",
"Expr",
")",
")",
"{",
"expandMemInst",
"(",
"Inst",
",",
"IDLoc",
",",
"Instructions",
",",
"MCID",
".",
"mayLoad",
"(",
")",
",",
"false",
")",
";",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"}",
"if",
"(",
"needsExpansion",
"(",
"Inst",
")",
")",
"expandInstruction",
"(",
"Inst",
",",
"IDLoc",
",",
"Instructions",
")",
";",
"else",
"Instructions",
".",
"push_back",
"(",
"Inst",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Process",
"a",
"single",
"instruction",
"and",
"collect",
"debug",
"info",
"anchors",
"."
] | [
"Mips",
"Mips",
"Mips::SLL",
"Mips::ZERO",
"Mips::ZERO",
"0",
"0",
"32768",
"32767"
] | MipsAsmParser102 | processInstruction | Mips | CPU | LLVM | 11,861 | 405 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseRegisterInfo",
"::",
"canSimplifyCallFramePseudos",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"hasReservedCallFrame",
"(",
"MF",
")",
"||",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"canSimplifyCallFramePseudos",
"-",
"If",
"there",
"is",
"a",
"reserved",
"call",
"frame",
",",
"the",
"call",
"frame",
"pseudos",
"can",
"be",
"simplified",
"."
] | [
"ARM",
"ARM"
] | ARMBaseRegisterInfo12 | canSimplifyCallFramePseudos | ARM | CPU | LLVM | 11,862 | 28 | 1 | [] |
[
"<s>",
"void",
"ARMBaseInstrInfo",
"::",
"breakPartialRegDependency",
"(",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"assert",
"(",
"OpNum",
"<",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumDefs",
"(",
")",
"&&",
"\"OpNum is not a def\"",
")",
";",
"assert",
"(",
"TRI",
"&&",
"\"Need TRI instance\"",
")",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNum",
")",
";",
"Register",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"Register",
"::",
"isPhysicalRegister",
"(",
"Reg",
")",
"&&",
"\"Can't break virtual register dependencies.\"",
")",
";",
"unsigned",
"DReg",
"=",
"Reg",
";",
"if",
"(",
"ARM",
"::",
"SPRRegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"DReg",
"=",
"ARM",
"::",
"D0",
"+",
"(",
"Reg",
"-",
"ARM",
"::",
"S0",
")",
"/",
"2",
";",
"assert",
"(",
"TRI",
"->",
"isSuperRegister",
"(",
"Reg",
",",
"DReg",
")",
"&&",
"\"Register enums broken\"",
")",
";",
"}",
"assert",
"(",
"ARM",
"::",
"DPRRegClass",
".",
"contains",
"(",
"DReg",
")",
"&&",
"\"Can only break D-reg deps\"",
")",
";",
"assert",
"(",
"MI",
".",
"definesRegister",
"(",
"DReg",
",",
"TRI",
")",
"&&",
"\"MI doesn't clobber full D-reg\"",
")",
";",
"BuildMI",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"ARM",
"::",
"FCONSTD",
")",
",",
"DReg",
")",
".",
"addImm",
"(",
"96",
")",
".",
"add",
"(",
"predOps",
"(",
"ARMCC",
"::",
"AL",
")",
")",
";",
"MI",
".",
"addRegisterKilled",
"(",
"DReg",
",",
"TRI",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Insert",
"a",
"dependency-breaking",
"instruction",
"before",
"MI",
"to",
"eliminate",
"an",
"unwanted",
"dependency",
"on",
"OpNum",
"."
] | [
"ARM",
"ARM",
"\"OpNum is not a def\"",
"\"Need TRI instance\"",
"\"Can't break virtual register dependencies.\"",
"ARM::SPRRegClass",
"ARM::D0",
"ARM::S0",
"2",
"\"Register enums broken\"",
"ARM::DPRRegClass",
"\"Can only break D-reg deps\"",
"\"MI doesn't clobber full D-reg\"",
"ARM::FCONSTD",
"96",
"ARMCC::AL"
] | ARMBaseInstrInfo110 | breakPartialRegDependency | ARM | CPU | LLVM | 11,863 | 206 | 1 | [] |
[
"<s>",
"SDValue",
"BlackfinTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"Op",
".",
"getNode",
"(",
")",
"->",
"dump",
"(",
")",
";",
"llvm_unreachable",
"(",
"\"Should not custom lower this!\"",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"llvm_unreachable",
"(",
"\"TLS not implemented for Blackfin.\"",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"LowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"SDValue",
"(",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"SDValue",
"(",
")",
";",
"case",
"ISD",
"::",
"ADDE",
":",
"case",
"ISD",
"::",
"SUBE",
":",
"return",
"LowerADDE",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"Blackfin",
"\"Should not custom lower this!\"",
"ISD::GlobalAddress",
"ISD::GlobalTLSAddress",
"\"TLS not implemented for Blackfin.\"",
"ISD::JumpTable",
"ISD::FRAMEADDR",
"ISD::RETURNADDR",
"ISD::ADDE",
"ISD::SUBE"
] | BlackfinISelLowering2 | LowerOperation | Blackfin | DSP | LLVM | 11,864 | 115 | 1 | [] |
[
"<s>",
"StackOffset",
"HexagonFrameLowering",
"::",
"getFrameIndexReference",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
",",
"Register",
"&",
"FrameReg",
")",
"const",
"{",
"auto",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"auto",
"&",
"HRI",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"int",
"Offset",
"=",
"MFI",
".",
"getObjectOffset",
"(",
"FI",
")",
";",
"bool",
"HasAlloca",
"=",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
";",
"bool",
"HasExtraAlign",
"=",
"HRI",
".",
"needsStackRealignment",
"(",
"MF",
")",
";",
"bool",
"NoOpt",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"None",
";",
"auto",
"&",
"HMFI",
"=",
"*",
"MF",
".",
"getInfo",
"<",
"HexagonMachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"FrameSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"Register",
"SP",
"=",
"HRI",
".",
"getStackRegister",
"(",
")",
";",
"Register",
"FP",
"=",
"HRI",
".",
"getFrameRegister",
"(",
")",
";",
"Register",
"AP",
"=",
"HMFI",
".",
"getStackAlignBasePhysReg",
"(",
")",
";",
"if",
"(",
"AP",
"==",
"0",
")",
"AP",
"=",
"FP",
";",
"bool",
"UseFP",
"=",
"false",
",",
"UseAP",
"=",
"false",
";",
"if",
"(",
"NoOpt",
"&&",
"!",
"HasExtraAlign",
")",
"UseFP",
"=",
"true",
";",
"if",
"(",
"MFI",
".",
"isFixedObjectIndex",
"(",
"FI",
")",
"||",
"MFI",
".",
"isObjectPreAllocated",
"(",
"FI",
")",
")",
"{",
"UseFP",
"|=",
"(",
"HasAlloca",
"||",
"HasExtraAlign",
")",
";",
"}",
"else",
"{",
"if",
"(",
"HasAlloca",
")",
"{",
"if",
"(",
"HasExtraAlign",
")",
"UseAP",
"=",
"true",
";",
"else",
"UseFP",
"=",
"true",
";",
"}",
"}",
"bool",
"HasFP",
"=",
"hasFP",
"(",
"MF",
")",
";",
"assert",
"(",
"(",
"HasFP",
"||",
"!",
"UseFP",
")",
"&&",
"\"This function must have frame pointer\"",
")",
";",
"if",
"(",
"Offset",
">",
"0",
"&&",
"!",
"HasFP",
")",
"Offset",
"-=",
"8",
";",
"if",
"(",
"UseFP",
")",
"FrameReg",
"=",
"FP",
";",
"else",
"if",
"(",
"UseAP",
")",
"FrameReg",
"=",
"AP",
";",
"else",
"FrameReg",
"=",
"SP",
";",
"int",
"RealOffset",
"=",
"Offset",
";",
"if",
"(",
"!",
"UseFP",
"&&",
"!",
"UseAP",
")",
"RealOffset",
"=",
"FrameSize",
"+",
"Offset",
";",
"return",
"StackOffset",
"::",
"getFixed",
"(",
"RealOffset",
")",
";",
"}",
"</s>"
] | [
"getFrameIndexReference",
"-",
"This",
"method",
"should",
"return",
"the",
"base",
"register",
"and",
"offset",
"used",
"to",
"reference",
"a",
"frame",
"index",
"location",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"0",
"\"This function must have frame pointer\"",
"0",
"8"
] | HexagonFrameLowering3 | getFrameIndexReference | Hexagon | DSP | LLVM | 11,865 | 304 | 1 | [] |
[
"<s>",
"bool",
"aarch64_is_extend_from_extract",
"(",
"scalar_int_mode",
"mode",
",",
"rtx",
"mult_imm",
",",
"rtx",
"extract_imm",
")",
"{",
"HOST_WIDE_INT",
"mult_val",
",",
"extract_val",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"mult_imm",
")",
"||",
"!",
"CONST_INT_P",
"(",
"extract_imm",
")",
")",
"return",
"false",
";",
"mult_val",
"=",
"INTVAL",
"(",
"mult_imm",
")",
";",
"extract_val",
"=",
"INTVAL",
"(",
"extract_imm",
")",
";",
"if",
"(",
"extract_val",
">",
"8",
"&&",
"extract_val",
"<",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"&&",
"exact_log2",
"(",
"extract_val",
"&",
"~",
"7",
")",
">",
"0",
"&&",
"(",
"extract_val",
"&",
"7",
")",
"<=",
"4",
"&&",
"mult_val",
"==",
"(",
"1",
"<<",
"(",
"extract_val",
"&",
"7",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"offsets",
"to",
"a",
"zero/sign-extract",
"operation",
"represent",
"an",
"expression",
"that",
"matches",
"an",
"extend",
"operation",
".",
"The",
"operands",
"represent",
"the",
"paramters",
"from",
"(",
"extract",
":",
"MODE",
"(",
"mult",
"(",
"reg",
")",
"(",
"MULT_IMM",
")",
")",
"(",
"EXTRACT_IMM",
")",
"(",
"const_int",
"0",
")",
")",
"."
] | [
"aarch64",
"8",
"7",
"0",
"7",
"4",
"1",
"7"
] | aarch64 | aarch64_is_extend_from_extract | aarch64 | CPU | GCC | 11,866 | 99 | 1 | [] |
[
"<s>",
"bool",
"SparcTargetMachine",
"::",
"addPreEmitPass",
"(",
"PassManagerBase",
"&",
"PM",
",",
"bool",
"Fast",
")",
"{",
"PM",
".",
"add",
"(",
"createSparcFPMoverPass",
"(",
"*",
"this",
")",
")",
";",
"PM",
".",
"add",
"(",
"createSparcDelaySlotFillerPass",
"(",
"*",
"this",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"Sparc"
] | SparcTargetMachine37 | addPreEmitPass | Sparc | CPU | LLVM | 11,867 | 39 | 1 | [] |
[
"<s>",
"void",
"emitFill",
"(",
"const",
"MCExpr",
"&",
"NumBytes",
",",
"uint64_t",
"FillValue",
",",
"SMLoc",
"Loc",
")",
"override",
"{",
"emitDataMappingSymbol",
"(",
")",
";",
"MCObjectStreamer",
"::",
"emitFill",
"(",
"NumBytes",
",",
"FillValue",
",",
"Loc",
")",
";",
"}",
"</s>"
] | [
"Emit",
"Size",
"bytes",
"worth",
"of",
"the",
"value",
"specified",
"by",
"FillValue",
"."
] | [
"ARM"
] | ARMELFStreamer22 | emitFill | ARM | CPU | LLVM | 11,868 | 32 | 1 | [] |
[
"<s>",
"void",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"override",
"{",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"AMDGPU"
] | R600FrameLowering | emitEpilogue | AMDGPU | GPU | LLVM | 11,869 | 15 | 1 | [] |
[
"<s>",
"bool",
"csky_split_xor",
"(",
"rtx",
"*",
"operands",
")",
"{",
"HOST_WIDE_INT",
"mask",
"=",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
";",
"if",
"(",
"mask",
"==",
"0",
")",
"{",
"emit_move_insn",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"1",
"]",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"mask",
"==",
"-",
"1",
")",
"{",
"if",
"(",
"CSKY_ISA_FEATURE",
"(",
"E2",
")",
")",
"emit_insn",
"(",
"gen_cskyv2_one_cmplsi2",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"1",
"]",
")",
")",
";",
"else",
"{",
"emit_move_insn",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"1",
"]",
")",
";",
"emit_insn",
"(",
"gen_ck801_one_cmplsi2",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"0",
"]",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"if",
"(",
"CSKY_ISA_FEATURE",
"(",
"E2",
")",
"&&",
"csky_arith_O_operand",
"(",
"operands",
"[",
"2",
"]",
",",
"SImode",
")",
")",
"return",
"false",
";",
"if",
"(",
"reload_completed",
")",
"{",
"emit_move_insn",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"2",
"]",
")",
";",
"operands",
"[",
"2",
"]",
"=",
"operands",
"[",
"1",
"]",
";",
"operands",
"[",
"1",
"]",
"=",
"operands",
"[",
"0",
"]",
";",
"}",
"else",
"operands",
"[",
"2",
"]",
"=",
"copy_to_mode_reg",
"(",
"SImode",
",",
"operands",
"[",
"2",
"]",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Split",
"operands",
"for",
"an",
"XOR",
"expression",
"when",
"OPERANDS",
"[",
"2",
"]",
"is",
"a",
"constant",
".",
"Note",
"operands",
"[",
"0",
"]",
"is",
"marked",
"earlyclobber",
"in",
"this",
"case",
"and",
"can",
"be",
"overwritten",
".",
"Return",
"true",
"if",
"``",
"DONE",
"''",
",",
"false",
"otherwise",
"."
] | [
"csky",
"2",
"0",
"0",
"1",
"1",
"0",
"1",
"0",
"1",
"0",
"0",
"2",
"0",
"2",
"2",
"1",
"1",
"0",
"2",
"2"
] | csky | csky_split_xor | csky | CPU | GCC | 11,870 | 189 | 1 | [] |
[
"<s>",
"unsigned",
"getMaxSupportedInterleaveFactor",
"(",
")",
"const",
"override",
"{",
"return",
"6",
";",
"}",
"</s>"
] | [
"Get",
"the",
"maximum",
"supported",
"factor",
"for",
"interleaved",
"memory",
"accesses",
"."
] | [
"AArch64",
"6"
] | AArch64ISelLowering71 | getMaxSupportedInterleaveFactor | AArch64 | CPU | LLVM | 11,871 | 11 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"c6x_function_arg_boundary",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
")",
"{",
"unsigned",
"int",
"boundary",
"=",
"type",
"?",
"TYPE_ALIGN",
"(",
"type",
")",
":",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
";",
"if",
"(",
"boundary",
">",
"BITS_PER_WORD",
")",
"return",
"2",
"*",
"BITS_PER_WORD",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"if",
"(",
"size",
">",
"4",
")",
"return",
"2",
"*",
"BITS_PER_WORD",
";",
"if",
"(",
"boundary",
"<",
"BITS_PER_WORD",
")",
"{",
"if",
"(",
"size",
">=",
"3",
")",
"return",
"BITS_PER_WORD",
";",
"if",
"(",
"size",
">=",
"2",
")",
"return",
"2",
"*",
"BITS_PER_UNIT",
";",
"}",
"}",
"return",
"boundary",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG_BOUNDARY",
"."
] | [
"c6x",
"2",
"4",
"2",
"3",
"2",
"2"
] | c6x | c6x_function_arg_boundary | c6x | VLIW | GCC | 11,872 | 98 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_default_short_enums",
"(",
"void",
")",
"{",
"return",
"ARM_DEFAULT_SHORT_ENUMS",
";",
"}",
"</s>"
] | [
"AAPCS",
"based",
"ABIs",
"use",
"short",
"enums",
"by",
"default",
"."
] | [
"arm"
] | arm | arm_default_short_enums | arm | CPU | GCC | 11,873 | 11 | 1 | [] |
[
"<s>",
"void",
"applyFixup",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"char",
"*",
"Data",
",",
"unsigned",
"DataSize",
",",
"uint64_t",
"Value",
")",
"const",
"{",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"MCFixupKind",
"Kind",
"=",
"Fixup",
".",
"getKind",
"(",
")",
";",
"unsigned",
"NumBytes",
"=",
"(",
"getFixupKindInfo",
"(",
"Kind",
")",
".",
"TargetSize",
"+",
"7",
")",
"/",
"8",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"Data",
"[",
"Offset",
"+",
"i",
"]",
"=",
"(",
"uint8_t",
")",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"TOY",
"7",
"8",
"0",
"8",
"0xff"
] | TOYAsmBackend | applyFixup | TOY | CPU | LLVM | 11,874 | 95 | 1 | [] |
[
"<s>",
"void",
"AArch64PassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"addPass",
"(",
"createAtomicExpandPass",
"(",
")",
")",
";",
"if",
"(",
"EnableSVEIntrinsicOpts",
"&&",
"TM",
"->",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"Aggressive",
")",
"addPass",
"(",
"createSVEIntrinsicOptsPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableAtomicTidy",
")",
"addPass",
"(",
"createCFGSimplificationPass",
"(",
"SimplifyCFGOptions",
"(",
")",
".",
"forwardSwitchCondToPhi",
"(",
"true",
")",
".",
"convertSwitchRangeToICmp",
"(",
"true",
")",
".",
"convertSwitchToLookupTable",
"(",
"true",
")",
".",
"needCanonicalLoops",
"(",
"false",
")",
".",
"hoistCommonInsts",
"(",
"true",
")",
".",
"sinkCommonInsts",
"(",
"true",
")",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"if",
"(",
"EnableLoopDataPrefetch",
")",
"addPass",
"(",
"createLoopDataPrefetchPass",
"(",
")",
")",
";",
"if",
"(",
"EnableFalkorHWPFFix",
")",
"addPass",
"(",
"createFalkorMarkStridedAccessesPass",
"(",
")",
")",
";",
"}",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"addPass",
"(",
"createAArch64StackTaggingPass",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"None",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"createInterleavedLoadCombinePass",
"(",
")",
")",
";",
"addPass",
"(",
"createInterleavedAccessPass",
"(",
")",
")",
";",
"}",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"Aggressive",
"&&",
"EnableGEPOpt",
")",
"{",
"addPass",
"(",
"createSeparateConstOffsetFromGEPPass",
"(",
"true",
")",
")",
";",
"addPass",
"(",
"createEarlyCSEPass",
"(",
")",
")",
";",
"addPass",
"(",
"createLICMPass",
"(",
")",
")",
";",
"}",
"if",
"(",
"TM",
"->",
"getTargetTriple",
"(",
")",
".",
"isOSWindows",
"(",
")",
")",
"addPass",
"(",
"createCFGuardCheckPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine69 | addIRPasses | AArch64 | CPU | LLVM | 11,875 | 233 | 1 | [] |
[
"<s>",
"void",
"VideoCore4InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"VideoCore4",
"::",
"MEM32_LD_LI",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"VideoCore4",
"VideoCore4",
"VideoCore4::MEM32_LD_LI",
"0"
] | VideoCore4InstrInfo | loadRegFromStackSlot | VideoCore4 | DSP | LLVM | 11,876 | 143 | 1 | [] |
[
"<s>",
"SDValue",
"ARMTargetLowering",
"::",
"PerformCMOVCombine",
"(",
"SDNode",
"*",
"N",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"Cmp",
"=",
"N",
"->",
"getOperand",
"(",
"4",
")",
";",
"if",
"(",
"Cmp",
".",
"getOpcode",
"(",
")",
"!=",
"ARMISD",
"::",
"CMPZ",
")",
"return",
"SDValue",
"(",
")",
";",
"EVT",
"VT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"DebugLoc",
"dl",
"=",
"N",
"->",
"getDebugLoc",
"(",
")",
";",
"SDValue",
"LHS",
"=",
"Cmp",
".",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"RHS",
"=",
"Cmp",
".",
"getOperand",
"(",
"1",
")",
";",
"SDValue",
"FalseVal",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"TrueVal",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"SDValue",
"ARMcc",
"=",
"N",
"->",
"getOperand",
"(",
"2",
")",
";",
"ARMCC",
"::",
"CondCodes",
"CC",
"=",
"(",
"ARMCC",
"::",
"CondCodes",
")",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"ARMcc",
")",
"->",
"getZExtValue",
"(",
")",
";",
"SDValue",
"Res",
";",
"if",
"(",
"CC",
"==",
"ARMCC",
"::",
"NE",
"&&",
"FalseVal",
"==",
"RHS",
"&&",
"FalseVal",
"!=",
"LHS",
")",
"{",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ARMISD",
"::",
"CMOV",
",",
"dl",
",",
"VT",
",",
"LHS",
",",
"TrueVal",
",",
"ARMcc",
",",
"N",
"->",
"getOperand",
"(",
"3",
")",
",",
"Cmp",
")",
";",
"}",
"else",
"if",
"(",
"CC",
"==",
"ARMCC",
"::",
"EQ",
"&&",
"TrueVal",
"==",
"RHS",
")",
"{",
"SDValue",
"ARMcc",
";",
"SDValue",
"NewCmp",
"=",
"getARMCmp",
"(",
"LHS",
",",
"RHS",
",",
"ISD",
"::",
"SETNE",
",",
"ARMcc",
",",
"DAG",
",",
"dl",
")",
";",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ARMISD",
"::",
"CMOV",
",",
"dl",
",",
"VT",
",",
"LHS",
",",
"FalseVal",
",",
"ARMcc",
",",
"N",
"->",
"getOperand",
"(",
"3",
")",
",",
"NewCmp",
")",
";",
"}",
"if",
"(",
"Res",
".",
"getNode",
"(",
")",
")",
"{",
"APInt",
"KnownZero",
",",
"KnownOne",
";",
"DAG",
".",
"ComputeMaskedBits",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"KnownZero",
",",
"KnownOne",
")",
";",
"if",
"(",
"KnownZero",
"==",
"0xfffffffe",
")",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"Res",
",",
"DAG",
".",
"getValueType",
"(",
"MVT",
"::",
"i1",
")",
")",
";",
"else",
"if",
"(",
"KnownZero",
"==",
"0xffffff00",
")",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"Res",
",",
"DAG",
".",
"getValueType",
"(",
"MVT",
"::",
"i8",
")",
")",
";",
"else",
"if",
"(",
"KnownZero",
"==",
"0xffff0000",
")",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"Res",
",",
"DAG",
".",
"getValueType",
"(",
"MVT",
"::",
"i16",
")",
")",
";",
"}",
"return",
"Res",
";",
"}",
"</s>"
] | [
"PerformCMOVCombine",
"-",
"Target-specific",
"DAG",
"combining",
"for",
"ARMISD",
":",
":CMOV",
"."
] | [
"ARM",
"ARM",
"4",
"ARMISD::CMPZ",
"0",
"0",
"1",
"0",
"1",
"ARM",
"2",
"ARMCC::CondCodes",
"ARMCC::CondCodes",
"ARM",
"ARMCC::NE",
"ARMISD::CMOV",
"ARM",
"3",
"ARMCC::EQ",
"ARM",
"ARM",
"ISD::SETNE",
"ARM",
"ARMISD::CMOV",
"ARM",
"3",
"0",
"0xfffffffe",
"ISD::AssertZext",
"MVT::i32",
"MVT::i1",
"0xffffff00",
"ISD::AssertZext",
"MVT::i32",
"MVT::i8",
"0xffff0000",
"ISD::AssertZext",
"MVT::i32",
"MVT::i16"
] | ARMISelLowering107 | PerformCMOVCombine | ARM | CPU | LLVM | 11,877 | 391 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"isLdStPairSuppressed",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"static_assert",
"(",
"MOSuppressPair",
"<",
"(",
"1",
"<<",
"MachineMemOperand",
"::",
"MOTargetNumBits",
")",
",",
"\"Too many target MO flags\"",
")",
";",
"for",
"(",
"auto",
"*",
"MM",
":",
"MI",
"->",
"memoperands",
"(",
")",
")",
"{",
"if",
"(",
"MM",
"->",
"getFlags",
"(",
")",
"&",
"(",
"MOSuppressPair",
"<<",
"MachineMemOperand",
"::",
"MOTargetStartBit",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"pairing",
"the",
"given",
"load",
"or",
"store",
"is",
"hinted",
"to",
"be",
"unprofitable",
"."
] | [
"AArch64",
"AArch64",
"1",
"\"Too many target MO flags\""
] | AArch64InstrInfo110 | isLdStPairSuppressed | AArch64 | CPU | LLVM | 11,878 | 66 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_option_override",
"(",
"void",
")",
"{",
"ix86_option_override_internal",
"(",
"true",
",",
"&",
"global_options",
",",
"&",
"global_options_set",
")",
";",
"}",
"</s>"
] | [
"Implement",
"the",
"TARGET_OPTION_OVERRIDE",
"hook",
"."
] | [
"i386"
] | i3866 | ix86_option_override | i386 | CPU | GCC | 11,879 | 19 | 1 | [] |
[
"<s>",
"bool",
"AAPRegisterInfo",
"::",
"trackLivenessAfterRegAlloc",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"live-ins",
"should",
"be",
"tracked",
"after",
"register",
"allocation",
"."
] | [
"AAP",
"AAP"
] | AAPRegisterInfo | trackLivenessAfterRegAlloc | AAP | MPU | LLVM | 11,880 | 16 | 1 | [] |
[
"<s>",
"void",
"VEInstPrinter",
"::",
"printRegName",
"(",
"raw_ostream",
"&",
"OS",
",",
"unsigned",
"RegNo",
")",
"const",
"{",
"unsigned",
"AltIdx",
"=",
"VE",
"::",
"AsmName",
";",
"OS",
"<<",
"'%'",
"<<",
"getRegisterName",
"(",
"RegNo",
",",
"AltIdx",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"assembler",
"register",
"name",
"."
] | [
"VE",
"VE",
"VE::AsmName"
] | VEInstPrinter4 | printRegName | VE | CPU | LLVM | 11,881 | 33 | 1 | [] |
[
"<s>",
"bool",
"fixupNeedsRelaxation",
"(",
"MCFixup",
"const",
"&",
",",
"uint64_t",
",",
"MCRelaxableFragment",
"const",
"*",
",",
"MCAsmLayout",
"const",
"&",
")",
"const",
"override",
"{",
"llvm_unreachable",
"(",
"\"fixupNeedsRelaxation() unimplemented\"",
")",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"Hexagon",
"\"fixupNeedsRelaxation() unimplemented\""
] | HexagonAsmBackend13 | fixupNeedsRelaxation | Hexagon | DSP | LLVM | 11,882 | 26 | 1 | [] |
[
"<s>",
"unsigned",
"char",
"AArch64Subtarget",
"::",
"ClassifyGlobalReference",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"const",
"{",
"bool",
"isDecl",
"=",
"GV",
"->",
"hasAvailableExternallyLinkage",
"(",
")",
";",
"if",
"(",
"GV",
"->",
"isDeclaration",
"(",
")",
"&&",
"!",
"GV",
"->",
"isMaterializable",
"(",
")",
")",
"isDecl",
"=",
"true",
";",
"if",
"(",
"TM",
".",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Large",
"&&",
"isTargetMachO",
"(",
")",
")",
"return",
"AArch64II",
"::",
"MO_GOT",
";",
"if",
"(",
"TM",
".",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Small",
"&&",
"GV",
"->",
"isWeakForLinker",
"(",
")",
"&&",
"isDecl",
")",
"{",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"Static",
")",
"return",
"AArch64II",
"::",
"MO_CONSTPOOL",
";",
"else",
"return",
"AArch64II",
"::",
"MO_GOT",
";",
"}",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"Static",
"&&",
"GV",
"->",
"hasDefaultVisibility",
"(",
")",
")",
"{",
"if",
"(",
"isTargetMachO",
"(",
")",
")",
"return",
"(",
"isDecl",
"||",
"GV",
"->",
"isWeakForLinker",
"(",
")",
")",
"?",
"AArch64II",
"::",
"MO_GOT",
":",
"AArch64II",
"::",
"MO_NO_FLAG",
";",
"else",
"return",
"GV",
"->",
"hasLocalLinkage",
"(",
")",
"?",
"AArch64II",
"::",
"MO_NO_FLAG",
":",
"AArch64II",
"::",
"MO_GOT",
";",
"}",
"return",
"AArch64II",
"::",
"MO_NO_FLAG",
";",
"}",
"</s>"
] | [
"ClassifyGlobalReference",
"-",
"Find",
"the",
"target",
"operand",
"flags",
"that",
"describe",
"how",
"a",
"global",
"value",
"should",
"be",
"referenced",
"for",
"the",
"current",
"subtarget",
"."
] | [
"AArch64",
"AArch64",
"AArch64II::MO_GOT",
"AArch64II::MO_CONSTPOOL",
"AArch64II::MO_GOT",
"AArch64II::MO_GOT",
"AArch64II::MO_NO_FLAG",
"AArch64II::MO_NO_FLAG",
"AArch64II::MO_GOT",
"AArch64II::MO_NO_FLAG"
] | AArch64Subtarget35 | ClassifyGlobalReference | AArch64 | CPU | LLVM | 11,883 | 179 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonTTIImpl",
"::",
"getCacheLineSize",
"(",
")",
"const",
"{",
"return",
"getST",
"(",
")",
"->",
"getL1CacheLineSize",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"target",
"cache",
"line",
"size",
"in",
"bytes",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo1 | getCacheLineSize | Hexagon | DSP | LLVM | 11,884 | 18 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"spu_function_arg_offset",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
")",
"{",
"if",
"(",
"type",
"&&",
"INTEGRAL_TYPE_P",
"(",
"type",
")",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<",
"4",
")",
"return",
"4",
"-",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG_OFFSET",
".",
"The",
"SPU",
"ABI",
"wants",
"32/64-bit",
"types",
"at",
"offset",
"0",
"in",
"the",
"quad-word",
"on",
"the",
"stack",
".",
"8/16-bit",
"types",
"should",
"be",
"at",
"offsets",
"3/2",
"respectively",
"."
] | [
"spu",
"4",
"4",
"0"
] | spu3 | spu_function_arg_offset | spu | MPU | GCC | 11,885 | 39 | 1 | [] |
[
"<s>",
"bool",
"RISCVInstrInfo",
"::",
"isAsCheapAsAMove",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"const",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"RISCV",
"::",
"ADDI",
":",
"case",
"RISCV",
"::",
"ORI",
":",
"case",
"RISCV",
"::",
"XORI",
":",
"return",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"RISCV",
"::",
"X0",
")",
";",
"}",
"return",
"MI",
".",
"isAsCheapAsAMove",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"instruction",
"is",
"as",
"cheap",
"as",
"a",
"move",
"instruction",
"."
] | [
"RISCV",
"RISCV",
"RISCV::ADDI",
"RISCV::ORI",
"RISCV::XORI",
"1",
"1",
"RISCV::X0"
] | RISCVInstrInfo11 | isAsCheapAsAMove | RISCV | CPU | LLVM | 11,886 | 84 | 1 | [] |
[
"<s>",
"unsigned",
"AArch64TTI",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"OperandValueKind",
"Opd1Info",
",",
"OperandValueKind",
"Opd2Info",
",",
"OperandValueProperties",
"Opd1PropInfo",
",",
"OperandValueProperties",
"Opd2PropInfo",
")",
"const",
"{",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"Ty",
")",
";",
"int",
"ISD",
"=",
"TLI",
"->",
"InstructionOpcodeToISD",
"(",
"Opcode",
")",
";",
"if",
"(",
"ISD",
"==",
"ISD",
"::",
"SDIV",
"&&",
"Opd2Info",
"==",
"TargetTransformInfo",
"::",
"OK_UniformConstantValue",
"&&",
"Opd2PropInfo",
"==",
"TargetTransformInfo",
"::",
"OP_PowerOf2",
")",
"{",
"unsigned",
"Cost",
"=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Add",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Sub",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Select",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"AShr",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"return",
"Cost",
";",
"}",
"switch",
"(",
"ISD",
")",
"{",
"default",
":",
"return",
"TargetTransformInfo",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
")",
";",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"XOR",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"AND",
":",
"return",
"1",
"*",
"LT",
".",
"first",
";",
"}",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"AArch64",
"AArch64",
"ISD::SDIV",
"ISD::ADD",
"ISD::MUL",
"ISD::XOR",
"ISD::OR",
"ISD::AND",
"1"
] | AArch64TargetTransformInfo68 | getArithmeticInstrCost | AArch64 | CPU | LLVM | 11,887 | 230 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"h8300_asm_insn_count",
"(",
"const",
"char",
"*",
"template",
")",
"{",
"unsigned",
"int",
"count",
"=",
"1",
";",
"for",
"(",
";",
"*",
"template",
";",
"template",
"++",
")",
"if",
"(",
"*",
"template",
"==",
"'\\n'",
")",
"count",
"++",
";",
"return",
"count",
";",
"}",
"</s>"
] | [
"Count",
"the",
"number",
"of",
"assembly",
"instructions",
"in",
"a",
"string",
"TEMPLATE",
"."
] | [
"h8300",
"1"
] | h83003 | h8300_asm_insn_count | h8300 | MPU | GCC | 11,888 | 40 | 1 | [] |
[
"<s>",
"Register",
"MipsOutgoingValueHandler",
"::",
"getStackAddress",
"(",
"const",
"CCValAssign",
"&",
"VA",
",",
"MachineMemOperand",
"*",
"&",
"MMO",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"const",
"TargetFrameLowering",
"*",
"TFL",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"LLT",
"p0",
"=",
"LLT",
"::",
"pointer",
"(",
"0",
",",
"32",
")",
";",
"LLT",
"s32",
"=",
"LLT",
"::",
"scalar",
"(",
"32",
")",
";",
"auto",
"SPReg",
"=",
"MIRBuilder",
".",
"buildCopy",
"(",
"p0",
",",
"Register",
"(",
"Mips",
"::",
"SP",
")",
")",
";",
"unsigned",
"Offset",
"=",
"VA",
".",
"getLocMemOffset",
"(",
")",
";",
"auto",
"OffsetReg",
"=",
"MIRBuilder",
".",
"buildConstant",
"(",
"s32",
",",
"Offset",
")",
";",
"auto",
"AddrReg",
"=",
"MIRBuilder",
".",
"buildPtrAdd",
"(",
"p0",
",",
"SPReg",
",",
"OffsetReg",
")",
";",
"MachinePointerInfo",
"MPO",
"=",
"MachinePointerInfo",
"::",
"getStack",
"(",
"MIRBuilder",
".",
"getMF",
"(",
")",
",",
"Offset",
")",
";",
"unsigned",
"Size",
"=",
"alignTo",
"(",
"VA",
".",
"getValVT",
"(",
")",
".",
"getSizeInBits",
"(",
")",
",",
"8",
")",
"/",
"8",
";",
"Align",
"Alignment",
"=",
"commonAlignment",
"(",
"TFL",
"->",
"getStackAlign",
"(",
")",
",",
"Offset",
")",
";",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MPO",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"Size",
",",
"Alignment",
")",
";",
"return",
"AddrReg",
".",
"getReg",
"(",
"0",
")",
";",
"}",
"</s>"
] | [
"Materialize",
"a",
"VReg",
"containing",
"the",
"address",
"of",
"the",
"specified",
"stack-based",
"object",
"."
] | [
"Mips",
"Mips",
"0",
"32",
"32",
"Mips::SP",
"8",
"8",
"0"
] | MipsCallLowering16 | getStackAddress | Mips | CPU | LLVM | 11,889 | 191 | 1 | [] |
[
"<s>",
"bool",
"HexagonPacketizer",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"Fn",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineLoopInfo",
"&",
"MLI",
"=",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"const",
"MachineBranchProbabilityInfo",
"*",
"MBPI",
"=",
"&",
"getAnalysis",
"<",
"MachineBranchProbabilityInfo",
">",
"(",
")",
";",
"HexagonPacketizerList",
"Packetizer",
"(",
"Fn",
",",
"MLI",
",",
"MBPI",
")",
";",
"assert",
"(",
"Packetizer",
".",
"getResourceTracker",
"(",
")",
"&&",
"\"Empty DFA table!\"",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"MBBe",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"MBBe",
";",
"++",
"MBB",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"End",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MI",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"while",
"(",
"MI",
"!=",
"End",
")",
"{",
"if",
"(",
"MI",
"->",
"isKill",
"(",
")",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"DeleteMI",
"=",
"MI",
";",
"++",
"MI",
";",
"MBB",
"->",
"erase",
"(",
"DeleteMI",
")",
";",
"End",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"continue",
";",
"}",
"++",
"MI",
";",
"}",
"}",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"MBBe",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"MBBe",
";",
"++",
"MBB",
")",
"{",
"unsigned",
"RemainingCount",
"=",
"MBB",
"->",
"size",
"(",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"RegionEnd",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"RegionEnd",
"!=",
"MBB",
"->",
"begin",
"(",
")",
";",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"RegionEnd",
";",
"for",
"(",
";",
"I",
"!=",
"MBB",
"->",
"begin",
"(",
")",
";",
"--",
"I",
",",
"--",
"RemainingCount",
")",
"{",
"if",
"(",
"TII",
"->",
"isSchedulingBoundary",
"(",
"std",
"::",
"prev",
"(",
"I",
")",
",",
"&",
"*",
"MBB",
",",
"Fn",
")",
")",
"break",
";",
"}",
"I",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"if",
"(",
"I",
"==",
"RegionEnd",
")",
"{",
"RegionEnd",
"=",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
";",
"--",
"RemainingCount",
";",
"continue",
";",
"}",
"if",
"(",
"I",
"==",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
")",
"{",
"RegionEnd",
"=",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
";",
"continue",
";",
"}",
"Packetizer",
".",
"PacketizeMIs",
"(",
"&",
"*",
"MBB",
",",
"I",
",",
"RegionEnd",
")",
";",
"RegionEnd",
"=",
"I",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"\"Empty DFA table!\""
] | HexagonVLIWPacketizer37 | runOnMachineFunction | Hexagon | DSP | LLVM | 11,890 | 356 | 1 | [] |
[
"<s>",
"void",
"assignValueToAddress",
"(",
"Register",
"ValVReg",
",",
"Register",
"Addr",
",",
"uint64_t",
"Size",
",",
"MachinePointerInfo",
"&",
"MPO",
",",
"CCValAssign",
"&",
"VA",
")",
"override",
"{",
"assert",
"(",
"(",
"Size",
"==",
"1",
"||",
"Size",
"==",
"2",
"||",
"Size",
"==",
"4",
"||",
"Size",
"==",
"8",
")",
"&&",
"\"Unsupported size\"",
")",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"SExt",
"||",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"ZExt",
")",
"{",
"Size",
"=",
"4",
";",
"assert",
"(",
"MRI",
".",
"getType",
"(",
"ValVReg",
")",
".",
"isScalar",
"(",
")",
"&&",
"\"Only scalars supported atm\"",
")",
";",
"auto",
"LoadVReg",
"=",
"buildLoad",
"(",
"LLT",
"::",
"scalar",
"(",
"32",
")",
",",
"Addr",
",",
"Size",
",",
"1",
",",
"MPO",
")",
";",
"MIRBuilder",
".",
"buildTrunc",
"(",
"ValVReg",
",",
"LoadVReg",
")",
";",
"}",
"else",
"{",
"buildLoad",
"(",
"ValVReg",
",",
"Addr",
",",
"Size",
",",
"1",
",",
"MPO",
")",
";",
"}",
"}",
"</s>"
] | [
"An",
"overload",
"which",
"takes",
"an",
"ArgInfo",
"if",
"additional",
"information",
"about",
"the",
"arg",
"is",
"needed",
"."
] | [
"ARM",
"1",
"2",
"4",
"8",
"\"Unsupported size\"",
"4",
"\"Only scalars supported atm\"",
"32",
"1",
"1"
] | ARMCallLowering22 | assignValueToAddress | ARM | CPU | LLVM | 11,891 | 136 | 1 | [] |
[
"<s>",
"static",
"bool",
"bfin_assemble_integer",
"(",
"rtx",
"value",
",",
"unsigned",
"int",
"size",
",",
"int",
"aligned_p",
")",
"{",
"if",
"(",
"TARGET_FDPIC",
"&&",
"size",
"==",
"UNITS_PER_WORD",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"value",
")",
"==",
"SYMBOL_REF",
"&&",
"SYMBOL_REF_FUNCTION_P",
"(",
"value",
")",
")",
"{",
"fputs",
"(",
"\"\\t.picptr\\tfuncdesc(\"",
",",
"asm_out_file",
")",
";",
"output_addr_const",
"(",
"asm_out_file",
",",
"value",
")",
";",
"fputs",
"(",
"\")\\n\"",
",",
"asm_out_file",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"aligned_p",
")",
"{",
"assemble_integer_with_op",
"(",
"\"\\t.4byte\\t\"",
",",
"value",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"default_assemble_integer",
"(",
"value",
",",
"size",
",",
"aligned_p",
")",
";",
"}",
"</s>"
] | [
"Implementation",
"of",
"TARGET_ASM_INTEGER",
".",
"When",
"using",
"FD-PIC",
",",
"we",
"need",
"to",
"tell",
"the",
"assembler",
"to",
"generate",
"pointers",
"to",
"function",
"descriptors",
"in",
"some",
"cases",
"."
] | [
"bfin",
"\"\\t.picptr\\tfuncdesc(\"",
"\")\\n\"",
"\"\\t.4byte\\t\""
] | bfin | bfin_assemble_integer | bfin | DSP | GCC | 11,892 | 93 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_move64",
"(",
"rtx",
"dst",
",",
"rtx",
"src",
")",
"{",
"if",
"(",
"push_operand",
"(",
"dst",
",",
"GET_MODE",
"(",
"dst",
")",
")",
")",
"{",
"if",
"(",
"reg_overlap_mentioned_p",
"(",
"stack_pointer_rtx",
",",
"src",
")",
")",
"{",
"return",
"\"pushl\t@%H0,%T1\\n\\tpushl\t@%H0,%T1\"",
";",
"}",
"return",
"\"pushl\t@%H0,%T1\\n\\tpushl\t@%H0,%S1\"",
";",
"}",
"if",
"(",
"whichway",
"(",
"dst",
",",
"src",
")",
"<",
"0",
")",
"return",
"\"$ldl\t%T0,%T1\\n\\t$ldl\t%S0,%S1 ! di a\"",
";",
"else",
"return",
"\"$ldl\t%S0,%S1\\n\\t$ldl\t%T0,%T1 ! di b\"",
";",
"}",
"</s>"
] | [
"Return",
"string",
"to",
"move",
"64",
"bit",
"operand",
"without",
"trampling",
"arguments",
"."
] | [
"z8k",
"\"pushl\t@%H0,%T1\\n\\tpushl\t@%H0,%T1\"",
"\"pushl\t@%H0,%T1\\n\\tpushl\t@%H0,%S1\"",
"0",
"\"$ldl\t%T0,%T1\\n\\t$ldl\t%S0,%S1 ! di a\"",
"\"$ldl\t%S0,%S1\\n\\t$ldl\t%T0,%T1 ! di b\""
] | z8k | output_move64 | z8k | MPU | GCC | 11,893 | 62 | 1 | [] |
[
"<s>",
"void",
"ARCTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"[ARC-ISEL] ReplaceNodeResults \"",
")",
";",
"LLVM_DEBUG",
"(",
"N",
"->",
"dump",
"(",
"&",
"DAG",
")",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"; use_count=\"",
"<<",
"N",
"->",
"use_size",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"READCYCLECOUNTER",
":",
"if",
"(",
"N",
"->",
"getValueType",
"(",
"0",
")",
"==",
"MVT",
"::",
"i64",
")",
"{",
"SDValue",
"V",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"READCYCLECOUNTER",
",",
"SDLoc",
"(",
"N",
")",
",",
"DAG",
".",
"getVTList",
"(",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Other",
")",
",",
"N",
"->",
"getOperand",
"(",
"0",
")",
")",
";",
"SDValue",
"Op",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ZERO_EXTEND",
",",
"SDLoc",
"(",
"N",
")",
",",
"MVT",
"::",
"i64",
",",
"V",
")",
";",
"Results",
".",
"push_back",
"(",
"Op",
")",
";",
"Results",
".",
"push_back",
"(",
"V",
".",
"getValue",
"(",
"1",
")",
")",
";",
"}",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"ARC",
"ARC",
"\"[ARC-ISEL] ReplaceNodeResults \"",
"\"; use_count=\"",
"\"\\n\"",
"ISD::READCYCLECOUNTER",
"0",
"MVT::i64",
"ISD::READCYCLECOUNTER",
"MVT::i32",
"MVT::Other",
"0",
"ISD::ZERO_EXTEND",
"MVT::i64",
"1"
] | ARCISelLowering3 | ReplaceNodeResults | ARC | MPU | LLVM | 11,894 | 175 | 1 | [] |
[
"<s>",
"bool",
"PPCCallLowering",
"::",
"lowerReturn",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Value",
"*",
"Val",
",",
"ArrayRef",
"<",
"Register",
">",
"VRegs",
",",
"FunctionLoweringInfo",
"&",
"FLI",
",",
"Register",
"SwiftErrorVReg",
")",
"const",
"{",
"assert",
"(",
"(",
"(",
"Val",
"&&",
"!",
"VRegs",
".",
"empty",
"(",
")",
")",
"||",
"(",
"!",
"Val",
"&&",
"VRegs",
".",
"empty",
"(",
")",
")",
")",
"&&",
"\"Return value without a vreg\"",
")",
";",
"if",
"(",
"VRegs",
".",
"size",
"(",
")",
">",
"0",
")",
"return",
"false",
";",
"MIRBuilder",
".",
"buildInstr",
"(",
"PPC",
"::",
"BLR8",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"behaves",
"as",
"the",
"extended",
"lowerReturn",
"function",
",",
"but",
"for",
"targets",
"that",
"do",
"not",
"support",
"swifterror",
"value",
"promotion",
"."
] | [
"PowerPC",
"PPC",
"\"Return value without a vreg\"",
"0",
"PPC::BLR8"
] | PPCCallLowering | lowerReturn | PowerPC | CPU | LLVM | 11,895 | 84 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"front",
"(",
")",
"const",
"{",
"return",
"Uses",
".",
"top",
"(",
")",
";",
"}",
"</s>"
] | [
"front",
"-",
"Get",
"the",
"first",
"character",
"in",
"the",
"string",
"."
] | [
"Hexagon"
] | BitTracker17 | front | Hexagon | DSP | LLVM | 11,896 | 15 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
"AllowModify",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"--",
"I",
";",
"if",
"(",
"I",
"->",
"isDebugInstr",
"(",
")",
")",
"continue",
";",
"if",
"(",
"!",
"isUnpredicatedTerminator",
"(",
"*",
"I",
")",
")",
"break",
";",
"if",
"(",
"!",
"I",
"->",
"isBranch",
"(",
")",
")",
"return",
"true",
";",
"SystemZII",
"::",
"Branch",
"Branch",
"(",
"getBranchInfo",
"(",
"*",
"I",
")",
")",
";",
"if",
"(",
"!",
"Branch",
".",
"hasMBBTarget",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"Branch",
".",
"Type",
"!=",
"SystemZII",
"::",
"BranchNormal",
")",
"return",
"true",
";",
"if",
"(",
"Branch",
".",
"CCMask",
"==",
"SystemZ",
"::",
"CCMASK_ANY",
")",
"{",
"if",
"(",
"!",
"AllowModify",
")",
"{",
"TBB",
"=",
"Branch",
".",
"getMBBTarget",
"(",
")",
";",
"continue",
";",
"}",
"while",
"(",
"std",
"::",
"next",
"(",
"I",
")",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"std",
"::",
"next",
"(",
"I",
")",
"->",
"eraseFromParent",
"(",
")",
";",
"Cond",
".",
"clear",
"(",
")",
";",
"FBB",
"=",
"nullptr",
";",
"if",
"(",
"MBB",
".",
"isLayoutSuccessor",
"(",
"Branch",
".",
"getMBBTarget",
"(",
")",
")",
")",
"{",
"TBB",
"=",
"nullptr",
";",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"continue",
";",
"}",
"TBB",
"=",
"Branch",
".",
"getMBBTarget",
"(",
")",
";",
"continue",
";",
"}",
"if",
"(",
"Cond",
".",
"empty",
"(",
")",
")",
"{",
"FBB",
"=",
"TBB",
";",
"TBB",
"=",
"Branch",
".",
"getMBBTarget",
"(",
")",
";",
"Cond",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"Branch",
".",
"CCValid",
")",
")",
";",
"Cond",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"Branch",
".",
"CCMask",
")",
")",
";",
"continue",
";",
"}",
"assert",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"2",
"&&",
"TBB",
"&&",
"\"Should have seen a conditional branch\"",
")",
";",
"if",
"(",
"TBB",
"!=",
"Branch",
".",
"getMBBTarget",
"(",
")",
")",
"return",
"true",
";",
"unsigned",
"OldCCValid",
"=",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
";",
"unsigned",
"OldCCMask",
"=",
"Cond",
"[",
"1",
"]",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"OldCCValid",
"==",
"Branch",
".",
"CCValid",
"&&",
"OldCCMask",
"==",
"Branch",
".",
"CCMask",
")",
"continue",
";",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZII::Branch",
"SystemZII::BranchNormal",
"SystemZ::CCMASK_ANY",
"2",
"\"Should have seen a conditional branch\"",
"0",
"1"
] | SystemZInstrInfo16 | analyzeBranch | SystemZ | CPU | LLVM | 11,897 | 364 | 1 | [] |
[
"<s>",
"unsigned",
"MipsMCCodeEmitter",
"::",
"getBranchTargetOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
">>",
"2",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"\"getBranchTargetOpValue expects only expressions or immediates\"",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"Create",
"(",
"0",
",",
"Expr",
",",
"MCFixupKind",
"(",
"Mips",
"::",
"fixup_Mips_PC16",
")",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTargetOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"2",
"\"getBranchTargetOpValue expects only expressions or immediates\"",
"0",
"Mips::fixup_Mips_PC16",
"0"
] | MipsMCCodeEmitter12 | getBranchTargetOpValue | Mips | CPU | LLVM | 11,898 | 98 | 1 | [] |
[
"<s>",
"bool",
"MipsSubtarget",
"::",
"enablePostRAScheduler",
"(",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
",",
"TargetSubtargetInfo",
"::",
"AntiDepBreakMode",
"&",
"Mode",
",",
"RegClassVector",
"&",
"CriticalPathRCs",
")",
"const",
"{",
"Mode",
"=",
"TargetSubtargetInfo",
"::",
"ANTIDEP_NONE",
";",
"CriticalPathRCs",
".",
"clear",
"(",
")",
";",
"CriticalPathRCs",
".",
"push_back",
"(",
"hasMips64",
"(",
")",
"?",
"&",
"Mips",
"::",
"GPR64RegClass",
":",
"&",
"Mips",
"::",
"GPR32RegClass",
")",
";",
"return",
"OptLevel",
">=",
"CodeGenOpt",
"::",
"Aggressive",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"subtarget",
"should",
"run",
"a",
"scheduler",
"after",
"register",
"allocation",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips::GPR64RegClass",
"Mips::GPR32RegClass"
] | MipsSubtarget16 | enablePostRAScheduler | Mips | CPU | LLVM | 11,899 | 61 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.