ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"static",
"void",
"microblaze_block_move_straight",
"(",
"rtx",
"dest",
",",
"rtx",
"src",
",",
"HOST_WIDE_INT",
"length",
")",
"{",
"HOST_WIDE_INT",
"offset",
",",
"delta",
";",
"unsigned",
"HOST_WIDE_INT",
"bits",
";",
"int",
"i",
";",
"machine_mode",
"mode",
";",
"rtx",
"*",
"regs",
";",
"bits",
"=",
"BITS_PER_WORD",
";",
"mode",
"=",
"int_mode_for_size",
"(",
"bits",
",",
"0",
")",
".",
"require",
"(",
")",
";",
"delta",
"=",
"bits",
"/",
"BITS_PER_UNIT",
";",
"regs",
"=",
"XALLOCAVEC",
"(",
"rtx",
",",
"length",
"/",
"delta",
")",
";",
"for",
"(",
"offset",
"=",
"0",
",",
"i",
"=",
"0",
";",
"offset",
"+",
"delta",
"<=",
"length",
";",
"offset",
"+=",
"delta",
",",
"i",
"++",
")",
"{",
"regs",
"[",
"i",
"]",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_move_insn",
"(",
"regs",
"[",
"i",
"]",
",",
"adjust_address",
"(",
"src",
",",
"mode",
",",
"offset",
")",
")",
";",
"}",
"for",
"(",
"offset",
"=",
"0",
",",
"i",
"=",
"0",
";",
"offset",
"+",
"delta",
"<=",
"length",
";",
"offset",
"+=",
"delta",
",",
"i",
"++",
")",
"emit_move_insn",
"(",
"adjust_address",
"(",
"dest",
",",
"mode",
",",
"offset",
")",
",",
"regs",
"[",
"i",
"]",
")",
";",
"if",
"(",
"offset",
"<",
"length",
")",
"{",
"src",
"=",
"adjust_address",
"(",
"src",
",",
"BLKmode",
",",
"offset",
")",
";",
"dest",
"=",
"adjust_address",
"(",
"dest",
",",
"BLKmode",
",",
"offset",
")",
";",
"move_by_pieces",
"(",
"dest",
",",
"src",
",",
"length",
"-",
"offset",
",",
"MIN",
"(",
"MEM_ALIGN",
"(",
"src",
")",
",",
"MEM_ALIGN",
"(",
"dest",
")",
")",
",",
"0",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"straight-line",
"code",
"to",
"move",
"LENGTH",
"bytes",
"from",
"SRC",
"to",
"DEST",
".",
"Assume",
"that",
"the",
"areas",
"do",
"not",
"overlap",
"."
] | [
"microblaze",
"0",
"0",
"0",
"0",
"0",
"0"
] | microblaze5 | microblaze_block_move_straight | microblaze | MPU | GCC | 26,000 | 216 | 1 | [] |
[
"<s>",
"static",
"int",
"mn10300_arg_partial_bytes",
"(",
"cumulative_args_t",
"cum_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"int",
"size",
";",
"int",
"nregs",
"=",
"2",
";",
"size",
"=",
"arg",
".",
"promoted_size_in_bytes",
"(",
")",
";",
"cum",
"->",
"nbytes",
"=",
"(",
"cum",
"->",
"nbytes",
"+",
"3",
")",
"&",
"~",
"3",
";",
"if",
"(",
"cum",
"->",
"nbytes",
">",
"nregs",
"*",
"UNITS_PER_WORD",
")",
"return",
"0",
";",
"if",
"(",
"cum",
"->",
"nbytes",
"+",
"size",
"<=",
"nregs",
"*",
"UNITS_PER_WORD",
")",
"return",
"0",
";",
"if",
"(",
"arg",
".",
"type",
"==",
"NULL_TREE",
"&&",
"cum",
"->",
"nbytes",
"+",
"size",
">",
"nregs",
"*",
"UNITS_PER_WORD",
")",
"return",
"0",
";",
"return",
"nregs",
"*",
"UNITS_PER_WORD",
"-",
"cum",
"->",
"nbytes",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"bytes",
"of",
"registers",
"to",
"use",
"for",
"an",
"argument",
"passed",
"partially",
"in",
"registers",
"and",
"partially",
"in",
"memory",
"."
] | [
"mn10300",
"2",
"3",
"3",
"0",
"0",
"0"
] | mn10300 | mn10300_arg_partial_bytes | mn10300 | MPU | GCC | 26,001 | 112 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"verifyInstruction",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"StringRef",
"&",
"ErrInfo",
")",
"const",
"{",
"Optional",
"<",
"ExtAddrMode",
">",
"AMOrNone",
"=",
"getAddrModeFromMemoryOp",
"(",
"MI",
",",
"nullptr",
")",
";",
"if",
"(",
"!",
"AMOrNone",
")",
"return",
"true",
";",
"ExtAddrMode",
"AM",
"=",
"*",
"AMOrNone",
";",
"if",
"(",
"AM",
".",
"ScaledReg",
"!=",
"X86",
"::",
"NoRegister",
")",
"{",
"switch",
"(",
"AM",
".",
"Scale",
")",
"{",
"case",
"1",
":",
"case",
"2",
":",
"case",
"4",
":",
"case",
"8",
":",
"break",
";",
"default",
":",
"ErrInfo",
"=",
"\"Scale factor in address must be 1, 2, 4 or 8\"",
";",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"!",
"isInt",
"<",
"32",
">",
"(",
"AM",
".",
"Displacement",
")",
")",
"{",
"ErrInfo",
"=",
"\"Displacement in address must fit into 32-bit signed \"",
"\"integer\"",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Perform",
"target-specific",
"instruction",
"verification",
"."
] | [
"X86",
"X86",
"X86::NoRegister",
"1",
"2",
"4",
"8",
"\"Scale factor in address must be 1, 2, 4 or 8\"",
"32",
"\"Displacement in address must fit into 32-bit signed \"",
"\"integer\""
] | X86InstrInfo76 | verifyInstruction | X86 | CPU | LLVM | 26,002 | 113 | 1 | [] |
[
"<s>",
"bool",
"ARMPassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"const",
"ARMSubtarget",
"*",
"Subtarget",
"=",
"&",
"getARMSubtarget",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"hasAnyDataBarrier",
"(",
")",
"&&",
"!",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
")",
"addPass",
"(",
"createAtomicExpandLoadLinkedPass",
"(",
"TM",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createGlobalMergePass",
"(",
"TM",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine45 | addPreISel | ARM | CPU | LLVM | 26,003 | 64 | 1 | [] |
[
"<s>",
"bool",
"isMem",
"(",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"isMem",
"-",
"Is",
"this",
"a",
"memory",
"operand",
"?"
] | [
"CAHP"
] | CAHPAsmParser | isMem | CAHP | CPU | LLVM | 26,004 | 11 | 1 | [] |
[
"<s>",
"SDValue",
"ARMTargetLowering",
"::",
"BuildSDIVPow2",
"(",
"SDNode",
"*",
"N",
",",
"const",
"APInt",
"&",
"Divisor",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDNode",
"*",
">",
"&",
"Created",
")",
"const",
"{",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SDIV",
")",
"return",
"SDValue",
"(",
")",
";",
"const",
"auto",
"&",
"ST",
"=",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"DAG",
".",
"getSubtarget",
"(",
")",
")",
";",
"const",
"auto",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"const",
"bool",
"MinSize",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"optForMinSize",
"(",
")",
";",
"const",
"bool",
"HasDivide",
"=",
"ST",
".",
"isThumb",
"(",
")",
"?",
"ST",
".",
"hasDivideInThumbMode",
"(",
")",
":",
"ST",
".",
"hasDivideInARMMode",
"(",
")",
";",
"if",
"(",
"N",
"->",
"getOperand",
"(",
"0",
")",
".",
"getValueType",
"(",
")",
".",
"isVector",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"!",
"(",
"MinSize",
"&&",
"HasDivide",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"!",
"ST",
".",
"isThumb",
"(",
")",
")",
"return",
"SDValue",
"(",
"N",
",",
"0",
")",
";",
"if",
"(",
"Divisor",
".",
"sgt",
"(",
"128",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"return",
"SDValue",
"(",
"N",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"Targets",
"may",
"override",
"this",
"function",
"to",
"provide",
"custom",
"SDIV",
"lowering",
"for",
"power-of-2",
"denominators",
"."
] | [
"ARM",
"ARM",
"ISD::SDIV",
"ARM",
"ARM",
"0",
"0",
"128",
"0"
] | ARMISelLowering (3) | BuildSDIVPow2 | ARM | CPU | LLVM | 26,005 | 187 | 1 | [] |
[
"<s>",
"void",
"NVPTXInstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"DestRC",
"=",
"MRI",
".",
"getRegClass",
"(",
"DestReg",
")",
";",
"const",
"TargetRegisterClass",
"*",
"SrcRC",
"=",
"MRI",
".",
"getRegClass",
"(",
"SrcReg",
")",
";",
"if",
"(",
"DestRC",
"->",
"getSize",
"(",
")",
"!=",
"SrcRC",
"->",
"getSize",
"(",
")",
")",
"report_fatal_error",
"(",
"\"Copy one register into another with a different width\"",
")",
";",
"unsigned",
"Op",
";",
"if",
"(",
"DestRC",
"==",
"&",
"NVPTX",
"::",
"Int1RegsRegClass",
")",
"{",
"Op",
"=",
"NVPTX",
"::",
"IMOV1rr",
";",
"}",
"else",
"if",
"(",
"DestRC",
"==",
"&",
"NVPTX",
"::",
"Int16RegsRegClass",
")",
"{",
"Op",
"=",
"NVPTX",
"::",
"IMOV16rr",
";",
"}",
"else",
"if",
"(",
"DestRC",
"==",
"&",
"NVPTX",
"::",
"Int32RegsRegClass",
")",
"{",
"Op",
"=",
"(",
"SrcRC",
"==",
"&",
"NVPTX",
"::",
"Int32RegsRegClass",
"?",
"NVPTX",
"::",
"IMOV32rr",
":",
"NVPTX",
"::",
"BITCONVERT_32_F2I",
")",
";",
"}",
"else",
"if",
"(",
"DestRC",
"==",
"&",
"NVPTX",
"::",
"Int64RegsRegClass",
")",
"{",
"Op",
"=",
"(",
"SrcRC",
"==",
"&",
"NVPTX",
"::",
"Int64RegsRegClass",
"?",
"NVPTX",
"::",
"IMOV64rr",
":",
"NVPTX",
"::",
"BITCONVERT_64_F2I",
")",
";",
"}",
"else",
"if",
"(",
"DestRC",
"==",
"&",
"NVPTX",
"::",
"Float32RegsRegClass",
")",
"{",
"Op",
"=",
"(",
"SrcRC",
"==",
"&",
"NVPTX",
"::",
"Float32RegsRegClass",
"?",
"NVPTX",
"::",
"FMOV32rr",
":",
"NVPTX",
"::",
"BITCONVERT_32_I2F",
")",
";",
"}",
"else",
"if",
"(",
"DestRC",
"==",
"&",
"NVPTX",
"::",
"Float64RegsRegClass",
")",
"{",
"Op",
"=",
"(",
"SrcRC",
"==",
"&",
"NVPTX",
"::",
"Float64RegsRegClass",
"?",
"NVPTX",
"::",
"FMOV64rr",
":",
"NVPTX",
"::",
"BITCONVERT_64_I2F",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Bad register copy\"",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Op",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"NVPTX",
"NVPTX",
"\"Copy one register into another with a different width\"",
"NVPTX::Int1RegsRegClass",
"NVPTX::IMOV1rr",
"NVPTX::Int16RegsRegClass",
"NVPTX::IMOV16rr",
"NVPTX::Int32RegsRegClass",
"NVPTX::Int32RegsRegClass",
"NVPTX::IMOV32rr",
"NVPTX::BITCONVERT_32_F2I",
"NVPTX::Int64RegsRegClass",
"NVPTX::Int64RegsRegClass",
"NVPTX::IMOV64rr",
"NVPTX::BITCONVERT_64_F2I",
"NVPTX::Float32RegsRegClass",
"NVPTX::Float32RegsRegClass",
"NVPTX::FMOV32rr",
"NVPTX::BITCONVERT_32_I2F",
"NVPTX::Float64RegsRegClass",
"NVPTX::Float64RegsRegClass",
"NVPTX::FMOV64rr",
"NVPTX::BITCONVERT_64_I2F",
"\"Bad register copy\""
] | NVPTXInstrInfo30 | copyPhysReg | NVPTX | GPU | LLVM | 26,006 | 285 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"nvptx_promote_function_mode",
"(",
"const_tree",
"type",
",",
"machine_mode",
"mode",
",",
"int",
"*",
"punsignedp",
",",
"const_tree",
"funtype",
",",
"int",
"for_return",
")",
"{",
"if",
"(",
"type",
"==",
"NULL_TREE",
")",
"return",
"mode",
";",
"if",
"(",
"for_return",
")",
"return",
"promote_mode",
"(",
"type",
",",
"mode",
",",
"punsignedp",
")",
";",
"if",
"(",
"TYPE_ARG_TYPES",
"(",
"funtype",
")",
"==",
"NULL_TREE",
"&&",
"type",
"!=",
"NULL_TREE",
"&&",
"!",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"mode",
"=",
"DFmode",
";",
"mode",
"=",
"arg_promotion",
"(",
"mode",
")",
";",
"}",
"return",
"mode",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_PROMOTE_FUNCTION_MODE",
"."
] | [
"nvptx"
] | nvptx2 | nvptx_promote_function_mode | nvptx | GPU | GCC | 26,007 | 86 | 1 | [] |
[
"<s>",
"void",
"order_regs_for_local_alloc",
"(",
")",
"{",
"unsigned",
"int",
"i",
";",
"static",
"const",
"int",
"order_0",
"[",
"]",
"=",
"{",
"24",
",",
"25",
",",
"18",
",",
"19",
",",
"20",
",",
"21",
",",
"22",
",",
"23",
",",
"30",
",",
"31",
",",
"26",
",",
"27",
",",
"28",
",",
"29",
",",
"17",
",",
"16",
",",
"15",
",",
"14",
",",
"13",
",",
"12",
",",
"11",
",",
"10",
",",
"9",
",",
"8",
",",
"7",
",",
"6",
",",
"5",
",",
"4",
",",
"3",
",",
"2",
",",
"0",
",",
"1",
",",
"32",
",",
"33",
",",
"34",
",",
"35",
"}",
";",
"static",
"const",
"int",
"order_1",
"[",
"]",
"=",
"{",
"18",
",",
"19",
",",
"20",
",",
"21",
",",
"22",
",",
"23",
",",
"24",
",",
"25",
",",
"30",
",",
"31",
",",
"26",
",",
"27",
",",
"28",
",",
"29",
",",
"17",
",",
"16",
",",
"15",
",",
"14",
",",
"13",
",",
"12",
",",
"11",
",",
"10",
",",
"9",
",",
"8",
",",
"7",
",",
"6",
",",
"5",
",",
"4",
",",
"3",
",",
"2",
",",
"0",
",",
"1",
",",
"32",
",",
"33",
",",
"34",
",",
"35",
"}",
";",
"static",
"const",
"int",
"order_2",
"[",
"]",
"=",
"{",
"25",
",",
"24",
",",
"23",
",",
"22",
",",
"21",
",",
"20",
",",
"19",
",",
"18",
",",
"30",
",",
"31",
",",
"26",
",",
"27",
",",
"28",
",",
"29",
",",
"17",
",",
"16",
",",
"15",
",",
"14",
",",
"13",
",",
"12",
",",
"11",
",",
"10",
",",
"9",
",",
"8",
",",
"7",
",",
"6",
",",
"5",
",",
"4",
",",
"3",
",",
"2",
",",
"1",
",",
"0",
",",
"32",
",",
"33",
",",
"34",
",",
"35",
"}",
";",
"const",
"int",
"*",
"order",
"=",
"(",
"TARGET_ORDER_1",
"?",
"order_1",
":",
"TARGET_ORDER_2",
"?",
"order_2",
":",
"order_0",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"order_0",
")",
";",
"++",
"i",
")",
"reg_alloc_order",
"[",
"i",
"]",
"=",
"order",
"[",
"i",
"]",
";",
"}",
"</s>"
] | [
"Choose",
"the",
"order",
"in",
"which",
"to",
"allocate",
"hard",
"registers",
"for",
"pseudo-registers",
"local",
"to",
"a",
"basic",
"block",
".",
"Store",
"the",
"desired",
"register",
"order",
"in",
"the",
"array",
"`",
"reg_alloc_order",
"'",
".",
"Element",
"0",
"should",
"be",
"the",
"register",
"to",
"allocate",
"first",
";",
"element",
"1",
",",
"the",
"next",
"register",
";",
"and",
"so",
"on",
"."
] | [
"avr",
"24",
"25",
"18",
"19",
"20",
"21",
"22",
"23",
"30",
"31",
"26",
"27",
"28",
"29",
"17",
"16",
"15",
"14",
"13",
"12",
"11",
"10",
"9",
"8",
"7",
"6",
"5",
"4",
"3",
"2",
"0",
"1",
"32",
"33",
"34",
"35",
"18",
"19",
"20",
"21",
"22",
"23",
"24",
"25",
"30",
"31",
"26",
"27",
"28",
"29",
"17",
"16",
"15",
"14",
"13",
"12",
"11",
"10",
"9",
"8",
"7",
"6",
"5",
"4",
"3",
"2",
"0",
"1",
"32",
"33",
"34",
"35",
"25",
"24",
"23",
"22",
"21",
"20",
"19",
"18",
"30",
"31",
"26",
"27",
"28",
"29",
"17",
"16",
"15",
"14",
"13",
"12",
"11",
"10",
"9",
"8",
"7",
"6",
"5",
"4",
"3",
"2",
"1",
"0",
"32",
"33",
"34",
"35",
"0"
] | avr2 | order_regs_for_local_alloc | avr | MPU | GCC | 26,008 | 296 | 1 | [] |
[
"<s>",
"bool",
"mayNeedRelaxation",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"the",
"given",
"instruction",
"may",
"need",
"relaxation",
"."
] | [
"RV16K"
] | RV16KAsmBackend | mayNeedRelaxation | RV16K | Virtual ISA | LLVM | 26,009 | 20 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUAsmParser",
"::",
"checkTargetMatchPredicate",
"(",
"MCInst",
"&",
"Inst",
")",
"{",
"uint64_t",
"TSFlags",
"=",
"MII",
".",
"get",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
".",
"TSFlags",
";",
"if",
"(",
"(",
"getForcedEncodingSize",
"(",
")",
"==",
"32",
"&&",
"(",
"TSFlags",
"&",
"SIInstrFlags",
"::",
"VOP3",
")",
")",
"||",
"(",
"getForcedEncodingSize",
"(",
")",
"==",
"64",
"&&",
"!",
"(",
"TSFlags",
"&",
"SIInstrFlags",
"::",
"VOP3",
")",
")",
")",
"return",
"Match_InvalidOperand",
";",
"if",
"(",
"(",
"TSFlags",
"&",
"SIInstrFlags",
"::",
"VOP3",
")",
"&&",
"(",
"TSFlags",
"&",
"SIInstrFlags",
"::",
"VOPAsmPrefer32Bit",
")",
"&&",
"getForcedEncodingSize",
"(",
")",
"!=",
"64",
")",
"return",
"Match_PreferE32",
";",
"return",
"Match_Success",
";",
"}",
"</s>"
] | [
"checkTargetMatchPredicate",
"-",
"Validate",
"the",
"instruction",
"match",
"against",
"any",
"complex",
"target",
"predicates",
"not",
"expressible",
"via",
"match",
"classes",
"."
] | [
"AMDGPU",
"AMDGPU",
"32",
"SIInstrFlags::VOP3",
"64",
"SIInstrFlags::VOP3",
"SIInstrFlags::VOP3",
"SIInstrFlags::VOPAsmPrefer32Bit",
"64"
] | AMDGPUAsmParser (2) | checkTargetMatchPredicate | AMDGPU | GPU | LLVM | 26,010 | 95 | 1 | [] |
[
"<s>",
"const",
"MCFixupKindInfo",
"&",
"XtensaAsmBackend",
"::",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"Xtensa",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"\"fixup_xtensa_ldst_imm4_scale2\"",
",",
"12",
",",
"4",
",",
"0",
"}",
",",
"{",
"\"fixup_xtensa_jump_target\"",
",",
"6",
",",
"18",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_xtensa_cond_branch12_target\"",
",",
"12",
",",
"12",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"}",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";",
"assert",
"(",
"unsigned",
"(",
"Kind",
"-",
"FirstTargetFixupKind",
")",
"<",
"getNumFixupKinds",
"(",
")",
"&&",
"\"Invalid kind!\"",
")",
";",
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";",
"}",
"</s>"
] | [
"Get",
"information",
"on",
"a",
"fixup",
"kind",
"."
] | [
"Xtensa",
"Xtensa",
"Xtensa::NumTargetFixupKinds",
"\"fixup_xtensa_ldst_imm4_scale2\"",
"12",
"4",
"0",
"\"fixup_xtensa_jump_target\"",
"6",
"18",
"\"fixup_xtensa_cond_branch12_target\"",
"12",
"12",
"\"Invalid kind!\""
] | XtensaAsmBackend | getFixupKindInfo | Xtensa | MPU | LLVM | 26,011 | 98 | 1 | [] |
[
"<s>",
"virtual",
"const",
"Tile64RegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"Tile64"
] | Tile64TargetMachine | getRegisterInfo | Tile64 | VLIW | LLVM | 26,012 | 18 | 1 | [] |
[
"<s>",
"void",
"AlphaInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"RC",
"==",
"Alpha",
"::",
"F4RCRegisterClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Alpha",
"::",
"STS",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"F31",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"Alpha",
"::",
"F8RCRegisterClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Alpha",
"::",
"STT",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"F31",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"Alpha",
"::",
"GPRCRegisterClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Alpha",
"::",
"STQ",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"F31",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Unhandled register class\"",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"Alpha",
"Alpha",
"Alpha::F4RCRegisterClass",
"Alpha::STS",
"Alpha::F31",
"Alpha::F8RCRegisterClass",
"Alpha::STT",
"Alpha::F31",
"Alpha::GPRCRegisterClass",
"Alpha::STQ",
"Alpha::F31",
"\"Unhandled register class\""
] | AlphaInstrInfo3 | storeRegToStackSlot | Alpha | MPU | LLVM | 26,013 | 204 | 1 | [] |
[
"<s>",
"static",
"bool",
"str_prefix_p",
"(",
"const",
"char",
"*",
"str",
",",
"const",
"char",
"*",
"prefix",
")",
"{",
"return",
"strncmp",
"(",
"str",
",",
"prefix",
",",
"strlen",
"(",
"prefix",
")",
")",
"==",
"0",
";",
"}",
"</s>"
] | [
"Return",
"true",
"iff",
"STR",
"starts",
"with",
"PREFIX",
"."
] | [
"avr",
"0"
] | gen-avr-mmcu-specs5 | str_prefix_p | avr | MPU | GCC | 26,014 | 31 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"NVPTX specific alloca hoisting\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"NVPTX",
"\"NVPTX specific alloca hoisting\""
] | NVPTXAllocaHoisting14 | getPassName | NVPTX | GPU | LLVM | 26,015 | 13 | 1 | [] |
[
"<s>",
"static",
"bool",
"nios2_legitimate_constant_p",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"x",
")",
"{",
"rtx",
"base",
",",
"offset",
";",
"split_const",
"(",
"x",
",",
"&",
"base",
",",
"&",
"offset",
")",
";",
"return",
"GET_CODE",
"(",
"base",
")",
"!=",
"SYMBOL_REF",
"||",
"!",
"SYMBOL_REF_TLS_MODEL",
"(",
"base",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMATE_CONSTANT_P",
"."
] | [
"nios2"
] | nios2 | nios2_legitimate_constant_p | nios2 | MPU | GCC | 26,016 | 43 | 1 | [] |
[
"<s>",
"bool",
"MSP430BSel",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"mf",
")",
"{",
"MF",
"=",
"&",
"mf",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"MSP430InstrInfo",
"*",
">",
"(",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"if",
"(",
"!",
"BranchSelectEnabled",
")",
"return",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"\\n********** \"",
"<<",
"getPassName",
"(",
")",
"<<",
"\" **********\\n\"",
")",
";",
"OffsetVector",
"BlockOffsets",
";",
"unsigned",
"FunctionSize",
"=",
"measureFunction",
"(",
"BlockOffsets",
")",
";",
"if",
"(",
"isInRage",
"(",
"FunctionSize",
")",
")",
"{",
"return",
"false",
";",
"}",
"bool",
"MadeChange",
"=",
"false",
";",
"while",
"(",
"expandBranches",
"(",
"BlockOffsets",
")",
")",
"MadeChange",
"=",
"true",
";",
"return",
"MadeChange",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"MSP430",
"MSP430",
"MSP430",
"\"\\n********** \"",
"\" **********\\n\""
] | MSP430BranchSelector15 | runOnMachineFunction | MSP430 | MPU | LLVM | 26,017 | 101 | 1 | [] |
[
"<s>",
"void",
"s390_reload_larl_operand",
"(",
"rtx",
"reg",
",",
"rtx",
"addr",
",",
"rtx",
"scratch",
")",
"{",
"HOST_WIDE_INT",
"addend",
";",
"rtx",
"symref",
";",
"if",
"(",
"!",
"s390_loadrelative_operand_p",
"(",
"addr",
",",
"&",
"symref",
",",
"&",
"addend",
")",
")",
"gcc_unreachable",
"(",
")",
";",
"if",
"(",
"!",
"(",
"addend",
"&",
"1",
")",
")",
"emit_move_insn",
"(",
"reg",
",",
"addr",
")",
";",
"else",
"{",
"if",
"(",
"REGNO",
"(",
"reg",
")",
"<",
"FIRST_PSEUDO_REGISTER",
"&&",
"REGNO_REG_CLASS",
"(",
"REGNO",
"(",
"reg",
")",
")",
"==",
"ADDR_REGS",
")",
"scratch",
"=",
"reg",
";",
"gcc_assert",
"(",
"REGNO",
"(",
"scratch",
")",
"<",
"FIRST_PSEUDO_REGISTER",
")",
";",
"gcc_assert",
"(",
"REGNO_REG_CLASS",
"(",
"REGNO",
"(",
"scratch",
")",
")",
"==",
"ADDR_REGS",
")",
";",
"if",
"(",
"addend",
"!=",
"1",
")",
"emit_move_insn",
"(",
"scratch",
",",
"gen_rtx_CONST",
"(",
"Pmode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"symref",
",",
"GEN_INT",
"(",
"addend",
"-",
"1",
")",
")",
")",
")",
";",
"else",
"emit_move_insn",
"(",
"scratch",
",",
"symref",
")",
";",
"s390_load_address",
"(",
"reg",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"scratch",
",",
"const1_rtx",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"ADDR",
"is",
"moved",
"into",
"REG",
"using",
"larl",
".",
"If",
"ADDR",
"is",
"n't",
"a",
"valid",
"larl",
"operand",
"SCRATCH",
"is",
"used",
"to",
"reload",
"the",
"even",
"part",
"of",
"the",
"address",
"and",
"adding",
"one",
"."
] | [
"s390",
"1",
"1",
"1"
] | s390 | s390_reload_larl_operand | s390 | MPU | GCC | 26,018 | 155 | 1 | [] |
[
"<s>",
"std",
"::",
"vector",
"<",
"const",
"SUnit",
"*",
">",
"GCNILPScheduler",
"::",
"schedule",
"(",
"ArrayRef",
"<",
"const",
"SUnit",
"*",
">",
"BotRoots",
",",
"const",
"ScheduleDAG",
"&",
"DAG",
")",
"{",
"auto",
"&",
"SUnits",
"=",
"const_cast",
"<",
"ScheduleDAG",
"&",
">",
"(",
"DAG",
")",
".",
"SUnits",
";",
"std",
"::",
"vector",
"<",
"SUnit",
">",
"SUSavedCopy",
";",
"SUSavedCopy",
".",
"resize",
"(",
"SUnits",
".",
"size",
"(",
")",
")",
";",
"for",
"(",
"const",
"SUnit",
"&",
"SU",
":",
"SUnits",
")",
"SUSavedCopy",
"[",
"SU",
".",
"NodeNum",
"]",
"=",
"SU",
";",
"SUNumbers",
".",
"assign",
"(",
"SUnits",
".",
"size",
"(",
")",
",",
"0",
")",
";",
"for",
"(",
"const",
"SUnit",
"&",
"SU",
":",
"SUnits",
")",
"CalcNodeSethiUllmanNumber",
"(",
"&",
"SU",
",",
"SUNumbers",
")",
";",
"for",
"(",
"auto",
"SU",
":",
"BotRoots",
")",
"{",
"AvailQueue",
".",
"push_back",
"(",
"*",
"new",
"(",
"Alloc",
".",
"Allocate",
"(",
")",
")",
"Candidate",
"(",
"const_cast",
"<",
"SUnit",
"*",
">",
"(",
"SU",
")",
")",
")",
";",
"}",
"releasePredecessors",
"(",
"&",
"DAG",
".",
"ExitSU",
")",
";",
"std",
"::",
"vector",
"<",
"const",
"SUnit",
"*",
">",
"Schedule",
";",
"Schedule",
".",
"reserve",
"(",
"SUnits",
".",
"size",
"(",
")",
")",
";",
"while",
"(",
"true",
")",
"{",
"if",
"(",
"AvailQueue",
".",
"empty",
"(",
")",
"&&",
"!",
"PendingQueue",
".",
"empty",
"(",
")",
")",
"{",
"auto",
"EarliestSU",
"=",
"std",
"::",
"min_element",
"(",
"PendingQueue",
".",
"begin",
"(",
")",
",",
"PendingQueue",
".",
"end",
"(",
")",
",",
"[",
"=",
"]",
"(",
"const",
"Candidate",
"&",
"C1",
",",
"const",
"Candidate",
"&",
"C2",
")",
"{",
"return",
"C1",
".",
"SU",
"->",
"getHeight",
"(",
")",
"<",
"C2",
".",
"SU",
"->",
"getHeight",
"(",
")",
";",
"}",
")",
"->",
"SU",
";",
"advanceToCycle",
"(",
"std",
"::",
"max",
"(",
"CurCycle",
"+",
"1",
",",
"EarliestSU",
"->",
"getHeight",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"AvailQueue",
".",
"empty",
"(",
")",
")",
"break",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"\\n=== Picking candidate\\n\"",
"\"Ready queue:\"",
";",
"for",
"(",
"auto",
"&",
"C",
":",
"AvailQueue",
")",
"dbgs",
"(",
")",
"<<",
"' '",
"<<",
"C",
".",
"SU",
"->",
"NodeNum",
";",
"dbgs",
"(",
")",
"<<",
"'\\n'",
";",
")",
";",
"auto",
"C",
"=",
"pickCandidate",
"(",
")",
";",
"assert",
"(",
"C",
")",
";",
"AvailQueue",
".",
"remove",
"(",
"*",
"C",
")",
";",
"auto",
"SU",
"=",
"C",
"->",
"SU",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Selected \"",
";",
"SU",
"->",
"dump",
"(",
"&",
"DAG",
")",
")",
";",
"advanceToCycle",
"(",
"SU",
"->",
"getHeight",
"(",
")",
")",
";",
"releasePredecessors",
"(",
"SU",
")",
";",
"Schedule",
".",
"push_back",
"(",
"SU",
")",
";",
"SU",
"->",
"isScheduled",
"=",
"true",
";",
"}",
"assert",
"(",
"SUnits",
".",
"size",
"(",
")",
"==",
"Schedule",
".",
"size",
"(",
")",
")",
";",
"std",
"::",
"reverse",
"(",
"Schedule",
".",
"begin",
"(",
")",
",",
"Schedule",
".",
"end",
"(",
")",
")",
";",
"for",
"(",
"auto",
"&",
"SU",
":",
"SUnits",
")",
"SU",
"=",
"SUSavedCopy",
"[",
"SU",
".",
"NodeNum",
"]",
";",
"return",
"Schedule",
";",
"}",
"</s>"
] | [
"Schedule",
"-",
"This",
"is",
"called",
"back",
"from",
"ScheduleDAGInstrs",
":",
":Run",
"(",
")",
"when",
"it",
"'s",
"time",
"to",
"do",
"some",
"work",
"."
] | [
"AMDGPU",
"0",
"1",
"\"\\n=== Picking candidate\\n\"",
"\"Ready queue:\"",
"\"Selected \""
] | GCNILPSched5 | schedule | AMDGPU | GPU | LLVM | 26,019 | 440 | 1 | [] |
[
"<s>",
"bool",
"RISCVSubtarget",
"::",
"enableSubRegLiveness",
"(",
")",
"const",
"{",
"return",
"EnableSubRegLiveness",
";",
"}",
"</s>"
] | [
"Enable",
"tracking",
"of",
"subregister",
"liveness",
"in",
"register",
"allocator",
"."
] | [
"RISCV",
"RISCV"
] | RISCVSubtarget11 | enableSubRegLiveness | RISCV | CPU | LLVM | 26,020 | 12 | 1 | [] |
[
"<s>",
"SDValue",
"VETargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Should not custom lower this!\"",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"lowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"lowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"lowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"lowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"return",
"lowerGlobalTLSAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"lowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"lowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"lowerVASTART",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VAARG",
":",
"return",
"lowerVAARG",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"VE",
"VE",
"\"Should not custom lower this!\"",
"ISD::BlockAddress",
"ISD::ConstantPool",
"ISD::DYNAMIC_STACKALLOC",
"ISD::GlobalAddress",
"ISD::GlobalTLSAddress",
"ISD::LOAD",
"ISD::STORE",
"ISD::VASTART",
"ISD::VAARG"
] | VEISelLowering21 | LowerOperation | VE | CPU | LLVM | 26,021 | 149 | 1 | [] |
[
"<s>",
"int",
"AMDGPUInstrInfo",
"::",
"pseudoToMCOpcode",
"(",
"int",
"Opcode",
")",
"const",
"{",
"int",
"MCOp",
"=",
"AMDGPU",
"::",
"getMCOpcode",
"(",
"Opcode",
",",
"AMDGPUSubtargetToSISubtarget",
"(",
"ST",
".",
"getGeneration",
"(",
")",
")",
")",
";",
"if",
"(",
"MCOp",
"==",
"-",
"1",
")",
"return",
"Opcode",
";",
"if",
"(",
"MCOp",
"==",
"(",
"uint16_t",
")",
"-",
"1",
")",
"return",
"-",
"1",
";",
"return",
"MCOp",
";",
"}",
"</s>"
] | [
"Return",
"a",
"target-specific",
"opcode",
"if",
"Opcode",
"is",
"a",
"pseudo",
"instruction",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::getMCOpcode",
"SI",
"1",
"1",
"1"
] | AMDGPUInstrInfo | pseudoToMCOpcode | AMDGPU | GPU | LLVM | 26,022 | 57 | 1 | [] |
[
"<s>",
"static",
"int",
"loongarch_immediate_operand_p",
"(",
"int",
"code",
",",
"HOST_WIDE_INT",
"x",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"ASHIFT",
":",
"case",
"ASHIFTRT",
":",
"case",
"LSHIFTRT",
":",
"return",
"true",
";",
"case",
"ROTATE",
":",
"case",
"ROTATERT",
":",
"return",
"true",
";",
"case",
"AND",
":",
"case",
"IOR",
":",
"case",
"XOR",
":",
"return",
"IMM12_OPERAND_UNSIGNED",
"(",
"x",
")",
";",
"case",
"PLUS",
":",
"case",
"LT",
":",
"case",
"LTU",
":",
"return",
"IMM12_OPERAND",
"(",
"x",
")",
";",
"case",
"EQ",
":",
"case",
"NE",
":",
"case",
"GT",
":",
"case",
"GTU",
":",
"return",
"x",
"==",
"0",
";",
"case",
"GE",
":",
"case",
"GEU",
":",
"return",
"x",
"==",
"1",
";",
"case",
"LE",
":",
"return",
"IMM12_OPERAND",
"(",
"x",
"+",
"1",
")",
";",
"case",
"LEU",
":",
"return",
"IMM12_OPERAND",
"(",
"x",
"+",
"1",
")",
"&&",
"x",
"+",
"1",
"!=",
"0",
";",
"case",
"SIGN_EXTRACT",
":",
"case",
"ZERO_EXTRACT",
":",
"return",
"1",
";",
"default",
":",
"return",
"x",
"==",
"0",
";",
"}",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"there",
"is",
"a",
"instruction",
"that",
"implements",
"CODE",
"and",
"if",
"that",
"instruction",
"accepts",
"X",
"as",
"an",
"immediate",
"operand",
"."
] | [
"loongarch",
"0",
"1",
"1",
"1",
"1",
"0",
"1",
"0"
] | loongarch | loongarch_immediate_operand_p | loongarch | CPU | GCC | 26,023 | 141 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"switch",
"(",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction not supported on this GPU\"",
")",
";",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"unrecognized instruction mnemonic\"",
")",
";",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0ULL",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"{",
"if",
"(",
"isForcedVOP3",
"(",
")",
")",
"{",
"AMDGPUOperand",
"&",
"LastOp",
"=",
"(",
"(",
"AMDGPUOperand",
"&",
")",
"*",
"Operands",
"[",
"Operands",
".",
"size",
"(",
")",
"-",
"1",
"]",
")",
";",
"if",
"(",
"LastOp",
".",
"isRegKind",
"(",
")",
"||",
"(",
"LastOp",
".",
"isImm",
"(",
")",
"&&",
"LastOp",
".",
"getImmTy",
"(",
")",
"!=",
"AMDGPUOperand",
"::",
"ImmTyNone",
")",
")",
"{",
"SMLoc",
"S",
"=",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Operands",
".",
"push_back",
"(",
"AMDGPUOperand",
"::",
"CreateImm",
"(",
"0",
",",
"S",
",",
"AMDGPUOperand",
"::",
"ImmTyClamp",
")",
")",
";",
"Operands",
".",
"push_back",
"(",
"AMDGPUOperand",
"::",
"CreateImm",
"(",
"0",
",",
"S",
",",
"AMDGPUOperand",
"::",
"ImmTyOMod",
")",
")",
";",
"bool",
"Res",
"=",
"MatchAndEmitInstruction",
"(",
"IDLoc",
",",
"Opcode",
",",
"Operands",
",",
"Out",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
";",
"if",
"(",
"!",
"Res",
")",
"return",
"Res",
";",
"}",
"}",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"}",
"ErrorLoc",
"=",
"(",
"(",
"AMDGPUOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_PreferE32",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"internal error: instruction without _e64 suffix \"",
"\"should be encoded as e32\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Implement any new match types added!\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"AMDGPU",
"AMDGPU",
"\"instruction not supported on this GPU\"",
"\"unrecognized instruction mnemonic\"",
"0ULL",
"AMDGPU",
"AMDGPU",
"1",
"AMDGPU",
"AMDGPU",
"0",
"AMDGPU",
"AMDGPU",
"0",
"AMDGPU",
"\"too few operands for instruction\"",
"AMDGPU",
"\"invalid operand for instruction\"",
"\"internal error: instruction without _e64 suffix \"",
"\"should be encoded as e32\"",
"\"Implement any new match types added!\""
] | AMDGPUAsmParser | MatchAndEmitInstruction | AMDGPU | GPU | LLVM | 26,024 | 322 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"getExplicitSectionGlobal",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"SectionKind",
"Kind",
",",
"Mangler",
"&",
"Mang",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"const",
"override",
"{",
"return",
"DataSection",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"method",
"to",
"assign",
"a",
"section",
"to",
"globals",
"with",
"an",
"explicit",
"section",
"specfied",
"."
] | [
"WebAssembly"
] | WebAssemblyTargetObjectFile7 | getExplicitSectionGlobal | WebAssembly | Virtual ISA | LLVM | 26,025 | 28 | 1 | [] |
[
"<s>",
"BitVector",
"FISCRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"FISC",
"::",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"FISC",
"::",
"LR",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"FISC",
"FISC",
"FISC::SP",
"FISC::LR"
] | FISCRegisterInfo | getReservedRegs | FISC | CPU | LLVM | 26,026 | 42 | 1 | [] |
[
"<s>",
"static",
"void",
"nds32_asm_function_epilogue",
"(",
"FILE",
"*",
"file",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\t! END EPILOGUE\\n\"",
")",
";",
"}",
"</s>"
] | [
"The",
"content",
"produced",
"from",
"this",
"function",
"will",
"be",
"placed",
"after",
"epilogue",
"body",
"."
] | [
"nds32",
"\"\\t! END EPILOGUE\\n\""
] | nds32 | nds32_asm_function_epilogue | nds32 | CPU | GCC | 26,027 | 17 | 1 | [] |
[
"<s>",
"SDValue",
"SITargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"LowerBRCOND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"{",
"SDValue",
"Result",
"=",
"LowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"assert",
"(",
"(",
"!",
"Result",
".",
"getNode",
"(",
")",
"||",
"Result",
".",
"getNode",
"(",
")",
"->",
"getNumValues",
"(",
")",
"==",
"2",
")",
"&&",
"\"Load should return a value and a chain\"",
")",
";",
"return",
"Result",
";",
"}",
"case",
"ISD",
"::",
"FSIN",
":",
"case",
"ISD",
"::",
"FCOS",
":",
"return",
"LowerTrig",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"LowerSELECT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FDIV",
":",
"return",
"LowerFDIV",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ATOMIC_CMP_SWAP",
":",
"return",
"LowerATOMIC_CMP_SWAP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"LowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"return",
"LowerGlobalAddress",
"(",
"MFI",
",",
"Op",
",",
"DAG",
")",
";",
"}",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
":",
"return",
"LowerINTRINSIC_W_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_VOID",
":",
"return",
"LowerINTRINSIC_VOID",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ADDRSPACECAST",
":",
"return",
"lowerADDRSPACECAST",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INSERT_VECTOR_ELT",
":",
"return",
"lowerINSERT_VECTOR_ELT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
":",
"return",
"lowerEXTRACT_VECTOR_ELT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BUILD_VECTOR",
":",
"return",
"lowerBUILD_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_ROUND",
":",
"return",
"lowerFP_ROUND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"TRAP",
":",
"return",
"lowerTRAP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DEBUGTRAP",
":",
"return",
"lowerDEBUGTRAP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FABS",
":",
"case",
"ISD",
"::",
"FNEG",
":",
"case",
"ISD",
"::",
"FCANONICALIZE",
":",
"return",
"splitUnaryVectorOp",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SRL",
":",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"SUB",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"SMIN",
":",
"case",
"ISD",
"::",
"SMAX",
":",
"case",
"ISD",
"::",
"UMIN",
":",
"case",
"ISD",
"::",
"UMAX",
":",
"case",
"ISD",
"::",
"FMINNUM",
":",
"case",
"ISD",
"::",
"FMAXNUM",
":",
"case",
"ISD",
"::",
"FADD",
":",
"case",
"ISD",
"::",
"FMUL",
":",
"return",
"splitBinaryVectorOp",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"ISD::BRCOND",
"ISD::LOAD",
"2",
"\"Load should return a value and a chain\"",
"ISD::FSIN",
"ISD::FCOS",
"ISD::SELECT",
"ISD::FDIV",
"ISD::ATOMIC_CMP_SWAP",
"ISD::STORE",
"ISD::GlobalAddress",
"SI",
"SI",
"ISD::INTRINSIC_WO_CHAIN",
"SI",
"ISD::INTRINSIC_W_CHAIN",
"SI",
"ISD::INTRINSIC_VOID",
"SI",
"ISD::ADDRSPACECAST",
"ISD::INSERT_VECTOR_ELT",
"ISD::EXTRACT_VECTOR_ELT",
"ISD::BUILD_VECTOR",
"ISD::FP_ROUND",
"ISD::TRAP",
"ISD::DEBUGTRAP",
"ISD::FABS",
"ISD::FNEG",
"ISD::FCANONICALIZE",
"ISD::SHL",
"ISD::SRA",
"ISD::SRL",
"ISD::ADD",
"ISD::SUB",
"ISD::MUL",
"ISD::SMIN",
"ISD::SMAX",
"ISD::UMIN",
"ISD::UMAX",
"ISD::FMINNUM",
"ISD::FMAXNUM",
"ISD::FADD",
"ISD::FMUL"
] | SIISelLowering | LowerOperation | AMDGPU | GPU | LLVM | 26,028 | 442 | 1 | [] |
[
"<s>",
"const",
"MCS51RegisterInfo",
"&",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"MCS51",
"MCS51"
] | MCS51InstrInfo | getRegisterInfo | MCS51 | MPU | LLVM | 26,029 | 12 | 1 | [] |
[
"<s>",
"unsigned",
"int",
"compute_logical_op_length",
"(",
"machine_mode",
"mode",
",",
"rtx",
"*",
"operands",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"operands",
"[",
"3",
"]",
")",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"intval",
"=",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"(",
"(",
"GET_CODE",
"(",
"operands",
"[",
"2",
"]",
")",
"==",
"CONST_INT",
")",
"&&",
"register_operand",
"(",
"operands",
"[",
"1",
"]",
",",
"VOIDmode",
")",
"?",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
":",
"0x55555555",
")",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"det",
"=",
"(",
"code",
"!=",
"AND",
")",
"?",
"intval",
":",
"~",
"intval",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"b0",
"=",
"(",
"det",
">>",
"0",
")",
"&",
"0xff",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"b1",
"=",
"(",
"det",
">>",
"8",
")",
"&",
"0xff",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"w0",
"=",
"(",
"det",
">>",
"0",
")",
"&",
"0xffff",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"w1",
"=",
"(",
"det",
">>",
"16",
")",
"&",
"0xffff",
";",
"int",
"lower_half_easy_p",
"=",
"0",
";",
"int",
"upper_half_easy_p",
"=",
"0",
";",
"unsigned",
"int",
"length",
"=",
"0",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_HImode",
":",
"if",
"(",
"b0",
"!=",
"0",
"&&",
"b1",
"!=",
"0",
")",
"{",
"length",
"=",
"h8300_length_from_table",
"(",
"operands",
"[",
"1",
"]",
",",
"operands",
"[",
"2",
"]",
",",
"&",
"logicw_length_table",
")",
";",
"}",
"else",
"{",
"if",
"(",
"b0",
"!=",
"0",
")",
"length",
"+=",
"2",
";",
"if",
"(",
"b1",
"!=",
"0",
")",
"length",
"+=",
"2",
";",
"}",
"break",
";",
"case",
"E_SImode",
":",
"lower_half_easy_p",
"=",
"(",
"b0",
"==",
"0",
"||",
"b1",
"==",
"0",
"||",
"(",
"code",
"!=",
"IOR",
"&&",
"w0",
"==",
"0xffff",
")",
")",
";",
"upper_half_easy_p",
"=",
"(",
"(",
"code",
"!=",
"IOR",
"&&",
"w1",
"==",
"0xffff",
")",
"||",
"(",
"code",
"==",
"AND",
"&&",
"w1",
"==",
"0xff00",
")",
")",
";",
"if",
"(",
"w0",
"!=",
"0",
"&&",
"w1",
"!=",
"0",
"&&",
"!",
"(",
"lower_half_easy_p",
"&&",
"upper_half_easy_p",
")",
"&&",
"!",
"(",
"code",
"==",
"IOR",
"&&",
"w1",
"==",
"0xffff",
"&&",
"(",
"w0",
"&",
"0x8000",
")",
"!=",
"0",
"&&",
"lower_half_easy_p",
")",
")",
"{",
"length",
"=",
"h8300_length_from_table",
"(",
"operands",
"[",
"1",
"]",
",",
"operands",
"[",
"2",
"]",
",",
"&",
"logicl_length_table",
")",
";",
"}",
"else",
"{",
"if",
"(",
"w0",
"==",
"0xffff",
"&&",
"(",
"code",
"!=",
"IOR",
")",
")",
"{",
"length",
"+=",
"2",
";",
"}",
"else",
"if",
"(",
"(",
"b0",
"!=",
"0",
")",
"&&",
"(",
"b1",
"!=",
"0",
")",
")",
"{",
"length",
"+=",
"4",
";",
"}",
"else",
"{",
"if",
"(",
"b0",
"!=",
"0",
")",
"length",
"+=",
"2",
";",
"if",
"(",
"b1",
"!=",
"0",
")",
"length",
"+=",
"2",
";",
"}",
"if",
"(",
"w1",
"==",
"0xffff",
"&&",
"(",
"code",
"!=",
"IOR",
")",
")",
"{",
"length",
"+=",
"2",
";",
"}",
"else",
"if",
"(",
"code",
"==",
"IOR",
"&&",
"w1",
"==",
"0xffff",
"&&",
"(",
"w0",
"&",
"0x8000",
")",
"!=",
"0",
")",
"{",
"length",
"+=",
"2",
";",
"}",
"else",
"if",
"(",
"code",
"==",
"AND",
"&&",
"w1",
"==",
"0xff00",
")",
"{",
"length",
"+=",
"2",
";",
"}",
"else",
"{",
"if",
"(",
"w1",
"!=",
"0",
")",
"length",
"+=",
"4",
";",
"}",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"length",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"length",
"of",
"a",
"logical",
"insn",
"."
] | [
"h8300",
"3",
"2",
"1",
"2",
"0x55555555",
"0",
"0xff",
"8",
"0xff",
"0",
"0xffff",
"16",
"0xffff",
"0",
"0",
"0",
"0",
"0",
"1",
"2",
"0",
"2",
"0",
"2",
"0",
"0",
"0xffff",
"0xffff",
"0xff00",
"0",
"0",
"0xffff",
"0x8000",
"0",
"1",
"2",
"0xffff",
"2",
"0",
"0",
"4",
"0",
"2",
"0",
"2",
"0xffff",
"2",
"0xffff",
"0x8000",
"0",
"2",
"0xff00",
"2",
"0",
"4"
] | h83001 | compute_logical_op_length | h8300 | MPU | GCC | 26,030 | 472 | 1 | [] |
[
"<s>",
"static",
"rtx",
"sparc_function_value_1",
"(",
"const_tree",
"type",
",",
"machine_mode",
"mode",
",",
"bool",
"outgoing",
")",
"{",
"int",
"regbase",
"=",
"(",
"outgoing",
"?",
"SPARC_INCOMING_INT_ARG_FIRST",
":",
"SPARC_OUTGOING_INT_ARG_FIRST",
")",
";",
"enum",
"mode_class",
"mclass",
"=",
"GET_MODE_CLASS",
"(",
"mode",
")",
";",
"int",
"regno",
";",
"if",
"(",
"type",
"&&",
"TREE_CODE",
"(",
"type",
")",
"==",
"VECTOR_TYPE",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"(",
"TARGET_ARCH32",
"&&",
"size",
"<=",
"8",
")",
"||",
"(",
"TARGET_ARCH64",
"&&",
"size",
"<=",
"32",
")",
")",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"return",
"function_arg_vector_value",
"(",
"size",
",",
"SPARC_FP_ARG_FIRST",
")",
";",
"mclass",
"=",
"MODE_FLOAT",
";",
"}",
"if",
"(",
"TARGET_ARCH64",
"&&",
"type",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"RECORD_TYPE",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"size",
"<=",
"32",
")",
";",
"return",
"function_arg_record_value",
"(",
"type",
",",
"mode",
",",
"0",
",",
"1",
",",
"regbase",
")",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"UNION_TYPE",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"size",
"<=",
"32",
")",
";",
"return",
"function_arg_union_value",
"(",
"size",
",",
"mode",
",",
"0",
",",
"regbase",
")",
";",
"}",
"else",
"if",
"(",
"mclass",
"==",
"MODE_FLOAT",
"||",
"mclass",
"==",
"MODE_COMPLEX_FLOAT",
")",
";",
"else",
"if",
"(",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"size",
"<=",
"32",
")",
";",
"mode",
"=",
"mode_for_size",
"(",
"size",
"*",
"BITS_PER_UNIT",
",",
"MODE_INT",
",",
"0",
")",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"return",
"function_arg_union_value",
"(",
"size",
",",
"mode",
",",
"0",
",",
"regbase",
")",
";",
"else",
"mclass",
"=",
"MODE_INT",
";",
"}",
"else",
"if",
"(",
"mclass",
"==",
"MODE_INT",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<",
"UNITS_PER_WORD",
")",
"mode",
"=",
"word_mode",
";",
"}",
"else",
"if",
"(",
"TARGET_ARCH32",
"&&",
"mclass",
"==",
"MODE_INT",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<",
"UNITS_PER_WORD",
")",
"mode",
"=",
"word_mode",
";",
"if",
"(",
"(",
"mclass",
"==",
"MODE_FLOAT",
"||",
"mclass",
"==",
"MODE_COMPLEX_FLOAT",
")",
"&&",
"TARGET_FPU",
")",
"regno",
"=",
"SPARC_FP_ARG_FIRST",
";",
"else",
"regno",
"=",
"regbase",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"}",
"</s>"
] | [
"Handle",
"TARGET_FUNCTION_VALUE",
",",
"and",
"TARGET_LIBCALL_VALUE",
"target",
"hook",
".",
"For",
"v9",
",",
"function",
"return",
"values",
"are",
"subject",
"to",
"the",
"same",
"rules",
"as",
"arguments",
",",
"except",
"that",
"up",
"to",
"32",
"bytes",
"may",
"be",
"returned",
"in",
"registers",
"."
] | [
"sparc",
"8",
"32",
"32",
"0",
"1",
"32",
"0",
"32",
"0",
"0"
] | sparc4 | sparc_function_value_1 | sparc | CPU | GCC | 26,031 | 325 | 1 | [] |
[
"<s>",
"const",
"uint16_t",
"*",
"X86RegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"bool",
"callsEHReturn",
"=",
"false",
";",
"bool",
"ghcCall",
"=",
"false",
";",
"bool",
"oclBiCall",
"=",
"false",
";",
"bool",
"hipeCall",
"=",
"false",
";",
"bool",
"HasAVX",
"=",
"TM",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
".",
"hasAVX",
"(",
")",
";",
"if",
"(",
"MF",
")",
"{",
"callsEHReturn",
"=",
"MF",
"->",
"getMMI",
"(",
")",
".",
"callsEHReturn",
"(",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
"->",
"getFunction",
"(",
")",
";",
"ghcCall",
"=",
"(",
"F",
"?",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"GHC",
":",
"false",
")",
";",
"oclBiCall",
"=",
"(",
"F",
"?",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"Intel_OCL_BI",
":",
"false",
")",
";",
"hipeCall",
"=",
"(",
"F",
"?",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"HiPE",
":",
"false",
")",
";",
"}",
"if",
"(",
"ghcCall",
"||",
"hipeCall",
")",
"return",
"CSR_NoRegs_SaveList",
";",
"if",
"(",
"oclBiCall",
")",
"{",
"if",
"(",
"HasAVX",
"&&",
"IsWin64",
")",
"return",
"CSR_Win64_Intel_OCL_BI_AVX_SaveList",
";",
"if",
"(",
"HasAVX",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_AVX_SaveList",
";",
"if",
"(",
"!",
"HasAVX",
"&&",
"!",
"IsWin64",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_SaveList",
";",
"}",
"if",
"(",
"Is64Bit",
")",
"{",
"if",
"(",
"IsWin64",
")",
"return",
"CSR_Win64_SaveList",
";",
"if",
"(",
"callsEHReturn",
")",
"return",
"CSR_64EHRet_SaveList",
";",
"return",
"CSR_64_SaveList",
";",
"}",
"if",
"(",
"callsEHReturn",
")",
"return",
"CSR_32EHRet_SaveList",
";",
"return",
"CSR_32_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"X86",
"X86",
"X86"
] | X86RegisterInfo24 | getCalleeSavedRegs | X86 | CPU | LLVM | 26,032 | 213 | 1 | [] |
[
"<s>",
"iterator",
"end",
"(",
")",
"const",
"{",
"return",
"Masks",
".",
"end",
"(",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"const_iterator",
"to",
"the",
"end",
"of",
"the",
"symbol",
"table",
"."
] | [
"Hexagon"
] | RDFGraph11 | end | Hexagon | DSP | LLVM | 26,033 | 14 | 1 | [] |
[
"<s>",
"rtx",
"h8300_return_addr_rtx",
"(",
"int",
"count",
",",
"rtx",
"frame",
")",
"{",
"rtx",
"ret",
";",
"if",
"(",
"count",
"==",
"0",
")",
"ret",
"=",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"RETURN_ADDRESS_POINTER_REGNUM",
")",
")",
";",
"else",
"if",
"(",
"flag_omit_frame_pointer",
")",
"return",
"(",
"rtx",
")",
"0",
";",
"else",
"ret",
"=",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"memory_address",
"(",
"Pmode",
",",
"plus_constant",
"(",
"frame",
",",
"UNITS_PER_WORD",
")",
")",
")",
";",
"set_mem_alias_set",
"(",
"ret",
",",
"get_frame_alias_set",
"(",
")",
")",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"RETURN_ADDR_RTX",
"."
] | [
"h8300",
"0",
"0"
] | h83003 | h8300_return_addr_rtx | h8300 | MPU | GCC | 26,034 | 77 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips_expand_vpc_loongson_even_odd",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"unsigned",
"i",
",",
"odd",
",",
"nelt",
"=",
"d",
"->",
"nelt",
";",
"rtx",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
";",
"if",
"(",
"!",
"(",
"TARGET_HARD_FLOAT",
"&&",
"TARGET_LOONGSON_VECTORS",
")",
")",
"return",
"false",
";",
"if",
"(",
"nelt",
"<",
"4",
")",
"return",
"false",
";",
"odd",
"=",
"d",
"->",
"perm",
"[",
"0",
"]",
";",
"if",
"(",
"odd",
">",
"1",
")",
"return",
"false",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"if",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"!=",
"i",
"*",
"2",
"+",
"odd",
")",
"return",
"false",
";",
"if",
"(",
"d",
"->",
"testing_p",
")",
"return",
"true",
";",
"t0",
"=",
"gen_reg_rtx",
"(",
"d",
"->",
"vmode",
")",
";",
"t1",
"=",
"gen_reg_rtx",
"(",
"d",
"->",
"vmode",
")",
";",
"switch",
"(",
"d",
"->",
"vmode",
")",
"{",
"case",
"V4HImode",
":",
"emit_insn",
"(",
"gen_loongson_punpckhhw",
"(",
"t0",
",",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
")",
")",
";",
"emit_insn",
"(",
"gen_loongson_punpcklhw",
"(",
"t1",
",",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
")",
")",
";",
"if",
"(",
"odd",
")",
"emit_insn",
"(",
"gen_loongson_punpckhhw",
"(",
"d",
"->",
"target",
",",
"t1",
",",
"t0",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_loongson_punpcklhw",
"(",
"d",
"->",
"target",
",",
"t1",
",",
"t0",
")",
")",
";",
"break",
";",
"case",
"V8QImode",
":",
"t2",
"=",
"gen_reg_rtx",
"(",
"d",
"->",
"vmode",
")",
";",
"t3",
"=",
"gen_reg_rtx",
"(",
"d",
"->",
"vmode",
")",
";",
"emit_insn",
"(",
"gen_loongson_punpckhbh",
"(",
"t0",
",",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
")",
")",
";",
"emit_insn",
"(",
"gen_loongson_punpcklbh",
"(",
"t1",
",",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
")",
")",
";",
"emit_insn",
"(",
"gen_loongson_punpckhbh",
"(",
"t2",
",",
"t1",
",",
"t0",
")",
")",
";",
"emit_insn",
"(",
"gen_loongson_punpcklbh",
"(",
"t3",
",",
"t1",
",",
"t0",
")",
")",
";",
"if",
"(",
"odd",
")",
"emit_insn",
"(",
"gen_loongson_punpckhbh",
"(",
"d",
"->",
"target",
",",
"t3",
",",
"t2",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_loongson_punpcklbh",
"(",
"d",
"->",
"target",
",",
"t3",
",",
"t2",
")",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Recognize",
"patterns",
"for",
"even-odd",
"extraction",
"."
] | [
"mips",
"4",
"0",
"1",
"1",
"2"
] | mips4 | mips_expand_vpc_loongson_even_odd | mips | CPU | GCC | 26,035 | 327 | 1 | [] |
[
"<s>",
"static",
"void",
"aarch64_print_operand_address",
"(",
"FILE",
"*",
"f",
",",
"machine_mode",
"mode",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"!",
"aarch64_print_address_internal",
"(",
"f",
",",
"mode",
",",
"x",
",",
"ADDR_QUERY_ANY",
")",
")",
"output_addr_const",
"(",
"f",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"Print",
"address",
"'",
"x",
"'",
"of",
"a",
"memory",
"access",
"with",
"mode",
"'mode",
"'",
"."
] | [
"aarch64"
] | aarch64 | aarch64_print_operand_address | aarch64 | CPU | GCC | 26,036 | 37 | 1 | [] |
[
"<s>",
"WebAssemblyTargetMachine",
"::",
"WebAssemblyTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
".",
"isArch64Bit",
"(",
")",
"?",
"\"e-m:e-p:64:64-i64:64-n32:64-S128\"",
":",
"\"e-m:e-p:32:32-i64:64-n32:64-S128\"",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"TLOF",
"(",
"make_unique",
"<",
"WebAssemblyTargetObjectFile",
">",
"(",
")",
")",
"{",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"WebAssembly",
"architecture",
"model",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"\"e-m:e-p:64:64-i64:64-n32:64-S128\"",
"\"e-m:e-p:32:32-i64:64-n32:64-S128\"",
"WebAssembly"
] | WebAssemblyTargetMachine4 | WebAssemblyTargetMachine | WebAssembly | Virtual ISA | LLVM | 26,037 | 93 | 1 | [] |
[
"<s>",
"unsigned",
"getFlatAddressSpace",
"(",
")",
"const",
"{",
"if",
"(",
"IsGraphicsShader",
")",
"return",
"-",
"1",
";",
"return",
"ST",
"->",
"hasFlatAddressSpace",
"(",
")",
"?",
"AMDGPUAS",
"::",
"FLAT_ADDRESS",
":",
"AMDGPUAS",
"::",
"UNKNOWN_ADDRESS_SPACE",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"address",
"space",
"ID",
"for",
"a",
"target",
"'s",
"'flat",
"'",
"address",
"space",
"."
] | [
"AMDGPU",
"1",
"AMDGPU",
"AMDGPU"
] | AMDGPUTargetTransformInfo | getFlatAddressSpace | AMDGPU | GPU | LLVM | 26,038 | 30 | 1 | [] |
[
"<s>",
"unsigned",
"getStackAlignment",
"(",
")",
"const",
"{",
"return",
"4",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"minimum",
"alignment",
"known",
"to",
"hold",
"of",
"the",
"stack",
"frame",
"on",
"entry",
"to",
"the",
"function",
"and",
"which",
"must",
"be",
"maintained",
"by",
"every",
"function",
"for",
"this",
"subtarget",
"."
] | [
"AMDGPU",
"4"
] | AMDGPUSubtarget | getStackAlignment | AMDGPU | GPU | LLVM | 26,039 | 10 | 1 | [] |
[
"<s>",
"static",
"void",
"riscv_file_start",
"(",
"void",
")",
"{",
"default_file_start",
"(",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.option %spic\\n\"",
",",
"(",
"flag_pic",
"?",
"\"\"",
":",
"\"no\"",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_FILE_START",
"."
] | [
"riscv",
"\"\\t.option %spic\\n\"",
"\"\"",
"\"no\""
] | riscv2 | riscv_file_start | riscv | CPU | GCC | 26,040 | 27 | 1 | [] |
[
"<s>",
"int",
"easy_df_const",
"(",
"rtx",
"op",
")",
"{",
"REAL_VALUE_TYPE",
"r",
";",
"long",
"l",
"[",
"2",
"]",
";",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"r",
",",
"op",
")",
";",
"REAL_VALUE_TO_TARGET_DOUBLE",
"(",
"r",
",",
"l",
")",
";",
"if",
"(",
"l",
"[",
"0",
"]",
"==",
"0",
"&&",
"l",
"[",
"1",
"]",
"==",
"0",
")",
"return",
"1",
";",
"if",
"(",
"(",
"l",
"[",
"0",
"]",
"&",
"0xffff",
")",
"==",
"0",
"&&",
"l",
"[",
"1",
"]",
"==",
"0",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"1",
"if",
"OP",
"is",
"a",
"DFmode",
"const",
"we",
"want",
"to",
"handle",
"inline",
".",
"This",
"must",
"match",
"the",
"code",
"in",
"the",
"movdf",
"pattern",
".",
"It",
"is",
"used",
"by",
"the",
"'",
"H",
"'",
"CONST_DOUBLE_OK_FOR_LETTER",
"."
] | [
"m32r",
"2",
"0",
"0",
"1",
"0",
"1",
"0",
"0xffff",
"0",
"1",
"0",
"1",
"0"
] | m32r3 | easy_df_const | m32r | MPU | GCC | 26,041 | 76 | 1 | [] |
[
"<s>",
"TargetLoweringBase",
"::",
"LegalizeTypeAction",
"SITargetLowering",
"::",
"getPreferredVectorAction",
"(",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
"!=",
"1",
"&&",
"VT",
".",
"getScalarType",
"(",
")",
".",
"bitsLE",
"(",
"MVT",
"::",
"i16",
")",
")",
"return",
"TypeSplitVector",
";",
"return",
"TargetLoweringBase",
"::",
"getPreferredVectorAction",
"(",
"VT",
")",
";",
"}",
"</s>"
] | [
"Customize",
"the",
"preferred",
"legalization",
"strategy",
"for",
"certain",
"types",
"."
] | [
"AMDGPU",
"SI",
"1",
"MVT::i16"
] | SIISelLowering (2)3 | getPreferredVectorAction | AMDGPU | GPU | LLVM | 26,042 | 47 | 1 | [] |
[
"<s>",
"SMLoc",
"getStartLoc",
"(",
")",
"const",
"override",
"{",
"return",
"StartLoc",
";",
"}",
"</s>"
] | [
"getStartLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"first",
"token",
"of",
"this",
"operand",
"."
] | [
"SystemZ"
] | SystemZAsmParser (2) | getStartLoc | SystemZ | CPU | LLVM | 26,043 | 11 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_vector_duplicate_value",
"(",
"machine_mode",
"mode",
",",
"rtx",
"target",
",",
"rtx",
"val",
")",
"{",
"bool",
"ok",
";",
"rtx_insn",
"*",
"insn",
";",
"rtx",
"dup",
";",
"recog_data_d",
"recog_data_save",
"=",
"recog_data",
";",
"dup",
"=",
"gen_vec_duplicate",
"(",
"mode",
",",
"val",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"dup",
")",
")",
";",
"if",
"(",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"{",
"rtx_insn",
"*",
"seq",
";",
"machine_mode",
"innermode",
"=",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"rtx",
"reg",
";",
"start_sequence",
"(",
")",
";",
"reg",
"=",
"force_reg",
"(",
"innermode",
",",
"val",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"reg",
")",
"!=",
"innermode",
")",
"reg",
"=",
"gen_lowpart",
"(",
"innermode",
",",
"reg",
")",
";",
"SET_SRC",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"=",
"gen_vec_duplicate",
"(",
"mode",
",",
"reg",
")",
";",
"seq",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"if",
"(",
"seq",
")",
"emit_insn_before",
"(",
"seq",
",",
"insn",
")",
";",
"ok",
"=",
"recog_memoized",
"(",
"insn",
")",
">=",
"0",
";",
"gcc_assert",
"(",
"ok",
")",
";",
"}",
"recog_data",
"=",
"recog_data_save",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"ix86_expand_vector_init_duplicate",
".",
"Tries",
"to",
"fill",
"target",
"with",
"val",
"via",
"vec_duplicate",
"."
] | [
"i386",
"0",
"0"
] | i386-expand1 | ix86_vector_duplicate_value | i386 | CPU | GCC | 26,044 | 165 | 1 | [] |
[
"<s>",
"enum",
"cris_pic_symbol_type",
"cris_pic_symbol_type_of",
"(",
"rtx",
"x",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"SYMBOL_REF",
":",
"return",
"SYMBOL_REF_LOCAL_P",
"(",
"x",
")",
"?",
"cris_gotrel_symbol",
":",
"cris_got_symbol",
";",
"case",
"LABEL_REF",
":",
"return",
"cris_gotrel_symbol",
";",
"case",
"CONST",
":",
"return",
"cris_pic_symbol_type_of",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"case",
"PLUS",
":",
"case",
"MINUS",
":",
"{",
"enum",
"cris_pic_symbol_type",
"t1",
"=",
"cris_pic_symbol_type_of",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"enum",
"cris_pic_symbol_type",
"t2",
"=",
"cris_pic_symbol_type_of",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
";",
"gcc_assert",
"(",
"t1",
"==",
"cris_no_symbol",
"||",
"t2",
"==",
"cris_no_symbol",
")",
";",
"if",
"(",
"t1",
"==",
"cris_got_symbol",
"||",
"t1",
"==",
"cris_got_symbol",
")",
"return",
"cris_got_symbol_needing_fixup",
";",
"return",
"t1",
"!=",
"cris_no_symbol",
"?",
"t1",
":",
"t2",
";",
"}",
"case",
"CONST_INT",
":",
"case",
"CONST_DOUBLE",
":",
"return",
"cris_no_symbol",
";",
"case",
"UNSPEC",
":",
"return",
"cris_invalid_pic_symbol",
";",
"default",
":",
"fatal_insn",
"(",
"\"unrecognized supposed constant\"",
",",
"x",
")",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"to",
"find",
"the",
"right",
"PIC-type",
"symbol",
"to",
"generate",
",",
"given",
"the",
"original",
"(",
"non-PIC",
")",
"representation",
"."
] | [
"cris",
"0",
"0",
"1",
"\"unrecognized supposed constant\""
] | cris3 | cris_pic_symbol_type_of | cris | MPU | GCC | 26,045 | 148 | 1 | [] |
[
"<s>",
"static",
"type_suffix_index",
"long_type_suffix",
"(",
"function_resolver",
"&",
"r",
",",
"type_suffix_index",
"type",
")",
"{",
"unsigned",
"int",
"element_bits",
"=",
"type_suffixes",
"[",
"type",
"]",
".",
"element_bits",
";",
"if",
"(",
"type_suffixes",
"[",
"type",
"]",
".",
"integer_p",
"&&",
"element_bits",
"<",
"64",
")",
"return",
"find_type_suffix",
"(",
"type_suffixes",
"[",
"type",
"]",
".",
"tclass",
",",
"element_bits",
"*",
"2",
")",
";",
"r",
".",
"report_no_such_form",
"(",
"type",
")",
";",
"return",
"NUM_TYPE_SUFFIXES",
";",
"}",
"</s>"
] | [
"TYPE",
"is",
"the",
"largest",
"type",
"suffix",
"associated",
"with",
"the",
"arguments",
"of",
"R",
",",
"but",
"the",
"result",
"is",
"twice",
"as",
"wide",
".",
"Return",
"the",
"associated",
"type",
"suffix",
"if",
"it",
"exists",
",",
"otherwise",
"report",
"an",
"appropriate",
"error",
"and",
"return",
"NUM_TYPE_SUFFIXES",
"."
] | [
"aarch64",
"64",
"2"
] | aarch64-sve-builtins-shapes | long_type_suffix | aarch64 | CPU | GCC | 26,046 | 62 | 1 | [] |
[
"<s>",
"static",
"tree",
"gcn_goacc_get_worker_red_decl",
"(",
"tree",
"type",
",",
"unsigned",
"offset",
")",
"{",
"machine_function",
"*",
"machfun",
"=",
"cfun",
"->",
"machine",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"REFERENCE_TYPE",
")",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"tree",
"var_type",
"=",
"build_qualified_type",
"(",
"type",
",",
"(",
"TYPE_QUALS",
"(",
"type",
")",
"|",
"ENCODE_QUAL_ADDR_SPACE",
"(",
"ADDR_SPACE_LDS",
")",
")",
")",
";",
"gcc_assert",
"(",
"offset",
"<",
"(",
"machfun",
"->",
"reduction_limit",
"-",
"machfun",
"->",
"reduction_base",
")",
")",
";",
"tree",
"ptr_type",
"=",
"build_pointer_type",
"(",
"var_type",
")",
";",
"tree",
"addr",
"=",
"build_int_cst",
"(",
"ptr_type",
",",
"machfun",
"->",
"reduction_base",
"+",
"offset",
")",
";",
"return",
"build_simple_mem_ref",
"(",
"addr",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"temporary",
"variable",
"decl",
"to",
"use",
"for",
"an",
"OpenACC",
"worker",
"reduction",
"."
] | [
"gcn"
] | gcn-tree | gcn_goacc_get_worker_red_decl | gcn | GPU | GCC | 26,047 | 99 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmPrinter",
"::",
"doFinalization",
"(",
"Module",
"&",
"M",
")",
"{",
"for",
"(",
"Module",
"::",
"const_global_iterator",
"I",
"=",
"M",
".",
"global_begin",
"(",
")",
",",
"E",
"=",
"M",
".",
"global_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"printModuleLevelGV",
"(",
"I",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetDarwin",
"(",
")",
")",
"{",
"SwitchToDataSection",
"(",
"\"\"",
")",
";",
"for",
"(",
"StringSet",
"<",
">",
"::",
"iterator",
"i",
"=",
"FnStubs",
".",
"begin",
"(",
")",
",",
"e",
"=",
"FnStubs",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"SwitchToTextSection",
"(",
"\".section __TEXT,__picsymbolstub4,symbol_stubs,\"",
"\"none,16\"",
",",
"0",
")",
";",
"else",
"SwitchToTextSection",
"(",
"\".section __TEXT,__symbol_stub4,symbol_stubs,\"",
"\"none,12\"",
",",
"0",
")",
";",
"EmitAlignment",
"(",
"2",
")",
";",
"O",
"<<",
"\"\\t.code\\t32\\n\"",
";",
"const",
"char",
"*",
"p",
"=",
"i",
"->",
"getKeyData",
"(",
")",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$stub\"",
")",
";",
"O",
"<<",
"\":\\n\"",
";",
"O",
"<<",
"\"\\t.indirect_symbol \"",
"<<",
"p",
"<<",
"\"\\n\"",
";",
"O",
"<<",
"\"\\tldr ip, \"",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$slp\"",
")",
";",
"O",
"<<",
"\"\\n\"",
";",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"{",
"printSuffixedName",
"(",
"p",
",",
"\"$scv\"",
")",
";",
"O",
"<<",
"\":\\n\"",
";",
"O",
"<<",
"\"\\tadd ip, pc, ip\\n\"",
";",
"}",
"O",
"<<",
"\"\\tldr pc, [ip, #0]\\n\"",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$slp\"",
")",
";",
"O",
"<<",
"\":\\n\"",
";",
"O",
"<<",
"\"\\t.long\\t\"",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$lazy_ptr\"",
")",
";",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"{",
"O",
"<<",
"\"-(\"",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$scv\"",
")",
";",
"O",
"<<",
"\"+8)\\n\"",
";",
"}",
"else",
"O",
"<<",
"\"\\n\"",
";",
"SwitchToDataSection",
"(",
"\".lazy_symbol_pointer\"",
",",
"0",
")",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$lazy_ptr\"",
")",
";",
"O",
"<<",
"\":\\n\"",
";",
"O",
"<<",
"\"\\t.indirect_symbol \"",
"<<",
"p",
"<<",
"\"\\n\"",
";",
"O",
"<<",
"\"\\t.long\\tdyld_stub_binding_helper\\n\"",
";",
"}",
"O",
"<<",
"\"\\n\"",
";",
"if",
"(",
"!",
"GVNonLazyPtrs",
".",
"empty",
"(",
")",
")",
"{",
"SwitchToDataSection",
"(",
"\"\\t.non_lazy_symbol_pointer\"",
",",
"0",
")",
";",
"for",
"(",
"StringSet",
"<",
">",
"::",
"iterator",
"i",
"=",
"GVNonLazyPtrs",
".",
"begin",
"(",
")",
",",
"e",
"=",
"GVNonLazyPtrs",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"char",
"*",
"p",
"=",
"i",
"->",
"getKeyData",
"(",
")",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$non_lazy_ptr\"",
")",
";",
"O",
"<<",
"\":\\n\"",
";",
"O",
"<<",
"\"\\t.indirect_symbol \"",
"<<",
"p",
"<<",
"\"\\n\"",
";",
"O",
"<<",
"\"\\t.long\\t0\\n\"",
";",
"}",
"}",
"if",
"(",
"!",
"HiddenGVNonLazyPtrs",
".",
"empty",
"(",
")",
")",
"{",
"SwitchToSection",
"(",
"TAI",
"->",
"getDataSection",
"(",
")",
")",
";",
"for",
"(",
"StringSet",
"<",
">",
"::",
"iterator",
"i",
"=",
"HiddenGVNonLazyPtrs",
".",
"begin",
"(",
")",
",",
"e",
"=",
"HiddenGVNonLazyPtrs",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"char",
"*",
"p",
"=",
"i",
"->",
"getKeyData",
"(",
")",
";",
"EmitAlignment",
"(",
"2",
")",
";",
"printSuffixedName",
"(",
"p",
",",
"\"$non_lazy_ptr\"",
")",
";",
"O",
"<<",
"\":\\n\"",
";",
"O",
"<<",
"\"\\t.long \"",
"<<",
"p",
"<<",
"\"\\n\"",
";",
"}",
"}",
"DW",
"->",
"EndModule",
"(",
")",
";",
"O",
"<<",
"\"\\t.subsections_via_symbols\\n\"",
";",
"}",
"else",
"{",
"DW",
"->",
"EndModule",
"(",
")",
";",
"}",
"return",
"AsmPrinter",
"::",
"doFinalization",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"doFinalization",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"any",
"necessary",
"clean",
"up",
"after",
"all",
"passes",
"have",
"run",
"."
] | [
"ARM",
"ARM",
"\"\"",
"\".section __TEXT,__picsymbolstub4,symbol_stubs,\"",
"\"none,16\"",
"0",
"\".section __TEXT,__symbol_stub4,symbol_stubs,\"",
"\"none,12\"",
"0",
"2",
"\"\\t.code\\t32\\n\"",
"\"$stub\"",
"\":\\n\"",
"\"\\t.indirect_symbol \"",
"\"\\n\"",
"\"\\tldr ip, \"",
"\"$slp\"",
"\"\\n\"",
"\"$scv\"",
"\":\\n\"",
"\"\\tadd ip, pc, ip\\n\"",
"\"\\tldr pc, [ip, #0]\\n\"",
"\"$slp\"",
"\":\\n\"",
"\"\\t.long\\t\"",
"\"$lazy_ptr\"",
"\"-(\"",
"\"$scv\"",
"\"+8)\\n\"",
"\"\\n\"",
"\".lazy_symbol_pointer\"",
"0",
"\"$lazy_ptr\"",
"\":\\n\"",
"\"\\t.indirect_symbol \"",
"\"\\n\"",
"\"\\t.long\\tdyld_stub_binding_helper\\n\"",
"\"\\n\"",
"\"\\t.non_lazy_symbol_pointer\"",
"0",
"\"$non_lazy_ptr\"",
"\":\\n\"",
"\"\\t.indirect_symbol \"",
"\"\\n\"",
"\"\\t.long\\t0\\n\"",
"2",
"\"$non_lazy_ptr\"",
"\":\\n\"",
"\"\\t.long \"",
"\"\\n\"",
"\"\\t.subsections_via_symbols\\n\""
] | ARMAsmPrinter31 | doFinalization | ARM | CPU | LLVM | 26,048 | 495 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"MSP430TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"StringRef",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'r'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i8",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"MSP430",
"::",
"GR8RegClass",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"MSP430",
"::",
"GR16RegClass",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"MSP430",
"MSP430",
"1",
"0",
"MVT::i8",
"0U",
"MSP430::GR8RegClass",
"0U",
"MSP430::GR16RegClass"
] | MSP430ISelLowering (2) | getRegForInlineAsmConstraint | MSP430 | MPU | LLVM | 26,049 | 102 | 1 | [] |
[
"<s>",
"bool",
"requiresFrameIndexScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"post",
"PEI",
"scavenging",
"of",
"registers",
"for",
"materializing",
"frame",
"index",
"constants",
"."
] | [
"RV16K"
] | RV16KRegisterInfo | requiresFrameIndexScavenging | RV16K | Virtual ISA | LLVM | 26,050 | 15 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_reorg",
"(",
"void",
")",
"{",
"compute_bb_for_insn",
"(",
")",
";",
"thread_prologue_and_epilogue_insns",
"(",
")",
";",
"bb_insn_map_t",
"bb_insn_map",
";",
"nvptx_split_blocks",
"(",
"&",
"bb_insn_map",
")",
";",
"df_clear_flags",
"(",
"DF_LR_RUN_DCE",
")",
";",
"df_set_flags",
"(",
"DF_NO_INSN_RESCAN",
"|",
"DF_NO_HARD_REGS",
")",
";",
"df_live_add_problem",
"(",
")",
";",
"df_live_set_all_dirty",
"(",
")",
";",
"df_analyze",
"(",
")",
";",
"regstat_init_n_sets_and_refs",
"(",
")",
";",
"if",
"(",
"dump_file",
")",
"df_dump",
"(",
"dump_file",
")",
";",
"int",
"max_regs",
"=",
"max_reg_num",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"LAST_VIRTUAL_REGISTER",
"+",
"1",
";",
"i",
"<",
"max_regs",
";",
"i",
"++",
")",
"if",
"(",
"REG_N_SETS",
"(",
"i",
")",
"==",
"0",
"&&",
"REG_N_REFS",
"(",
"i",
")",
"==",
"0",
")",
"regno_reg_rtx",
"[",
"i",
"]",
"=",
"const0_rtx",
";",
"tree",
"attr",
"=",
"oacc_get_fn_attrib",
"(",
"current_function_decl",
")",
";",
"if",
"(",
"attr",
")",
"{",
"unsigned",
"mask",
"=",
"0",
";",
"tree",
"dims",
"=",
"TREE_VALUE",
"(",
"attr",
")",
";",
"unsigned",
"ix",
";",
"for",
"(",
"ix",
"=",
"0",
";",
"ix",
"!=",
"GOMP_DIM_MAX",
";",
"ix",
"++",
",",
"dims",
"=",
"TREE_CHAIN",
"(",
"dims",
")",
")",
"{",
"int",
"size",
"=",
"TREE_INT_CST_LOW",
"(",
"TREE_VALUE",
"(",
"dims",
")",
")",
";",
"tree",
"allowed",
"=",
"TREE_PURPOSE",
"(",
"dims",
")",
";",
"if",
"(",
"size",
"!=",
"1",
"&&",
"!",
"(",
"allowed",
"&&",
"integer_zerop",
"(",
"allowed",
")",
")",
")",
"mask",
"|=",
"GOMP_DIM_MASK",
"(",
"ix",
")",
";",
"}",
"gcc_assert",
"(",
"!",
"(",
"mask",
"&",
"GOMP_DIM_MASK",
"(",
"GOMP_DIM_WORKER",
")",
")",
"||",
"(",
"mask",
"&",
"GOMP_DIM_MASK",
"(",
"GOMP_DIM_VECTOR",
")",
")",
")",
";",
"parallel",
"*",
"pars",
"=",
"nvptx_discover_pars",
"(",
"&",
"bb_insn_map",
")",
";",
"nvptx_process_pars",
"(",
"pars",
")",
";",
"nvptx_neuter_pars",
"(",
"pars",
",",
"mask",
",",
"0",
")",
";",
"delete",
"pars",
";",
"}",
"nvptx_reorg_subreg",
"(",
")",
";",
"if",
"(",
"TARGET_UNIFORM_SIMT",
")",
"nvptx_reorg_uniform_simt",
"(",
")",
";",
"regstat_free_n_sets_and_refs",
"(",
")",
";",
"df_finish_pass",
"(",
"true",
")",
";",
"}",
"</s>"
] | [
"Clean",
"up",
"subreg",
"operands",
".",
"In",
"ptx",
"assembly",
",",
"everything",
"is",
"typed",
",",
"and",
"the",
"presence",
"of",
"subregs",
"would",
"break",
"the",
"rules",
"for",
"most",
"instructions",
".",
"Replace",
"them",
"with",
"a",
"suitable",
"new",
"register",
"of",
"the",
"right",
"size",
",",
"plus",
"conversion",
"copyin/copyout",
"instructions",
"."
] | [
"nvptx",
"1",
"0",
"0",
"0",
"0",
"1",
"0"
] | nvptx4 | nvptx_reorg | nvptx | GPU | GCC | 26,051 | 272 | 1 | [] |
[
"<s>",
"ArrayRef",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"char",
"*",
">>",
"PPCInstrInfo",
"::",
"getSerializableDirectMachineOperandTargetFlags",
"(",
")",
"const",
"{",
"using",
"namespace",
"PPCII",
";",
"static",
"const",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"char",
"*",
">",
"TargetFlags",
"[",
"]",
"=",
"{",
"{",
"MO_LO",
",",
"\"ppc-lo\"",
"}",
",",
"{",
"MO_HA",
",",
"\"ppc-ha\"",
"}",
",",
"{",
"MO_TPREL_LO",
",",
"\"ppc-tprel-lo\"",
"}",
",",
"{",
"MO_TPREL_HA",
",",
"\"ppc-tprel-ha\"",
"}",
",",
"{",
"MO_DTPREL_LO",
",",
"\"ppc-dtprel-lo\"",
"}",
",",
"{",
"MO_TLSLD_LO",
",",
"\"ppc-tlsld-lo\"",
"}",
",",
"{",
"MO_TOC_LO",
",",
"\"ppc-toc-lo\"",
"}",
",",
"{",
"MO_TLS",
",",
"\"ppc-tls\"",
"}",
"}",
";",
"return",
"makeArrayRef",
"(",
"TargetFlags",
")",
";",
"}",
"</s>"
] | [
"Return",
"an",
"array",
"that",
"contains",
"the",
"direct",
"target",
"flag",
"values",
"and",
"their",
"names",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"\"ppc-lo\"",
"\"ppc-ha\"",
"\"ppc-tprel-lo\"",
"\"ppc-tprel-ha\"",
"\"ppc-dtprel-lo\"",
"\"ppc-tlsld-lo\"",
"\"ppc-toc-lo\"",
"\"ppc-tls\""
] | PPCInstrInfo (2)2 | getSerializableDirectMachineOperandTargetFlags | PowerPC | CPU | LLVM | 26,052 | 96 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"AMDGPUDisassembler",
"::",
"getRegClassName",
"(",
"unsigned",
"RegClassID",
")",
"const",
"{",
"return",
"getContext",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
"->",
"getRegClassName",
"(",
"&",
"AMDGPUMCRegisterClasses",
"[",
"RegClassID",
"]",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"name",
"of",
"the",
"register",
"class",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPUDisassembler (2) | getRegClassName | AMDGPU | GPU | LLVM | 26,053 | 31 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"AArch64RegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"assert",
"(",
"MF",
"&&",
"\"Invalid MachineFunction pointer.\"",
")",
";",
"if",
"(",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"GHC",
")",
"return",
"CSR_AArch64_NoRegs_SaveList",
";",
"if",
"(",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"AnyReg",
")",
"return",
"CSR_AArch64_AllRegs_SaveList",
";",
"if",
"(",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"CXX_FAST_TLS",
")",
"return",
"MF",
"->",
"getInfo",
"<",
"AArch64FunctionInfo",
">",
"(",
")",
"->",
"isSplitCSR",
"(",
")",
"?",
"CSR_AArch64_CXX_TLS_Darwin_PE_SaveList",
":",
"CSR_AArch64_CXX_TLS_Darwin_SaveList",
";",
"else",
"return",
"CSR_AArch64_AAPCS_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"AArch64",
"AArch64",
"\"Invalid MachineFunction pointer.\"",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64RegisterInfo (2) | getCalleeSavedRegs | AArch64 | CPU | LLVM | 26,054 | 98 | 1 | [] |
[
"<s>",
"void",
"Initialize",
"(",
"MCAsmParser",
"&",
"Parser",
")",
"override",
"{",
"MCAsmParserExtension",
"::",
"Initialize",
"(",
"Parser",
")",
";",
"DefaultFunctionTable",
"=",
"GetOrCreateFunctionTableSymbol",
"(",
"getContext",
"(",
")",
",",
"\"__indirect_function_table\"",
")",
";",
"if",
"(",
"!",
"STI",
"->",
"checkFeatures",
"(",
"\"+reference-types\"",
")",
")",
"DefaultFunctionTable",
"->",
"setOmitFromLinkingSection",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"WebAssembly",
"\"__indirect_function_table\"",
"\"+reference-types\""
] | WebAssemblyAsmParser | Initialize | WebAssembly | Virtual ISA | LLVM | 26,055 | 44 | 1 | [] |
[
"<s>",
"static",
"void",
"alpha_extract_integer",
"(",
"rtx",
"x",
",",
"HOST_WIDE_INT",
"*",
"p0",
",",
"HOST_WIDE_INT",
"*",
"p1",
")",
"{",
"HOST_WIDE_INT",
"i0",
",",
"i1",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_VECTOR",
")",
"x",
"=",
"simplify_subreg",
"(",
"DImode",
",",
"x",
",",
"GET_MODE",
"(",
"x",
")",
",",
"0",
")",
";",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
")",
"{",
"i0",
"=",
"INTVAL",
"(",
"x",
")",
";",
"i1",
"=",
"-",
"(",
"i0",
"<",
"0",
")",
";",
"}",
"else",
"if",
"(",
"HOST_BITS_PER_WIDE_INT",
">=",
"64",
")",
"{",
"i0",
"=",
"CONST_DOUBLE_LOW",
"(",
"x",
")",
";",
"i1",
"=",
"-",
"(",
"i0",
"<",
"0",
")",
";",
"}",
"else",
"{",
"i0",
"=",
"CONST_DOUBLE_LOW",
"(",
"x",
")",
";",
"i1",
"=",
"CONST_DOUBLE_HIGH",
"(",
"x",
")",
";",
"}",
"*",
"p0",
"=",
"i0",
";",
"*",
"p1",
"=",
"i1",
";",
"}",
"</s>"
] | [
"Given",
"an",
"integral",
"CONST_INT",
",",
"CONST_DOUBLE",
",",
"or",
"CONST_VECTOR",
",",
"return",
"the",
"low",
"64",
"bits",
"."
] | [
"alpha",
"0",
"0",
"64",
"0"
] | alpha4 | alpha_extract_integer | alpha | MPU | GCC | 26,056 | 124 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"buildOutlinedFrame",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineFunction",
"&",
"MF",
",",
"const",
"outliner",
"::",
"OutlinedFunction",
"&",
"OF",
")",
"const",
"{",
"if",
"(",
"OF",
".",
"FrameConstructionID",
"==",
"MachineOutlinerTailCall",
")",
"return",
";",
"MachineInstr",
"*",
"retq",
"=",
"BuildMI",
"(",
"MF",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"RET64",
")",
")",
";",
"MBB",
".",
"insert",
"(",
"MBB",
".",
"end",
"(",
")",
",",
"retq",
")",
";",
"}",
"</s>"
] | [
"Insert",
"a",
"custom",
"frame",
"for",
"outlined",
"functions",
"."
] | [
"X86",
"X86",
"X86::RET64"
] | X86InstrInfo153 | buildOutlinedFrame | X86 | CPU | LLVM | 26,057 | 66 | 1 | [] |
[
"<s>",
"void",
"MipsSEFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MipsFunctionInfo",
"*",
"MipsFI",
"=",
"MF",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
";",
"const",
"MipsSEInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"MipsSEInstrInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"const",
"MipsRegisterInfo",
"&",
"RegInfo",
"=",
"*",
"static_cast",
"<",
"const",
"MipsRegisterInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"SP",
"=",
"STI",
".",
"isABI_N64",
"(",
")",
"?",
"Mips",
"::",
"SP_64",
":",
"Mips",
"::",
"SP",
";",
"unsigned",
"FP",
"=",
"STI",
".",
"isABI_N64",
"(",
")",
"?",
"Mips",
"::",
"FP_64",
":",
"Mips",
"::",
"FP",
";",
"unsigned",
"ZERO",
"=",
"STI",
".",
"isABI_N64",
"(",
")",
"?",
"Mips",
"::",
"ZERO_64",
":",
"Mips",
"::",
"ZERO",
";",
"unsigned",
"ADDu",
"=",
"STI",
".",
"isABI_N64",
"(",
")",
"?",
"Mips",
"::",
"DADDu",
":",
"Mips",
"::",
"ADDu",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBBI",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"MFI",
"->",
"getCalleeSavedInfo",
"(",
")",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"--",
"I",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"ADDu",
")",
",",
"SP",
")",
".",
"addReg",
"(",
"FP",
")",
".",
"addReg",
"(",
"ZERO",
")",
";",
"}",
"if",
"(",
"MipsFI",
"->",
"callsEhReturn",
"(",
")",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"STI",
".",
"isABI_N64",
"(",
")",
"?",
"&",
"Mips",
"::",
"GPR64RegClass",
":",
"&",
"Mips",
"::",
"GPR32RegClass",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBBI",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"MFI",
"->",
"getCalleeSavedInfo",
"(",
")",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"--",
"I",
";",
"for",
"(",
"int",
"J",
"=",
"0",
";",
"J",
"<",
"4",
";",
"++",
"J",
")",
"{",
"TII",
".",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"I",
",",
"ehDataReg",
"(",
"J",
")",
",",
"MipsFI",
"->",
"getEhDataRegFI",
"(",
"J",
")",
",",
"RC",
",",
"&",
"RegInfo",
")",
";",
"}",
"}",
"uint64_t",
"StackSize",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"if",
"(",
"!",
"StackSize",
")",
"return",
";",
"TII",
".",
"adjustStackPtr",
"(",
"SP",
",",
"StackSize",
",",
"MBB",
",",
"MBBI",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips::SP_64",
"Mips::SP",
"Mips::FP_64",
"Mips::FP",
"Mips::ZERO_64",
"Mips::ZERO",
"Mips::DADDu",
"Mips::ADDu",
"0",
"Mips",
"Mips::GPR64RegClass",
"Mips::GPR32RegClass",
"0",
"0",
"4",
"Mips"
] | MipsSEFrameLowering12 | emitEpilogue | Mips | CPU | LLVM | 26,058 | 378 | 1 | [] |
[
"<s>",
"bool",
"X86TargetMachine",
"::",
"addPostRegAlloc",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"PM",
".",
"add",
"(",
"createX86FloatingPointStackifierPass",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"register",
"allocation",
"pass",
"pipeline",
"but",
"before",
"prolog-epilog",
"insertion",
"."
] | [
"X86",
"X86",
"X86"
] | X86TargetMachine118 | addPostRegAlloc | X86 | CPU | LLVM | 26,059 | 28 | 1 | [] |
[
"<s>",
"SDValue",
"RV16KTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"report_fatal_error",
"(",
"\"unimplemented operand\"",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"LowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BR_CC",
":",
"return",
"LowerBR_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"LowerSELECT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"RV16K",
"RV16K",
"\"unimplemented operand\"",
"ISD::GlobalAddress",
"ISD::BlockAddress",
"ISD::BR_CC",
"ISD::SELECT",
"ISD::FRAMEADDR",
"ISD::RETURNADDR"
] | RV16KISelLowering | LowerOperation | RV16K | Virtual ISA | LLVM | 26,060 | 110 | 1 | [] |
[
"<s>",
"bool",
"X86PassConfig",
"::",
"addILPOpts",
"(",
")",
"{",
"addPass",
"(",
"&",
"EarlyIfConverterID",
")",
";",
"if",
"(",
"EnableMachineCombinerPass",
")",
"addPass",
"(",
"&",
"MachineCombinerID",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Add",
"passes",
"that",
"optimize",
"instruction",
"level",
"parallelism",
"for",
"out-of-order",
"targets",
"."
] | [
"X86",
"X86"
] | X86TargetMachine10 | addILPOpts | X86 | CPU | LLVM | 26,061 | 27 | 1 | [] |
[
"<s>",
"void",
"OutgoingValueHandler",
"::",
"assignValueToReg",
"(",
"unsigned",
"ValVReg",
",",
"const",
"CCValAssign",
"&",
"VA",
",",
"const",
"EVT",
"&",
"VT",
")",
"{",
"unsigned",
"PhysReg",
"=",
"VA",
".",
"getLocReg",
"(",
")",
";",
"const",
"MipsSubtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"MipsSubtarget",
"&",
">",
"(",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"&&",
"PhysReg",
">=",
"Mips",
"::",
"A0",
"&&",
"PhysReg",
"<=",
"Mips",
"::",
"A3",
")",
"{",
"MIRBuilder",
".",
"buildInstr",
"(",
"STI",
".",
"isFP64bit",
"(",
")",
"?",
"Mips",
"::",
"ExtractElementF64_64",
":",
"Mips",
"::",
"ExtractElementF64",
")",
".",
"addDef",
"(",
"PhysReg",
"+",
"(",
"STI",
".",
"isLittle",
"(",
")",
"?",
"1",
":",
"0",
")",
")",
".",
"addUse",
"(",
"ValVReg",
")",
".",
"addImm",
"(",
"1",
")",
".",
"constrainAllUses",
"(",
"MIRBuilder",
".",
"getTII",
"(",
")",
",",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
",",
"*",
"STI",
".",
"getRegBankInfo",
"(",
")",
")",
";",
"MIRBuilder",
".",
"buildInstr",
"(",
"STI",
".",
"isFP64bit",
"(",
")",
"?",
"Mips",
"::",
"ExtractElementF64_64",
":",
"Mips",
"::",
"ExtractElementF64",
")",
".",
"addDef",
"(",
"PhysReg",
"+",
"(",
"STI",
".",
"isLittle",
"(",
")",
"?",
"0",
":",
"1",
")",
")",
".",
"addUse",
"(",
"ValVReg",
")",
".",
"addImm",
"(",
"0",
")",
".",
"constrainAllUses",
"(",
"MIRBuilder",
".",
"getTII",
"(",
")",
",",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
",",
"*",
"STI",
".",
"getRegBankInfo",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
"&&",
"PhysReg",
">=",
"Mips",
"::",
"A0",
"&&",
"PhysReg",
"<=",
"Mips",
"::",
"A3",
")",
"{",
"MIRBuilder",
".",
"buildInstr",
"(",
"Mips",
"::",
"MFC1",
")",
".",
"addDef",
"(",
"PhysReg",
")",
".",
"addUse",
"(",
"ValVReg",
")",
".",
"constrainAllUses",
"(",
"MIRBuilder",
".",
"getTII",
"(",
")",
",",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
",",
"*",
"STI",
".",
"getRegBankInfo",
"(",
")",
")",
";",
"}",
"else",
"{",
"unsigned",
"ExtReg",
"=",
"extendRegister",
"(",
"ValVReg",
",",
"VA",
")",
";",
"MIRBuilder",
".",
"buildCopy",
"(",
"PhysReg",
",",
"ExtReg",
")",
";",
"MIB",
".",
"addUse",
"(",
"PhysReg",
",",
"RegState",
"::",
"Implicit",
")",
";",
"}",
"}",
"</s>"
] | [
"The",
"specified",
"value",
"has",
"been",
"assigned",
"to",
"a",
"physical",
"register",
",",
"handle",
"the",
"appropriate",
"COPY",
"(",
"either",
"to",
"or",
"from",
")",
"and",
"mark",
"any",
"relevant",
"uses/defines",
"as",
"needed",
"."
] | [
"Mips",
"Mips",
"Mips",
"MVT::f64",
"Mips::A0",
"Mips::A3",
"Mips::ExtractElementF64_64",
"Mips::ExtractElementF64",
"1",
"0",
"1",
"Mips::ExtractElementF64_64",
"Mips::ExtractElementF64",
"0",
"1",
"0",
"MVT::f32",
"Mips::A0",
"Mips::A3",
"Mips::MFC1"
] | MipsCallLowering27 | assignValueToReg | Mips | CPU | LLVM | 26,062 | 310 | 1 | [] |
[
"<s>",
"bool",
"X86IntelAsmPrinter",
"::",
"doFinalization",
"(",
"Module",
"&",
"M",
")",
"{",
"const",
"TargetData",
"*",
"TD",
"=",
"TM",
".",
"getTargetData",
"(",
")",
";",
"for",
"(",
"Module",
"::",
"const_global_iterator",
"I",
"=",
"M",
".",
"global_begin",
"(",
")",
",",
"E",
"=",
"M",
".",
"global_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"isDeclaration",
"(",
")",
")",
"continue",
";",
"if",
"(",
"EmitSpecialLLVMGlobal",
"(",
"I",
")",
")",
"continue",
";",
"std",
"::",
"string",
"name",
"=",
"Mang",
"->",
"getValueName",
"(",
"I",
")",
";",
"Constant",
"*",
"C",
"=",
"I",
"->",
"getInitializer",
"(",
")",
";",
"unsigned",
"Align",
"=",
"TD",
"->",
"getPreferredAlignmentLog",
"(",
"I",
")",
";",
"bool",
"bCustomSegment",
"=",
"false",
";",
"switch",
"(",
"I",
"->",
"getLinkage",
"(",
")",
")",
"{",
"case",
"GlobalValue",
"::",
"CommonLinkage",
":",
"case",
"GlobalValue",
"::",
"LinkOnceAnyLinkage",
":",
"case",
"GlobalValue",
"::",
"LinkOnceODRLinkage",
":",
"case",
"GlobalValue",
"::",
"WeakAnyLinkage",
":",
"case",
"GlobalValue",
"::",
"WeakODRLinkage",
":",
"SwitchToDataSection",
"(",
"\"\"",
")",
";",
"O",
"<<",
"name",
"<<",
"\"?\\tsegment common 'COMMON'\\n\"",
";",
"bCustomSegment",
"=",
"true",
";",
"break",
";",
"case",
"GlobalValue",
"::",
"AppendingLinkage",
":",
"SwitchToDataSection",
"(",
"\"\"",
")",
";",
"O",
"<<",
"name",
"<<",
"\"?\\tsegment public 'DATA'\\n\"",
";",
"bCustomSegment",
"=",
"true",
";",
"break",
";",
"case",
"GlobalValue",
"::",
"DLLExportLinkage",
":",
"DLLExportedGVs",
".",
"insert",
"(",
"name",
")",
";",
"case",
"GlobalValue",
"::",
"ExternalLinkage",
":",
"O",
"<<",
"\"\\tpublic \"",
"<<",
"name",
"<<",
"\"\\n\"",
";",
"case",
"GlobalValue",
"::",
"InternalLinkage",
":",
"SwitchToSection",
"(",
"TAI",
"->",
"getDataSection",
"(",
")",
")",
";",
"break",
";",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"Unknown linkage type!\"",
")",
";",
"}",
"if",
"(",
"!",
"bCustomSegment",
")",
"EmitAlignment",
"(",
"Align",
",",
"I",
")",
";",
"O",
"<<",
"name",
"<<",
"\":\"",
";",
"if",
"(",
"VerboseAsm",
")",
"O",
"<<",
"\"\\t\\t\\t\\t\"",
"<<",
"TAI",
"->",
"getCommentString",
"(",
")",
"<<",
"\" \"",
"<<",
"I",
"->",
"getName",
"(",
")",
";",
"O",
"<<",
"'\\n'",
";",
"EmitGlobalConstant",
"(",
"C",
")",
";",
"if",
"(",
"bCustomSegment",
")",
"O",
"<<",
"name",
"<<",
"\"?\\tends\\n\"",
";",
"}",
"if",
"(",
"!",
"DLLExportedGVs",
".",
"empty",
"(",
")",
"||",
"!",
"DLLExportedFns",
".",
"empty",
"(",
")",
")",
"{",
"SwitchToDataSection",
"(",
"\"\"",
")",
";",
"O",
"<<",
"\"; WARNING: The following code is valid only with MASM v8.x\"",
"<<",
"\"and (possible) higher\\n\"",
"<<",
"\"; This version of MASM is usually shipped with Microsoft \"",
"<<",
"\"Visual Studio 2005\\n\"",
"<<",
"\"; or (possible) further versions. Unfortunately, there is no \"",
"<<",
"\"way to support\\n\"",
"<<",
"\"; dllexported symbols in the earlier versions of MASM in fully \"",
"<<",
"\"automatic way\\n\\n\"",
";",
"O",
"<<",
"\"_drectve\\t segment info alias('.drectve')\\n\"",
";",
"}",
"for",
"(",
"StringSet",
"<",
">",
"::",
"iterator",
"i",
"=",
"DLLExportedGVs",
".",
"begin",
"(",
")",
",",
"e",
"=",
"DLLExportedGVs",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"O",
"<<",
"\"\\t db ' /EXPORT:\"",
"<<",
"i",
"->",
"getKeyData",
"(",
")",
"<<",
"\",data'\\n\"",
";",
"for",
"(",
"StringSet",
"<",
">",
"::",
"iterator",
"i",
"=",
"DLLExportedFns",
".",
"begin",
"(",
")",
",",
"e",
"=",
"DLLExportedFns",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"O",
"<<",
"\"\\t db ' /EXPORT:\"",
"<<",
"i",
"->",
"getKeyData",
"(",
")",
"<<",
"\"'\\n\"",
";",
"if",
"(",
"!",
"DLLExportedGVs",
".",
"empty",
"(",
")",
"||",
"!",
"DLLExportedFns",
".",
"empty",
"(",
")",
")",
"O",
"<<",
"\"_drectve\\t ends\\n\"",
";",
"bool",
"Result",
"=",
"AsmPrinter",
"::",
"doFinalization",
"(",
"M",
")",
";",
"SwitchToDataSection",
"(",
"\"\"",
")",
";",
"O",
"<<",
"\"\\tend\\n\"",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"doFinalization",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"any",
"necessary",
"clean",
"up",
"after",
"all",
"passes",
"have",
"run",
"."
] | [
"X86",
"X86",
"\"\"",
"\"?\\tsegment common 'COMMON'\\n\"",
"\"\"",
"\"?\\tsegment public 'DATA'\\n\"",
"\"\\tpublic \"",
"\"\\n\"",
"0",
"\"Unknown linkage type!\"",
"\":\"",
"\"\\t\\t\\t\\t\"",
"\" \"",
"\"?\\tends\\n\"",
"\"\"",
"\"; WARNING: The following code is valid only with MASM v8.x\"",
"\"and (possible) higher\\n\"",
"\"; This version of MASM is usually shipped with Microsoft \"",
"\"Visual Studio 2005\\n\"",
"\"; or (possible) further versions. Unfortunately, there is no \"",
"\"way to support\\n\"",
"\"; dllexported symbols in the earlier versions of MASM in fully \"",
"\"automatic way\\n\\n\"",
"\"_drectve\\t segment info alias('.drectve')\\n\"",
"\"\\t db ' /EXPORT:\"",
"\",data'\\n\"",
"\"\\t db ' /EXPORT:\"",
"\"'\\n\"",
"\"_drectve\\t ends\\n\"",
"\"\"",
"\"\\tend\\n\""
] | X86IntelAsmPrinter | doFinalization | X86 | CPU | LLVM | 26,063 | 462 | 1 | [] |
[
"<s>",
"bool",
"R600MachineCFGStructurizer",
"::",
"isReturnBlock",
"(",
"MachineBasicBlock",
"*",
"MBB",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"getReturnInstr",
"(",
"MBB",
")",
";",
"bool",
"IsReturn",
"=",
"MBB",
"->",
"succ_empty",
"(",
")",
";",
"if",
"(",
"MI",
")",
"assert",
"(",
"IsReturn",
")",
";",
"else",
"if",
"(",
"IsReturn",
")",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"BB\"",
"<<",
"MBB",
"->",
"getNumber",
"(",
")",
"<<",
"\" is return block without RETURN instr\\n\"",
";",
")",
";",
"return",
"IsReturn",
";",
"}",
"</s>"
] | [
"Convenience",
"function",
"that",
"returns",
"true",
"if",
"the",
"block",
"ends",
"in",
"a",
"return",
"instruction",
"."
] | [
"AMDGPU",
"R600",
"\"BB\"",
"\" is return block without RETURN instr\\n\""
] | R600MachineCFGStructurizer | isReturnBlock | AMDGPU | GPU | LLVM | 26,064 | 64 | 1 | [] |
[
"<s>",
"void",
"AMDGPUPreLegalizerCombiner",
"::",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"AU",
".",
"addRequired",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"getSelectionDAGFallbackAnalysisUsage",
"(",
"AU",
")",
";",
"AU",
".",
"addRequired",
"<",
"GISelKnownBitsAnalysis",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"GISelKnownBitsAnalysis",
">",
"(",
")",
";",
"if",
"(",
"!",
"IsOptNone",
")",
"{",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"}",
"AU",
".",
"addRequired",
"<",
"GISelCSEAnalysisWrapperPass",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"GISelCSEAnalysisWrapperPass",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUPreLegalizerCombiner1 | getAnalysisUsage | AMDGPU | GPU | LLVM | 26,065 | 100 | 1 | [] |
[
"<s>",
"static",
"rtx",
"ix86_get_drap_rtx",
"(",
"void",
")",
"{",
"if",
"(",
"ix86_force_drap",
"||",
"!",
"ACCUMULATE_OUTGOING_ARGS",
")",
"crtl",
"->",
"need_drap",
"=",
"true",
";",
"if",
"(",
"stack_realign_drap",
")",
"{",
"unsigned",
"int",
"regno",
"=",
"find_drap_reg",
"(",
")",
";",
"rtx",
"drap_vreg",
";",
"rtx",
"arg_ptr",
";",
"rtx_insn",
"*",
"seq",
",",
"*",
"insn",
";",
"arg_ptr",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"regno",
")",
";",
"crtl",
"->",
"drap_reg",
"=",
"arg_ptr",
";",
"start_sequence",
"(",
")",
";",
"drap_vreg",
"=",
"copy_to_reg",
"(",
"arg_ptr",
")",
";",
"seq",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"insn",
"=",
"emit_insn_before",
"(",
"seq",
",",
"NEXT_INSN",
"(",
"entry_of_function",
"(",
")",
")",
")",
";",
"if",
"(",
"!",
"optimize",
")",
"{",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_SET_VDRAP",
",",
"drap_vreg",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"return",
"drap_vreg",
";",
"}",
"else",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Handle",
"the",
"TARGET_GET_DRAP_RTX",
"hook",
".",
"Return",
"NULL",
"if",
"no",
"DRAP",
"is",
"needed",
"or",
"an",
"rtx",
"for",
"DRAP",
"otherwise",
"."
] | [
"i386",
"1"
] | i3864 | ix86_get_drap_rtx | i386 | CPU | GCC | 26,066 | 128 | 1 | [] |
[
"<s>",
"static",
"bool",
"shift_p",
"(",
"rtx",
"x",
",",
"enum",
"rtx_code",
"code",
",",
"int",
"amount",
")",
"{",
"return",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"code",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"amount",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"X",
"is",
"a",
"shift",
"with",
"code",
"CODE",
"and",
"an",
"integer",
"amount",
"AMOUNT",
"."
] | [
"c6x",
"1",
"1"
] | c6x | shift_p | c6x | VLIW | GCC | 26,067 | 50 | 1 | [] |
[
"<s>",
"void",
"X86AsmInstrumentation",
"::",
"EmitInstruction",
"(",
"MCStreamer",
"&",
"Out",
",",
"const",
"MCInst",
"&",
"Inst",
")",
"{",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"X86",
"X86"
] | X86AsmInstrumentation | EmitInstruction | X86 | CPU | LLVM | 26,068 | 25 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"AAResultsWrapperPass",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"AArch64"
] | AArch64LoadStoreOptimizer (2)1 | getAnalysisUsage | AArch64 | CPU | LLVM | 26,069 | 27 | 1 | [] |
[
"<s>",
"void",
"printPCRelImm",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"uint64_t",
",",
"unsigned",
"OpNo",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"printPCRelImm",
"(",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"}",
"</s>"
] | [
"value",
"(",
"e.g",
"."
] | [
"AVR"
] | AVRInstPrinter1 | printPCRelImm | AVR | MPU | LLVM | 26,070 | 28 | 1 | [] |
[
"<s>",
"static",
"rtx",
"nios2_expand_builtin",
"(",
"tree",
"exp",
",",
"rtx",
"target",
",",
"rtx",
"subtarget",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"int",
"ignore",
"ATTRIBUTE_UNUSED",
")",
"{",
"tree",
"fndecl",
"=",
"TREE_OPERAND",
"(",
"CALL_EXPR_FN",
"(",
"exp",
")",
",",
"0",
")",
";",
"unsigned",
"int",
"fcode",
"=",
"DECL_MD_FUNCTION_CODE",
"(",
"fndecl",
")",
";",
"if",
"(",
"fcode",
"<",
"nios2_fpu_builtin_base",
")",
"{",
"const",
"struct",
"nios2_builtin_desc",
"*",
"d",
"=",
"&",
"nios2_builtins",
"[",
"fcode",
"]",
";",
"if",
"(",
"d",
"->",
"arch",
">",
"nios2_arch_option",
")",
"{",
"error",
"(",
"\"built-in function %s requires Nios II R%d\"",
",",
"d",
"->",
"name",
",",
"(",
"int",
")",
"d",
"->",
"arch",
")",
";",
"return",
"expand_call",
"(",
"exp",
",",
"target",
",",
"ignore",
")",
";",
"}",
"switch",
"(",
"fcode",
")",
"{",
"case",
"NIOS2_BUILTIN_sync",
":",
"emit_insn",
"(",
"gen_sync",
"(",
")",
")",
";",
"return",
"const0_rtx",
";",
"case",
"NIOS2_BUILTIN_ldbio",
":",
"case",
"NIOS2_BUILTIN_ldbuio",
":",
"case",
"NIOS2_BUILTIN_ldhio",
":",
"case",
"NIOS2_BUILTIN_ldhuio",
":",
"case",
"NIOS2_BUILTIN_ldwio",
":",
"case",
"NIOS2_BUILTIN_stbio",
":",
"case",
"NIOS2_BUILTIN_sthio",
":",
"case",
"NIOS2_BUILTIN_stwio",
":",
"case",
"NIOS2_BUILTIN_ldex",
":",
"case",
"NIOS2_BUILTIN_ldsex",
":",
"case",
"NIOS2_BUILTIN_stex",
":",
"case",
"NIOS2_BUILTIN_stsex",
":",
"return",
"nios2_expand_ldst_builtin",
"(",
"exp",
",",
"target",
",",
"d",
")",
";",
"case",
"NIOS2_BUILTIN_rdctl",
":",
"case",
"NIOS2_BUILTIN_wrctl",
":",
"return",
"nios2_expand_rdwrctl_builtin",
"(",
"exp",
",",
"target",
",",
"d",
")",
";",
"case",
"NIOS2_BUILTIN_rdprs",
":",
"return",
"nios2_expand_rdprs_builtin",
"(",
"exp",
",",
"target",
",",
"d",
")",
";",
"case",
"NIOS2_BUILTIN_flushd",
":",
"case",
"NIOS2_BUILTIN_flushda",
":",
"return",
"nios2_expand_cache_builtin",
"(",
"exp",
",",
"target",
",",
"d",
")",
";",
"case",
"NIOS2_BUILTIN_wrpie",
":",
"return",
"nios2_expand_wrpie_builtin",
"(",
"exp",
",",
"target",
",",
"d",
")",
";",
"case",
"NIOS2_BUILTIN_eni",
":",
"return",
"nios2_expand_eni_builtin",
"(",
"exp",
",",
"target",
",",
"d",
")",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"else",
"if",
"(",
"fcode",
"<",
"nios2_custom_builtin_base",
")",
"return",
"nios2_expand_fpu_builtin",
"(",
"exp",
",",
"fcode",
"-",
"nios2_fpu_builtin_base",
",",
"target",
")",
";",
"else",
"if",
"(",
"fcode",
"<",
"nios2_custom_builtin_end",
")",
"return",
"nios2_expand_custom_builtin",
"(",
"exp",
",",
"fcode",
"-",
"nios2_custom_builtin_base",
",",
"target",
")",
";",
"else",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_EXPAND_BUILTIN",
".",
"Expand",
"an",
"expression",
"EXP",
"that",
"calls",
"a",
"built-in",
"function",
",",
"with",
"result",
"going",
"to",
"TARGET",
"if",
"that",
"'s",
"convenient",
"(",
"and",
"in",
"mode",
"MODE",
"if",
"that",
"'s",
"convenient",
")",
".",
"SUBTARGET",
"may",
"be",
"used",
"as",
"the",
"target",
"for",
"computing",
"one",
"of",
"EXP",
"'s",
"operands",
".",
"IGNORE",
"is",
"nonzero",
"if",
"the",
"value",
"is",
"to",
"be",
"ignored",
"."
] | [
"nios2",
"0",
"\"built-in function %s requires Nios II R%d\""
] | nios2 | nios2_expand_builtin | nios2 | MPU | GCC | 26,071 | 287 | 1 | [] |
[
"<s>",
"void",
"general_scalar_chain",
"::",
"convert_reg",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"dst",
",",
"rtx",
"src",
")",
"{",
"start_sequence",
"(",
")",
";",
"if",
"(",
"!",
"TARGET_INTER_UNIT_MOVES_FROM_VEC",
")",
"{",
"rtx",
"tmp",
"=",
"assign_386_stack_local",
"(",
"smode",
",",
"SLOT_STV_TEMP",
")",
";",
"emit_move_insn",
"(",
"tmp",
",",
"src",
")",
";",
"if",
"(",
"!",
"TARGET_64BIT",
"&&",
"smode",
"==",
"DImode",
")",
"{",
"emit_move_insn",
"(",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"dst",
",",
"0",
")",
",",
"adjust_address",
"(",
"tmp",
",",
"SImode",
",",
"0",
")",
")",
";",
"emit_move_insn",
"(",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"dst",
",",
"4",
")",
",",
"adjust_address",
"(",
"tmp",
",",
"SImode",
",",
"4",
")",
")",
";",
"}",
"else",
"emit_move_insn",
"(",
"dst",
",",
"copy_rtx",
"(",
"tmp",
")",
")",
";",
"}",
"else",
"if",
"(",
"!",
"TARGET_64BIT",
"&&",
"smode",
"==",
"DImode",
")",
"{",
"if",
"(",
"TARGET_SSE4_1",
")",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"1",
",",
"const0_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"dst",
",",
"0",
")",
",",
"gen_rtx_VEC_SELECT",
"(",
"SImode",
",",
"gen_rtx_SUBREG",
"(",
"V4SImode",
",",
"src",
",",
"0",
")",
",",
"tmp",
")",
")",
")",
";",
"tmp",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"1",
",",
"const1_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"dst",
",",
"4",
")",
",",
"gen_rtx_VEC_SELECT",
"(",
"SImode",
",",
"gen_rtx_SUBREG",
"(",
"V4SImode",
",",
"src",
",",
"0",
")",
",",
"tmp",
")",
")",
")",
";",
"}",
"else",
"{",
"rtx",
"vcopy",
"=",
"gen_reg_rtx",
"(",
"V2DImode",
")",
";",
"emit_move_insn",
"(",
"vcopy",
",",
"gen_rtx_SUBREG",
"(",
"V2DImode",
",",
"src",
",",
"0",
")",
")",
";",
"emit_move_insn",
"(",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"dst",
",",
"0",
")",
",",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"vcopy",
",",
"0",
")",
")",
";",
"emit_move_insn",
"(",
"vcopy",
",",
"gen_rtx_LSHIFTRT",
"(",
"V2DImode",
",",
"vcopy",
",",
"GEN_INT",
"(",
"32",
")",
")",
")",
";",
"emit_move_insn",
"(",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"dst",
",",
"4",
")",
",",
"gen_rtx_SUBREG",
"(",
"SImode",
",",
"vcopy",
",",
"0",
")",
")",
";",
"}",
"}",
"else",
"emit_move_insn",
"(",
"dst",
",",
"src",
")",
";",
"rtx_insn",
"*",
"seq",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"emit_conversion_insns",
"(",
"seq",
",",
"insn",
")",
";",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"\" Copied r%d to a scalar register r%d for insn %d\\n\"",
",",
"REGNO",
"(",
"src",
")",
",",
"REGNO",
"(",
"dst",
")",
",",
"INSN_UID",
"(",
"insn",
")",
")",
";",
"}",
"</s>"
] | [
"Convert",
"all",
"definitions",
"of",
"register",
"REGNO",
"and",
"fix",
"its",
"uses",
".",
"Scalar",
"copies",
"may",
"be",
"created",
"in",
"case",
"register",
"is",
"used",
"in",
"not",
"convertible",
"insn",
"."
] | [
"i386",
"0",
"0",
"4",
"4",
"1",
"0",
"0",
"1",
"4",
"0",
"0",
"0",
"0",
"32",
"4",
"0",
"\" Copied r%d to a scalar register r%d for insn %d\\n\""
] | i386-features | convert_reg | i386 | CPU | GCC | 26,072 | 355 | 1 | [] |
[
"<s>",
"SDValue",
"SystemZTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"return",
"combineZERO_EXTEND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"return",
"combineSIGN_EXTEND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"combineSIGN_EXTEND_INREG",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"MERGE_HIGH",
":",
"case",
"SystemZISD",
"::",
"MERGE_LOW",
":",
"return",
"combineMERGE",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"combineLOAD",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"combineSTORE",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
":",
"return",
"combineEXTRACT_VECTOR_ELT",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"JOIN_DWORDS",
":",
"return",
"combineJOIN_DWORDS",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"FP_ROUND",
":",
"return",
"combineFP_ROUND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"FP_EXTEND",
":",
"return",
"combineFP_EXTEND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"BSWAP",
":",
"return",
"combineBSWAP",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"BR_CCMASK",
":",
"return",
"combineBR_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"SELECT_CCMASK",
":",
"return",
"combineSELECT_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"GET_CCMASK",
":",
"return",
"combineGET_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SDIV",
":",
"case",
"ISD",
"::",
"UDIV",
":",
"case",
"ISD",
"::",
"SREM",
":",
"case",
"ISD",
"::",
"UREM",
":",
"return",
"combineIntDIVREM",
"(",
"N",
",",
"DCI",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"SystemZ",
"SystemZ",
"ISD::ZERO_EXTEND",
"ISD::SIGN_EXTEND",
"ISD::SIGN_EXTEND_INREG",
"SystemZISD::MERGE_HIGH",
"SystemZISD::MERGE_LOW",
"ISD::LOAD",
"ISD::STORE",
"ISD::EXTRACT_VECTOR_ELT",
"SystemZISD::JOIN_DWORDS",
"ISD::FP_ROUND",
"ISD::FP_EXTEND",
"ISD::BSWAP",
"SystemZISD::BR_CCMASK",
"SystemZISD::SELECT_CCMASK",
"SystemZISD::GET_CCMASK",
"ISD::SDIV",
"ISD::UDIV",
"ISD::SREM",
"ISD::UREM"
] | SystemZISelLowering | PerformDAGCombine | SystemZ | CPU | LLVM | 26,073 | 250 | 1 | [] |
[
"<s>",
"static",
"int",
"rs6000_builtin_vectorization_cost",
"(",
"enum",
"vect_cost_for_stmt",
"type_of_cost",
",",
"tree",
"vectype",
",",
"int",
"misalign",
")",
"{",
"unsigned",
"elements",
";",
"tree",
"elem_type",
";",
"switch",
"(",
"type_of_cost",
")",
"{",
"case",
"scalar_stmt",
":",
"case",
"scalar_load",
":",
"case",
"scalar_store",
":",
"case",
"vector_stmt",
":",
"case",
"vector_load",
":",
"case",
"vector_store",
":",
"case",
"vec_to_scalar",
":",
"case",
"scalar_to_vec",
":",
"case",
"cond_branch_not_taken",
":",
"return",
"1",
";",
"case",
"vec_perm",
":",
"if",
"(",
"TARGET_VSX",
")",
"return",
"3",
";",
"else",
"return",
"1",
";",
"case",
"vec_promote_demote",
":",
"if",
"(",
"TARGET_VSX",
")",
"return",
"4",
";",
"else",
"return",
"1",
";",
"case",
"cond_branch_taken",
":",
"return",
"3",
";",
"case",
"unaligned_load",
":",
"case",
"vector_gather_load",
":",
"if",
"(",
"TARGET_EFFICIENT_UNALIGNED_VSX",
")",
"return",
"1",
";",
"if",
"(",
"TARGET_VSX",
"&&",
"TARGET_ALLOW_MOVMISALIGN",
")",
"{",
"elements",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"vectype",
")",
";",
"if",
"(",
"elements",
"==",
"2",
")",
"return",
"2",
";",
"if",
"(",
"elements",
"==",
"4",
")",
"{",
"switch",
"(",
"misalign",
")",
"{",
"case",
"8",
":",
"return",
"2",
";",
"case",
"-",
"1",
":",
"case",
"4",
":",
"case",
"12",
":",
"return",
"22",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"}",
"if",
"(",
"TARGET_ALTIVEC",
")",
"gcc_unreachable",
"(",
")",
";",
"return",
"2",
";",
"case",
"unaligned_store",
":",
"case",
"vector_scatter_store",
":",
"if",
"(",
"TARGET_EFFICIENT_UNALIGNED_VSX",
")",
"return",
"1",
";",
"if",
"(",
"TARGET_VSX",
"&&",
"TARGET_ALLOW_MOVMISALIGN",
")",
"{",
"elements",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"vectype",
")",
";",
"if",
"(",
"elements",
"==",
"2",
")",
"return",
"2",
";",
"if",
"(",
"elements",
"==",
"4",
")",
"{",
"switch",
"(",
"misalign",
")",
"{",
"case",
"8",
":",
"return",
"2",
";",
"case",
"-",
"1",
":",
"case",
"4",
":",
"case",
"12",
":",
"return",
"23",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"}",
"if",
"(",
"TARGET_ALTIVEC",
")",
"gcc_unreachable",
"(",
")",
";",
"return",
"2",
";",
"case",
"vec_construct",
":",
"elem_type",
"=",
"TREE_TYPE",
"(",
"vectype",
")",
";",
"if",
"(",
"SCALAR_FLOAT_TYPE_P",
"(",
"elem_type",
")",
"&&",
"TYPE_PRECISION",
"(",
"elem_type",
")",
"==",
"32",
")",
"return",
"5",
";",
"else",
"if",
"(",
"INTEGRAL_TYPE_P",
"(",
"elem_type",
")",
")",
"{",
"if",
"(",
"TARGET_P9_VECTOR",
")",
"return",
"TYPE_VECTOR_SUBPARTS",
"(",
"vectype",
")",
"-",
"1",
"+",
"2",
";",
"else",
"return",
"TYPE_VECTOR_SUBPARTS",
"(",
"vectype",
")",
"-",
"1",
"+",
"5",
";",
"}",
"else",
"return",
"2",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"targetm.vectorize.builtin_vectorization_cost",
"."
] | [
"rs6000",
"1",
"3",
"1",
"4",
"1",
"3",
"1",
"2",
"2",
"4",
"8",
"2",
"1",
"4",
"12",
"22",
"2",
"1",
"2",
"2",
"4",
"8",
"2",
"1",
"4",
"12",
"23",
"2",
"32",
"5",
"1",
"2",
"1",
"5",
"2"
] | rs60007 | rs6000_builtin_vectorization_cost | rs6000 | CPU | GCC | 26,074 | 338 | 1 | [] |
[
"<s>",
"static",
"bool",
"visium_class_likely_spilled_p",
"(",
"reg_class_t",
"rclass",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"pseudos",
"that",
"have",
"been",
"assigned",
"to",
"registers",
"of",
"RCLASS",
"would",
"likely",
"be",
"spilled",
"because",
"registers",
"of",
"RCLASS",
"are",
"needed",
"for",
"spill",
"registers",
"."
] | [
"visium"
] | visium | visium_class_likely_spilled_p | visium | Virtual ISA | GCC | 26,075 | 13 | 1 | [] |
[
"<s>",
"void",
"msp430_extract_mcu_data",
"(",
"const",
"char",
"*",
"mcu_name",
")",
"{",
"static",
"int",
"executed",
"=",
"0",
";",
"int",
"devices_csv_not_found",
"=",
"0",
";",
"int",
"i",
";",
"if",
"(",
"mcu_name",
"==",
"NULL",
"||",
"executed",
"==",
"1",
")",
"return",
";",
"executed",
"=",
"1",
";",
"switch",
"(",
"parse_devices_csv",
"(",
"mcu_name",
")",
")",
"{",
"case",
"0",
":",
"return",
";",
"case",
"1",
":",
"break",
";",
"case",
"2",
":",
"devices_csv_not_found",
"=",
"1",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"for",
"(",
"i",
"=",
"ARRAY_SIZE",
"(",
"hard_msp430_mcu_data",
")",
";",
"i",
"--",
";",
")",
"if",
"(",
"strcasecmp",
"(",
"mcu_name",
",",
"hard_msp430_mcu_data",
"[",
"i",
"]",
".",
"name",
")",
"==",
"0",
")",
"{",
"extracted_mcu_data",
"=",
"hard_msp430_mcu_data",
"[",
"i",
"]",
";",
"break",
";",
"}",
"if",
"(",
"extracted_mcu_data",
".",
"name",
"!=",
"NULL",
")",
"{",
"switch",
"(",
"extracted_mcu_data",
".",
"hwmpy",
")",
"{",
"case",
"0",
":",
"case",
"1",
":",
"case",
"2",
":",
"case",
"4",
":",
"case",
"8",
":",
"break",
";",
"default",
":",
"error",
"(",
"\"unrecognized %<hwmpy%> field in \"",
"\"%<hard_msp430_mcu_data[%d]%>: %qd\"",
",",
"i",
",",
"hard_msp430_mcu_data",
"[",
"i",
"]",
".",
"hwmpy",
")",
";",
"break",
";",
"}",
"switch",
"(",
"extracted_mcu_data",
".",
"revision",
")",
"{",
"case",
"0",
":",
"case",
"1",
":",
"case",
"2",
":",
"break",
";",
"default",
":",
"error",
"(",
"\"unrecognized %<revision%> field in \"",
"\"%<hard_msp430_mcu_data[%d]%>: %qd\"",
",",
"i",
",",
"hard_msp430_mcu_data",
"[",
"i",
"]",
".",
"revision",
")",
";",
"}",
"}",
"else",
"if",
"(",
"msp430_warn_devices_csv",
"&&",
"devices_csv_not_found",
")",
"warning",
"(",
"0",
",",
"\"could not locate MCU data file %<devices.csv%>\"",
")",
";",
"else",
"if",
"(",
"msp430_warn_mcu",
"&&",
"extracted_mcu_data",
".",
"name",
"==",
"NULL",
")",
"{",
"}",
"}",
"</s>"
] | [
"Main",
"entry",
"point",
"to",
"load",
"the",
"MCU",
"data",
"for",
"the",
"given",
"-mmcu",
"into",
"extracted_mcu_data",
".",
"First",
",",
"the",
"``",
"devices.csv",
"''",
"MCU",
"data",
"file",
"is",
"searched",
"for",
",",
"if",
"it",
"is",
"found",
",",
"and",
"the",
"MCU",
"has",
"a",
"record",
"in",
"it",
",",
"then",
"that",
"data",
"is",
"used",
".",
"Otherwise",
",",
"hard_msp430_mcu_data",
"(",
"initialized",
"at",
"the",
"bottom",
"of",
"this",
"file",
")",
"is",
"searched",
"for",
"the",
"MCU",
"name",
".",
"This",
"function",
"only",
"needs",
"to",
"be",
"executed",
"once",
",",
"but",
"it",
"can",
"be",
"first",
"called",
"from",
"a",
"number",
"of",
"different",
"locations",
"."
] | [
"msp430",
"0",
"0",
"1",
"1",
"0",
"1",
"2",
"1",
"0",
"0",
"1",
"2",
"4",
"8",
"\"unrecognized %<hwmpy%> field in \"",
"\"%<hard_msp430_mcu_data[%d]%>: %qd\"",
"0",
"1",
"2",
"\"unrecognized %<revision%> field in \"",
"\"%<hard_msp430_mcu_data[%d]%>: %qd\"",
"0",
"\"could not locate MCU data file %<devices.csv%>\""
] | msp430-devices | msp430_extract_mcu_data | msp430 | MPU | GCC | 26,076 | 231 | 1 | [] |
[
"<s>",
"unsigned",
"X86VectorTargetTransformInfo",
"::",
"getNumberOfRegisters",
"(",
"bool",
"Vector",
")",
"const",
"{",
"const",
"X86Subtarget",
"&",
"ST",
"=",
"TLI",
"->",
"getTargetMachine",
"(",
")",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"if",
"(",
"ST",
".",
"is64Bit",
"(",
")",
")",
"return",
"16",
";",
"return",
"8",
";",
"}",
"</s>"
] | [
"�",
"?",
"Vector",
"TTI",
"begin",
"�",
"?"
] | [
"X86",
"X86",
"X86",
"X86",
"16",
"8"
] | X86ISelLowering98 | getNumberOfRegisters | X86 | CPU | LLVM | 26,077 | 43 | 1 | [] |
[
"<s>",
"int",
"pa_attr_length_millicode_call",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"unsigned",
"long",
"distance",
"=",
"-",
"1",
";",
"unsigned",
"long",
"total",
"=",
"IN_NAMED_SECTION_P",
"(",
"cfun",
"->",
"decl",
")",
"?",
"0",
":",
"total_code_bytes",
";",
"if",
"(",
"INSN_ADDRESSES_SET_P",
"(",
")",
")",
"{",
"distance",
"=",
"(",
"total",
"+",
"insn_current_reference_address",
"(",
"insn",
")",
")",
";",
"if",
"(",
"distance",
"<",
"total",
")",
"distance",
"=",
"-",
"1",
";",
"}",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"if",
"(",
"!",
"TARGET_LONG_CALLS",
"&&",
"distance",
"<",
"7600000",
")",
"return",
"8",
";",
"return",
"20",
";",
"}",
"else",
"if",
"(",
"TARGET_PORTABLE_RUNTIME",
")",
"return",
"24",
";",
"else",
"{",
"if",
"(",
"!",
"TARGET_LONG_CALLS",
"&&",
"distance",
"<",
"MAX_PCREL17F_OFFSET",
")",
"return",
"8",
";",
"if",
"(",
"!",
"flag_pic",
")",
"return",
"12",
";",
"return",
"24",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"attribute",
"length",
"for",
"the",
"millicode",
"call",
"instruction",
"INSN",
".",
"The",
"length",
"must",
"match",
"the",
"code",
"generated",
"by",
"pa_output_millicode_call",
".",
"We",
"include",
"the",
"delay",
"slot",
"in",
"the",
"returned",
"length",
"as",
"it",
"is",
"better",
"to",
"over",
"estimate",
"the",
"length",
"than",
"to",
"under",
"estimate",
"it",
"."
] | [
"pa",
"1",
"0",
"1",
"7600000",
"8",
"20",
"24",
"8",
"12",
"24"
] | pa | pa_attr_length_millicode_call | pa | CPU | GCC | 26,078 | 116 | 1 | [] |
[
"<s>",
"rtx",
"visium_return_addr_rtx",
"(",
"int",
"count",
",",
"rtx",
"frame",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"count",
"!=",
"0",
")",
"return",
"NULL_RTX",
";",
"visium_frame_needed",
"=",
"true",
";",
"return",
"gen_frame_mem",
"(",
"Pmode",
",",
"plus_constant",
"(",
"Pmode",
",",
"hard_frame_pointer_rtx",
",",
"4",
")",
")",
";",
"}",
"</s>"
] | [
"A",
"C",
"expression",
"whose",
"value",
"is",
"RTL",
"representing",
"the",
"value",
"of",
"the",
"return",
"address",
"for",
"the",
"frame",
"COUNT",
"steps",
"up",
"from",
"the",
"current",
"frame",
",",
"after",
"the",
"prologue",
".",
"FRAMEADDR",
"is",
"the",
"frame",
"pointer",
"of",
"the",
"COUNT",
"frame",
",",
"or",
"the",
"frame",
"pointer",
"of",
"the",
"COUNT",
"-",
"1",
"frame",
"if",
"`",
"RETURN_ADDR_IN_PREVIOUS_FRAME",
"'",
"is",
"defined",
".",
"The",
"value",
"of",
"the",
"expression",
"must",
"always",
"be",
"the",
"correct",
"address",
"when",
"COUNT",
"is",
"zero",
",",
"but",
"may",
"be",
"`",
"NULL_RTX",
"'",
"if",
"there",
"is",
"not",
"way",
"to",
"determine",
"the",
"return",
"address",
"of",
"other",
"frames",
"."
] | [
"visium",
"0",
"4"
] | visium | visium_return_addr_rtx | visium | Virtual ISA | GCC | 26,079 | 40 | 1 | [] |
[
"<s>",
"static",
"void",
"tilegx_reorg",
"(",
"void",
")",
"{",
"compute_bb_for_insn",
"(",
")",
";",
"if",
"(",
"flag_reorder_blocks_and_partition",
")",
"{",
"tilegx_fixup_pcrel_references",
"(",
")",
";",
"}",
"if",
"(",
"flag_schedule_insns_after_reload",
")",
"{",
"split_all_insns",
"(",
")",
";",
"timevar_push",
"(",
"TV_SCHED2",
")",
";",
"schedule_insns",
"(",
")",
";",
"timevar_pop",
"(",
"TV_SCHED2",
")",
";",
"tilegx_gen_bundles",
"(",
")",
";",
"}",
"df_analyze",
"(",
")",
";",
"if",
"(",
"flag_var_tracking",
")",
"{",
"timevar_push",
"(",
"TV_VAR_TRACKING",
")",
";",
"variable_tracking_main",
"(",
")",
";",
"reorder_var_tracking_notes",
"(",
")",
";",
"timevar_pop",
"(",
"TV_VAR_TRACKING",
")",
";",
"}",
"df_finish_pass",
"(",
"false",
")",
";",
"}",
"</s>"
] | [
"Perform",
"machine",
"dependent",
"operations",
"on",
"the",
"rtl",
"chain",
"INSNS",
"."
] | [
"tilegx"
] | tilegx | tilegx_reorg | tilegx | VLIW | GCC | 26,080 | 83 | 1 | [] |
[
"<s>",
"std",
"::",
"string",
"AMDGPUIntrinsicInfo",
"::",
"getName",
"(",
"unsigned",
"IntrID",
",",
"Type",
"*",
"*",
"Tys",
",",
"unsigned",
"NumTys",
")",
"const",
"{",
"return",
"getName",
"(",
"IntrID",
",",
"makeArrayRef",
"(",
"Tys",
",",
"NumTys",
")",
")",
".",
"str",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"with",
"the",
"name",
"of",
"the",
"plan",
"and",
"the",
"applicable",
"VFs",
"and",
"UFs",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUIntrinsicInfo | getName | AMDGPU | GPU | LLVM | 26,081 | 38 | 1 | [] |
[
"<s>",
"void",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"override",
"{",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"BPF"
] | BPFFrameLowering4 | eliminateCallFramePseudoInstr | BPF | Virtual ISA | LLVM | 26,082 | 27 | 1 | [] |
[
"<s>",
"bool",
"csky_valid_fpuv2_mem_operand",
"(",
"rtx",
"op",
")",
"{",
"struct",
"csky_address",
"addr",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"!=",
"MEM",
")",
"return",
"false",
";",
"if",
"(",
"!",
"decompose_csky_address",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"&",
"addr",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"is_csky_address_register_rtx_p",
"(",
"addr",
".",
"base",
",",
"0",
")",
")",
"return",
"false",
";",
"if",
"(",
"addr",
".",
"index",
")",
"{",
"if",
"(",
"!",
"is_csky_address_register_rtx_p",
"(",
"addr",
".",
"index",
",",
"0",
")",
")",
"return",
"false",
";",
"if",
"(",
"addr",
".",
"scale",
"==",
"1",
"||",
"addr",
".",
"scale",
"==",
"2",
"||",
"addr",
".",
"scale",
"==",
"4",
"||",
"addr",
".",
"scale",
"==",
"8",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"addr",
".",
"disp",
")",
"{",
"rtx",
"disp",
"=",
"addr",
".",
"disp",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"disp",
")",
")",
"return",
"false",
";",
"if",
"(",
"(",
"(",
"unsigned",
")",
"INTVAL",
"(",
"disp",
")",
"%",
"4",
")",
"==",
"0",
"&&",
"(",
"unsigned",
")",
"INTVAL",
"(",
"disp",
")",
"<=",
"(",
"unsigned",
")",
"1020",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Support",
"for",
"the",
"Q",
"memory",
"constraint",
".",
"Returns",
"true",
"if",
"OP",
"is",
"a",
"MEM",
"RTX",
"with",
"an",
"address",
"consisting",
"of",
"base",
"+",
"index",
"or",
"base",
"+",
"displacement",
"."
] | [
"csky",
"0",
"0",
"0",
"1",
"2",
"4",
"8",
"4",
"0",
"1020"
] | csky | csky_valid_fpuv2_mem_operand | csky | CPU | GCC | 26,083 | 178 | 1 | [] |
[
"<s>",
"TargetTransformInfo",
"MipsTargetMachine",
"::",
"getTargetTransformInfo",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"if",
"(",
"Subtarget",
"->",
"allowMixed16_32",
"(",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"No Target Transform Info Pass Added\\n\"",
")",
";",
"return",
"TargetTransformInfo",
"(",
"F",
".",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
")",
";",
"}",
"LLVM_DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"Target Transform Info Pass Added\\n\"",
")",
";",
"return",
"TargetTransformInfo",
"(",
"BasicTTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetTransformInfo",
"implementation",
"for",
"the",
"target",
"."
] | [
"Mips",
"Mips",
"\"No Target Transform Info Pass Added\\n\"",
"\"Target Transform Info Pass Added\\n\""
] | MipsTargetMachine43 | getTargetTransformInfo | Mips | CPU | LLVM | 26,084 | 66 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_sim_finish_insn",
"(",
"struct",
"mips_sim",
"*",
"state",
",",
"rtx",
"insn",
")",
"{",
"if",
"(",
"JUMP_P",
"(",
"insn",
")",
")",
"mips_sim_issue_nop",
"(",
"state",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"SEQ_BEGIN",
"(",
"insn",
")",
")",
")",
"{",
"case",
"CODE_LABEL",
":",
"case",
"CALL_INSN",
":",
"mips_sim_reset",
"(",
"state",
")",
";",
"break",
";",
"case",
"JUMP_INSN",
":",
"if",
"(",
"INSN_ANNULLED_BRANCH_P",
"(",
"SEQ_BEGIN",
"(",
"insn",
")",
")",
")",
"mips_sim_reset",
"(",
"state",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"</s>"
] | [
"Update",
"simulation",
"state",
"STATE",
"so",
"that",
"it",
"'s",
"ready",
"to",
"accept",
"the",
"instruction",
"after",
"INSN",
".",
"INSN",
"should",
"be",
"part",
"of",
"the",
"main",
"rtl",
"chain",
",",
"not",
"a",
"member",
"of",
"a",
"SEQUENCE",
"."
] | [
"mips"
] | mips3 | mips_sim_finish_insn | mips | CPU | GCC | 26,085 | 75 | 1 | [] |
[
"<s>",
"void",
"UPTInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"if",
"(",
"!",
"printAliasInstr",
"(",
"MI",
",",
"O",
")",
")",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"UPT",
"UPT"
] | UPTInstPrinter | printInst | UPT | CPU | LLVM | 26,086 | 48 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_vectorize_vec_perm_const",
"(",
"machine_mode",
"vmode",
",",
"machine_mode",
"op_mode",
",",
"rtx",
"target",
",",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"const",
"vec_perm_indices",
"&",
"sel",
")",
"{",
"if",
"(",
"vmode",
"!=",
"op_mode",
")",
"return",
"false",
";",
"struct",
"expand_vec_perm_d",
"d",
";",
"int",
"i",
",",
"nelt",
",",
"which",
";",
"if",
"(",
"!",
"VALID_NEON_DREG_MODE",
"(",
"vmode",
")",
"&&",
"!",
"VALID_NEON_QREG_MODE",
"(",
"vmode",
")",
")",
"return",
"false",
";",
"d",
".",
"target",
"=",
"target",
";",
"if",
"(",
"op0",
")",
"{",
"rtx",
"nop0",
"=",
"force_reg",
"(",
"vmode",
",",
"op0",
")",
";",
"if",
"(",
"op0",
"==",
"op1",
")",
"op1",
"=",
"nop0",
";",
"op0",
"=",
"nop0",
";",
"}",
"if",
"(",
"op1",
")",
"op1",
"=",
"force_reg",
"(",
"vmode",
",",
"op1",
")",
";",
"d",
".",
"op0",
"=",
"op0",
";",
"d",
".",
"op1",
"=",
"op1",
";",
"d",
".",
"vmode",
"=",
"vmode",
";",
"gcc_assert",
"(",
"VECTOR_MODE_P",
"(",
"d",
".",
"vmode",
")",
")",
";",
"d",
".",
"testing_p",
"=",
"!",
"target",
";",
"nelt",
"=",
"GET_MODE_NUNITS",
"(",
"d",
".",
"vmode",
")",
";",
"for",
"(",
"i",
"=",
"which",
"=",
"0",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"{",
"int",
"ei",
"=",
"sel",
"[",
"i",
"]",
"&",
"(",
"2",
"*",
"nelt",
"-",
"1",
")",
";",
"which",
"|=",
"(",
"ei",
"<",
"nelt",
"?",
"1",
":",
"2",
")",
";",
"}",
"switch",
"(",
"which",
")",
"{",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"case",
"3",
":",
"d",
".",
"one_vector_p",
"=",
"false",
";",
"if",
"(",
"d",
".",
"testing_p",
"||",
"!",
"rtx_equal_p",
"(",
"op0",
",",
"op1",
")",
")",
"break",
";",
"case",
"2",
":",
"d",
".",
"op0",
"=",
"op1",
";",
"d",
".",
"one_vector_p",
"=",
"true",
";",
"break",
";",
"case",
"1",
":",
"d",
".",
"op1",
"=",
"op0",
";",
"d",
".",
"one_vector_p",
"=",
"true",
";",
"break",
";",
"}",
"d",
".",
"perm",
".",
"new_vector",
"(",
"sel",
".",
"encoding",
"(",
")",
",",
"d",
".",
"one_vector_p",
"?",
"1",
":",
"2",
",",
"nelt",
")",
";",
"if",
"(",
"!",
"d",
".",
"testing_p",
")",
"return",
"arm_expand_vec_perm_const_1",
"(",
"&",
"d",
")",
";",
"d",
".",
"target",
"=",
"gen_raw_REG",
"(",
"d",
".",
"vmode",
",",
"LAST_VIRTUAL_REGISTER",
"+",
"1",
")",
";",
"d",
".",
"op1",
"=",
"d",
".",
"op0",
"=",
"gen_raw_REG",
"(",
"d",
".",
"vmode",
",",
"LAST_VIRTUAL_REGISTER",
"+",
"2",
")",
";",
"if",
"(",
"!",
"d",
".",
"one_vector_p",
")",
"d",
".",
"op1",
"=",
"gen_raw_REG",
"(",
"d",
".",
"vmode",
",",
"LAST_VIRTUAL_REGISTER",
"+",
"3",
")",
";",
"start_sequence",
"(",
")",
";",
"bool",
"ret",
"=",
"arm_expand_vec_perm_const_1",
"(",
"&",
"d",
")",
";",
"end_sequence",
"(",
")",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_VECTORIZE_VEC_PERM_CONST",
"."
] | [
"arm",
"0",
"2",
"1",
"1",
"2",
"3",
"2",
"1",
"1",
"2",
"1",
"2",
"3"
] | arm1 | arm_vectorize_vec_perm_const | arm | CPU | GCC | 26,087 | 385 | 1 | [] |
[
"<s>",
"static",
"bool",
"or1k_legitimate_address_p",
"(",
"machine_mode",
",",
"rtx",
"x",
",",
"bool",
"strict_p",
")",
"{",
"rtx",
"base",
",",
"addend",
";",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"REG",
":",
"base",
"=",
"x",
";",
"break",
";",
"case",
"PLUS",
":",
"base",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"addend",
"=",
"XEXP",
"(",
"x",
",",
"1",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"base",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"strict_p",
"&&",
"virtual_frame_reg_operand",
"(",
"base",
",",
"VOIDmode",
")",
")",
"return",
"CONST_INT_P",
"(",
"addend",
")",
";",
"if",
"(",
"!",
"satisfies_constraint_I",
"(",
"addend",
")",
")",
"return",
"false",
";",
"break",
";",
"case",
"LO_SUM",
":",
"base",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"base",
")",
")",
"return",
"false",
";",
"x",
"=",
"XEXP",
"(",
"x",
",",
"1",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"CONST",
":",
"case",
"SYMBOL_REF",
":",
"case",
"LABEL_REF",
":",
"break",
";",
"case",
"UNSPEC",
":",
"switch",
"(",
"XINT",
"(",
"x",
",",
"1",
")",
")",
"{",
"case",
"UNSPEC_GOT",
":",
"case",
"UNSPEC_GOTOFF",
":",
"case",
"UNSPEC_TPOFF",
":",
"case",
"UNSPEC_GOTTPOFF",
":",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"unsigned",
"regno",
"=",
"REGNO",
"(",
"base",
")",
";",
"if",
"(",
"regno",
">=",
"FIRST_PSEUDO_REGISTER",
")",
"{",
"if",
"(",
"strict_p",
")",
"regno",
"=",
"reg_renumber",
"[",
"regno",
"]",
";",
"else",
"return",
"true",
";",
"}",
"if",
"(",
"strict_p",
")",
"return",
"regno",
"<=",
"31",
";",
"else",
"return",
"REGNO_OK_FOR_BASE_P",
"(",
"regno",
")",
";",
"}",
"</s>"
] | [
"Worker",
"for",
"TARGET_LEGITIMATE_ADDRESS_P",
".",
"Returns",
"true",
"if",
"X",
"is",
"a",
"legitimate",
"address",
"RTX",
"on",
"OpenRISC",
"."
] | [
"or1k",
"0",
"1",
"0",
"1",
"1",
"31"
] | or1k | or1k_legitimate_address_p | or1k | CPU | GCC | 26,088 | 246 | 1 | [] |
[
"<s>",
"static",
"void",
"vr4130_true_reg_dependence_p_1",
"(",
"rtx",
"x",
",",
"const_rtx",
"pat",
"ATTRIBUTE_UNUSED",
",",
"void",
"*",
"data",
")",
"{",
"rtx",
"*",
"insn_ptr",
";",
"insn_ptr",
"=",
"(",
"rtx",
"*",
")",
"data",
";",
"if",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"*",
"insn_ptr",
"!=",
"0",
"&&",
"reg_referenced_p",
"(",
"x",
",",
"PATTERN",
"(",
"*",
"insn_ptr",
")",
")",
")",
"*",
"insn_ptr",
"=",
"0",
";",
"}",
"</s>"
] | [
"A",
"note_stores",
"callback",
"used",
"by",
"vr4130_true_reg_dependence_p",
".",
"DATA",
"points",
"to",
"an",
"rtx",
"that",
"is",
"initially",
"an",
"instruction",
".",
"Nullify",
"the",
"rtx",
"if",
"the",
"instruction",
"uses",
"the",
"value",
"of",
"register",
"X",
"."
] | [
"mips",
"0",
"0"
] | mips | vr4130_true_reg_dependence_p_1 | mips | CPU | GCC | 26,089 | 57 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"PowerPC Machine Code Emitter\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"PowerPC",
"\"PowerPC Machine Code Emitter\""
] | PPCCodeEmitter | getPassName | PowerPC | CPU | LLVM | 26,090 | 13 | 1 | [] |
[
"<s>",
"bool",
"aarch64_is_long_call_p",
"(",
"rtx",
"sym",
")",
"{",
"return",
"aarch64_decl_is_long_call_p",
"(",
"SYMBOL_REF_DECL",
"(",
"sym",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"calls",
"to",
"symbol-ref",
"SYM",
"should",
"be",
"treated",
"as",
"long-calls",
"(",
"ie",
"called",
"via",
"a",
"register",
")",
"."
] | [
"aarch64"
] | aarch64 | aarch64_is_long_call_p | aarch64 | CPU | GCC | 26,091 | 17 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"SITargetLowering",
"::",
"shouldExpandAtomicRMWInIR",
"(",
"AtomicRMWInst",
"*",
"RMW",
")",
"const",
"{",
"auto",
"ReportUnsafeHWInst",
"=",
"[",
"&",
"]",
"(",
"TargetLowering",
"::",
"AtomicExpansionKind",
"Kind",
")",
"{",
"OptimizationRemarkEmitter",
"ORE",
"(",
"RMW",
"->",
"getFunction",
"(",
")",
")",
";",
"LLVMContext",
"&",
"Ctx",
"=",
"RMW",
"->",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"SmallVector",
"<",
"StringRef",
">",
"SSNs",
";",
"Ctx",
".",
"getSyncScopeNames",
"(",
"SSNs",
")",
";",
"auto",
"MemScope",
"=",
"SSNs",
"[",
"RMW",
"->",
"getSyncScopeID",
"(",
")",
"]",
".",
"empty",
"(",
")",
"?",
"\"system\"",
":",
"SSNs",
"[",
"RMW",
"->",
"getSyncScopeID",
"(",
")",
"]",
";",
"ORE",
".",
"emit",
"(",
"[",
"&",
"]",
"(",
")",
"{",
"return",
"OptimizationRemark",
"(",
"DEBUG_TYPE",
",",
"\"Passed\"",
",",
"RMW",
")",
"<<",
"\"Hardware instruction generated for atomic \"",
"<<",
"RMW",
"->",
"getOperationName",
"(",
"RMW",
"->",
"getOperation",
"(",
")",
")",
"<<",
"\" operation at memory scope \"",
"<<",
"MemScope",
"<<",
"\" due to an unsafe request.\"",
";",
"}",
")",
";",
"return",
"Kind",
";",
"}",
";",
"switch",
"(",
"RMW",
"->",
"getOperation",
"(",
")",
")",
"{",
"case",
"AtomicRMWInst",
"::",
"FAdd",
":",
"{",
"Type",
"*",
"Ty",
"=",
"RMW",
"->",
"getType",
"(",
")",
";",
"if",
"(",
"Ty",
"->",
"isHalfTy",
"(",
")",
")",
"return",
"AtomicExpansionKind",
"::",
"None",
";",
"if",
"(",
"!",
"Ty",
"->",
"isFloatTy",
"(",
")",
"&&",
"(",
"!",
"Subtarget",
"->",
"hasGFX90AInsts",
"(",
")",
"||",
"!",
"Ty",
"->",
"isDoubleTy",
"(",
")",
")",
")",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"unsigned",
"AS",
"=",
"RMW",
"->",
"getPointerAddressSpace",
"(",
")",
";",
"if",
"(",
"(",
"AS",
"==",
"AMDGPUAS",
"::",
"GLOBAL_ADDRESS",
"||",
"AS",
"==",
"AMDGPUAS",
"::",
"FLAT_ADDRESS",
")",
"&&",
"Subtarget",
"->",
"hasAtomicFaddInsts",
"(",
")",
")",
"{",
"if",
"(",
"RMW",
"->",
"getFunction",
"(",
")",
"->",
"getFnAttribute",
"(",
"\"amdgpu-unsafe-fp-atomics\"",
")",
".",
"getValueAsString",
"(",
")",
"!=",
"\"true\"",
")",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"if",
"(",
"Subtarget",
"->",
"hasGFX90AInsts",
"(",
")",
")",
"{",
"if",
"(",
"Ty",
"->",
"isFloatTy",
"(",
")",
"&&",
"AS",
"==",
"AMDGPUAS",
"::",
"FLAT_ADDRESS",
")",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"auto",
"SSID",
"=",
"RMW",
"->",
"getSyncScopeID",
"(",
")",
";",
"if",
"(",
"SSID",
"==",
"SyncScope",
"::",
"System",
"||",
"SSID",
"==",
"RMW",
"->",
"getContext",
"(",
")",
".",
"getOrInsertSyncScopeID",
"(",
"\"one-as\"",
")",
")",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"return",
"ReportUnsafeHWInst",
"(",
"AtomicExpansionKind",
"::",
"None",
")",
";",
"}",
"if",
"(",
"AS",
"==",
"AMDGPUAS",
"::",
"FLAT_ADDRESS",
")",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"return",
"RMW",
"->",
"use_empty",
"(",
")",
"?",
"ReportUnsafeHWInst",
"(",
"AtomicExpansionKind",
"::",
"None",
")",
":",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"}",
"if",
"(",
"AS",
"==",
"AMDGPUAS",
"::",
"LOCAL_ADDRESS",
"&&",
"Subtarget",
"->",
"hasLDSFPAtomicAdd",
"(",
")",
")",
"{",
"if",
"(",
"!",
"Ty",
"->",
"isDoubleTy",
"(",
")",
")",
"return",
"AtomicExpansionKind",
"::",
"None",
";",
"if",
"(",
"fpModeMatchesGlobalFPAtomicMode",
"(",
"RMW",
")",
")",
"return",
"AtomicExpansionKind",
"::",
"None",
";",
"return",
"RMW",
"->",
"getFunction",
"(",
")",
"->",
"getFnAttribute",
"(",
"\"amdgpu-unsafe-fp-atomics\"",
")",
".",
"getValueAsString",
"(",
")",
"==",
"\"true\"",
"?",
"ReportUnsafeHWInst",
"(",
"AtomicExpansionKind",
"::",
"None",
")",
":",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"}",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"}",
"default",
":",
"break",
";",
"}",
"return",
"AMDGPUTargetLowering",
"::",
"shouldExpandAtomicRMWInIR",
"(",
"RMW",
")",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"IR-level",
"AtomicExpand",
"pass",
"should",
"expand",
"the",
"given",
"AtomicRMW",
",",
"if",
"at",
"all",
"."
] | [
"AMDGPU",
"SI",
"\"system\"",
"\"Passed\"",
"\"Hardware instruction generated for atomic \"",
"\" operation at memory scope \"",
"\" due to an unsafe request.\"",
"AMDGPU",
"AMDGPU",
"\"amdgpu-unsafe-fp-atomics\"",
"\"true\"",
"AMDGPU",
"SI",
"SI",
"SI",
"\"one-as\"",
"AMDGPU",
"AMDGPU",
"\"amdgpu-unsafe-fp-atomics\"",
"\"true\"",
"AMDGPU"
] | SIISelLowering118 | shouldExpandAtomicRMWInIR | AMDGPU | GPU | LLVM | 26,092 | 456 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyReplacePhysRegs",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"********** Replace Physical Registers **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
";",
"}",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"auto",
"&",
"TRI",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"assert",
"(",
"!",
"mustPreserveAnalysisID",
"(",
"LiveIntervalsID",
")",
"&&",
"\"LiveIntervals shouldn't be active yet!\"",
")",
";",
"MRI",
".",
"leaveSSA",
"(",
")",
";",
"MRI",
".",
"invalidateLiveness",
"(",
")",
";",
"for",
"(",
"unsigned",
"PReg",
"=",
"WebAssembly",
"::",
"NoRegister",
"+",
"1",
";",
"PReg",
"<",
"WebAssembly",
"::",
"NUM_TARGET_REGS",
";",
"++",
"PReg",
")",
"{",
"if",
"(",
"PReg",
"==",
"WebAssembly",
"::",
"VALUE_STACK",
"||",
"PReg",
"==",
"WebAssembly",
"::",
"ARGUMENTS",
")",
"continue",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
".",
"getMinimalPhysRegClass",
"(",
"PReg",
")",
";",
"unsigned",
"VReg",
"=",
"WebAssembly",
"::",
"NoRegister",
";",
"for",
"(",
"auto",
"I",
"=",
"MRI",
".",
"reg_begin",
"(",
"PReg",
")",
",",
"E",
"=",
"MRI",
".",
"reg_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"MachineOperand",
"&",
"MO",
"=",
"*",
"I",
"++",
";",
"if",
"(",
"!",
"MO",
".",
"isImplicit",
"(",
")",
")",
"{",
"if",
"(",
"VReg",
"==",
"WebAssembly",
"::",
"NoRegister",
")",
"VReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"MO",
".",
"setReg",
"(",
"VReg",
")",
";",
"if",
"(",
"MO",
".",
"getParent",
"(",
")",
"->",
"isDebugValue",
"(",
")",
")",
"MO",
".",
"setIsDebug",
"(",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Replace Physical Registers **********\\n\"",
"\"********** Function: \"",
"WebAssembly",
"\"LiveIntervals shouldn't be active yet!\"",
"WebAssembly::NoRegister",
"1",
"WebAssembly::NUM_TARGET_REGS",
"WebAssembly::VALUE_STACK",
"WebAssembly::ARGUMENTS",
"WebAssembly::NoRegister",
"WebAssembly::NoRegister"
] | WebAssemblyReplacePhysRegs16 | runOnMachineFunction | WebAssembly | Virtual ISA | LLVM | 26,093 | 242 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"M88kRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"return",
"CSR_M88k_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"M88k",
"M88k",
"M88k"
] | M88kRegisterInfo | getCalleeSavedRegs | M88k | MPU | LLVM | 26,094 | 18 | 1 | [] |
[
"<s>",
"TargetTransformInfo",
"TPCTargetMachine",
"::",
"getTargetTransformInfo",
"(",
"const",
"Function",
"&",
"F",
")",
"{",
"return",
"TargetTransformInfo",
"(",
"TPCTTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetTransformInfo",
"implementation",
"for",
"the",
"target",
"."
] | [
"TPC",
"TPC",
"TPC"
] | TPCTargetMachine | getTargetTransformInfo | TPC | Virtual ISA | LLVM | 26,095 | 23 | 1 | [] |
[
"<s>",
"bool",
"AVRAsmParser",
"::",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
"Info",
",",
"StringRef",
"Mnemonic",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"{",
"Operands",
".",
"push_back",
"(",
"AVROperand",
"::",
"CreateToken",
"(",
"Mnemonic",
",",
"NameLoc",
")",
")",
";",
"bool",
"first",
"=",
"true",
";",
"while",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"if",
"(",
"!",
"first",
")",
"eatComma",
"(",
")",
";",
"first",
"=",
"false",
";",
"auto",
"MatchResult",
"=",
"MatchOperandParserImpl",
"(",
"Operands",
",",
"Mnemonic",
")",
";",
"if",
"(",
"MatchResult",
"==",
"MatchOperand_Success",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"MatchResult",
"==",
"MatchOperand_ParseFail",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"failed to parse register and immediate pair\"",
")",
";",
"}",
"if",
"(",
"parseOperand",
"(",
"Operands",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"unexpected token in argument list\"",
")",
";",
"}",
"}",
"Parser",
".",
"Lex",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"AVR",
"AVR",
"AVROperand::CreateToken",
"\"failed to parse register and immediate pair\"",
"\"unexpected token in argument list\""
] | AVRAsmParser | ParseInstruction | AVR | MPU | LLVM | 26,096 | 164 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"isInlineConstant",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"unsigned",
"OpIdx",
")",
"const",
"{",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MII",
".",
"get",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"!",
"AMDGPU",
"::",
"isSISrcOperand",
"(",
"Desc",
",",
"OpIdx",
")",
")",
"{",
"return",
"false",
";",
"}",
"const",
"MCOperand",
"&",
"MO",
"=",
"Inst",
".",
"getOperand",
"(",
"OpIdx",
")",
";",
"int64_t",
"Val",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"auto",
"OpSize",
"=",
"AMDGPU",
"::",
"getOperandSize",
"(",
"Desc",
",",
"OpIdx",
")",
";",
"switch",
"(",
"OpSize",
")",
"{",
"case",
"8",
":",
"return",
"AMDGPU",
"::",
"isInlinableLiteral64",
"(",
"Val",
",",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"case",
"4",
":",
"return",
"AMDGPU",
"::",
"isInlinableLiteral32",
"(",
"Val",
",",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"case",
"2",
":",
"{",
"const",
"unsigned",
"OperandType",
"=",
"Desc",
".",
"OpInfo",
"[",
"OpIdx",
"]",
".",
"OperandType",
";",
"if",
"(",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_IMM_INT16",
"||",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_INT16",
"||",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_INT16",
")",
"return",
"AMDGPU",
"::",
"isInlinableIntLiteral",
"(",
"Val",
")",
";",
"if",
"(",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_V2INT16",
"||",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_V2INT16",
"||",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_IMM_V2INT16",
")",
"return",
"AMDGPU",
"::",
"isInlinableIntLiteralV216",
"(",
"Val",
")",
";",
"if",
"(",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_V2FP16",
"||",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_AC_V2FP16",
"||",
"OperandType",
"==",
"AMDGPU",
"::",
"OPERAND_REG_IMM_V2FP16",
")",
"return",
"AMDGPU",
"::",
"isInlinableLiteralV216",
"(",
"Val",
",",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"return",
"AMDGPU",
"::",
"isInlinableLiteral16",
"(",
"Val",
",",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"}",
"default",
":",
"llvm_unreachable",
"(",
"\"invalid operand size\"",
")",
";",
"}",
"}",
"</s>"
] | [
"returns",
"true",
"if",
"the",
"operand",
"OpIdx",
"in",
"MI",
"is",
"a",
"valid",
"inline",
"immediate",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::isSISrcOperand",
"AMDGPU::getOperandSize",
"8",
"AMDGPU::isInlinableLiteral64",
"4",
"AMDGPU::isInlinableLiteral32",
"2",
"AMDGPU::OPERAND_REG_IMM_INT16",
"AMDGPU::OPERAND_REG_INLINE_C_INT16",
"AMDGPU::OPERAND_REG_INLINE_AC_INT16",
"AMDGPU::isInlinableIntLiteral",
"AMDGPU::OPERAND_REG_INLINE_C_V2INT16",
"AMDGPU::OPERAND_REG_INLINE_AC_V2INT16",
"AMDGPU::OPERAND_REG_IMM_V2INT16",
"AMDGPU::isInlinableIntLiteralV216",
"AMDGPU::OPERAND_REG_INLINE_C_V2FP16",
"AMDGPU::OPERAND_REG_INLINE_AC_V2FP16",
"AMDGPU::OPERAND_REG_IMM_V2FP16",
"AMDGPU::isInlinableLiteralV216",
"AMDGPU::isInlinableLiteral16",
"\"invalid operand size\""
] | AMDGPUAsmParser1 | isInlineConstant | AMDGPU | GPU | LLVM | 26,097 | 243 | 1 | [] |
[
"<s>",
"void",
"init_cumulative_args",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"tree",
"fntype",
",",
"rtx",
"libname",
"ATTRIBUTE_UNUSED",
")",
"{",
"static",
"CUMULATIVE_ARGS",
"zero_cum",
";",
"tree",
"param",
";",
"tree",
"next_param",
";",
"if",
"(",
"TARGET_DEBUG_D_MODE",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"\\ninit_cumulative_args, fntype = 0x%.8lx\"",
",",
"(",
"long",
")",
"fntype",
")",
";",
"if",
"(",
"!",
"fntype",
")",
"fputc",
"(",
"'\\n'",
",",
"stderr",
")",
";",
"else",
"{",
"tree",
"ret_type",
"=",
"TREE_TYPE",
"(",
"fntype",
")",
";",
"fprintf",
"(",
"stderr",
",",
"\", fntype code = %s, ret code = %s\\n\"",
",",
"tree_code_name",
"[",
"(",
"int",
")",
"TREE_CODE",
"(",
"fntype",
")",
"]",
",",
"tree_code_name",
"[",
"(",
"int",
")",
"TREE_CODE",
"(",
"ret_type",
")",
"]",
")",
";",
"}",
"}",
"*",
"cum",
"=",
"zero_cum",
";",
"for",
"(",
"param",
"=",
"fntype",
"?",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
":",
"0",
";",
"param",
"!=",
"0",
";",
"param",
"=",
"next_param",
")",
"{",
"next_param",
"=",
"TREE_CHAIN",
"(",
"param",
")",
";",
"if",
"(",
"next_param",
"==",
"0",
"&&",
"TREE_VALUE",
"(",
"param",
")",
"!=",
"void_type_node",
")",
"cum",
"->",
"gp_reg_found",
"=",
"1",
";",
"}",
"}",
"</s>"
] | [
"Handle",
"the",
"INIT_CUMULATIVE_ARGS",
"macro",
".",
"Initialize",
"a",
"variable",
"CUM",
"of",
"type",
"CUMULATIVE_ARGS",
"for",
"a",
"call",
"to",
"a",
"function",
"whose",
"data",
"type",
"is",
"FNTYPE",
".",
"For",
"a",
"library",
"call",
",",
"FNTYPE",
"is",
"0",
"."
] | [
"iq2000",
"\"\\ninit_cumulative_args, fntype = 0x%.8lx\"",
"\", fntype code = %s, ret code = %s\\n\"",
"0",
"0",
"0",
"1"
] | iq20002 | init_cumulative_args | iq2000 | CPU | GCC | 26,098 | 150 | 1 | [] |
[
"<s>",
"int",
"ccr_bit",
"(",
"rtx",
"op",
",",
"int",
"scc_p",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"op",
")",
";",
"machine_mode",
"cc_mode",
";",
"int",
"cc_regnum",
";",
"int",
"base_bit",
";",
"rtx",
"reg",
";",
"if",
"(",
"!",
"COMPARISON_P",
"(",
"op",
")",
")",
"return",
"-",
"1",
";",
"reg",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"reg",
")",
"||",
"!",
"CR_REGNO_P",
"(",
"REGNO",
"(",
"reg",
")",
")",
")",
"return",
"-",
"1",
";",
"cc_mode",
"=",
"GET_MODE",
"(",
"reg",
")",
";",
"cc_regnum",
"=",
"REGNO",
"(",
"reg",
")",
";",
"base_bit",
"=",
"4",
"*",
"(",
"cc_regnum",
"-",
"CR0_REGNO",
")",
";",
"validate_condition_mode",
"(",
"code",
",",
"cc_mode",
")",
";",
"if",
"(",
"scc_p",
")",
"switch",
"(",
"code",
")",
"{",
"case",
"EQ",
":",
"case",
"GT",
":",
"case",
"LT",
":",
"case",
"UNORDERED",
":",
"case",
"GTU",
":",
"case",
"LTU",
":",
"break",
";",
"default",
":",
"return",
"-",
"1",
";",
"}",
"switch",
"(",
"code",
")",
"{",
"case",
"NE",
":",
"return",
"scc_p",
"?",
"base_bit",
"+",
"3",
":",
"base_bit",
"+",
"2",
";",
"case",
"EQ",
":",
"return",
"base_bit",
"+",
"2",
";",
"case",
"GT",
":",
"case",
"GTU",
":",
"case",
"UNLE",
":",
"return",
"base_bit",
"+",
"1",
";",
"case",
"LT",
":",
"case",
"LTU",
":",
"case",
"UNGE",
":",
"return",
"base_bit",
";",
"case",
"ORDERED",
":",
"case",
"UNORDERED",
":",
"return",
"base_bit",
"+",
"3",
";",
"case",
"GE",
":",
"case",
"GEU",
":",
"return",
"scc_p",
"?",
"base_bit",
"+",
"3",
":",
"base_bit",
";",
"case",
"LE",
":",
"case",
"LEU",
":",
"return",
"scc_p",
"?",
"base_bit",
"+",
"3",
":",
"base_bit",
"+",
"1",
";",
"default",
":",
"return",
"-",
"1",
";",
"}",
"}",
"</s>"
] | [
"Given",
"a",
"comparison",
"operation",
",",
"return",
"the",
"bit",
"number",
"in",
"CCR",
"to",
"test",
".",
"We",
"know",
"this",
"is",
"a",
"valid",
"comparison",
".",
"SCC_P",
"is",
"1",
"if",
"this",
"is",
"for",
"an",
"scc",
".",
"That",
"means",
"that",
"%",
"D",
"will",
"have",
"been",
"used",
"instead",
"of",
"%",
"C",
",",
"so",
"the",
"bits",
"will",
"be",
"in",
"different",
"places",
".",
"Return",
"-1",
"if",
"OP",
"is",
"n't",
"a",
"valid",
"comparison",
"for",
"some",
"reason",
"."
] | [
"rs6000",
"1",
"0",
"1",
"4",
"1",
"3",
"2",
"2",
"1",
"3",
"3",
"3",
"1",
"1"
] | rs6000 | ccr_bit | rs6000 | CPU | GCC | 26,099 | 244 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.