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>",
"unsigned",
"postOffset",
"(",
"unsigned",
"LogAlign",
"=",
"0",
")",
"const",
"{",
"unsigned",
"PO",
"=",
"Offset",
"+",
"Size",
";",
"if",
"(",
"!",
"LogAlign",
")",
"return",
"PO",
";",
"return",
"PO",
"+",
"UnknownPadding",
"(",
"LogAlign",
",",
"internalKnownBits",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"offset",
"immediately",
"following",
"this",
"block",
"."
] | [
"AArch64",
"0"
] | AArch64BranchFixupPass1 | postOffset | AArch64 | CPU | LLVM | 19,700 | 38 | 1 | [] |
[
"<s>",
"bool",
"ix86_agi_dependent",
"(",
"rtx_insn",
"*",
"set_insn",
",",
"rtx_insn",
"*",
"use_insn",
")",
"{",
"int",
"i",
";",
"extract_insn_cached",
"(",
"use_insn",
")",
";",
"for",
"(",
"i",
"=",
"recog_data",
".",
"n_operands",
"-",
"1",
";",
"i",
">=",
"0",
";",
"--",
"i",
")",
"if",
"(",
"MEM_P",
"(",
"recog_data",
".",
"operand",
"[",
"i",
"]",
")",
")",
"{",
"rtx",
"addr",
"=",
"XEXP",
"(",
"recog_data",
".",
"operand",
"[",
"i",
"]",
",",
"0",
")",
";",
"if",
"(",
"modified_in_p",
"(",
"addr",
",",
"set_insn",
")",
"!=",
"0",
")",
"{",
"rtx",
"set",
"=",
"single_set",
"(",
"set_insn",
")",
";",
"if",
"(",
"set",
"&&",
"(",
"push_operand",
"(",
"SET_DEST",
"(",
"set",
")",
",",
"GET_MODE",
"(",
"SET_DEST",
"(",
"set",
")",
")",
")",
"||",
"pop_operand",
"(",
"SET_SRC",
"(",
"set",
")",
",",
"GET_MODE",
"(",
"SET_SRC",
"(",
"set",
")",
")",
")",
")",
")",
"{",
"struct",
"ix86_address",
"parts",
";",
"if",
"(",
"ix86_decompose_address",
"(",
"addr",
",",
"&",
"parts",
")",
"&&",
"parts",
".",
"base",
"==",
"stack_pointer_rtx",
"&&",
"(",
"parts",
".",
"index",
"==",
"NULL_RTX",
"||",
"MEM_P",
"(",
"SET_DEST",
"(",
"set",
")",
")",
"||",
"!",
"modified_in_p",
"(",
"parts",
".",
"index",
",",
"set_insn",
")",
")",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"iff",
"USE_INSN",
"has",
"a",
"memory",
"address",
"with",
"operands",
"set",
"by",
"SET_INSN",
"."
] | [
"i386",
"1",
"0",
"0",
"0"
] | x86-tune-sched | ix86_agi_dependent | i386 | CPU | GCC | 19,701 | 186 | 1 | [] |
[
"<s>",
"static",
"void",
"add_to_sp",
"(",
"rtx",
"spreg",
",",
"HOST_WIDE_INT",
"value",
",",
"int",
"frame",
")",
"{",
"if",
"(",
"value",
"==",
"0",
")",
"return",
";",
"if",
"(",
"value",
">",
"120",
"||",
"value",
"<",
"-",
"120",
")",
"{",
"rtx",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"REG_P1",
")",
";",
"rtx",
"insn",
";",
"if",
"(",
"frame",
")",
"frame_related_constant_load",
"(",
"tmpreg",
",",
"value",
",",
"TRUE",
")",
";",
"else",
"{",
"insn",
"=",
"emit_move_insn",
"(",
"tmpreg",
",",
"GEN_INT",
"(",
"value",
")",
")",
";",
"if",
"(",
"frame",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"spreg",
",",
"spreg",
",",
"tmpreg",
")",
")",
";",
"if",
"(",
"frame",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"else",
"do",
"{",
"int",
"size",
"=",
"value",
";",
"rtx",
"insn",
";",
"if",
"(",
"size",
">",
"60",
")",
"size",
"=",
"60",
";",
"else",
"if",
"(",
"size",
"<",
"-",
"60",
")",
"size",
"=",
"-",
"60",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"spreg",
",",
"spreg",
",",
"GEN_INT",
"(",
"size",
")",
")",
")",
";",
"if",
"(",
"frame",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"value",
"-=",
"size",
";",
"}",
"while",
"(",
"value",
"!=",
"0",
")",
";",
"}",
"</s>"
] | [
"Generate",
"efficient",
"code",
"to",
"add",
"a",
"value",
"to",
"the",
"frame",
"pointer",
".",
"We",
"can",
"use",
"P1",
"as",
"a",
"scratch",
"register",
".",
"Set",
"RTX_FRAME_RELATED_P",
"on",
"the",
"generated",
"insns",
"if",
"FRAME",
"is",
"nonzero",
"."
] | [
"bfin",
"0",
"120",
"120",
"1",
"1",
"60",
"60",
"60",
"60",
"1",
"0"
] | bfin2 | add_to_sp | bfin | DSP | GCC | 19,702 | 187 | 1 | [] |
[
"<s>",
"static",
"rtx",
"nds32_expand_builtin_null_ftype_reg",
"(",
"enum",
"insn_code",
"icode",
",",
"tree",
"exp",
",",
"rtx",
"target",
")",
"{",
"struct",
"expand_operand",
"ops",
"[",
"1",
"]",
";",
"tree",
"arg0",
";",
"rtx",
"value0",
";",
"arg0",
"=",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"0",
")",
";",
"value0",
"=",
"expand_normal",
"(",
"arg0",
")",
";",
"create_input_operand",
"(",
"&",
"ops",
"[",
"0",
"]",
",",
"value0",
",",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"arg0",
")",
")",
")",
";",
"if",
"(",
"!",
"maybe_expand_insn",
"(",
"icode",
",",
"1",
",",
"ops",
")",
")",
"error",
"(",
"\"invalid argument to built-in function\"",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Function",
"to",
"expand",
"builtin",
"function",
"for",
"'",
"[",
"(",
"unspec_volatile",
"[",
"(",
"reg",
")",
"]",
")",
"]",
"'",
"."
] | [
"nds32",
"1",
"0",
"0",
"1",
"\"invalid argument to built-in function\""
] | nds32-intrinsic2 | nds32_expand_builtin_null_ftype_reg | nds32 | CPU | GCC | 19,703 | 84 | 1 | [] |
[
"<s>",
"static",
"bool",
"cdx_mov_immed",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"CONST_INT_P",
"(",
"op",
")",
")",
"{",
"HOST_WIDE_INT",
"ival",
"=",
"INTVAL",
"(",
"op",
")",
";",
"return",
"(",
"(",
"ival",
">=",
"0",
"&&",
"ival",
"<=",
"124",
")",
"||",
"ival",
"==",
"0xff",
"||",
"ival",
"==",
"-",
"2",
"||",
"ival",
"==",
"-",
"1",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"OP",
"is",
"within",
"range",
"of",
"CDX",
"movi.n",
"immediates",
"."
] | [
"nios2",
"0",
"124",
"0xff",
"2",
"1"
] | nios2 | cdx_mov_immed | nios2 | MPU | GCC | 19,704 | 56 | 1 | [] |
[
"<s>",
"static",
"poly_uint64",
"aarch64_vectorize_preferred_vector_alignment",
"(",
"const_tree",
"type",
")",
"{",
"if",
"(",
"aarch64_sve_data_mode_p",
"(",
"TYPE_MODE",
"(",
"type",
")",
")",
")",
"{",
"HOST_WIDE_INT",
"result",
";",
"if",
"(",
"!",
"GET_MODE_BITSIZE",
"(",
"TYPE_MODE",
"(",
"type",
")",
")",
".",
"is_constant",
"(",
"&",
"result",
")",
"||",
"!",
"pow2p_hwi",
"(",
"result",
")",
")",
"result",
"=",
"TYPE_ALIGN",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
";",
"return",
"result",
";",
"}",
"return",
"TYPE_ALIGN",
"(",
"type",
")",
";",
"}",
"</s>"
] | [
"Implement",
"target",
"hook",
"TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT",
"."
] | [
"aarch64"
] | aarch641 | aarch64_vectorize_preferred_vector_alignment | aarch64 | CPU | GCC | 19,705 | 66 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"mayBeEmittedAsTailCall",
"(",
"const",
"CallInst",
"*",
"CI",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
"->",
"supportsTailCall",
"(",
")",
")",
"return",
"false",
";",
"auto",
"Attr",
"=",
"CI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getFnAttribute",
"(",
"\"disable-tail-calls\"",
")",
";",
"if",
"(",
"!",
"CI",
"->",
"isTailCall",
"(",
")",
"||",
"Attr",
".",
"getValueAsString",
"(",
")",
"==",
"\"true\"",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"may",
"be",
"able",
"emit",
"the",
"call",
"instruction",
"as",
"a",
"tail",
"call",
"."
] | [
"ARM",
"ARM",
"\"disable-tail-calls\"",
"\"true\""
] | ARMISelLowering (2)6 | mayBeEmittedAsTailCall | ARM | CPU | LLVM | 19,706 | 66 | 1 | [] |
[
"<s>",
"const",
"AVRRegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"AVR",
"AVR"
] | AVRSubtarget | getRegisterInfo | AVR | MPU | LLVM | 19,707 | 18 | 1 | [] |
[
"<s>",
"SDValue",
"XCoreTargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_XCore",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"Chain",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
",",
"InFlag",
")",
".",
"getValue",
"(",
"1",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"2",
")",
";",
"InVals",
".",
"push_back",
"(",
"Chain",
".",
"getValue",
"(",
"0",
")",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"XCore",
"XCore",
"ISD::InputArg",
"16",
"XCore",
"0",
"1",
"2",
"0"
] | XCoreISelLowering15 | LowerCallResult | XCore | MPU | LLVM | 19,708 | 164 | 1 | [] |
[
"<s>",
"void",
"m68hc11_output_swap",
"(",
"rtx",
"insn",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"operands",
"[",
"]",
")",
"{",
"if",
"(",
"X_REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
"||",
"X_REG_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
"{",
"if",
"(",
"cc_prev_status",
".",
"value1",
"!=",
"0",
"&&",
"(",
"D_REG_P",
"(",
"cc_prev_status",
".",
"value1",
")",
"||",
"X_REG_P",
"(",
"cc_prev_status",
".",
"value1",
")",
")",
")",
"{",
"cc_status",
"=",
"cc_prev_status",
";",
"if",
"(",
"D_REG_P",
"(",
"cc_status",
".",
"value1",
")",
")",
"cc_status",
".",
"value1",
"=",
"gen_rtx_REG",
"(",
"GET_MODE",
"(",
"cc_status",
".",
"value1",
")",
",",
"HARD_X_REGNUM",
")",
";",
"else",
"cc_status",
".",
"value1",
"=",
"gen_rtx_REG",
"(",
"GET_MODE",
"(",
"cc_status",
".",
"value1",
")",
",",
"HARD_D_REGNUM",
")",
";",
"}",
"else",
"CC_STATUS_INIT",
";",
"output_asm_insn",
"(",
"\"xgdx\"",
",",
"operands",
")",
";",
"}",
"else",
"{",
"if",
"(",
"cc_prev_status",
".",
"value1",
"!=",
"0",
"&&",
"(",
"D_REG_P",
"(",
"cc_prev_status",
".",
"value1",
")",
"||",
"Y_REG_P",
"(",
"cc_prev_status",
".",
"value1",
")",
")",
")",
"{",
"cc_status",
"=",
"cc_prev_status",
";",
"if",
"(",
"D_REG_P",
"(",
"cc_status",
".",
"value1",
")",
")",
"cc_status",
".",
"value1",
"=",
"gen_rtx_REG",
"(",
"GET_MODE",
"(",
"cc_status",
".",
"value1",
")",
",",
"HARD_Y_REGNUM",
")",
";",
"else",
"cc_status",
".",
"value1",
"=",
"gen_rtx_REG",
"(",
"GET_MODE",
"(",
"cc_status",
".",
"value1",
")",
",",
"HARD_D_REGNUM",
")",
";",
"}",
"else",
"CC_STATUS_INIT",
";",
"output_asm_insn",
"(",
"\"xgdy\"",
",",
"operands",
")",
";",
"}",
"}",
"</s>"
] | [
"Code",
"generation",
"."
] | [
"m68hc11",
"1",
"0",
"0",
"\"xgdx\"",
"0",
"\"xgdy\""
] | m68hc111 | m68hc11_output_swap | m68hc11 | MPU | GCC | 19,709 | 201 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_xcoff_select_rtx_section",
"(",
"enum",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"unsigned",
"HOST_WIDE_INT",
"align",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"ASM_OUTPUT_SPECIAL_POOL_ENTRY_P",
"(",
"x",
",",
"mode",
")",
")",
"toc_section",
"(",
")",
";",
"else",
"read_only_private_data_section",
"(",
")",
";",
"}",
"</s>"
] | [
"Select",
"section",
"for",
"constant",
"in",
"constant",
"pool",
".",
"On",
"RS/6000",
",",
"all",
"constants",
"are",
"in",
"the",
"private",
"read-only",
"data",
"area",
".",
"However",
",",
"if",
"this",
"is",
"being",
"placed",
"in",
"the",
"TOC",
"it",
"must",
"be",
"output",
"as",
"a",
"toc",
"entry",
"."
] | [
"rs6000"
] | rs60003 | rs6000_xcoff_select_rtx_section | rs6000 | CPU | GCC | 19,710 | 36 | 1 | [] |
[
"<s>",
"char",
"*",
"neon_output_shift_immediate",
"(",
"const",
"char",
"*",
"mnem",
",",
"char",
"sign",
",",
"rtx",
"*",
"op2",
",",
"machine_mode",
"mode",
",",
"int",
"quad",
",",
"bool",
"isleftshift",
")",
"{",
"int",
"width",
",",
"is_valid",
";",
"static",
"char",
"templ",
"[",
"40",
"]",
";",
"is_valid",
"=",
"neon_immediate_valid_for_shift",
"(",
"*",
"op2",
",",
"mode",
",",
"op2",
",",
"&",
"width",
",",
"isleftshift",
")",
";",
"gcc_assert",
"(",
"is_valid",
"!=",
"0",
")",
";",
"if",
"(",
"quad",
")",
"sprintf",
"(",
"templ",
",",
"\"%s.%c%d\\t%%q0, %%q1, %%2\"",
",",
"mnem",
",",
"sign",
",",
"width",
")",
";",
"else",
"sprintf",
"(",
"templ",
",",
"\"%s.%c%d\\t%%P0, %%P1, %%2\"",
",",
"mnem",
",",
"sign",
",",
"width",
")",
";",
"return",
"templ",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"suitable",
"for",
"output",
"of",
"Neon",
"immediate",
"shift",
"operation",
"(",
"VSHR",
"or",
"VSHL",
")",
"MNEM",
"."
] | [
"arm",
"40",
"0",
"\"%s.%c%d\\t%%q0, %%q1, %%2\"",
"\"%s.%c%d\\t%%P0, %%P1, %%2\""
] | arm | neon_output_shift_immediate | arm | CPU | GCC | 19,711 | 97 | 1 | [] |
[
"<s>",
"static",
"void",
"choose_basereg",
"(",
"HOST_WIDE_INT",
"cfa_offset",
",",
"rtx",
"&",
"base_reg",
",",
"HOST_WIDE_INT",
"&",
"base_offset",
",",
"unsigned",
"int",
"align_reqested",
",",
"unsigned",
"int",
"*",
"align",
")",
"{",
"const",
"struct",
"machine_function",
"*",
"m",
"=",
"cfun",
"->",
"machine",
";",
"unsigned",
"int",
"hfp_align",
";",
"unsigned",
"int",
"drap_align",
";",
"unsigned",
"int",
"sp_align",
";",
"bool",
"hfp_ok",
"=",
"fp_valid_at",
"(",
"cfa_offset",
")",
";",
"bool",
"drap_ok",
"=",
"m",
"->",
"fs",
".",
"drap_valid",
";",
"bool",
"sp_ok",
"=",
"sp_valid_at",
"(",
"cfa_offset",
")",
";",
"hfp_align",
"=",
"drap_align",
"=",
"sp_align",
"=",
"INCOMING_STACK_BOUNDARY",
";",
"if",
"(",
"align_reqested",
")",
"{",
"if",
"(",
"m",
"->",
"fs",
".",
"realigned",
")",
"hfp_align",
"=",
"drap_align",
"=",
"sp_align",
"=",
"crtl",
"->",
"stack_alignment_needed",
";",
"else",
"if",
"(",
"m",
"->",
"fs",
".",
"sp_realigned",
")",
"sp_align",
"=",
"crtl",
"->",
"stack_alignment_needed",
";",
"hfp_ok",
"=",
"hfp_ok",
"&&",
"hfp_align",
">=",
"align_reqested",
";",
"drap_ok",
"=",
"drap_ok",
"&&",
"drap_align",
">=",
"align_reqested",
";",
"sp_ok",
"=",
"sp_ok",
"&&",
"sp_align",
">=",
"align_reqested",
";",
"}",
"if",
"(",
"m",
"->",
"use_fast_prologue_epilogue",
")",
"{",
"if",
"(",
"hfp_ok",
")",
"{",
"base_reg",
"=",
"hard_frame_pointer_rtx",
";",
"base_offset",
"=",
"m",
"->",
"fs",
".",
"fp_offset",
"-",
"cfa_offset",
";",
"}",
"else",
"if",
"(",
"drap_ok",
")",
"{",
"base_reg",
"=",
"crtl",
"->",
"drap_reg",
";",
"base_offset",
"=",
"0",
"-",
"cfa_offset",
";",
"}",
"else",
"if",
"(",
"sp_ok",
")",
"{",
"base_reg",
"=",
"stack_pointer_rtx",
";",
"base_offset",
"=",
"m",
"->",
"fs",
".",
"sp_offset",
"-",
"cfa_offset",
";",
"}",
"}",
"else",
"{",
"HOST_WIDE_INT",
"toffset",
";",
"int",
"len",
"=",
"16",
",",
"tlen",
";",
"if",
"(",
"sp_ok",
")",
"{",
"base_reg",
"=",
"stack_pointer_rtx",
";",
"base_offset",
"=",
"m",
"->",
"fs",
".",
"sp_offset",
"-",
"cfa_offset",
";",
"len",
"=",
"choose_baseaddr_len",
"(",
"STACK_POINTER_REGNUM",
",",
"base_offset",
")",
";",
"}",
"if",
"(",
"drap_ok",
")",
"{",
"toffset",
"=",
"0",
"-",
"cfa_offset",
";",
"tlen",
"=",
"choose_baseaddr_len",
"(",
"REGNO",
"(",
"crtl",
"->",
"drap_reg",
")",
",",
"toffset",
")",
";",
"if",
"(",
"tlen",
"<=",
"len",
")",
"{",
"base_reg",
"=",
"crtl",
"->",
"drap_reg",
";",
"base_offset",
"=",
"toffset",
";",
"len",
"=",
"tlen",
";",
"}",
"}",
"if",
"(",
"hfp_ok",
")",
"{",
"toffset",
"=",
"m",
"->",
"fs",
".",
"fp_offset",
"-",
"cfa_offset",
";",
"tlen",
"=",
"choose_baseaddr_len",
"(",
"HARD_FRAME_POINTER_REGNUM",
",",
"toffset",
")",
";",
"if",
"(",
"tlen",
"<=",
"len",
")",
"{",
"base_reg",
"=",
"hard_frame_pointer_rtx",
";",
"base_offset",
"=",
"toffset",
";",
"}",
"}",
"}",
"if",
"(",
"align",
")",
"{",
"if",
"(",
"base_reg",
"==",
"stack_pointer_rtx",
")",
"*",
"align",
"=",
"sp_align",
";",
"else",
"if",
"(",
"base_reg",
"==",
"crtl",
"->",
"drap_reg",
")",
"*",
"align",
"=",
"drap_align",
";",
"else",
"if",
"(",
"base_reg",
"==",
"hard_frame_pointer_rtx",
")",
"*",
"align",
"=",
"hfp_align",
";",
"}",
"}",
"</s>"
] | [
"Choose",
"a",
"base",
"register",
"based",
"upon",
"alignment",
"requested",
",",
"speed",
"and/or",
"size",
"."
] | [
"i386",
"0",
"16",
"0"
] | i386 | choose_basereg | i386 | CPU | GCC | 19,712 | 386 | 1 | [] |
[
"<s>",
"bool",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCRelaxableFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"fixupNeedsRelaxation() unimplemeted\"",
")",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"Z80",
"\"fixupNeedsRelaxation() unimplemeted\""
] | Z80AsmBackend | fixupNeedsRelaxation | Z80 | MPU | LLVM | 19,713 | 29 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"arg_area_size",
"(",
"void",
")",
"{",
"if",
"(",
"current_function_outgoing_args_size",
")",
"{",
"if",
"(",
"current_function_outgoing_args_size",
">=",
"FIXED_STACK_AREA",
")",
"return",
"current_function_outgoing_args_size",
";",
"else",
"return",
"FIXED_STACK_AREA",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"bytes",
"we",
"must",
"reserve",
"for",
"outgoing",
"arguments",
"in",
"the",
"current",
"function",
"'s",
"stack",
"frame",
"."
] | [
"bfin",
"0"
] | bfin2 | arg_area_size | bfin | DSP | GCC | 19,714 | 30 | 1 | [] |
[
"<s>",
"void",
"v850_output_aligned_bss",
"(",
"FILE",
"*",
"file",
",",
"tree",
"decl",
",",
"const",
"char",
"*",
"name",
",",
"unsigned",
"HOST_WIDE_INT",
"size",
",",
"int",
"align",
")",
"{",
"switch",
"(",
"v850_get_data_area",
"(",
"decl",
")",
")",
"{",
"case",
"DATA_AREA_ZDA",
":",
"switch_to_section",
"(",
"zbss_section",
")",
";",
"break",
";",
"case",
"DATA_AREA_SDA",
":",
"switch_to_section",
"(",
"sbss_section",
")",
";",
"break",
";",
"case",
"DATA_AREA_TDA",
":",
"switch_to_section",
"(",
"tdata_section",
")",
";",
"default",
":",
"switch_to_section",
"(",
"bss_section",
")",
";",
"break",
";",
"}",
"ASM_OUTPUT_ALIGN",
"(",
"file",
",",
"floor_log2",
"(",
"align",
"/",
"BITS_PER_UNIT",
")",
")",
";",
"last_assemble_variable_decl",
"=",
"decl",
";",
"ASM_DECLARE_OBJECT_NAME",
"(",
"file",
",",
"name",
",",
"decl",
")",
";",
"ASM_OUTPUT_LABEL",
"(",
"file",
",",
"name",
")",
";",
"ASM_OUTPUT_SKIP",
"(",
"file",
",",
"size",
"?",
"size",
":",
"1",
")",
";",
"}",
"</s>"
] | [
"A",
"version",
"of",
"asm_output_aligned_bss",
"(",
")",
"that",
"copes",
"with",
"the",
"special",
"data",
"areas",
"of",
"the",
"v850",
"."
] | [
"v850",
"1"
] | v8504 | v850_output_aligned_bss | v850 | MPU | GCC | 19,715 | 113 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"host_detect_local_cpu",
"(",
"int",
"argc",
",",
"const",
"char",
"*",
"*",
"argv",
")",
"{",
"const",
"char",
"*",
"cpu",
"=",
"NULL",
";",
"char",
"*",
"ret",
"=",
"NULL",
";",
"char",
"buf",
"[",
"128",
"]",
";",
"FILE",
"*",
"f",
";",
"bool",
"arch",
";",
"if",
"(",
"argc",
"<",
"1",
")",
"return",
"NULL",
";",
"arch",
"=",
"strcmp",
"(",
"argv",
"[",
"0",
"]",
",",
"\"arch\"",
")",
"==",
"0",
";",
"if",
"(",
"!",
"arch",
"&&",
"strcmp",
"(",
"argv",
"[",
"0",
"]",
",",
"\"tune\"",
")",
")",
"return",
"NULL",
";",
"f",
"=",
"fopen",
"(",
"\"/proc/cpuinfo\"",
",",
"\"r\"",
")",
";",
"if",
"(",
"f",
"==",
"NULL",
")",
"goto",
"fallback_cpu",
";",
"while",
"(",
"fgets",
"(",
"buf",
",",
"sizeof",
"(",
"buf",
")",
",",
"f",
")",
"!=",
"NULL",
")",
"if",
"(",
"startswith",
"(",
"buf",
",",
"\"cpu model\"",
")",
")",
"{",
"if",
"(",
"strstr",
"(",
"buf",
",",
"\"Godson2 V0.2\"",
")",
"!=",
"NULL",
"||",
"strstr",
"(",
"buf",
",",
"\"Loongson-2 V0.2\"",
")",
"!=",
"NULL",
"||",
"strstr",
"(",
"buf",
",",
"\"Loongson-2E\"",
")",
"!=",
"NULL",
")",
"cpu",
"=",
"\"loongson2e\"",
";",
"else",
"if",
"(",
"strstr",
"(",
"buf",
",",
"\"Godson2 V0.3\"",
")",
"!=",
"NULL",
"||",
"strstr",
"(",
"buf",
",",
"\"Loongson-2 V0.3\"",
")",
"!=",
"NULL",
"||",
"strstr",
"(",
"buf",
",",
"\"Loongson-2F\"",
")",
"!=",
"NULL",
")",
"cpu",
"=",
"\"loongson2f\"",
";",
"else",
"if",
"(",
"strstr",
"(",
"buf",
",",
"\"Godson3 V0.5\"",
")",
"!=",
"NULL",
"||",
"strstr",
"(",
"buf",
",",
"\"Loongson-3 V0.5\"",
")",
"!=",
"NULL",
"||",
"strstr",
"(",
"buf",
",",
"\"Loongson-3A\"",
")",
"!=",
"NULL",
")",
"cpu",
"=",
"\"loongson3a\"",
";",
"else",
"if",
"(",
"strstr",
"(",
"buf",
",",
"\"SiByte SB1\"",
")",
"!=",
"NULL",
")",
"cpu",
"=",
"\"sb1\"",
";",
"else",
"if",
"(",
"strstr",
"(",
"buf",
",",
"\"R5000\"",
")",
"!=",
"NULL",
")",
"cpu",
"=",
"\"r5000\"",
";",
"else",
"if",
"(",
"strstr",
"(",
"buf",
",",
"\"Octeon II\"",
")",
"!=",
"NULL",
")",
"cpu",
"=",
"\"octeon2\"",
";",
"else",
"if",
"(",
"strstr",
"(",
"buf",
",",
"\"Octeon\"",
")",
"!=",
"NULL",
")",
"cpu",
"=",
"\"octeon\"",
";",
"break",
";",
"}",
"fclose",
"(",
"f",
")",
";",
"fallback_cpu",
":",
"ret",
"=",
"reconcat",
"(",
"ret",
",",
"\" -mnan=2008 \"",
",",
"NULL",
")",
";",
"if",
"(",
"cpu",
"==",
"NULL",
")",
"cpu",
"=",
"(",
"const",
"char",
"*",
")",
"getauxval",
"(",
"AT_BASE_PLATFORM",
")",
";",
"if",
"(",
"cpu",
"==",
"NULL",
")",
"cpu",
"=",
"_MIPS_ARCH",
";",
"if",
"(",
"cpu",
")",
"ret",
"=",
"reconcat",
"(",
"ret",
",",
"ret",
",",
"\"-m\"",
",",
"argv",
"[",
"0",
"]",
",",
"\"=\"",
",",
"cpu",
",",
"NULL",
")",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"This",
"will",
"be",
"called",
"by",
"the",
"spec",
"parser",
"in",
"gcc.cc",
"when",
"it",
"sees",
"a",
"%",
":",
"local_cpu_detect",
"(",
"args",
")",
"construct",
".",
"Currently",
"it",
"will",
"be",
"called",
"with",
"either",
"``",
"cpu",
"''",
"or",
"``",
"tune",
"''",
"as",
"argument",
"depending",
"on",
"if",
"-mcpu=native",
"or",
"-mtune=native",
"is",
"to",
"be",
"substituted",
".",
"It",
"returns",
"a",
"string",
"containing",
"new",
"command",
"line",
"parameters",
"to",
"be",
"put",
"at",
"the",
"place",
"of",
"the",
"above",
"two",
"options",
",",
"depending",
"on",
"what",
"CPU",
"this",
"is",
"executed",
".",
"E.g",
".",
"``",
"-mcpu=ultrasparc3",
"''",
"on",
"an",
"UltraSPARC",
"III",
"for",
"-mcpu=native",
".",
"If",
"the",
"routine",
"ca",
"n't",
"detect",
"a",
"known",
"processor",
",",
"the",
"-mcpu",
"or",
"-mtune",
"option",
"is",
"discarded",
".",
"ARGC",
"and",
"ARGV",
"are",
"set",
"depending",
"on",
"the",
"actual",
"arguments",
"given",
"in",
"the",
"spec",
"."
] | [
"mips",
"128",
"1",
"0",
"\"arch\"",
"0",
"0",
"\"tune\"",
"\"/proc/cpuinfo\"",
"\"r\"",
"\"cpu model\"",
"\"Godson2 V0.2\"",
"\"Loongson-2 V0.2\"",
"\"Loongson-2E\"",
"\"loongson2e\"",
"\"Godson2 V0.3\"",
"\"Loongson-2 V0.3\"",
"\"Loongson-2F\"",
"\"loongson2f\"",
"\"Godson3 V0.5\"",
"\"Loongson-3 V0.5\"",
"\"Loongson-3A\"",
"\"loongson3a\"",
"\"SiByte SB1\"",
"\"sb1\"",
"\"R5000\"",
"\"r5000\"",
"\"Octeon II\"",
"\"octeon2\"",
"\"Octeon\"",
"\"octeon\"",
"\" -mnan=2008 \"",
"\"-m\"",
"0",
"\"=\""
] | driver-native1 | host_detect_local_cpu | mips | CPU | GCC | 19,716 | 370 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"mn10300_output_add",
"(",
"rtx",
"operands",
"[",
"3",
"]",
",",
"bool",
"need_flags",
")",
"{",
"rtx",
"dest",
",",
"src1",
",",
"src2",
";",
"unsigned",
"int",
"dest_regnum",
",",
"src1_regnum",
",",
"src2_regnum",
";",
"enum",
"reg_class",
"src1_class",
",",
"src2_class",
",",
"dest_class",
";",
"dest",
"=",
"operands",
"[",
"0",
"]",
";",
"src1",
"=",
"operands",
"[",
"1",
"]",
";",
"src2",
"=",
"operands",
"[",
"2",
"]",
";",
"dest_regnum",
"=",
"true_regnum",
"(",
"dest",
")",
";",
"src1_regnum",
"=",
"true_regnum",
"(",
"src1",
")",
";",
"dest_class",
"=",
"REGNO_REG_CLASS",
"(",
"dest_regnum",
")",
";",
"src1_class",
"=",
"REGNO_REG_CLASS",
"(",
"src1_regnum",
")",
";",
"if",
"(",
"CONST_INT_P",
"(",
"src2",
")",
")",
"{",
"gcc_assert",
"(",
"dest_regnum",
"==",
"src1_regnum",
")",
";",
"if",
"(",
"src2",
"==",
"const1_rtx",
"&&",
"!",
"need_flags",
")",
"return",
"\"inc %0\"",
";",
"if",
"(",
"INTVAL",
"(",
"src2",
")",
"==",
"4",
"&&",
"!",
"need_flags",
"&&",
"dest_class",
"!=",
"DATA_REGS",
")",
"return",
"\"inc4 %0\"",
";",
"gcc_assert",
"(",
"!",
"need_flags",
"||",
"dest_class",
"!=",
"SP_REGS",
")",
";",
"return",
"\"add %2,%0\"",
";",
"}",
"else",
"if",
"(",
"CONSTANT_P",
"(",
"src2",
")",
")",
"return",
"\"add %2,%0\"",
";",
"src2_regnum",
"=",
"true_regnum",
"(",
"src2",
")",
";",
"src2_class",
"=",
"REGNO_REG_CLASS",
"(",
"src2_regnum",
")",
";",
"if",
"(",
"dest_regnum",
"==",
"src1_regnum",
")",
"return",
"\"add %2,%0\"",
";",
"if",
"(",
"dest_regnum",
"==",
"src2_regnum",
")",
"return",
"\"add %1,%0\"",
";",
"if",
"(",
"TARGET_AM33",
"&&",
"optimize_insn_for_speed_p",
"(",
")",
")",
"return",
"\"add %2,%1,%0\"",
";",
"if",
"(",
"src1_class",
"!=",
"EXTENDED_REGS",
"&&",
"src2_class",
"!=",
"EXTENDED_REGS",
"&&",
"dest_class",
"!=",
"EXTENDED_REGS",
")",
"{",
"if",
"(",
"src1_class",
"==",
"dest_class",
")",
"return",
"\"mov %1,%0\\n\\tadd %2,%0\"",
";",
"else",
"return",
"\"mov %2,%0\\n\\tadd %1,%0\"",
";",
"}",
"if",
"(",
"dest_class",
"==",
"EXTENDED_REGS",
"||",
"src1_class",
"==",
"src2_class",
")",
"return",
"\"add %2,%1,%0\"",
";",
"if",
"(",
"src1_class",
"==",
"EXTENDED_REGS",
")",
"return",
"\"mov %1,%0\\n\\tadd %2,%0\"",
";",
"else",
"return",
"\"mov %2,%0\\n\\tadd %1,%0\"",
";",
"}",
"</s>"
] | [
"Output",
"an",
"addition",
"operation",
"."
] | [
"mn10300",
"3",
"0",
"1",
"2",
"\"inc %0\"",
"4",
"\"inc4 %0\"",
"\"add %2,%0\"",
"\"add %2,%0\"",
"\"add %2,%0\"",
"\"add %1,%0\"",
"\"add %2,%1,%0\"",
"\"mov %1,%0\\n\\tadd %2,%0\"",
"\"mov %2,%0\\n\\tadd %1,%0\"",
"\"add %2,%1,%0\"",
"\"mov %1,%0\\n\\tadd %2,%0\"",
"\"mov %2,%0\\n\\tadd %1,%0\""
] | mn10300 | mn10300_output_add | mn10300 | MPU | GCC | 19,717 | 257 | 1 | [] |
[
"<s>",
"bool",
"function_resolver",
"::",
"require_vector_type",
"(",
"unsigned",
"int",
"argno",
",",
"vector_type_index",
"type",
")",
"{",
"tree",
"expected",
"=",
"acle_vector_types",
"[",
"0",
"]",
"[",
"type",
"]",
";",
"tree",
"actual",
"=",
"get_argument_type",
"(",
"argno",
")",
";",
"if",
"(",
"actual",
"==",
"error_mark_node",
")",
"return",
"false",
";",
"if",
"(",
"!",
"matches_type_p",
"(",
"expected",
",",
"actual",
")",
")",
"{",
"error_at",
"(",
"location",
",",
"\"passing %qT to argument %d of %qE, which\"",
"\" expects %qT\"",
",",
"actual",
",",
"argno",
"+",
"1",
",",
"fndecl",
",",
"expected",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Require",
"argument",
"ARGNO",
"to",
"have",
"vector",
"type",
"TYPE",
",",
"in",
"cases",
"where",
"this",
"requirement",
"holds",
"for",
"all",
"uses",
"of",
"the",
"function",
".",
"Return",
"true",
"if",
"the",
"argument",
"has",
"the",
"right",
"form",
",",
"otherwise",
"report",
"an",
"appropriate",
"error",
"."
] | [
"aarch64",
"0",
"\"passing %qT to argument %d of %qE, which\"",
"\" expects %qT\"",
"1"
] | aarch64-sve-builtins1 | require_vector_type | aarch64 | CPU | GCC | 19,718 | 78 | 1 | [] |
[
"<s>",
"virtual",
"const",
"SystemZRegisterInfo",
"&",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZInstrInfo12 | getRegisterInfo | SystemZ | CPU | LLVM | 19,719 | 13 | 1 | [] |
[
"<s>",
"int",
"cris_legitimate_pic_operand",
"(",
"rtx",
"x",
")",
"{",
"return",
"cris_valid_pic_const",
"(",
"x",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"The",
"LEGITIMATE_PIC_OPERAND_P",
"worker",
"."
] | [
"cris"
] | cris | cris_legitimate_pic_operand | cris | MPU | GCC | 19,720 | 16 | 1 | [] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Wasn't expecting to be able to lower this!\"",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"LowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"LowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"return",
"LowerGlobalTLSAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"LowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SETCC",
":",
"return",
"LowerSETCC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INIT_TRAMPOLINE",
":",
"return",
"LowerINIT_TRAMPOLINE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ADJUST_TRAMPOLINE",
":",
"return",
"LowerADJUST_TRAMPOLINE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"VAARG",
":",
"return",
"LowerVAARG",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"VACOPY",
":",
"return",
"LowerVACOPY",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"STACKRESTORE",
":",
"return",
"LowerSTACKRESTORE",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"EH_SJLJ_SETJMP",
":",
"return",
"lowerEH_SJLJ_SETJMP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EH_SJLJ_LONGJMP",
":",
"return",
"lowerEH_SJLJ_LONGJMP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_UINT",
":",
"case",
"ISD",
"::",
"FP_TO_SINT",
":",
"return",
"LowerFP_TO_INT",
"(",
"Op",
",",
"DAG",
",",
"SDLoc",
"(",
"Op",
")",
")",
";",
"case",
"ISD",
"::",
"UINT_TO_FP",
":",
"case",
"ISD",
"::",
"SINT_TO_FP",
":",
"return",
"LowerINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FLT_ROUNDS_",
":",
"return",
"LowerFLT_ROUNDS_",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL_PARTS",
":",
"return",
"LowerSHL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRL_PARTS",
":",
"return",
"LowerSRL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRA_PARTS",
":",
"return",
"LowerSRA_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BUILD_VECTOR",
":",
"return",
"LowerBUILD_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VECTOR_SHUFFLE",
":",
"return",
"LowerVECTOR_SHUFFLE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SCALAR_TO_VECTOR",
":",
"return",
"LowerSCALAR_TO_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"LowerMUL",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
":",
"return",
"SDValue",
"(",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"PowerPC",
"PPC",
"\"Wasn't expecting to be able to lower this!\"",
"ISD::ConstantPool",
"ISD::BlockAddress",
"ISD::GlobalAddress",
"ISD::GlobalTLSAddress",
"ISD::JumpTable",
"ISD::SETCC",
"ISD::INIT_TRAMPOLINE",
"ISD::ADJUST_TRAMPOLINE",
"ISD::VASTART",
"PPC",
"ISD::VAARG",
"PPC",
"ISD::VACOPY",
"PPC",
"ISD::STACKRESTORE",
"PPC",
"ISD::DYNAMIC_STACKALLOC",
"PPC",
"ISD::EH_SJLJ_SETJMP",
"ISD::EH_SJLJ_LONGJMP",
"ISD::SELECT_CC",
"ISD::FP_TO_UINT",
"ISD::FP_TO_SINT",
"ISD::UINT_TO_FP",
"ISD::SINT_TO_FP",
"ISD::FLT_ROUNDS_",
"ISD::SHL_PARTS",
"ISD::SRL_PARTS",
"ISD::SRA_PARTS",
"ISD::BUILD_VECTOR",
"ISD::VECTOR_SHUFFLE",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::SCALAR_TO_VECTOR",
"ISD::MUL",
"ISD::INTRINSIC_W_CHAIN",
"ISD::RETURNADDR",
"ISD::FRAMEADDR"
] | PPCISelLowering (2)1 | LowerOperation | PowerPC | CPU | LLVM | 19,721 | 444 | 1 | [] |
[
"<s>",
"static",
"rtx",
"stv_expand_builtin",
"(",
"insn_code",
"icode",
",",
"rtx",
"*",
"op",
",",
"machine_mode",
"tmode",
",",
"machine_mode",
"smode",
")",
"{",
"op",
"[",
"2",
"]",
"=",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"op",
"[",
"2",
"]",
")",
";",
"if",
"(",
"icode",
"==",
"CODE_FOR_altivec_stvx_v2df",
"||",
"icode",
"==",
"CODE_FOR_altivec_stvx_v2di",
"||",
"icode",
"==",
"CODE_FOR_altivec_stvx_v4sf",
"||",
"icode",
"==",
"CODE_FOR_altivec_stvx_v4si",
"||",
"icode",
"==",
"CODE_FOR_altivec_stvx_v8hi",
"||",
"icode",
"==",
"CODE_FOR_altivec_stvx_v16qi",
")",
"{",
"rtx",
"rawaddr",
";",
"if",
"(",
"op",
"[",
"1",
"]",
"==",
"const0_rtx",
")",
"rawaddr",
"=",
"op",
"[",
"2",
"]",
";",
"else",
"{",
"op",
"[",
"1",
"]",
"=",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"op",
"[",
"1",
"]",
")",
";",
"rawaddr",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"op",
"[",
"2",
"]",
",",
"op",
"[",
"1",
"]",
")",
";",
"}",
"rtx",
"addr",
"=",
"gen_rtx_AND",
"(",
"Pmode",
",",
"rawaddr",
",",
"gen_rtx_CONST_INT",
"(",
"Pmode",
",",
"-",
"16",
")",
")",
";",
"addr",
"=",
"gen_rtx_MEM",
"(",
"tmode",
",",
"addr",
")",
";",
"op",
"[",
"0",
"]",
"=",
"copy_to_mode_reg",
"(",
"tmode",
",",
"op",
"[",
"0",
"]",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"addr",
",",
"op",
"[",
"0",
"]",
")",
")",
";",
"}",
"else",
"if",
"(",
"icode",
"==",
"CODE_FOR_vsx_stxvrbx",
"||",
"icode",
"==",
"CODE_FOR_vsx_stxvrhx",
"||",
"icode",
"==",
"CODE_FOR_vsx_stxvrwx",
"||",
"icode",
"==",
"CODE_FOR_vsx_stxvrdx",
")",
"{",
"rtx",
"truncrtx",
"=",
"gen_rtx_TRUNCATE",
"(",
"tmode",
",",
"op",
"[",
"0",
"]",
")",
";",
"op",
"[",
"0",
"]",
"=",
"copy_to_mode_reg",
"(",
"E_TImode",
",",
"truncrtx",
")",
";",
"rtx",
"addr",
";",
"if",
"(",
"op",
"[",
"1",
"]",
"==",
"const0_rtx",
")",
"addr",
"=",
"gen_rtx_MEM",
"(",
"tmode",
",",
"op",
"[",
"2",
"]",
")",
";",
"else",
"{",
"op",
"[",
"1",
"]",
"=",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"op",
"[",
"1",
"]",
")",
";",
"addr",
"=",
"gen_rtx_MEM",
"(",
"tmode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"op",
"[",
"2",
"]",
",",
"op",
"[",
"1",
"]",
")",
")",
";",
"}",
"rtx",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"addr",
",",
"op",
"[",
"0",
"]",
")",
";",
"if",
"(",
"pat",
")",
"emit_insn",
"(",
"pat",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"1",
"]",
".",
"predicate",
"(",
"op",
"[",
"0",
"]",
",",
"smode",
")",
")",
"op",
"[",
"0",
"]",
"=",
"copy_to_mode_reg",
"(",
"smode",
",",
"op",
"[",
"0",
"]",
")",
";",
"rtx",
"addr",
";",
"if",
"(",
"op",
"[",
"1",
"]",
"==",
"const0_rtx",
")",
"addr",
"=",
"gen_rtx_MEM",
"(",
"tmode",
",",
"op",
"[",
"2",
"]",
")",
";",
"else",
"{",
"op",
"[",
"1",
"]",
"=",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"op",
"[",
"1",
"]",
")",
";",
"addr",
"=",
"gen_rtx_MEM",
"(",
"tmode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"op",
"[",
"2",
"]",
",",
"op",
"[",
"1",
"]",
")",
")",
";",
"}",
"rtx",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"addr",
",",
"op",
"[",
"0",
"]",
")",
";",
"if",
"(",
"pat",
")",
"emit_insn",
"(",
"pat",
")",
";",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"AltiVec",
"vector",
"store",
"builtin",
",",
"and",
"return",
"the",
"expanded",
"rtx",
"."
] | [
"rs6000",
"2",
"2",
"1",
"2",
"1",
"1",
"2",
"1",
"16",
"0",
"0",
"0",
"0",
"0",
"1",
"2",
"1",
"1",
"2",
"1",
"0",
"1",
"0",
"0",
"0",
"1",
"2",
"1",
"1",
"2",
"1",
"0"
] | rs6000-builtin1 | stv_expand_builtin | rs6000 | CPU | GCC | 19,722 | 439 | 1 | [] |
[
"<s>",
"static",
"section",
"*",
"loongarch_select_rtx_section",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"unsigned",
"HOST_WIDE_INT",
"align",
")",
"{",
"if",
"(",
"loongarch_rtx_constant_in_small_data_p",
"(",
"mode",
")",
")",
"return",
"get_named_section",
"(",
"NULL",
",",
"\".sdata\"",
",",
"0",
")",
";",
"return",
"default_elf_select_rtx_section",
"(",
"mode",
",",
"x",
",",
"align",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_SELECT_RTX_SECTION",
"."
] | [
"loongarch",
"\".sdata\"",
"0"
] | loongarch | loongarch_select_rtx_section | loongarch | CPU | GCC | 19,723 | 44 | 1 | [] |
[
"<s>",
"bool",
"SPIRVPreLegalizer",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"SPIRVSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"SPIRVSubtarget",
">",
"(",
")",
";",
"SPIRVGlobalRegistry",
"*",
"GR",
"=",
"ST",
".",
"getSPIRVGlobalRegistry",
"(",
")",
";",
"GR",
"->",
"setCurrentFunc",
"(",
"MF",
")",
";",
"MachineIRBuilder",
"MIB",
"(",
"MF",
")",
";",
"addConstantsToTrack",
"(",
"MF",
",",
"GR",
")",
";",
"foldConstantsIntoIntrinsics",
"(",
"MF",
")",
";",
"insertBitcasts",
"(",
"MF",
",",
"GR",
",",
"MIB",
")",
";",
"generateAssignInstrs",
"(",
"MF",
",",
"GR",
",",
"MIB",
")",
";",
"processInstrsWithTypeFolding",
"(",
"MF",
",",
"GR",
",",
"MIB",
")",
";",
"processSwitches",
"(",
"MF",
",",
"GR",
",",
"MIB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"SPIRV",
"SPIRV",
"SPIRV",
"SPIRV",
"SPIRV",
"SPIRV"
] | SPIRVPreLegalizer1 | runOnMachineFunction | SPIRV | Virtual ISA | LLVM | 19,724 | 99 | 1 | [] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"getRecipEstimate",
"(",
"SDValue",
"Operand",
",",
"DAGCombinerInfo",
"&",
"DCI",
",",
"unsigned",
"&",
"RefinementSteps",
")",
"const",
"{",
"EVT",
"VT",
"=",
"Operand",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
"&&",
"Subtarget",
".",
"hasFRES",
"(",
")",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"&&",
"Subtarget",
".",
"hasFRE",
"(",
")",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"v4f32",
"&&",
"Subtarget",
".",
"hasAltivec",
"(",
")",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"v2f64",
"&&",
"Subtarget",
".",
"hasVSX",
"(",
")",
")",
")",
"{",
"RefinementSteps",
"=",
"Subtarget",
".",
"hasRecipPrec",
"(",
")",
"?",
"1",
":",
"3",
";",
"if",
"(",
"VT",
".",
"getScalarType",
"(",
")",
"==",
"MVT",
"::",
"f64",
")",
"++",
"RefinementSteps",
";",
"return",
"DCI",
".",
"DAG",
".",
"getNode",
"(",
"PPCISD",
"::",
"FRE",
",",
"SDLoc",
"(",
"Operand",
")",
",",
"VT",
",",
"Operand",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"reciprocal",
"estimate",
"value",
"for",
"the",
"input",
"operand",
"."
] | [
"PowerPC",
"PPC",
"MVT::f32",
"MVT::f64",
"MVT::v4f32",
"MVT::v2f64",
"1",
"3",
"MVT::f64",
"PPCISD::FRE"
] | PPCISelLowering167 | getRecipEstimate | PowerPC | CPU | LLVM | 19,725 | 141 | 1 | [] |
[
"<s>",
"bool",
"SparcAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"SmallVector",
"<",
"MCInst",
",",
"8",
">",
"Instructions",
";",
"unsigned",
"MatchResult",
"=",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
";",
"switch",
"(",
"MatchResult",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"{",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
"false",
";",
"}",
"case",
"Match_MissingFeature",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction requires a CPU feature not currently enabled\"",
")",
";",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0ULL",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"SparcOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"invalid instruction mnemonic\"",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"Sparc",
"Sparc",
"8",
"\"instruction requires a CPU feature not currently enabled\"",
"0ULL",
"\"too few operands for instruction\"",
"Sparc",
"\"invalid operand for instruction\"",
"\"invalid instruction mnemonic\""
] | SparcAsmParser43 | MatchAndEmitInstruction | Sparc | CPU | LLVM | 19,726 | 188 | 1 | [] |
[
"<s>",
"static",
"bool",
"alpha_in_small_data_p",
"(",
"tree",
"exp",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"exp",
")",
"==",
"STRING_CST",
")",
"return",
"false",
";",
"if",
"(",
"TREE_CODE",
"(",
"exp",
")",
"==",
"FUNCTION_DECL",
")",
"return",
"false",
";",
"if",
"(",
"TREE_CODE",
"(",
"exp",
")",
"==",
"VAR_DECL",
"&&",
"DECL_SECTION_NAME",
"(",
"exp",
")",
")",
"{",
"const",
"char",
"*",
"section",
"=",
"TREE_STRING_POINTER",
"(",
"DECL_SECTION_NAME",
"(",
"exp",
")",
")",
";",
"if",
"(",
"strcmp",
"(",
"section",
",",
"\".sdata\"",
")",
"==",
"0",
"||",
"strcmp",
"(",
"section",
",",
"\".sbss\"",
")",
"==",
"0",
")",
"return",
"true",
";",
"}",
"else",
"{",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"TREE_TYPE",
"(",
"exp",
")",
")",
";",
"if",
"(",
"size",
">",
"0",
"&&",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"size",
"<=",
"g_switch_value",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"EXP",
"should",
"be",
"placed",
"in",
"the",
"small",
"data",
"section",
"."
] | [
"alpha",
"\".sdata\"",
"0",
"\".sbss\"",
"0",
"0"
] | alpha3 | alpha_in_small_data_p | alpha | MPU | GCC | 19,727 | 119 | 1 | [] |
[
"<s>",
"unsigned",
"MipsSEInstrInfo",
"::",
"getOppositeBranchOpc",
"(",
"unsigned",
"Opc",
")",
"const",
"{",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Illegal opcode!\"",
")",
";",
"case",
"Mips",
"::",
"BEQ",
":",
"return",
"Mips",
"::",
"BNE",
";",
"case",
"Mips",
"::",
"BEQ_MM",
":",
"return",
"Mips",
"::",
"BNE_MM",
";",
"case",
"Mips",
"::",
"BNE",
":",
"return",
"Mips",
"::",
"BEQ",
";",
"case",
"Mips",
"::",
"BNE_MM",
":",
"return",
"Mips",
"::",
"BEQ_MM",
";",
"case",
"Mips",
"::",
"BGTZ",
":",
"return",
"Mips",
"::",
"BLEZ",
";",
"case",
"Mips",
"::",
"BGEZ",
":",
"return",
"Mips",
"::",
"BLTZ",
";",
"case",
"Mips",
"::",
"BLTZ",
":",
"return",
"Mips",
"::",
"BGEZ",
";",
"case",
"Mips",
"::",
"BLEZ",
":",
"return",
"Mips",
"::",
"BGTZ",
";",
"case",
"Mips",
"::",
"BEQ64",
":",
"return",
"Mips",
"::",
"BNE64",
";",
"case",
"Mips",
"::",
"BNE64",
":",
"return",
"Mips",
"::",
"BEQ64",
";",
"case",
"Mips",
"::",
"BGTZ64",
":",
"return",
"Mips",
"::",
"BLEZ64",
";",
"case",
"Mips",
"::",
"BGEZ64",
":",
"return",
"Mips",
"::",
"BLTZ64",
";",
"case",
"Mips",
"::",
"BLTZ64",
":",
"return",
"Mips",
"::",
"BGEZ64",
";",
"case",
"Mips",
"::",
"BLEZ64",
":",
"return",
"Mips",
"::",
"BGTZ64",
";",
"case",
"Mips",
"::",
"BC1T",
":",
"return",
"Mips",
"::",
"BC1F",
";",
"case",
"Mips",
"::",
"BC1F",
":",
"return",
"Mips",
"::",
"BC1T",
";",
"case",
"Mips",
"::",
"BEQZC_MM",
":",
"return",
"Mips",
"::",
"BNEZC_MM",
";",
"case",
"Mips",
"::",
"BNEZC_MM",
":",
"return",
"Mips",
"::",
"BEQZC_MM",
";",
"case",
"Mips",
"::",
"BEQZC",
":",
"return",
"Mips",
"::",
"BNEZC",
";",
"case",
"Mips",
"::",
"BNEZC",
":",
"return",
"Mips",
"::",
"BEQZC",
";",
"case",
"Mips",
"::",
"BEQC",
":",
"return",
"Mips",
"::",
"BNEC",
";",
"case",
"Mips",
"::",
"BNEC",
":",
"return",
"Mips",
"::",
"BEQC",
";",
"case",
"Mips",
"::",
"BGTZC",
":",
"return",
"Mips",
"::",
"BLEZC",
";",
"case",
"Mips",
"::",
"BGEZC",
":",
"return",
"Mips",
"::",
"BLTZC",
";",
"case",
"Mips",
"::",
"BLTZC",
":",
"return",
"Mips",
"::",
"BGEZC",
";",
"case",
"Mips",
"::",
"BLEZC",
":",
"return",
"Mips",
"::",
"BGTZC",
";",
"case",
"Mips",
"::",
"BEQZC64",
":",
"return",
"Mips",
"::",
"BNEZC64",
";",
"case",
"Mips",
"::",
"BNEZC64",
":",
"return",
"Mips",
"::",
"BEQZC64",
";",
"case",
"Mips",
"::",
"BEQC64",
":",
"return",
"Mips",
"::",
"BNEC64",
";",
"case",
"Mips",
"::",
"BNEC64",
":",
"return",
"Mips",
"::",
"BEQC64",
";",
"case",
"Mips",
"::",
"BGEC64",
":",
"return",
"Mips",
"::",
"BLTC64",
";",
"case",
"Mips",
"::",
"BGEUC64",
":",
"return",
"Mips",
"::",
"BLTUC64",
";",
"case",
"Mips",
"::",
"BLTC64",
":",
"return",
"Mips",
"::",
"BGEC64",
";",
"case",
"Mips",
"::",
"BLTUC64",
":",
"return",
"Mips",
"::",
"BGEUC64",
";",
"case",
"Mips",
"::",
"BGTZC64",
":",
"return",
"Mips",
"::",
"BLEZC64",
";",
"case",
"Mips",
"::",
"BGEZC64",
":",
"return",
"Mips",
"::",
"BLTZC64",
";",
"case",
"Mips",
"::",
"BLTZC64",
":",
"return",
"Mips",
"::",
"BGEZC64",
";",
"case",
"Mips",
"::",
"BLEZC64",
":",
"return",
"Mips",
"::",
"BGTZC64",
";",
"case",
"Mips",
"::",
"BBIT0",
":",
"return",
"Mips",
"::",
"BBIT1",
";",
"case",
"Mips",
"::",
"BBIT1",
":",
"return",
"Mips",
"::",
"BBIT0",
";",
"case",
"Mips",
"::",
"BBIT032",
":",
"return",
"Mips",
"::",
"BBIT132",
";",
"case",
"Mips",
"::",
"BBIT132",
":",
"return",
"Mips",
"::",
"BBIT032",
";",
"}",
"}",
"</s>"
] | [
"getOppositeBranchOpc",
"-",
"Return",
"the",
"inverse",
"of",
"the",
"specified",
"opcode",
",",
"e.g",
"."
] | [
"Mips",
"Mips",
"\"Illegal opcode!\"",
"Mips::BEQ",
"Mips::BNE",
"Mips::BEQ_MM",
"Mips::BNE_MM",
"Mips::BNE",
"Mips::BEQ",
"Mips::BNE_MM",
"Mips::BEQ_MM",
"Mips::BGTZ",
"Mips::BLEZ",
"Mips::BGEZ",
"Mips::BLTZ",
"Mips::BLTZ",
"Mips::BGEZ",
"Mips::BLEZ",
"Mips::BGTZ",
"Mips::BEQ64",
"Mips::BNE64",
"Mips::BNE64",
"Mips::BEQ64",
"Mips::BGTZ64",
"Mips::BLEZ64",
"Mips::BGEZ64",
"Mips::BLTZ64",
"Mips::BLTZ64",
"Mips::BGEZ64",
"Mips::BLEZ64",
"Mips::BGTZ64",
"Mips::BC1T",
"Mips::BC1F",
"Mips::BC1F",
"Mips::BC1T",
"Mips::BEQZC_MM",
"Mips::BNEZC_MM",
"Mips::BNEZC_MM",
"Mips::BEQZC_MM",
"Mips::BEQZC",
"Mips::BNEZC",
"Mips::BNEZC",
"Mips::BEQZC",
"Mips::BEQC",
"Mips::BNEC",
"Mips::BNEC",
"Mips::BEQC",
"Mips::BGTZC",
"Mips::BLEZC",
"Mips::BGEZC",
"Mips::BLTZC",
"Mips::BLTZC",
"Mips::BGEZC",
"Mips::BLEZC",
"Mips::BGTZC",
"Mips::BEQZC64",
"Mips::BNEZC64",
"Mips::BNEZC64",
"Mips::BEQZC64",
"Mips::BEQC64",
"Mips::BNEC64",
"Mips::BNEC64",
"Mips::BEQC64",
"Mips::BGEC64",
"Mips::BLTC64",
"Mips::BGEUC64",
"Mips::BLTUC64",
"Mips::BLTC64",
"Mips::BGEC64",
"Mips::BLTUC64",
"Mips::BGEUC64",
"Mips::BGTZC64",
"Mips::BLEZC64",
"Mips::BGEZC64",
"Mips::BLTZC64",
"Mips::BLTZC64",
"Mips::BGEZC64",
"Mips::BLEZC64",
"Mips::BGTZC64",
"Mips::BBIT0",
"Mips::BBIT1",
"Mips::BBIT1",
"Mips::BBIT0",
"Mips::BBIT032",
"Mips::BBIT132",
"Mips::BBIT132",
"Mips::BBIT032"
] | MipsSEInstrInfo12 | getOppositeBranchOpc | Mips | CPU | LLVM | 19,728 | 444 | 1 | [] |
[
"<s>",
"void",
"TriCorePassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"TriCore",
"TriCore"
] | TriCoreTargetMachine | addPreEmitPass | TriCore | MPU | LLVM | 19,729 | 8 | 1 | [] |
[
"<s>",
"int",
"aarch_forward_to_shift_is_not_shifted_reg",
"(",
"rtx_insn",
"*",
"producer",
",",
"rtx_insn",
"*",
"consumer",
")",
"{",
"rtx",
"value",
",",
"op",
";",
"rtx",
"early_op",
";",
"if",
"(",
"!",
"arm_get_set_operands",
"(",
"producer",
",",
"consumer",
",",
"&",
"value",
",",
"&",
"op",
")",
")",
"return",
"0",
";",
"if",
"(",
"(",
"early_op",
"=",
"arm_find_shift_sub_rtx",
"(",
"op",
")",
")",
")",
"{",
"if",
"(",
"REG_P",
"(",
"early_op",
")",
")",
"early_op",
"=",
"op",
";",
"if",
"(",
"GET_CODE",
"(",
"early_op",
")",
"==",
"ASHIFT",
")",
"return",
"(",
"!",
"REG_P",
"(",
"XEXP",
"(",
"early_op",
",",
"0",
")",
")",
"||",
"!",
"REG_P",
"(",
"XEXP",
"(",
"early_op",
",",
"1",
")",
")",
")",
";",
"else",
"return",
"1",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"the",
"CONSUMER",
"instruction",
"is",
"some",
"sort",
"of",
"arithmetic",
"or",
"logic",
"+",
"shift",
"operation",
",",
"and",
"the",
"register",
"we",
"are",
"writing",
"in",
"PRODUCER",
"is",
"not",
"used",
"in",
"a",
"register",
"shift",
"by",
"register",
"operation",
"."
] | [
"arm",
"0",
"0",
"1",
"1",
"0"
] | aarch-common3 | aarch_forward_to_shift_is_not_shifted_reg | arm | CPU | GCC | 19,730 | 105 | 1 | [] |
[
"<s>",
"const",
"PPCSubtarget",
"*",
"PPCTargetMachine",
"::",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"Attribute",
"CPUAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"target-cpu\"",
")",
";",
"Attribute",
"FSAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"target-features\"",
")",
";",
"std",
"::",
"string",
"CPU",
"=",
"CPUAttr",
".",
"isValid",
"(",
")",
"?",
"CPUAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetCPU",
";",
"std",
"::",
"string",
"FS",
"=",
"FSAttr",
".",
"isValid",
"(",
")",
"?",
"FSAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetFS",
";",
"bool",
"SoftFloat",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"use-soft-float\"",
")",
".",
"getValueAsString",
"(",
")",
"==",
"\"true\"",
";",
"if",
"(",
"SoftFloat",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"-hard-float\"",
":",
"\",-hard-float\"",
";",
"auto",
"&",
"I",
"=",
"SubtargetMap",
"[",
"CPU",
"+",
"FS",
"]",
";",
"if",
"(",
"!",
"I",
")",
"{",
"resetTargetOptions",
"(",
"F",
")",
";",
"I",
"=",
"std",
"::",
"make_unique",
"<",
"PPCSubtarget",
">",
"(",
"TargetTriple",
",",
"CPU",
",",
"computeFSAdditions",
"(",
"FS",
",",
"getOptLevel",
"(",
")",
",",
"getTargetTriple",
"(",
")",
")",
",",
"*",
"this",
")",
";",
"}",
"return",
"I",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"\"target-cpu\"",
"\"target-features\"",
"\"use-soft-float\"",
"\"true\"",
"\"-hard-float\"",
"\",-hard-float\"",
"PPC"
] | PPCTargetMachine5 | getSubtargetImpl | PowerPC | CPU | LLVM | 19,731 | 173 | 1 | [] |
[
"<s>",
"bool",
"FineIBTHashesSection",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"if",
"(",
"!",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-fine\"",
")",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"*",
"TM",
"=",
"&",
"getAnalysis",
"<",
"TargetPassConfig",
">",
"(",
")",
".",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"if",
"(",
"!",
"TM",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"&",
"F",
":",
"M",
")",
"{",
"if",
"(",
"F",
".",
"getName",
"(",
")",
".",
"startswith",
"(",
"\"__ibt_fine_plt\"",
")",
")",
"continue",
";",
"if",
"(",
"!",
"F",
".",
"doesNoCfCheck",
"(",
")",
"&&",
"!",
"F",
".",
"doesCoarseCfCheck",
"(",
")",
"&&",
"!",
"F",
".",
"hasLocalLinkage",
"(",
")",
")",
"{",
"if",
"(",
"F",
".",
"isIntrinsic",
"(",
")",
"&&",
"!",
"IsExternalIntrinsic",
"(",
"&",
"F",
")",
")",
"continue",
";",
"CreatePLTTemplate",
"(",
"M",
",",
"&",
"F",
")",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"X86",
"\"cf-protection-fine\"",
"\"__ibt_fine_plt\""
] | X86FineIBTHashesSection | runOnModule | X86 | CPU | LLVM | 19,732 | 130 | 1 | [] |
[
"<s>",
"int",
"vms_c_get_vms_ver",
"(",
"void",
")",
"{",
"return",
"VMS_DEFAULT_VMS_VER",
";",
"}",
"</s>"
] | [
"The",
"default",
"value",
"for",
"_VMS_VER",
"macro",
"."
] | [
"vms"
] | vms-c | vms_c_get_vms_ver | vms | Virtual ISA | GCC | 19,733 | 10 | 1 | [] |
[
"<s>",
"static",
"int",
"riscv_register_priority",
"(",
"int",
"regno",
")",
"{",
"if",
"(",
"riscv_compressed_reg_p",
"(",
"regno",
")",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"a",
"register",
"priority",
"for",
"hard",
"reg",
"REGNO",
"."
] | [
"riscv",
"1",
"0"
] | riscv | riscv_register_priority | riscv | CPU | GCC | 19,734 | 22 | 1 | [] |
[
"<s>",
"int",
"msp430_initial_elimination_offset",
"(",
"int",
"from",
",",
"int",
"to",
")",
"{",
"int",
"rv",
"=",
"0",
";",
"msp430_compute_frame_info",
"(",
")",
";",
"switch",
"(",
"to",
")",
"{",
"case",
"STACK_POINTER_REGNUM",
":",
"rv",
"+=",
"cfun",
"->",
"machine",
"->",
"framesize_outgoing",
";",
"rv",
"+=",
"cfun",
"->",
"machine",
"->",
"framesize_locals",
";",
"case",
"FRAME_POINTER_REGNUM",
":",
"rv",
"+=",
"cfun",
"->",
"machine",
"->",
"framesize_regs",
";",
"rv",
"+=",
"(",
"TARGET_LARGE",
"?",
"4",
":",
"2",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"switch",
"(",
"from",
")",
"{",
"case",
"FRAME_POINTER_REGNUM",
":",
"rv",
"-=",
"(",
"TARGET_LARGE",
"?",
"4",
":",
"2",
")",
";",
"rv",
"-=",
"cfun",
"->",
"machine",
"->",
"framesize_regs",
";",
"case",
"ARG_POINTER_REGNUM",
":",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"rv",
";",
"}",
"</s>"
] | [
"Implements",
"INITIAL_ELIMINATION_OFFSET",
"."
] | [
"msp430",
"0",
"4",
"2",
"4",
"2"
] | msp430 | msp430_initial_elimination_offset | msp430 | MPU | GCC | 19,735 | 115 | 1 | [] |
[
"<s>",
"static",
"SDValue",
"getVectorShuffle",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"EVT",
"VT",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SDValue",
"V1",
",",
"SDValue",
"V2",
",",
"ArrayRef",
"<",
"int",
">",
"Mask",
")",
"{",
"if",
"(",
"(",
"ISD",
"::",
"isBuildVectorOfConstantSDNodes",
"(",
"V1",
".",
"getNode",
"(",
")",
")",
"||",
"V1",
".",
"isUndef",
"(",
")",
")",
"&&",
"(",
"ISD",
"::",
"isBuildVectorOfConstantSDNodes",
"(",
"V2",
".",
"getNode",
"(",
")",
")",
"||",
"V2",
".",
"isUndef",
"(",
")",
")",
")",
"{",
"SmallVector",
"<",
"SDValue",
">",
"Ops",
"(",
"Mask",
".",
"size",
"(",
")",
",",
"DAG",
".",
"getUNDEF",
"(",
"VT",
".",
"getScalarType",
"(",
")",
")",
")",
";",
"for",
"(",
"int",
"I",
"=",
"0",
",",
"NumElts",
"=",
"Mask",
".",
"size",
"(",
")",
";",
"I",
"!=",
"NumElts",
";",
"++",
"I",
")",
"{",
"int",
"M",
"=",
"Mask",
"[",
"I",
"]",
";",
"if",
"(",
"M",
"<",
"0",
")",
"continue",
";",
"SDValue",
"V",
"=",
"(",
"M",
"<",
"NumElts",
")",
"?",
"V1",
":",
"V2",
";",
"if",
"(",
"V",
".",
"isUndef",
"(",
")",
")",
"continue",
";",
"Ops",
"[",
"I",
"]",
"=",
"V",
".",
"getOperand",
"(",
"M",
"%",
"NumElts",
")",
";",
"}",
"return",
"DAG",
".",
"getBuildVector",
"(",
"VT",
",",
"dl",
",",
"Ops",
")",
";",
"}",
"return",
"DAG",
".",
"getVectorShuffle",
"(",
"VT",
",",
"dl",
",",
"V1",
",",
"V2",
",",
"Mask",
")",
";",
"}",
"</s>"
] | [
"Return",
"an",
"ISD",
":",
":VECTOR_SHUFFLE",
"node",
"."
] | [
"X86",
"ISD::isBuildVectorOfConstantSDNodes",
"ISD::isBuildVectorOfConstantSDNodes",
"0",
"0"
] | X86ISelLowering100 | getVectorShuffle | X86 | CPU | LLVM | 19,736 | 201 | 1 | [] |
[
"<s>",
"static",
"bool",
"mn10300_hard_regno_mode_ok",
"(",
"unsigned",
"int",
"regno",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"FP_REGS",
"||",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"FP_ACC_REGS",
")",
"return",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_FLOAT",
"&&",
"(",
"(",
"regno",
"&",
"1",
")",
"==",
"0",
")",
";",
"if",
"(",
"!",
"TARGET_AM33",
"&&",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"EXTENDED_REGS",
")",
"return",
"false",
";",
"if",
"(",
"(",
"(",
"regno",
")",
"&",
"1",
")",
"==",
"0",
"||",
"GET_MODE_SIZE",
"(",
"mode",
")",
"==",
"4",
")",
"return",
"true",
";",
"if",
"(",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"DATA_REGS",
"||",
"(",
"TARGET_AM33",
"&&",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"ADDRESS_REGS",
")",
"||",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"EXTENDED_REGS",
")",
"return",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"4",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_HARD_REGNO_MODE_OK",
"."
] | [
"mn10300",
"1",
"0",
"1",
"0",
"4",
"4"
] | mn10300 | mn10300_hard_regno_mode_ok | mn10300 | MPU | GCC | 19,737 | 122 | 1 | [] |
[
"<s>",
"SDValue",
"X86TargetLowering",
"::",
"LowerAsmOutputForConstraint",
"(",
"SDValue",
"&",
"Chain",
",",
"SDValue",
"&",
"Flag",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"const",
"AsmOperandInfo",
"&",
"OpInfo",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"X86",
"::",
"CondCode",
"Cond",
"=",
"parseConstraintCode",
"(",
"OpInfo",
".",
"ConstraintCode",
")",
";",
"if",
"(",
"Cond",
"==",
"X86",
"::",
"COND_INVALID",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"OpInfo",
".",
"ConstraintVT",
".",
"isVector",
"(",
")",
"||",
"!",
"OpInfo",
".",
"ConstraintVT",
".",
"isInteger",
"(",
")",
"||",
"OpInfo",
".",
"ConstraintVT",
".",
"getSizeInBits",
"(",
")",
"<",
"8",
")",
"report_fatal_error",
"(",
"\"Flag output operand is of invalid type\"",
")",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"{",
"Flag",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"X86",
"::",
"EFLAGS",
",",
"MVT",
"::",
"i32",
",",
"Flag",
")",
";",
"Chain",
"=",
"Flag",
".",
"getValue",
"(",
"1",
")",
";",
"}",
"else",
"Flag",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"X86",
"::",
"EFLAGS",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"CC",
"=",
"getSETCC",
"(",
"Cond",
",",
"Flag",
",",
"DL",
",",
"DAG",
")",
";",
"SDValue",
"Result",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ZERO_EXTEND",
",",
"DL",
",",
"OpInfo",
".",
"ConstraintVT",
",",
"CC",
")",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Handle",
"Lowering",
"flag",
"assembly",
"outputs",
"."
] | [
"X86",
"X86",
"X86::CondCode",
"X86::COND_INVALID",
"8",
"\"Flag output operand is of invalid type\"",
"X86::EFLAGS",
"MVT::i32",
"1",
"X86::EFLAGS",
"MVT::i32",
"ISD::ZERO_EXTEND"
] | X86ISelLowering (2)5 | LowerAsmOutputForConstraint | X86 | CPU | LLVM | 19,738 | 186 | 1 | [] |
[
"<s>",
"SMLoc",
"getEndLoc",
"(",
")",
"const",
"override",
"{",
"return",
"EndLoc",
";",
"}",
"</s>"
] | [
"getEndLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"last",
"token",
"of",
"this",
"operand",
"."
] | [
"LoongArch"
] | LoongArchAsmParser | getEndLoc | LoongArch | CPU | LLVM | 19,739 | 11 | 1 | [] |
[
"<s>",
"MCInst",
"Thumb1InstrInfo",
"::",
"getNop",
"(",
")",
"const",
"{",
"return",
"MCInstBuilder",
"(",
"ARM",
"::",
"tMOVr",
")",
".",
"addReg",
"(",
"ARM",
"::",
"R8",
")",
".",
"addReg",
"(",
"ARM",
"::",
"R8",
")",
".",
"addImm",
"(",
"ARMCC",
"::",
"AL",
")",
".",
"addReg",
"(",
"0",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"noop",
"instruction",
"to",
"use",
"for",
"a",
"noop",
"."
] | [
"ARM",
"ARM::tMOVr",
"ARM::R8",
"ARM::R8",
"ARMCC::AL",
"0"
] | Thumb1InstrInfo20 | getNop | ARM | CPU | LLVM | 19,740 | 43 | 1 | [] |
[
"<s>",
"machine_mode",
"frv_select_cc_mode",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"x",
",",
"rtx",
"y",
")",
"{",
"if",
"(",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"x",
")",
")",
"==",
"MODE_FLOAT",
")",
"return",
"CC_FPmode",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"EQ",
":",
"case",
"NE",
":",
"case",
"LT",
":",
"case",
"GE",
":",
"return",
"y",
"==",
"const0_rtx",
"?",
"CC_NZmode",
":",
"CCmode",
";",
"case",
"GTU",
":",
"case",
"GEU",
":",
"case",
"LTU",
":",
"case",
"LEU",
":",
"return",
"y",
"==",
"const0_rtx",
"?",
"CC_NZmode",
":",
"CC_UNSmode",
";",
"default",
":",
"return",
"CCmode",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"SELECT_CC_MODE",
".",
"Choose",
"CC_FP",
"for",
"floating-point",
"comparisons",
",",
"CC_NZ",
"for",
"comparisons",
"against",
"zero",
"in",
"which",
"a",
"single",
"Z",
"or",
"N",
"flag",
"test",
"is",
"enough",
",",
"CC_UNS",
"for",
"other",
"unsigned",
"comparisons",
",",
"and",
"CC",
"for",
"other",
"signed",
"comparisons",
"."
] | [
"frv"
] | frv | frv_select_cc_mode | frv | VLIW | GCC | 19,741 | 83 | 1 | [] |
[
"<s>",
"uint64_t",
"MipsFrameLowering",
"::",
"estimateStackSize",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"&",
"TRI",
"=",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"int64_t",
"Size",
"=",
"0",
";",
"for",
"(",
"int",
"I",
"=",
"MFI",
".",
"getObjectIndexBegin",
"(",
")",
";",
"I",
"!=",
"0",
";",
"++",
"I",
")",
"if",
"(",
"MFI",
".",
"getObjectOffset",
"(",
"I",
")",
">",
"0",
")",
"Size",
"+=",
"MFI",
".",
"getObjectSize",
"(",
"I",
")",
";",
"for",
"(",
"const",
"MCPhysReg",
"*",
"R",
"=",
"TRI",
".",
"getCalleeSavedRegs",
"(",
"&",
"MF",
")",
";",
"*",
"R",
";",
"++",
"R",
")",
"{",
"unsigned",
"RegSize",
"=",
"TRI",
".",
"getSpillSize",
"(",
"*",
"TRI",
".",
"getMinimalPhysRegClass",
"(",
"*",
"R",
")",
")",
";",
"Size",
"=",
"alignTo",
"(",
"Size",
"+",
"RegSize",
",",
"RegSize",
")",
";",
"}",
"return",
"Size",
"+",
"MFI",
".",
"estimateStackSize",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Estimate",
"and",
"return",
"the",
"size",
"of",
"the",
"stack",
"frame",
"."
] | [
"Mips",
"Mips",
"0",
"0",
"0"
] | MipsFrameLowering22 | estimateStackSize | Mips | CPU | LLVM | 19,742 | 140 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"PPCRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"if",
"(",
"Subtarget",
".",
"isDarwinABI",
"(",
")",
")",
"return",
"Subtarget",
".",
"isPPC64",
"(",
")",
"?",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"CSR_Darwin64_Altivec_RegMask",
":",
"CSR_Darwin64_RegMask",
")",
":",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"CSR_Darwin32_Altivec_RegMask",
":",
"CSR_Darwin32_RegMask",
")",
";",
"return",
"Subtarget",
".",
"isPPC64",
"(",
")",
"?",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"CSR_SVR464_Altivec_RegMask",
":",
"CSR_SVR464_RegMask",
")",
":",
"(",
"Subtarget",
".",
"hasAltivec",
"(",
")",
"?",
"CSR_SVR432_Altivec_RegMask",
":",
"CSR_SVR432_RegMask",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC"
] | PPCRegisterInfo (2) | getCallPreservedMask | PowerPC | CPU | LLVM | 19,743 | 85 | 1 | [] |
[
"<s>",
"const",
"MCFixupKindInfo",
"&",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"override",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"AAP",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"\"fixup_AAP_NONE\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_BR16\"",
",",
"0",
",",
"9",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_BR32\"",
",",
"0",
",",
"9",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_BRCC16\"",
",",
"6",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_BRCC32\"",
",",
"6",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_BAL16\"",
",",
"0",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_BAL32\"",
",",
"0",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_ABS6\"",
",",
"0",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_ABS9\"",
",",
"0",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_ABS10\"",
",",
"0",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_ABS12\"",
",",
"0",
",",
"6",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_ABS16\"",
",",
"0",
",",
"6",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_SHIFT6\"",
",",
"0",
",",
"3",
",",
"0",
"}",
",",
"{",
"\"fixup_AAP_OFF10\"",
",",
"0",
",",
"3",
",",
"0",
"}",
"}",
";",
"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",
"."
] | [
"AAP",
"AAP::NumTargetFixupKinds",
"\"fixup_AAP_NONE\"",
"0",
"16",
"0",
"\"fixup_AAP_BR16\"",
"0",
"9",
"0",
"\"fixup_AAP_BR32\"",
"0",
"9",
"0",
"\"fixup_AAP_BRCC16\"",
"6",
"3",
"0",
"\"fixup_AAP_BRCC32\"",
"6",
"3",
"0",
"\"fixup_AAP_BAL16\"",
"0",
"3",
"0",
"\"fixup_AAP_BAL32\"",
"0",
"3",
"0",
"\"fixup_AAP_ABS6\"",
"0",
"3",
"0",
"\"fixup_AAP_ABS9\"",
"0",
"3",
"0",
"\"fixup_AAP_ABS10\"",
"0",
"3",
"0",
"\"fixup_AAP_ABS12\"",
"0",
"6",
"0",
"\"fixup_AAP_ABS16\"",
"0",
"6",
"0",
"\"fixup_AAP_SHIFT6\"",
"0",
"3",
"0",
"\"fixup_AAP_OFF10\"",
"0",
"3",
"0",
"\"Invalid kind!\""
] | AAPAsmBackend | getFixupKindInfo | AAP | MPU | LLVM | 19,744 | 202 | 1 | [] |
[
"<s>",
"bool",
"X86AsmBackend",
"::",
"writeNopData",
"(",
"uint64_t",
"Count",
",",
"MCObjectWriter",
"*",
"OW",
")",
"const",
"{",
"static",
"const",
"uint8_t",
"Nops",
"[",
"10",
"]",
"[",
"10",
"]",
"=",
"{",
"{",
"0x90",
"}",
",",
"{",
"0x66",
",",
"0x90",
"}",
",",
"{",
"0x0f",
",",
"0x1f",
",",
"0x00",
"}",
",",
"{",
"0x0f",
",",
"0x1f",
",",
"0x40",
",",
"0x00",
"}",
",",
"{",
"0x0f",
",",
"0x1f",
",",
"0x44",
",",
"0x00",
",",
"0x00",
"}",
",",
"{",
"0x66",
",",
"0x0f",
",",
"0x1f",
",",
"0x44",
",",
"0x00",
",",
"0x00",
"}",
",",
"{",
"0x0f",
",",
"0x1f",
",",
"0x80",
",",
"0x00",
",",
"0x00",
",",
"0x00",
",",
"0x00",
"}",
",",
"{",
"0x0f",
",",
"0x1f",
",",
"0x84",
",",
"0x00",
",",
"0x00",
",",
"0x00",
",",
"0x00",
",",
"0x00",
"}",
",",
"{",
"0x66",
",",
"0x0f",
",",
"0x1f",
",",
"0x84",
",",
"0x00",
",",
"0x00",
",",
"0x00",
",",
"0x00",
",",
"0x00",
"}",
",",
"{",
"0x66",
",",
"0x2e",
",",
"0x0f",
",",
"0x1f",
",",
"0x84",
",",
"0x00",
",",
"0x00",
",",
"0x00",
",",
"0x00",
",",
"0x00",
"}",
",",
"}",
";",
"if",
"(",
"CPU",
"==",
"\"generic\"",
"||",
"CPU",
"==",
"\"i386\"",
"||",
"CPU",
"==",
"\"i486\"",
"||",
"CPU",
"==",
"\"i586\"",
"||",
"CPU",
"==",
"\"pentium\"",
"||",
"CPU",
"==",
"\"pentium-mmx\"",
"||",
"CPU",
"==",
"\"geode\"",
")",
"{",
"for",
"(",
"uint64_t",
"i",
"=",
"0",
";",
"i",
"<",
"Count",
";",
"++",
"i",
")",
"OW",
"->",
"Write8",
"(",
"0x90",
")",
";",
"return",
"true",
";",
"}",
"const",
"uint64_t",
"OptimalCount",
"=",
"(",
"Count",
"<",
"16",
")",
"?",
"Count",
":",
"15",
";",
"const",
"uint64_t",
"Prefixes",
"=",
"OptimalCount",
"<=",
"10",
"?",
"0",
":",
"OptimalCount",
"-",
"10",
";",
"for",
"(",
"uint64_t",
"i",
"=",
"0",
",",
"e",
"=",
"Prefixes",
";",
"i",
"!=",
"e",
";",
"i",
"++",
")",
"OW",
"->",
"Write8",
"(",
"0x66",
")",
";",
"const",
"uint64_t",
"Rest",
"=",
"OptimalCount",
"-",
"Prefixes",
";",
"for",
"(",
"uint64_t",
"i",
"=",
"0",
",",
"e",
"=",
"Rest",
";",
"i",
"!=",
"e",
";",
"i",
"++",
")",
"OW",
"->",
"Write8",
"(",
"Nops",
"[",
"Rest",
"-",
"1",
"]",
"[",
"i",
"]",
")",
";",
"for",
"(",
"uint64_t",
"i",
"=",
"OptimalCount",
",",
"e",
"=",
"Count",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"OW",
"->",
"Write8",
"(",
"0x90",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Write",
"an",
"(",
"optimal",
")",
"nop",
"sequence",
"of",
"Count",
"bytes",
"to",
"the",
"given",
"output",
"."
] | [
"X86",
"X86",
"10",
"10",
"0x90",
"0x66",
"0x90",
"0x0f",
"0x1f",
"0x00",
"0x0f",
"0x1f",
"0x40",
"0x00",
"0x0f",
"0x1f",
"0x44",
"0x00",
"0x00",
"0x66",
"0x0f",
"0x1f",
"0x44",
"0x00",
"0x00",
"0x0f",
"0x1f",
"0x80",
"0x00",
"0x00",
"0x00",
"0x00",
"0x0f",
"0x1f",
"0x84",
"0x00",
"0x00",
"0x00",
"0x00",
"0x00",
"0x66",
"0x0f",
"0x1f",
"0x84",
"0x00",
"0x00",
"0x00",
"0x00",
"0x00",
"0x66",
"0x2e",
"0x0f",
"0x1f",
"0x84",
"0x00",
"0x00",
"0x00",
"0x00",
"0x00",
"\"generic\"",
"\"i386\"",
"\"i486\"",
"\"i586\"",
"\"pentium\"",
"\"pentium-mmx\"",
"\"geode\"",
"0",
"0x90",
"16",
"15",
"10",
"0",
"10",
"0",
"0x66",
"0",
"1",
"0x90"
] | X86AsmBackend20 | writeNopData | X86 | CPU | LLVM | 19,745 | 337 | 1 | [] |
[
"<s>",
"EVT",
"MipsTargetLowering",
"::",
"getTypeForExtReturn",
"(",
"LLVMContext",
"&",
"Context",
",",
"EVT",
"VT",
",",
"ISD",
"::",
"NodeType",
")",
"const",
"{",
"bool",
"Cond",
"=",
"!",
"Subtarget",
".",
"isABI_O32",
"(",
")",
"&&",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"32",
";",
"EVT",
"MinVT",
"=",
"getRegisterType",
"(",
"Context",
",",
"Cond",
"?",
"MVT",
"::",
"i64",
":",
"MVT",
"::",
"i32",
")",
";",
"return",
"VT",
".",
"bitsLT",
"(",
"MinVT",
")",
"?",
"MinVT",
":",
"VT",
";",
"}",
"</s>"
] | [
"Return",
"the",
"type",
"that",
"should",
"be",
"used",
"to",
"zero",
"or",
"sign",
"extend",
"a",
"zeroext/signext",
"integer",
"return",
"value",
"."
] | [
"Mips",
"Mips",
"ISD::NodeType",
"32",
"MVT::i64",
"MVT::i32"
] | MipsISelLowering (2)4 | getTypeForExtReturn | Mips | CPU | LLVM | 19,746 | 67 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_function_arg_advance",
"(",
"cumulative_args_t",
"cum_v",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"bool",
"named",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"HOST_WIDE_INT",
"bytes",
",",
"words",
";",
"int",
"nregs",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"bytes",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"else",
"bytes",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"words",
"=",
"CEIL",
"(",
"bytes",
",",
"UNITS_PER_WORD",
")",
";",
"if",
"(",
"type",
")",
"mode",
"=",
"type_natural_mode",
"(",
"type",
",",
"NULL",
",",
"false",
")",
";",
"if",
"(",
"(",
"type",
"&&",
"POINTER_BOUNDS_TYPE_P",
"(",
"type",
")",
")",
"||",
"POINTER_BOUNDS_MODE_P",
"(",
"mode",
")",
")",
"{",
"if",
"(",
"cum",
"->",
"bnds_in_bt",
")",
"{",
"cum",
"->",
"bnds_in_bt",
"--",
";",
"return",
";",
"}",
"if",
"(",
"cum",
"->",
"force_bnd_pass",
")",
"cum",
"->",
"force_bnd_pass",
"--",
";",
"cum",
"->",
"bnd_regno",
"++",
";",
"return",
";",
"}",
"cum",
"->",
"bnds_in_bt",
"=",
"0",
";",
"if",
"(",
"cum",
"->",
"force_bnd_pass",
")",
"{",
"cum",
"->",
"bnd_regno",
"+=",
"cum",
"->",
"force_bnd_pass",
";",
"cum",
"->",
"force_bnd_pass",
"=",
"0",
";",
"}",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"enum",
"calling_abi",
"call_abi",
"=",
"cum",
"?",
"cum",
"->",
"call_abi",
":",
"ix86_abi",
";",
"if",
"(",
"call_abi",
"==",
"MS_ABI",
")",
"nregs",
"=",
"function_arg_advance_ms_64",
"(",
"cum",
",",
"bytes",
",",
"words",
")",
";",
"else",
"nregs",
"=",
"function_arg_advance_64",
"(",
"cum",
",",
"mode",
",",
"type",
",",
"words",
",",
"named",
")",
";",
"}",
"else",
"nregs",
"=",
"function_arg_advance_32",
"(",
"cum",
",",
"mode",
",",
"type",
",",
"bytes",
",",
"words",
")",
";",
"if",
"(",
"cum",
"->",
"stdarg",
")",
"cum",
"->",
"force_bnd_pass",
"=",
"nregs",
";",
"if",
"(",
"!",
"nregs",
")",
"cum",
"->",
"bnds_in_bt",
"=",
"chkp_type_bounds_count",
"(",
"type",
")",
";",
"}",
"</s>"
] | [
"Update",
"the",
"data",
"in",
"CUM",
"to",
"advance",
"over",
"an",
"argument",
"of",
"mode",
"MODE",
"and",
"data",
"type",
"TYPE",
".",
"(",
"TYPE",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
".",
")"
] | [
"i386",
"0",
"0"
] | i3865 | ix86_function_arg_advance | i386 | CPU | GCC | 19,747 | 252 | 1 | [] |
[
"<s>",
"bool",
"valid",
"(",
")",
"const",
"{",
"return",
"Ref",
".",
"size",
"(",
")",
">=",
"sizeof",
"(",
"Item",
")",
"&&",
"Ref",
".",
"size",
"(",
")",
">=",
"getItemPadSize",
"(",
")",
";",
"}",
"</s>"
] | [
"valid",
"-",
"Return",
"true",
"if",
"iterator",
"is",
"at",
"an",
"overlap",
"."
] | [
"AMDGPU"
] | CodeObject | valid | AMDGPU | GPU | LLVM | 19,748 | 29 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"find_drap_reg",
"(",
"void",
")",
"{",
"tree",
"decl",
"=",
"cfun",
"->",
"decl",
";",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"if",
"(",
"DECL_STATIC_CHAIN",
"(",
"decl",
")",
"||",
"cfun",
"->",
"machine",
"->",
"no_caller_saved_registers",
"||",
"crtl",
"->",
"tail_call_emit",
")",
"return",
"R13_REG",
";",
"return",
"R10_REG",
";",
"}",
"else",
"{",
"if",
"(",
"DECL_STATIC_CHAIN",
"(",
"decl",
")",
"||",
"cfun",
"->",
"machine",
"->",
"no_caller_saved_registers",
"||",
"crtl",
"->",
"tail_call_emit",
"||",
"crtl",
"->",
"calls_eh_return",
")",
"return",
"DI_REG",
";",
"if",
"(",
"ix86_function_regparm",
"(",
"TREE_TYPE",
"(",
"decl",
")",
",",
"decl",
")",
"<=",
"2",
")",
"{",
"unsigned",
"int",
"ccvt",
"=",
"ix86_get_callcvt",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
";",
"if",
"(",
"(",
"ccvt",
"&",
"(",
"IX86_CALLCVT_FASTCALL",
"|",
"IX86_CALLCVT_THISCALL",
")",
")",
"==",
"0",
")",
"return",
"CX_REG",
";",
"}",
"return",
"DI_REG",
";",
"}",
"}",
"</s>"
] | [
"Find",
"an",
"available",
"register",
"to",
"be",
"used",
"as",
"dynamic",
"realign",
"argument",
"pointer",
"regsiter",
".",
"Such",
"a",
"register",
"will",
"be",
"written",
"in",
"prologue",
"and",
"used",
"in",
"begin",
"of",
"body",
",",
"so",
"it",
"must",
"not",
"be",
"1.",
"parameter",
"passing",
"register",
".",
"2",
".",
"GOT",
"pointer",
".",
"We",
"reuse",
"static-chain",
"register",
"if",
"it",
"is",
"available",
".",
"Otherwise",
",",
"we",
"use",
"DI",
"for",
"i386",
"and",
"R13",
"for",
"x86-64",
".",
"We",
"chose",
"R13",
"since",
"it",
"has",
"shorter",
"encoding",
".",
"Return",
":",
"the",
"regno",
"of",
"chosen",
"register",
"."
] | [
"i386",
"2",
"0"
] | i386 | find_drap_reg | i386 | CPU | GCC | 19,749 | 120 | 1 | [] |
[
"<s>",
"bool",
"LC3RegisterInfo",
"::",
"requiresRegisterScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"(",
"and",
"can",
"make",
"use",
"of",
")",
"the",
"register",
"scavenger",
"."
] | [
"LC3",
"LC3"
] | LC3RegisterInfo | requiresRegisterScavenging | LC3 | CPU | LLVM | 19,750 | 16 | 1 | [] |
[
"<s>",
"static",
"bool",
"mep_legitimate_constant_p",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"&&",
"(",
"reload_in_progress",
"||",
"reload_completed",
")",
")",
"{",
"char",
"e",
"=",
"mep_section_tag",
"(",
"x",
")",
";",
"return",
"(",
"e",
"!=",
"'t'",
"&&",
"e",
"!=",
"'b'",
")",
";",
"}",
"return",
"1",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMATE_CONSTANT_P",
"."
] | [
"mep",
"1"
] | mep | mep_legitimate_constant_p | mep | CPU | GCC | 19,751 | 52 | 1 | [] |
[
"<s>",
"MipsSubtarget",
"::",
"MipsSubtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"bool",
"little",
",",
"Reloc",
"::",
"Model",
"RM",
")",
":",
"MipsGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"MipsArchVersion",
"(",
"Mips32",
")",
",",
"MipsABI",
"(",
"UnknownABI",
")",
",",
"IsLittle",
"(",
"little",
")",
",",
"IsSingleFloat",
"(",
"false",
")",
",",
"IsFP64bit",
"(",
"false",
")",
",",
"IsGP64bit",
"(",
"false",
")",
",",
"HasVFPU",
"(",
"false",
")",
",",
"IsLinux",
"(",
"true",
")",
",",
"HasSEInReg",
"(",
"false",
")",
",",
"HasCondMov",
"(",
"false",
")",
",",
"HasMulDivAdd",
"(",
"false",
")",
",",
"HasMinMax",
"(",
"false",
")",
",",
"HasSwap",
"(",
"false",
")",
",",
"HasBitCount",
"(",
"false",
")",
",",
"InMips16Mode",
"(",
"false",
")",
",",
"HasDSP",
"(",
"false",
")",
",",
"HasDSPR2",
"(",
"false",
")",
",",
"IsAndroid",
"(",
"false",
")",
"{",
"std",
"::",
"string",
"CPUName",
"=",
"CPU",
";",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"CPUName",
"=",
"\"mips32\"",
";",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FS",
")",
";",
"InstrItins",
"=",
"getInstrItineraryForCPU",
"(",
"CPUName",
")",
";",
"if",
"(",
"MipsABI",
"==",
"UnknownABI",
")",
"MipsABI",
"=",
"hasMips64",
"(",
")",
"?",
"N64",
":",
"O32",
";",
"assert",
"(",
"(",
"(",
"!",
"hasMips64",
"(",
")",
"&&",
"(",
"isABI_O32",
"(",
")",
"||",
"isABI_EABI",
"(",
")",
")",
")",
"||",
"(",
"hasMips64",
"(",
")",
"&&",
"(",
"isABI_N32",
"(",
")",
"||",
"isABI_N64",
"(",
")",
")",
")",
")",
"&&",
"\"Invalid Arch & ABI pair.\"",
")",
";",
"if",
"(",
"TT",
".",
"find",
"(",
"\"linux\"",
")",
"==",
"std",
"::",
"string",
"::",
"npos",
")",
"IsLinux",
"=",
"false",
";",
"UseSmallSection",
"=",
"!",
"IsLinux",
"&&",
"(",
"RM",
"==",
"Reloc",
"::",
"Static",
")",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"\"mips32\"",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"\"Invalid Arch & ABI pair.\"",
"\"linux\""
] | MipsSubtarget9 | MipsSubtarget | Mips | CPU | LLVM | 19,752 | 255 | 1 | [] |
[
"<s>",
"bool",
"TGSICFGStructurizer",
"::",
"prepare",
"(",
")",
"{",
"bool",
"Changed",
"=",
"false",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"TGSICFGStructurizer::prepare\\n\"",
";",
")",
";",
"orderBlocks",
"(",
"FuncRep",
")",
";",
"SmallVector",
"<",
"MachineBasicBlock",
"*",
",",
"DEFAULT_VEC_SLOTS",
">",
"RetBlks",
";",
"for",
"(",
"MachineLoopInfo",
"::",
"iterator",
"It",
"=",
"MLI",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"MLI",
"->",
"end",
"(",
")",
";",
"It",
"!=",
"E",
";",
"++",
"It",
")",
"{",
"MachineLoop",
"*",
"LoopRep",
"=",
"(",
"*",
"It",
")",
";",
"MBBVector",
"ExitingMBBs",
";",
"LoopRep",
"->",
"getExitingBlocks",
"(",
"ExitingMBBs",
")",
";",
"if",
"(",
"ExitingMBBs",
".",
"size",
"(",
")",
"==",
"0",
")",
"{",
"MachineBasicBlock",
"*",
"DummyExitBlk",
"=",
"normalizeInfiniteLoopExit",
"(",
"LoopRep",
")",
";",
"if",
"(",
"DummyExitBlk",
")",
"RetBlks",
".",
"push_back",
"(",
"DummyExitBlk",
")",
";",
"}",
"}",
"for",
"(",
"SmallVectorImpl",
"<",
"MachineBasicBlock",
"*",
">",
"::",
"const_iterator",
"It",
"=",
"OrderedBlks",
".",
"begin",
"(",
")",
",",
"E",
"=",
"OrderedBlks",
".",
"end",
"(",
")",
";",
"It",
"!=",
"E",
";",
"++",
"It",
")",
"{",
"MachineBasicBlock",
"*",
"MBB",
"=",
"*",
"It",
";",
"removeUnconditionalBranch",
"(",
"MBB",
")",
";",
"removeRedundantConditionalBranch",
"(",
"MBB",
")",
";",
"if",
"(",
"isReturnBlock",
"(",
"MBB",
")",
")",
"{",
"RetBlks",
".",
"push_back",
"(",
"MBB",
")",
";",
"}",
"assert",
"(",
"MBB",
"->",
"succ_size",
"(",
")",
"<=",
"2",
")",
";",
"}",
"if",
"(",
"RetBlks",
".",
"size",
"(",
")",
">=",
"2",
")",
"{",
"addDummyExitBlock",
"(",
"RetBlks",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"prepare",
"-",
"Reset",
"state",
"and",
"prepare",
"for",
"a",
"new",
"spill",
"placement",
"computation",
"."
] | [
"TGSI",
"TGSI",
"\"TGSICFGStructurizer::prepare\\n\"",
"0",
"2",
"2"
] | TGSICFGStructurizer | prepare | TGSI | Virtual ISA | LLVM | 19,753 | 220 | 1 | [] |
[
"<s>",
"void",
"MetadataStreamerV3",
"::",
"verify",
"(",
"StringRef",
"HSAMetadataString",
")",
"const",
"{",
"errs",
"(",
")",
"<<",
"\"AMDGPU HSA Metadata Parser Test: \"",
";",
"std",
"::",
"shared_ptr",
"<",
"msgpack",
"::",
"Node",
">",
"FromHSAMetadataString",
"=",
"std",
"::",
"make_shared",
"<",
"msgpack",
"::",
"MapNode",
">",
"(",
")",
";",
"yaml",
"::",
"Input",
"YIn",
"(",
"HSAMetadataString",
")",
";",
"YIn",
">>",
"FromHSAMetadataString",
";",
"if",
"(",
"YIn",
".",
"error",
"(",
")",
")",
"{",
"errs",
"(",
")",
"<<",
"\"FAIL\\n\"",
";",
"return",
";",
"}",
"std",
"::",
"string",
"ToHSAMetadataString",
";",
"raw_string_ostream",
"StrOS",
"(",
"ToHSAMetadataString",
")",
";",
"yaml",
"::",
"Output",
"YOut",
"(",
"StrOS",
")",
";",
"YOut",
"<<",
"FromHSAMetadataString",
";",
"errs",
"(",
")",
"<<",
"(",
"HSAMetadataString",
"==",
"StrOS",
".",
"str",
"(",
")",
"?",
"\"PASS\"",
":",
"\"FAIL\"",
")",
"<<",
"'\\n'",
";",
"if",
"(",
"HSAMetadataString",
"!=",
"ToHSAMetadataString",
")",
"{",
"errs",
"(",
")",
"<<",
"\"Original input: \"",
"<<",
"HSAMetadataString",
"<<",
"'\\n'",
"<<",
"\"Produced output: \"",
"<<",
"StrOS",
".",
"str",
"(",
")",
"<<",
"'\\n'",
";",
"}",
"}",
"</s>"
] | [
"Check",
"if",
"this",
"register",
"bank",
"is",
"valid",
"."
] | [
"AMDGPU",
"\"AMDGPU HSA Metadata Parser Test: \"",
"\"FAIL\\n\"",
"\"PASS\"",
"\"FAIL\"",
"\"Original input: \"",
"\"Produced output: \""
] | AMDGPUHSAMetadataStreamer24 | verify | AMDGPU | GPU | LLVM | 19,754 | 139 | 1 | [] |
[
"<s>",
"Function",
"*",
"AMDGPUIntrinsicInfo",
"::",
"getDeclaration",
"(",
"Module",
"*",
"M",
",",
"unsigned",
"IntrID",
",",
"ArrayRef",
"<",
"Type",
"*",
">",
"Tys",
")",
"const",
"{",
"FunctionType",
"*",
"FTy",
"=",
"getType",
"(",
"M",
"->",
"getContext",
"(",
")",
",",
"IntrID",
",",
"Tys",
")",
";",
"Function",
"*",
"F",
"=",
"cast",
"<",
"Function",
">",
"(",
"M",
"->",
"getOrInsertFunction",
"(",
"getName",
"(",
"IntrID",
",",
"Tys",
")",
",",
"FTy",
")",
")",
";",
"AttributeList",
"AS",
"=",
"getAttributes",
"(",
"M",
"->",
"getContext",
"(",
")",
",",
"static_cast",
"<",
"SIIntrinsic",
"::",
"ID",
">",
"(",
"IntrID",
")",
")",
";",
"F",
"->",
"setAttributes",
"(",
"AS",
")",
";",
"return",
"F",
";",
"}",
"</s>"
] | [
"Create",
"or",
"insert",
"an",
"LLVM",
"Function",
"declaration",
"for",
"an",
"intrinsic",
",",
"and",
"return",
"it",
"."
] | [
"AMDGPU",
"AMDGPU",
"SIIntrinsic::ID"
] | AMDGPUIntrinsicInfo8 | getDeclaration | AMDGPU | GPU | LLVM | 19,755 | 96 | 1 | [] |
[
"<s>",
"static",
"int",
"sh_address_cost",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
",",
"addr_space_t",
"as",
"ATTRIBUTE_UNUSED",
",",
"bool",
"speed",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"REGNO",
"(",
"x",
")",
"==",
"GBR_REG",
")",
"return",
"2",
";",
"if",
"(",
"REG_P",
"(",
"x",
")",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"POST_INC",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"PRE_DEC",
")",
"return",
"1",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"{",
"if",
"(",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"GBR_REG",
"&&",
"gbr_displacement",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"mode",
")",
")",
"return",
"2",
";",
"const",
"HOST_WIDE_INT",
"offset",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
";",
"if",
"(",
"offset",
"==",
"0",
")",
"return",
"1",
";",
"if",
"(",
"offset",
">",
"0",
"&&",
"offset",
"<=",
"sh_max_mov_insn_displacement",
"(",
"mode",
",",
"false",
")",
")",
"return",
"(",
"mode",
"==",
"HImode",
"||",
"mode",
"==",
"QImode",
")",
"?",
"2",
":",
"1",
";",
"if",
"(",
"TARGET_SH2A",
"&&",
"offset",
">",
"0",
"&&",
"offset",
"<=",
"sh_max_mov_insn_displacement",
"(",
"mode",
",",
"true",
")",
")",
"return",
"2",
";",
"return",
"3",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"!",
"CONSTANT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"&&",
"!",
"TARGET_SHMEDIA",
")",
"return",
"3",
";",
"return",
"10",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"cost",
"of",
"an",
"address",
".",
"For",
"the",
"SH",
",",
"all",
"valid",
"addresses",
"are",
"the",
"same",
"cost",
".",
"Use",
"a",
"slightly",
"higher",
"cost",
"for",
"reg",
"+",
"reg",
"addressing",
",",
"since",
"it",
"increases",
"pressure",
"on",
"r0",
"."
] | [
"sh",
"2",
"1",
"0",
"1",
"0",
"1",
"2",
"1",
"0",
"1",
"0",
"2",
"1",
"0",
"2",
"3",
"1",
"3",
"10"
] | sh4 | sh_address_cost | sh | CPU | GCC | 19,756 | 226 | 1 | [] |
[
"<s>",
"unsigned",
"AArch64TTIImpl",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"TTI",
"::",
"OperandValueKind",
"Opd1Info",
",",
"TTI",
"::",
"OperandValueKind",
"Opd2Info",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd1PropInfo",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd2PropInfo",
")",
"{",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"Ty",
")",
";",
"int",
"ISD",
"=",
"TLI",
"->",
"InstructionOpcodeToISD",
"(",
"Opcode",
")",
";",
"if",
"(",
"ISD",
"==",
"ISD",
"::",
"SDIV",
"&&",
"Opd2Info",
"==",
"TargetTransformInfo",
"::",
"OK_UniformConstantValue",
"&&",
"Opd2PropInfo",
"==",
"TargetTransformInfo",
"::",
"OP_PowerOf2",
")",
"{",
"unsigned",
"Cost",
"=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Add",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Sub",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Select",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"AShr",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"return",
"Cost",
";",
"}",
"switch",
"(",
"ISD",
")",
"{",
"default",
":",
"return",
"BaseT",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
")",
";",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"XOR",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"AND",
":",
"return",
"1",
"*",
"LT",
".",
"first",
";",
"}",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"AArch64",
"AArch64",
"ISD::SDIV",
"ISD::ADD",
"ISD::MUL",
"ISD::XOR",
"ISD::OR",
"ISD::AND",
"1"
] | AArch64TargetTransformInfo32 | getArithmeticInstrCost | AArch64 | CPU | LLVM | 19,757 | 237 | 1 | [] |
[
"<s>",
"int",
"bpf_core_get_sou_member_index",
"(",
"ctf_container_ref",
"ctfc",
",",
"const",
"tree",
"node",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"node",
")",
"==",
"FIELD_DECL",
")",
"{",
"const",
"tree",
"container",
"=",
"DECL_CONTEXT",
"(",
"node",
")",
";",
"dw_die_ref",
"die",
"=",
"lookup_type_die",
"(",
"container",
")",
";",
"if",
"(",
"die",
"==",
"NULL",
")",
"return",
"-",
"1",
";",
"ctf_dtdef_ref",
"dtd",
"=",
"ctf_dtd_lookup",
"(",
"ctfc",
",",
"die",
")",
";",
"if",
"(",
"dtd",
"==",
"NULL",
")",
"return",
"-",
"1",
";",
"unsigned",
"int",
"kind",
"=",
"CTF_V2_INFO_KIND",
"(",
"dtd",
"->",
"dtd_data",
".",
"ctti_info",
")",
";",
"if",
"(",
"kind",
"!=",
"CTF_K_STRUCT",
"&&",
"kind",
"!=",
"CTF_K_UNION",
")",
"return",
"-",
"1",
";",
"tree",
"field",
"=",
"TYPE_FIELDS",
"(",
"container",
")",
";",
"int",
"i",
"=",
"0",
";",
"ctf_dmdef_t",
"*",
"dmd",
";",
"for",
"(",
"dmd",
"=",
"dtd",
"->",
"dtd_u",
".",
"dtu_members",
";",
"dmd",
"!=",
"NULL",
";",
"dmd",
"=",
"(",
"ctf_dmdef_t",
"*",
")",
"ctf_dmd_list_next",
"(",
"dmd",
")",
")",
"{",
"bool",
"field_has_btf",
"=",
"get_btf_id",
"(",
"dmd",
"->",
"dmd_type",
")",
"<=",
"BTF_MAX_TYPE",
";",
"if",
"(",
"field",
"==",
"node",
")",
"return",
"field_has_btf",
"?",
"i",
":",
"-",
"1",
";",
"if",
"(",
"field_has_btf",
")",
"i",
"++",
";",
"field",
"=",
"DECL_CHAIN",
"(",
"field",
")",
";",
"}",
"}",
"return",
"-",
"1",
";",
"}",
"</s>"
] | [
"Return",
"the",
"0-based",
"index",
"of",
"the",
"field",
"NODE",
"in",
"its",
"containing",
"struct",
"or",
"union",
"type",
"."
] | [
"bpf",
"1",
"1",
"1",
"0",
"1",
"1"
] | coreout1 | bpf_core_get_sou_member_index | bpf | Virtual ISA | GCC | 19,758 | 185 | 1 | [] |
[
"<s>",
"bool",
"R600Packetizer",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"Fn",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineLoopInfo",
"&",
"MLI",
"=",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"R600PacketizerList",
"Packetizer",
"(",
"Fn",
",",
"MLI",
")",
";",
"assert",
"(",
"Packetizer",
".",
"getResourceTracker",
"(",
")",
"&&",
"\"Empty DFA table!\"",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"MBBe",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"MBBe",
";",
"++",
"MBB",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"End",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MI",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"while",
"(",
"MI",
"!=",
"End",
")",
"{",
"if",
"(",
"MI",
"->",
"isKill",
"(",
")",
"||",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"IMPLICIT_DEF",
"||",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"CF_ALU",
"&&",
"!",
"MI",
"->",
"getOperand",
"(",
"8",
")",
".",
"getImm",
"(",
")",
")",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"DeleteMI",
"=",
"MI",
";",
"++",
"MI",
";",
"MBB",
"->",
"erase",
"(",
"DeleteMI",
")",
";",
"End",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"continue",
";",
"}",
"++",
"MI",
";",
"}",
"}",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"MBBe",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"MBBe",
";",
"++",
"MBB",
")",
"{",
"unsigned",
"RemainingCount",
"=",
"MBB",
"->",
"size",
"(",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"RegionEnd",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"RegionEnd",
"!=",
"MBB",
"->",
"begin",
"(",
")",
";",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"RegionEnd",
";",
"for",
"(",
";",
"I",
"!=",
"MBB",
"->",
"begin",
"(",
")",
";",
"--",
"I",
",",
"--",
"RemainingCount",
")",
"{",
"if",
"(",
"TII",
"->",
"isSchedulingBoundary",
"(",
"std",
"::",
"prev",
"(",
"I",
")",
",",
"MBB",
",",
"Fn",
")",
")",
"break",
";",
"}",
"I",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"if",
"(",
"I",
"==",
"RegionEnd",
")",
"{",
"RegionEnd",
"=",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
";",
"--",
"RemainingCount",
";",
"continue",
";",
"}",
"if",
"(",
"I",
"==",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
")",
"{",
"RegionEnd",
"=",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
";",
"continue",
";",
"}",
"Packetizer",
".",
"PacketizeMIs",
"(",
"MBB",
",",
"I",
",",
"RegionEnd",
")",
";",
"RegionEnd",
"=",
"I",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AMDGPU",
"R600",
"R600",
"\"Empty DFA table!\"",
"AMDGPU::IMPLICIT_DEF",
"AMDGPU::CF_ALU",
"8"
] | R600Packetizer26 | runOnMachineFunction | AMDGPU | GPU | LLVM | 19,759 | 371 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"areMemAccessesTriviallyDisjoint",
"(",
"MachineInstr",
"*",
"MIa",
",",
"MachineInstr",
"*",
"MIb",
",",
"AliasAnalysis",
"*",
"AA",
")",
"const",
"{",
"int",
"OffsetA",
"=",
"0",
",",
"OffsetB",
"=",
"0",
";",
"unsigned",
"SizeA",
"=",
"0",
",",
"SizeB",
"=",
"0",
";",
"if",
"(",
"MIa",
"->",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIb",
"->",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIa",
"->",
"hasOrderedMemoryRef",
"(",
")",
"||",
"MIa",
"->",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MIa",
"->",
"mayLoad",
"(",
")",
"&&",
"!",
"isMemOp",
"(",
"MIa",
")",
"&&",
"MIb",
"->",
"mayLoad",
"(",
")",
"&&",
"!",
"isMemOp",
"(",
"MIb",
")",
")",
"return",
"true",
";",
"unsigned",
"BaseRegA",
"=",
"getBaseAndOffset",
"(",
"MIa",
",",
"OffsetA",
",",
"SizeA",
")",
";",
"if",
"(",
"!",
"BaseRegA",
"||",
"!",
"SizeA",
")",
"return",
"false",
";",
"unsigned",
"BaseRegB",
"=",
"getBaseAndOffset",
"(",
"MIb",
",",
"OffsetB",
",",
"SizeB",
")",
";",
"if",
"(",
"!",
"BaseRegB",
"||",
"!",
"SizeB",
")",
"return",
"false",
";",
"if",
"(",
"BaseRegA",
"!=",
"BaseRegB",
")",
"return",
"false",
";",
"if",
"(",
"OffsetA",
">",
"OffsetB",
")",
"{",
"uint64_t",
"offDiff",
"=",
"(",
"uint64_t",
")",
"(",
"(",
"int64_t",
")",
"OffsetA",
"-",
"(",
"int64_t",
")",
"OffsetB",
")",
";",
"return",
"(",
"SizeB",
"<=",
"offDiff",
")",
";",
"}",
"else",
"if",
"(",
"OffsetA",
"<",
"OffsetB",
")",
"{",
"uint64_t",
"offDiff",
"=",
"(",
"uint64_t",
")",
"(",
"(",
"int64_t",
")",
"OffsetB",
"-",
"(",
"int64_t",
")",
"OffsetA",
")",
";",
"return",
"(",
"SizeA",
"<=",
"offDiff",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Sometimes",
",",
"it",
"is",
"possible",
"for",
"the",
"target",
"to",
"tell",
",",
"even",
"without",
"aliasing",
"information",
",",
"that",
"two",
"MIs",
"access",
"different",
"memory",
"addresses",
"."
] | [
"Hexagon",
"Hexagon",
"0",
"0",
"0",
"0"
] | HexagonInstrInfo5 | areMemAccessesTriviallyDisjoint | Hexagon | DSP | LLVM | 19,760 | 221 | 1 | [] |
[
"<s>",
"bool",
"toc_relative_expr_p",
"(",
"const_rtx",
"op",
",",
"bool",
"strict",
")",
"{",
"if",
"(",
"!",
"TARGET_TOC",
")",
"return",
"false",
";",
"if",
"(",
"TARGET_CMODEL",
"!=",
"CMODEL_SMALL",
")",
"{",
"if",
"(",
"strict",
"&&",
"!",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"LO_SUM",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
"&&",
"INT_REG_OK_FOR_BASE_P",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"strict",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"LO_SUM",
")",
"op",
"=",
"XEXP",
"(",
"op",
",",
"1",
")",
";",
"}",
"tocrel_base",
"=",
"op",
";",
"tocrel_offset",
"=",
"const0_rtx",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"PLUS",
"&&",
"add_cint_operand",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
",",
"GET_MODE",
"(",
"op",
")",
")",
")",
"{",
"tocrel_base",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"tocrel_offset",
"=",
"XEXP",
"(",
"op",
",",
"1",
")",
";",
"}",
"return",
"(",
"GET_CODE",
"(",
"tocrel_base",
")",
"==",
"UNSPEC",
"&&",
"XINT",
"(",
"tocrel_base",
",",
"1",
")",
"==",
"UNSPEC_TOCREL",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"OP",
"is",
"a",
"toc",
"pointer",
"relative",
"address",
"(",
"the",
"output",
"of",
"create_TOC_reference",
")",
".",
"If",
"STRICT",
",",
"do",
"not",
"match",
"high",
"part",
"or",
"non-split",
"-mcmodel=large/medium",
"toc",
"pointer",
"relative",
"addresses",
"."
] | [
"powerpcspe",
"0",
"0",
"1",
"1",
"0",
"1",
"1"
] | powerpcspe | toc_relative_expr_p | powerpcspe | CPU | GCC | 19,761 | 155 | 1 | [] |
[
"<s>",
"void",
"HexagonTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"InitializeELF",
"(",
"TM",
".",
"Options",
".",
"UseInitArray",
")",
";",
"SmallDataSection",
"=",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".sdata\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"SHF_ALLOC",
",",
"SectionKind",
"::",
"getDataRel",
"(",
")",
")",
";",
"SmallBSSSection",
"=",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".sbss\"",
",",
"ELF",
"::",
"SHT_NOBITS",
",",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"SHF_ALLOC",
",",
"SectionKind",
"::",
"getBSS",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"Hexagon",
"Hexagon",
"\".sdata\"",
"\".sbss\""
] | HexagonTargetObjectFile34 | Initialize | Hexagon | DSP | LLVM | 19,762 | 92 | 1 | [] |
[
"<s>",
"void",
"OR1KInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"OR1K",
"OR1K"
] | OR1KInstPrinter1 | printInst | OR1K | CPU | LLVM | 19,763 | 38 | 1 | [] |
[
"<s>",
"bool",
"isMem",
"(",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"isMem",
"-",
"Is",
"this",
"a",
"memory",
"operand",
"?"
] | [
"Teak"
] | TeakAsmParser | isMem | Teak | DSP | LLVM | 19,764 | 11 | 1 | [] |
[
"<s>",
"bool",
"ARMCodeEmitter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"TargetMachine",
"&",
"Target",
"=",
"const_cast",
"<",
"TargetMachine",
"&",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"assert",
"(",
"(",
"Target",
".",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"Default",
"||",
"Target",
".",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"Static",
")",
"&&",
"\"JIT relocation model must be set to static or default!\"",
")",
";",
"JTI",
"=",
"static_cast",
"<",
"ARMJITInfo",
"*",
">",
"(",
"Target",
".",
"getJITInfo",
"(",
")",
")",
";",
"II",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"Target",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TD",
"=",
"Target",
".",
"getDataLayout",
"(",
")",
";",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"MCPEs",
"=",
"&",
"MF",
".",
"getConstantPool",
"(",
")",
"->",
"getConstants",
"(",
")",
";",
"MJTEs",
"=",
"nullptr",
";",
"if",
"(",
"MF",
".",
"getJumpTableInfo",
"(",
")",
")",
"MJTEs",
"=",
"&",
"MF",
".",
"getJumpTableInfo",
"(",
")",
"->",
"getJumpTables",
"(",
")",
";",
"IsPIC",
"=",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
";",
"IsThumb",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
"->",
"isThumbFunction",
"(",
")",
";",
"JTI",
"->",
"Initialize",
"(",
"MF",
",",
"IsPIC",
")",
";",
"MMI",
"=",
"&",
"getAnalysis",
"<",
"MachineModuleInfo",
">",
"(",
")",
";",
"MCE",
".",
"setModuleInfo",
"(",
"MMI",
")",
";",
"do",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"JITTing function '\"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"\"'\\n\"",
")",
";",
"MCE",
".",
"startFunction",
"(",
"MF",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"E",
";",
"++",
"MBB",
")",
"{",
"MCE",
".",
"StartMachineBasicBlock",
"(",
"MBB",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"emitInstruction",
"(",
"*",
"I",
")",
";",
"}",
"}",
"while",
"(",
"MCE",
".",
"finishFunction",
"(",
"MF",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"\"JIT relocation model must be set to static or default!\"",
"ARM",
"ARM",
"ARM",
"ARM",
"\"JITTing function '\"",
"\"'\\n\""
] | ARMCodeEmitter14 | runOnMachineFunction | ARM | CPU | LLVM | 19,765 | 308 | 1 | [] |
[
"<s>",
"static",
"bool",
"is_microcoded_insn",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"if",
"(",
"!",
"insn",
"||",
"!",
"NONDEBUG_INSN_P",
"(",
"insn",
")",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"USE",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"CLOBBER",
")",
"return",
"false",
";",
"if",
"(",
"rs6000_cpu_attr",
"==",
"CPU_CELL",
")",
"return",
"get_attr_cell_micro",
"(",
"insn",
")",
"==",
"CELL_MICRO_ALWAYS",
";",
"if",
"(",
"rs6000_sched_groups",
"&&",
"(",
"rs6000_cpu",
"==",
"PROCESSOR_POWER4",
"||",
"rs6000_cpu",
"==",
"PROCESSOR_POWER5",
")",
")",
"{",
"enum",
"attr_type",
"type",
"=",
"get_attr_type",
"(",
"insn",
")",
";",
"if",
"(",
"(",
"type",
"==",
"TYPE_LOAD",
"&&",
"get_attr_update",
"(",
"insn",
")",
"==",
"UPDATE_YES",
"&&",
"get_attr_sign_extend",
"(",
"insn",
")",
"==",
"SIGN_EXTEND_YES",
")",
"||",
"(",
"(",
"type",
"==",
"TYPE_LOAD",
"||",
"type",
"==",
"TYPE_STORE",
")",
"&&",
"get_attr_update",
"(",
"insn",
")",
"==",
"UPDATE_YES",
"&&",
"get_attr_indexed",
"(",
"insn",
")",
"==",
"INDEXED_YES",
")",
"||",
"type",
"==",
"TYPE_MFCR",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"The",
"function",
"returns",
"a",
"true",
"if",
"INSN",
"is",
"microcoded",
".",
"Return",
"false",
"otherwise",
"."
] | [
"rs6000"
] | rs60004 | is_microcoded_insn | rs6000 | CPU | GCC | 19,766 | 141 | 1 | [] |
[
"<s>",
"void",
"R600PassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"addPass",
"(",
"createAMDGPUCFGStructurizerPass",
"(",
")",
")",
";",
"addPass",
"(",
"createR600ExpandSpecialInstrsPass",
"(",
")",
")",
";",
"addPass",
"(",
"&",
"FinalizeMachineBundlesID",
")",
";",
"addPass",
"(",
"createR600Packetizer",
"(",
")",
")",
";",
"addPass",
"(",
"createR600ControlFlowFinalizer",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"AMDGPU",
"R600",
"AMDGPU",
"R600",
"R600",
"R600"
] | R600TargetMachine1 | addPreEmitPass | AMDGPU | GPU | LLVM | 19,767 | 42 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_write_function_decl",
"(",
"std",
"::",
"stringstream",
"&",
"s",
",",
"const",
"char",
"*",
"name",
",",
"const_tree",
"decl",
")",
"{",
"tree",
"fntype",
"=",
"TREE_TYPE",
"(",
"decl",
")",
";",
"tree",
"result_type",
"=",
"TREE_TYPE",
"(",
"fntype",
")",
";",
"tree",
"args",
"=",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
";",
"tree",
"attrs",
"=",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
";",
"bool",
"kernel",
"=",
"write_as_kernel",
"(",
"attrs",
")",
";",
"bool",
"is_main",
"=",
"strcmp",
"(",
"name",
",",
"\"main\"",
")",
"==",
"0",
";",
"bool",
"args_from_decl",
"=",
"false",
";",
"if",
"(",
"args",
"==",
"0",
")",
"{",
"args",
"=",
"DECL_ARGUMENTS",
"(",
"decl",
")",
";",
"args_from_decl",
"=",
"true",
";",
"}",
"if",
"(",
"DECL_EXTERNAL",
"(",
"decl",
")",
")",
"s",
"<<",
"\".extern \"",
";",
"else",
"if",
"(",
"TREE_PUBLIC",
"(",
"decl",
")",
")",
"s",
"<<",
"\".visible \"",
";",
"if",
"(",
"kernel",
")",
"s",
"<<",
"\".entry \"",
";",
"else",
"s",
"<<",
"\".func \"",
";",
"bool",
"return_in_mem",
"=",
"false",
";",
"if",
"(",
"TYPE_MODE",
"(",
"result_type",
")",
"!=",
"VOIDmode",
")",
"{",
"machine_mode",
"mode",
"=",
"TYPE_MODE",
"(",
"result_type",
")",
";",
"if",
"(",
"!",
"RETURN_IN_REG_P",
"(",
"mode",
")",
")",
"return_in_mem",
"=",
"true",
";",
"else",
"{",
"mode",
"=",
"arg_promotion",
"(",
"mode",
")",
";",
"s",
"<<",
"\"(.param\"",
"<<",
"nvptx_ptx_type_from_mode",
"(",
"mode",
",",
"false",
")",
"<<",
"\" %out_retval)\"",
";",
"}",
"}",
"if",
"(",
"name",
"[",
"0",
"]",
"==",
"'*'",
")",
"s",
"<<",
"(",
"name",
"+",
"1",
")",
";",
"else",
"s",
"<<",
"name",
";",
"if",
"(",
"(",
"args",
"!=",
"NULL_TREE",
"&&",
"!",
"(",
"TREE_CODE",
"(",
"args",
")",
"==",
"TREE_LIST",
"&&",
"TREE_VALUE",
"(",
"args",
")",
"==",
"void_type_node",
")",
")",
"||",
"is_main",
"||",
"return_in_mem",
"||",
"DECL_STATIC_CHAIN",
"(",
"decl",
")",
")",
"{",
"s",
"<<",
"\"(\"",
";",
"int",
"i",
"=",
"0",
";",
"bool",
"any_args",
"=",
"false",
";",
"if",
"(",
"return_in_mem",
")",
"{",
"s",
"<<",
"\".param.u\"",
"<<",
"GET_MODE_BITSIZE",
"(",
"Pmode",
")",
"<<",
"\" %in_ar1\"",
";",
"i",
"++",
";",
"}",
"while",
"(",
"args",
"!=",
"NULL_TREE",
")",
"{",
"tree",
"type",
"=",
"args_from_decl",
"?",
"TREE_TYPE",
"(",
"args",
")",
":",
"TREE_VALUE",
"(",
"args",
")",
";",
"machine_mode",
"mode",
"=",
"TYPE_MODE",
"(",
"type",
")",
";",
"if",
"(",
"mode",
"!=",
"VOIDmode",
")",
"{",
"i",
"=",
"write_one_arg",
"(",
"s",
",",
"type",
",",
"i",
",",
"mode",
",",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
"==",
"0",
")",
";",
"any_args",
"=",
"true",
";",
"i",
"++",
";",
"}",
"args",
"=",
"TREE_CHAIN",
"(",
"args",
")",
";",
"}",
"if",
"(",
"stdarg_p",
"(",
"fntype",
")",
")",
"{",
"gcc_assert",
"(",
"i",
">",
"0",
")",
";",
"s",
"<<",
"\", .param.u\"",
"<<",
"GET_MODE_BITSIZE",
"(",
"Pmode",
")",
"<<",
"\" %in_argp\"",
";",
"}",
"if",
"(",
"DECL_STATIC_CHAIN",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"i",
">",
"0",
")",
"s",
"<<",
"\", \"",
";",
"s",
"<<",
"\".reg.u\"",
"<<",
"GET_MODE_BITSIZE",
"(",
"Pmode",
")",
"<<",
"reg_names",
"[",
"STATIC_CHAIN_REGNUM",
"]",
";",
"}",
"if",
"(",
"!",
"any_args",
"&&",
"is_main",
")",
"s",
"<<",
"\".param.u32 %argc, .param.u\"",
"<<",
"GET_MODE_BITSIZE",
"(",
"Pmode",
")",
"<<",
"\" %argv\"",
";",
"s",
"<<",
"\")\"",
";",
"}",
"}",
"</s>"
] | [
"Write",
"a",
"function",
"decl",
"for",
"DECL",
"to",
"S",
",",
"where",
"NAME",
"is",
"the",
"name",
"to",
"be",
"used",
"."
] | [
"nvptx",
"\"main\"",
"0",
"0",
"\".extern \"",
"\".visible \"",
"\".entry \"",
"\".func \"",
"\"(.param\"",
"\" %out_retval)\"",
"0",
"1",
"\"(\"",
"0",
"\".param.u\"",
"\" %in_ar1\"",
"0",
"0",
"\", .param.u\"",
"\" %in_argp\"",
"0",
"\", \"",
"\".reg.u\"",
"\".param.u32 %argc, .param.u\"",
"\" %argv\"",
"\")\""
] | nvptx2 | nvptx_write_function_decl | nvptx | GPU | GCC | 19,768 | 438 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"detect_caches_amd",
"(",
"unsigned",
"max_ext_level",
")",
"{",
"unsigned",
"eax",
",",
"ebx",
",",
"ecx",
",",
"edx",
";",
"struct",
"cache_desc",
"level1",
",",
"level2",
"=",
"{",
"0",
",",
"0",
",",
"0",
"}",
";",
"if",
"(",
"max_ext_level",
"<",
"0x80000005",
")",
"return",
"\"\"",
";",
"__cpuid",
"(",
"0x80000005",
",",
"eax",
",",
"ebx",
",",
"ecx",
",",
"edx",
")",
";",
"level1",
".",
"sizekb",
"=",
"(",
"ecx",
">>",
"24",
")",
"&",
"0xff",
";",
"level1",
".",
"assoc",
"=",
"(",
"ecx",
">>",
"16",
")",
"&",
"0xff",
";",
"level1",
".",
"line",
"=",
"ecx",
"&",
"0xff",
";",
"if",
"(",
"max_ext_level",
">=",
"0x80000006",
")",
"detect_l2_cache",
"(",
"&",
"level2",
")",
";",
"return",
"describe_cache",
"(",
"level1",
",",
"level2",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"description",
"of",
"caches",
"for",
"an",
"AMD",
"processor",
"."
] | [
"i386",
"0",
"0",
"0",
"0x80000005",
"\"\"",
"0x80000005",
"24",
"0xff",
"16",
"0xff",
"0xff",
"0x80000006"
] | driver-i386 | detect_caches_amd | i386 | CPU | GCC | 19,769 | 108 | 1 | [] |
[
"<s>",
"void",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCInst",
"&",
"Res",
")",
"const",
"override",
"{",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"Lanai"
] | LanaiAsmBackend21 | relaxInstruction | Lanai | CPU | LLVM | 19,770 | 21 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Imm",
".",
"isPosZero",
"(",
")",
"&&",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"||",
"VT",
"==",
"MVT",
"::",
"f32",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
"&&",
"Subtarget",
"->",
"hasFullFP16",
"(",
")",
")",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Legal fp imm: materialize 0 using the zero register\\n\"",
")",
";",
"return",
"true",
";",
"}",
"StringRef",
"FPType",
";",
"bool",
"IsLegal",
"=",
"false",
";",
"SmallString",
"<",
"128",
">",
"ImmStrVal",
";",
"Imm",
".",
"toString",
"(",
"ImmStrVal",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
")",
"{",
"FPType",
"=",
"\"f64\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP64Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"{",
"FPType",
"=",
"\"f32\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP32Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
"&&",
"Subtarget",
"->",
"hasFullFP16",
"(",
")",
")",
"{",
"FPType",
"=",
"\"f16\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP16Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"if",
"(",
"IsLegal",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Legal \"",
"<<",
"FPType",
"<<",
"\" imm value: \"",
"<<",
"ImmStrVal",
"<<",
"\"\\n\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"FPType",
".",
"empty",
"(",
")",
")",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Illegal \"",
"<<",
"FPType",
"<<",
"\" imm value: \"",
"<<",
"ImmStrVal",
"<<",
"\"\\n\"",
")",
";",
"else",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Illegal fp imm \"",
"<<",
"ImmStrVal",
"<<",
"\": unsupported fp type\\n\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"AArch64",
"AArch64",
"MVT::f64",
"MVT::f32",
"MVT::f16",
"\"Legal fp imm: materialize 0 using the zero register\\n\"",
"128",
"MVT::f64",
"\"f64\"",
"AArch64_AM::getFP64Imm",
"1",
"MVT::f32",
"\"f32\"",
"AArch64_AM::getFP32Imm",
"1",
"MVT::f16",
"\"f16\"",
"AArch64_AM::getFP16Imm",
"1",
"\"Legal \"",
"\" imm value: \"",
"\"\\n\"",
"\"Illegal \"",
"\" imm value: \"",
"\"\\n\"",
"\"Illegal fp imm \"",
"\": unsupported fp type\\n\""
] | AArch64ISelLowering106 | isFPImmLegal | AArch64 | CPU | LLVM | 19,771 | 242 | 1 | [] |
[
"<s>",
"bool",
"isTargetEHABICompatible",
"(",
")",
"const",
"{",
"return",
"(",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"EABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"EABIHF",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABIHF",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABIHF",
"||",
"isTargetAndroid",
"(",
")",
")",
"&&",
"!",
"isTargetDarwin",
"(",
")",
"&&",
"!",
"isTargetWindows",
"(",
")",
";",
"}",
"</s>"
] | [
"Tests",
"whether",
"the",
"target",
"supports",
"the",
"EHABI",
"exception",
"handling",
"standard",
"."
] | [
"ARM"
] | ARMSubtarget (2)3 | isTargetEHABICompatible | ARM | CPU | LLVM | 19,772 | 84 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isIndirectCall",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Hexagon",
"::",
"J2_callr",
":",
"case",
"Hexagon",
"::",
"J2_callrf",
":",
"case",
"Hexagon",
"::",
"J2_callrt",
":",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"callsite",
"is",
"an",
"indirect",
"call",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::J2_callr",
"Hexagon::J2_callrf",
"Hexagon::J2_callrt"
] | HexagonInstrInfo (2) | isIndirectCall | Hexagon | DSP | LLVM | 19,773 | 44 | 1 | [] |
[
"<s>",
"static",
"void",
"push_minipool_barrier",
"(",
"rtx",
"insn",
",",
"HOST_WIDE_INT",
"address",
")",
"{",
"Mfix",
"*",
"fix",
"=",
"(",
"Mfix",
"*",
")",
"obstack_alloc",
"(",
"&",
"minipool_obstack",
",",
"sizeof",
"(",
"*",
"fix",
")",
")",
";",
"fix",
"->",
"insn",
"=",
"insn",
";",
"fix",
"->",
"address",
"=",
"address",
";",
"fix",
"->",
"next",
"=",
"NULL",
";",
"if",
"(",
"minipool_fix_head",
"!=",
"NULL",
")",
"minipool_fix_tail",
"->",
"next",
"=",
"fix",
";",
"else",
"minipool_fix_head",
"=",
"fix",
";",
"minipool_fix_tail",
"=",
"fix",
";",
"}",
"</s>"
] | [
"Record",
"that",
"there",
"is",
"a",
"natural",
"barrier",
"in",
"the",
"insn",
"stream",
"at",
"ADDRESS",
"."
] | [
"arm"
] | arm3 | push_minipool_barrier | arm | CPU | GCC | 19,774 | 71 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"Res",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Don't know how to custom expand this!\"",
")",
";",
"case",
"ISD",
"::",
"READ_REGISTER",
":",
"ExpandREAD_REGISTER",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"BITCAST",
":",
"Res",
"=",
"ExpandBITCAST",
"(",
"N",
",",
"DAG",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SRL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SHL",
":",
"Res",
"=",
"Expand64BitShift",
"(",
"N",
",",
"DAG",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SREM",
":",
"case",
"ISD",
"::",
"UREM",
":",
"Res",
"=",
"LowerREM",
"(",
"N",
",",
"DAG",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SDIVREM",
":",
"case",
"ISD",
"::",
"UDIVREM",
":",
"Res",
"=",
"LowerDivRem",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
")",
";",
"assert",
"(",
"Res",
".",
"getNumOperands",
"(",
")",
"==",
"2",
"&&",
"\"DivRem needs two values\"",
")",
";",
"Results",
".",
"push_back",
"(",
"Res",
".",
"getValue",
"(",
"0",
")",
")",
";",
"Results",
".",
"push_back",
"(",
"Res",
".",
"getValue",
"(",
"1",
")",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"READCYCLECOUNTER",
":",
"ReplaceREADCYCLECOUNTER",
"(",
"N",
",",
"Results",
",",
"DAG",
",",
"Subtarget",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"UDIV",
":",
"case",
"ISD",
"::",
"SDIV",
":",
"assert",
"(",
"Subtarget",
"->",
"isTargetWindows",
"(",
")",
"&&",
"\"can only expand DIV on Windows\"",
")",
";",
"return",
"ExpandDIV_Windows",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
",",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
",",
"Results",
")",
";",
"case",
"ISD",
"::",
"ATOMIC_CMP_SWAP",
":",
"ReplaceCMP_SWAP_64Results",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"ReplaceLongIntrinsic",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ABS",
":",
"lowerABS",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"return",
";",
"}",
"if",
"(",
"Res",
".",
"getNode",
"(",
")",
")",
"Results",
".",
"push_back",
"(",
"Res",
")",
";",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"ARM",
"ARM",
"\"Don't know how to custom expand this!\"",
"ISD::READ_REGISTER",
"ISD::BITCAST",
"ISD::SRL",
"ISD::SRA",
"ISD::SHL",
"ISD::SREM",
"ISD::UREM",
"ISD::SDIVREM",
"ISD::UDIVREM",
"0",
"2",
"\"DivRem needs two values\"",
"0",
"1",
"ISD::READCYCLECOUNTER",
"ISD::UDIV",
"ISD::SDIV",
"\"can only expand DIV on Windows\"",
"0",
"ISD::SDIV",
"ISD::ATOMIC_CMP_SWAP",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::ABS"
] | ARMISelLowering10 | ReplaceNodeResults | ARM | CPU | LLVM | 19,775 | 315 | 1 | [] |
[
"<s>",
"int",
"s390_const_double_ok_for_constraint_p",
"(",
"rtx",
"value",
",",
"int",
"c",
",",
"const",
"char",
"*",
"str",
")",
"{",
"gcc_assert",
"(",
"c",
"==",
"str",
"[",
"0",
"]",
")",
";",
"switch",
"(",
"str",
"[",
"0",
"]",
")",
"{",
"case",
"'G'",
":",
"return",
"(",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"value",
")",
")",
"==",
"MODE_FLOAT",
"&&",
"value",
"==",
"CONST0_RTX",
"(",
"GET_MODE",
"(",
"value",
")",
")",
")",
";",
"default",
":",
"return",
"0",
";",
"}",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"VALUE",
"matches",
"the",
"constraint",
"STR",
"."
] | [
"s390",
"0",
"0",
"0"
] | s3903 | s390_const_double_ok_for_constraint_p | s390 | MPU | GCC | 19,776 | 66 | 1 | [] |
[
"<s>",
"void",
"AnalyzeCallOperands",
"(",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"CCAssignFn",
"Fn",
",",
"std",
"::",
"vector",
"<",
"TargetLowering",
"::",
"ArgListEntry",
">",
"&",
"FuncArgs",
",",
"const",
"SDNode",
"*",
"CallNode",
")",
"{",
"PreAnalyzeCallOperands",
"(",
"Outs",
",",
"FuncArgs",
",",
"CallNode",
")",
";",
"CCState",
"::",
"AnalyzeCallOperands",
"(",
"Outs",
",",
"Fn",
")",
";",
"OriginalArgWasF128",
".",
"clear",
"(",
")",
";",
"OriginalArgWasFloat",
".",
"clear",
"(",
")",
";",
"CallOperandIsFixed",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"AnalyzeCallOperands",
"-",
"Same",
"as",
"above",
"except",
"it",
"takes",
"vectors",
"of",
"types",
"and",
"argument",
"flags",
"."
] | [
"Mips",
"ISD::OutputArg"
] | MipsCCState | AnalyzeCallOperands | Mips | CPU | LLVM | 19,777 | 70 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"isBranchWithImm",
"(",
"unsigned",
"Opc",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"isBranchWithImm",
"-",
"Return",
"true",
"if",
"the",
"branch",
"contains",
"an",
"immediate",
"operand",
"("
] | [
"Mips"
] | MipsInstrInfo19 | isBranchWithImm | Mips | CPU | LLVM | 19,778 | 13 | 1 | [] |
[
"<s>",
"MCInstrDesc",
"const",
"&",
"HexagonMCInstrInfo",
"::",
"getDesc",
"(",
"MCInstrInfo",
"const",
"&",
"MCII",
",",
"MCInst",
"const",
"&",
"MCI",
")",
"{",
"return",
"MCII",
".",
"get",
"(",
"MCI",
".",
"getOpcode",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"target",
"instruction",
"descriptor",
"of",
"this",
"MachineInstr",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonMCInstrInfo (2)1 | getDesc | Hexagon | DSP | LLVM | 19,779 | 31 | 1 | [] |
[
"<s>",
"static",
"bool",
"scalar_move_insn_p",
"(",
"rtx_insn",
"*",
"rinsn",
")",
"{",
"return",
"get_attr_type",
"(",
"rinsn",
")",
"==",
"TYPE_VIMOVXV",
"||",
"get_attr_type",
"(",
"rinsn",
")",
"==",
"TYPE_VFMOVFV",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"instruction",
"is",
"scalar",
"move",
"instruction",
"."
] | [
"riscv"
] | riscv-vsetvl | scalar_move_insn_p | riscv | CPU | GCC | 19,780 | 25 | 1 | [] |
[
"<s>",
"void",
"Mips16FrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"Mips16InstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"Mips16InstrInfo",
"*",
">",
"(",
"STI",
".",
"getInstrInfo",
"(",
")",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"if",
"(",
"!",
"StackSize",
")",
"return",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Mips",
"::",
"Move32R16",
")",
",",
"Mips",
"::",
"SP",
")",
".",
"addReg",
"(",
"Mips",
"::",
"S0",
")",
";",
"TII",
".",
"restoreFrame",
"(",
"Mips",
"::",
"SP",
",",
"StackSize",
",",
"MBB",
",",
"MBBI",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips::Move32R16",
"Mips::SP",
"Mips::S0",
"Mips::SP"
] | Mips16FrameLowering12 | emitEpilogue | Mips | CPU | LLVM | 19,781 | 145 | 1 | [] |
[
"<s>",
"unsigned",
"AAPInstrInfo",
"::",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"MI",
".",
"getDesc",
"(",
")",
".",
"getSize",
"(",
")",
";",
"case",
"TargetOpcode",
"::",
"EH_LABEL",
":",
"case",
"TargetOpcode",
"::",
"IMPLICIT_DEF",
":",
"case",
"TargetOpcode",
"::",
"KILL",
":",
"case",
"TargetOpcode",
"::",
"DBG_VALUE",
":",
"return",
"0",
";",
"case",
"TargetOpcode",
"::",
"INLINEASM",
":",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"auto",
"&",
"TM",
"=",
"static_cast",
"<",
"const",
"AAPTargetMachine",
"&",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"return",
"getInlineAsmLength",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSymbolName",
"(",
")",
",",
"*",
"TM",
".",
"getMCAsmInfo",
"(",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"AAP",
"AAP",
"0",
"AAP",
"0"
] | AAPInstrInfo | getInstSizeInBytes | AAP | MPU | LLVM | 19,782 | 123 | 1 | [] |
[
"<s>",
"static",
"bool",
"isStore",
"(",
"int",
"Opcode",
")",
"{",
"return",
"Opcode",
"==",
"ARC",
"::",
"ST_rs9",
"||",
"Opcode",
"==",
"ARC",
"::",
"STH_rs9",
"||",
"Opcode",
"==",
"ARC",
"::",
"STB_rs9",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"this",
"recipe",
"is",
"a",
"store",
"."
] | [
"ARC",
"ARC::ST_rs9",
"ARC::STH_rs9",
"ARC::STB_rs9"
] | ARCInstrInfo | isStore | ARC | MPU | LLVM | 19,783 | 28 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"addPass",
"(",
"&",
"PostRAHazardRecognizerID",
")",
";",
"addPass",
"(",
"createSIMemoryLegalizerPass",
"(",
")",
")",
";",
"addPass",
"(",
"createSIInsertWaitcntsPass",
"(",
")",
")",
";",
"addPass",
"(",
"createSIShrinkInstructionsPass",
"(",
")",
")",
";",
"addPass",
"(",
"&",
"SIInsertSkipsPassID",
")",
";",
"addPass",
"(",
"createSIDebuggerInsertNopsPass",
"(",
")",
")",
";",
"addPass",
"(",
"&",
"BranchRelaxationPassID",
")",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"SI"
] | AMDGPUTargetMachine31 | addPreEmitPass | AMDGPU | GPU | LLVM | 19,784 | 54 | 1 | [] |
[
"<s>",
"bool",
"shouldForceRelocation",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
")",
"override",
"{",
"switch",
"(",
"(",
"Sparc",
"::",
"Fixups",
")",
"Fixup",
".",
"getKind",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"Sparc",
"::",
"fixup_sparc_wplt30",
":",
"if",
"(",
"Target",
".",
"getSymA",
"(",
")",
"->",
"getSymbol",
"(",
")",
".",
"isTemporary",
"(",
")",
")",
"return",
"false",
";",
"case",
"Sparc",
"::",
"fixup_sparc_tls_gd_hi22",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_gd_lo10",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_gd_add",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_gd_call",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ldm_hi22",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ldm_lo10",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ldm_add",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ldm_call",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ldo_hix22",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ldo_lox10",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ldo_add",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ie_hi22",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ie_lo10",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ie_ld",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ie_ldx",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_ie_add",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_le_hix22",
":",
"case",
"Sparc",
"::",
"fixup_sparc_tls_le_lox10",
":",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"Hook",
"to",
"check",
"if",
"a",
"relocation",
"is",
"needed",
"for",
"some",
"target",
"specific",
"reason",
"."
] | [
"Sparc",
"Sparc::Fixups",
"Sparc::fixup_sparc_wplt30",
"Sparc::fixup_sparc_tls_gd_hi22",
"Sparc::fixup_sparc_tls_gd_lo10",
"Sparc::fixup_sparc_tls_gd_add",
"Sparc::fixup_sparc_tls_gd_call",
"Sparc::fixup_sparc_tls_ldm_hi22",
"Sparc::fixup_sparc_tls_ldm_lo10",
"Sparc::fixup_sparc_tls_ldm_add",
"Sparc::fixup_sparc_tls_ldm_call",
"Sparc::fixup_sparc_tls_ldo_hix22",
"Sparc::fixup_sparc_tls_ldo_lox10",
"Sparc::fixup_sparc_tls_ldo_add",
"Sparc::fixup_sparc_tls_ie_hi22",
"Sparc::fixup_sparc_tls_ie_lo10",
"Sparc::fixup_sparc_tls_ie_ld",
"Sparc::fixup_sparc_tls_ie_ldx",
"Sparc::fixup_sparc_tls_ie_add",
"Sparc::fixup_sparc_tls_le_hix22",
"Sparc::fixup_sparc_tls_le_lox10"
] | SparcAsmBackend8 | shouldForceRelocation | Sparc | CPU | LLVM | 19,785 | 158 | 1 | [] |
[
"<s>",
"bool",
"MipsAbiFlags",
"::",
"merge",
"(",
"const",
"Input",
"&",
"pInput",
",",
"MipsAbiFlags",
"&",
"oldFlags",
",",
"const",
"MipsAbiFlags",
"&",
"newFlags",
")",
"{",
"if",
"(",
"oldFlags",
".",
"m_IsaLevel",
"==",
"0",
")",
"{",
"oldFlags",
"=",
"newFlags",
";",
"return",
"true",
";",
"}",
"if",
"(",
"newFlags",
".",
"m_IsaLevel",
">",
"oldFlags",
".",
"m_IsaLevel",
")",
"oldFlags",
".",
"m_IsaLevel",
"=",
"newFlags",
".",
"m_IsaLevel",
";",
"oldFlags",
".",
"m_IsaRev",
"=",
"std",
"::",
"max",
"(",
"oldFlags",
".",
"m_IsaRev",
",",
"newFlags",
".",
"m_IsaRev",
")",
";",
"oldFlags",
".",
"m_GprSize",
"=",
"std",
"::",
"max",
"(",
"oldFlags",
".",
"m_GprSize",
",",
"newFlags",
".",
"m_GprSize",
")",
";",
"oldFlags",
".",
"m_Cpr1Size",
"=",
"std",
"::",
"max",
"(",
"oldFlags",
".",
"m_Cpr1Size",
",",
"newFlags",
".",
"m_Cpr1Size",
")",
";",
"oldFlags",
".",
"m_Cpr2Size",
"=",
"std",
"::",
"max",
"(",
"oldFlags",
".",
"m_Cpr2Size",
",",
"newFlags",
".",
"m_Cpr2Size",
")",
";",
"oldFlags",
".",
"m_Ases",
"|=",
"newFlags",
".",
"m_Ases",
";",
"oldFlags",
".",
"m_Flags1",
"|=",
"newFlags",
".",
"m_Flags1",
";",
"if",
"(",
"oldFlags",
".",
"m_FpAbi",
"==",
"newFlags",
".",
"m_FpAbi",
")",
"return",
"true",
";",
"if",
"(",
"isFpGreater",
"(",
"newFlags",
".",
"m_FpAbi",
",",
"oldFlags",
".",
"m_FpAbi",
")",
")",
"{",
"oldFlags",
".",
"m_FpAbi",
"=",
"newFlags",
".",
"m_FpAbi",
";",
"return",
"true",
";",
"}",
"if",
"(",
"isFpGreater",
"(",
"oldFlags",
".",
"m_FpAbi",
",",
"newFlags",
".",
"m_FpAbi",
")",
")",
"return",
"true",
";",
"llvm",
"::",
"StringRef",
"oldAbiName",
"=",
"getFpAbiName",
"(",
"oldFlags",
".",
"m_FpAbi",
")",
";",
"llvm",
"::",
"StringRef",
"newAbiName",
"=",
"getFpAbiName",
"(",
"newFlags",
".",
"m_FpAbi",
")",
";",
"warning",
"(",
"diag",
"::",
"warn_Mips_fp_abi_incompatible",
")",
"<<",
"oldAbiName",
"<<",
"newAbiName",
"<<",
"pInput",
".",
"name",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Merge",
"target",
"triples",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"0",
"Mips"
] | MipsAbiFlags | merge | Mips | CPU | LLVM | 19,786 | 239 | 1 | [] |
[
"<s>",
"void",
"PPCHazardRecognizer970",
"::",
"EmitInstruction",
"(",
"SUnit",
"*",
"SU",
")",
"{",
"const",
"SDNode",
"*",
"Node",
"=",
"SU",
"->",
"getNode",
"(",
")",
"->",
"getFlaggedMachineNode",
"(",
")",
";",
"bool",
"isFirst",
",",
"isSingle",
",",
"isCracked",
",",
"isLoad",
",",
"isStore",
";",
"PPCII",
"::",
"PPC970_Unit",
"InstrType",
"=",
"GetInstrType",
"(",
"Node",
"->",
"getOpcode",
"(",
")",
",",
"isFirst",
",",
"isSingle",
",",
"isCracked",
",",
"isLoad",
",",
"isStore",
")",
";",
"if",
"(",
"InstrType",
"==",
"PPCII",
"::",
"PPC970_Pseudo",
")",
"return",
";",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getMachineOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"PPC",
"::",
"MTCTR",
")",
"HasCTRSet",
"=",
"true",
";",
"if",
"(",
"isStore",
")",
"{",
"unsigned",
"ThisStoreSize",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown store instruction!\"",
")",
";",
"case",
"PPC",
"::",
"STB",
":",
"case",
"PPC",
"::",
"STB8",
":",
"case",
"PPC",
"::",
"STBU",
":",
"case",
"PPC",
"::",
"STBU8",
":",
"case",
"PPC",
"::",
"STBX",
":",
"case",
"PPC",
"::",
"STBX8",
":",
"case",
"PPC",
"::",
"STVEBX",
":",
"ThisStoreSize",
"=",
"1",
";",
"break",
";",
"case",
"PPC",
"::",
"STH",
":",
"case",
"PPC",
"::",
"STH8",
":",
"case",
"PPC",
"::",
"STHU",
":",
"case",
"PPC",
"::",
"STHU8",
":",
"case",
"PPC",
"::",
"STHX",
":",
"case",
"PPC",
"::",
"STHX8",
":",
"case",
"PPC",
"::",
"STVEHX",
":",
"case",
"PPC",
"::",
"STHBRX",
":",
"ThisStoreSize",
"=",
"2",
";",
"break",
";",
"case",
"PPC",
"::",
"STFS",
":",
"case",
"PPC",
"::",
"STFSU",
":",
"case",
"PPC",
"::",
"STFSX",
":",
"case",
"PPC",
"::",
"STWX",
":",
"case",
"PPC",
"::",
"STWX8",
":",
"case",
"PPC",
"::",
"STWUX",
":",
"case",
"PPC",
"::",
"STW",
":",
"case",
"PPC",
"::",
"STW8",
":",
"case",
"PPC",
"::",
"STWU",
":",
"case",
"PPC",
"::",
"STWU8",
":",
"case",
"PPC",
"::",
"STVEWX",
":",
"case",
"PPC",
"::",
"STFIWX",
":",
"case",
"PPC",
"::",
"STWBRX",
":",
"ThisStoreSize",
"=",
"4",
";",
"break",
";",
"case",
"PPC",
"::",
"STD_32",
":",
"case",
"PPC",
"::",
"STDX_32",
":",
"case",
"PPC",
"::",
"STD",
":",
"case",
"PPC",
"::",
"STDU",
":",
"case",
"PPC",
"::",
"STFD",
":",
"case",
"PPC",
"::",
"STFDX",
":",
"case",
"PPC",
"::",
"STDX",
":",
"case",
"PPC",
"::",
"STDUX",
":",
"ThisStoreSize",
"=",
"8",
";",
"break",
";",
"case",
"PPC",
"::",
"STVX",
":",
"case",
"PPC",
"::",
"STVXL",
":",
"ThisStoreSize",
"=",
"16",
";",
"break",
";",
"}",
"StoreSize",
"[",
"NumStores",
"]",
"=",
"ThisStoreSize",
";",
"StorePtr1",
"[",
"NumStores",
"]",
"=",
"Node",
"->",
"getOperand",
"(",
"1",
")",
";",
"StorePtr2",
"[",
"NumStores",
"]",
"=",
"Node",
"->",
"getOperand",
"(",
"2",
")",
";",
"++",
"NumStores",
";",
"}",
"if",
"(",
"InstrType",
"==",
"PPCII",
"::",
"PPC970_BRU",
"||",
"isSingle",
")",
"NumIssued",
"=",
"4",
";",
"++",
"NumIssued",
";",
"if",
"(",
"isCracked",
")",
"++",
"NumIssued",
";",
"if",
"(",
"NumIssued",
"==",
"5",
")",
"EndDispatchGroup",
"(",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"PowerPC",
"PPC",
"PPCII::PPC970_Unit",
"PPCII::PPC970_Pseudo",
"PPC::MTCTR",
"\"Unknown store instruction!\"",
"PPC::STB",
"PPC::STB8",
"PPC::STBU",
"PPC::STBU8",
"PPC::STBX",
"PPC::STBX8",
"PPC::STVEBX",
"1",
"PPC::STH",
"PPC::STH8",
"PPC::STHU",
"PPC::STHU8",
"PPC::STHX",
"PPC::STHX8",
"PPC::STVEHX",
"PPC::STHBRX",
"2",
"PPC::STFS",
"PPC::STFSU",
"PPC::STFSX",
"PPC::STWX",
"PPC::STWX8",
"PPC::STWUX",
"PPC::STW",
"PPC::STW8",
"PPC::STWU",
"PPC::STWU8",
"PPC::STVEWX",
"PPC::STFIWX",
"PPC::STWBRX",
"4",
"PPC::STD_32",
"PPC::STDX_32",
"PPC::STD",
"PPC::STDU",
"PPC::STFD",
"PPC::STFDX",
"PPC::STDX",
"PPC::STDUX",
"8",
"PPC::STVX",
"PPC::STVXL",
"16",
"1",
"2",
"PPCII::PPC970_BRU",
"4",
"5"
] | PPCHazardRecognizers23 | EmitInstruction | PowerPC | CPU | LLVM | 19,787 | 402 | 1 | [] |
[
"<s>",
"formatted_raw_ostream",
"&",
"getOStream",
"(",
")",
"{",
"return",
"OS",
";",
"}",
"</s>"
] | [
"getOStream",
"-",
"Get",
"the",
"raw",
"output",
"stream",
"into",
"the",
"graph",
"file",
"."
] | [
"Cpu0"
] | Cpu0AsmStreamer | getOStream | Cpu0 | CPU | LLVM | 19,788 | 10 | 1 | [] |
[
"<s>",
"static",
"rtx",
"s390_find_execute",
"(",
"struct",
"constant_pool",
"*",
"pool",
",",
"rtx",
"insn",
")",
"{",
"struct",
"constant",
"*",
"c",
";",
"for",
"(",
"c",
"=",
"pool",
"->",
"execute",
";",
"c",
"!=",
"NULL",
";",
"c",
"=",
"c",
"->",
"next",
")",
"if",
"(",
"INSN_UID",
"(",
"insn",
")",
"==",
"INSN_UID",
"(",
"c",
"->",
"value",
")",
")",
"break",
";",
"gcc_assert",
"(",
"c",
")",
";",
"return",
"s390_pool_offset",
"(",
"pool",
",",
"gen_rtx_LABEL_REF",
"(",
"Pmode",
",",
"c",
"->",
"label",
")",
")",
";",
"}",
"</s>"
] | [
"Find",
"execute",
"target",
"for",
"INSN",
"in",
"the",
"constant",
"pool",
"POOL",
".",
"Return",
"an",
"RTX",
"describing",
"the",
"distance",
"from",
"the",
"start",
"of",
"the",
"pool",
"to",
"the",
"location",
"of",
"the",
"execute",
"target",
"."
] | [
"s390"
] | s390 | s390_find_execute | s390 | MPU | GCC | 19,789 | 73 | 1 | [] |
[
"<s>",
"static",
"tree",
"arm_mve_type_for_scalar_type",
"(",
"tree",
"eltype",
")",
"{",
"for",
"(",
"unsigned",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"__TYPE_FINAL",
";",
"++",
"i",
")",
"if",
"(",
"arm_simd_types",
"[",
"i",
"]",
".",
"eltype",
"==",
"eltype",
"&&",
"GET_MODE_SIZE",
"(",
"arm_simd_types",
"[",
"i",
"]",
".",
"mode",
")",
"==",
"16",
")",
"return",
"arm_simd_types",
"[",
"i",
"]",
".",
"itype",
";",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"MVE",
"abi",
"type",
"with",
"element",
"of",
"type",
"TYPE",
"."
] | [
"arm",
"0",
"16"
] | arm-mve-builtins | arm_mve_type_for_scalar_type | arm | CPU | GCC | 19,790 | 59 | 1 | [] |
[
"<s>",
"inline",
"hashval_t",
"mips_lo_sum_offset_hasher",
"::",
"hash",
"(",
"const",
"value_type",
"*",
"entry",
")",
"{",
"return",
"mips_hash_base",
"(",
"entry",
"->",
"base",
")",
";",
"}",
"</s>"
] | [
"Hash",
"function",
"for",
"builtin",
"functions",
"with",
"up",
"to",
"3",
"arguments",
"and",
"a",
"return",
"type",
"."
] | [
"mips"
] | mips4 | hash | mips | CPU | GCC | 19,791 | 21 | 1 | [] |
[
"<s>",
"void",
"changeSection",
"(",
"MCSection",
"*",
"Section",
",",
"const",
"MCExpr",
"*",
"Subsection",
")",
"override",
"{",
"}",
"</s>"
] | [
"Update",
"streamer",
"for",
"a",
"new",
"active",
"section",
"."
] | [
"Patmos"
] | PatmosInstrInfo1 | changeSection | Patmos | VLIW | LLVM | 19,792 | 15 | 1 | [] |
[
"<s>",
"bool",
"MMIXFrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"MMIX",
"MMIX"
] | MMIXFrameLowering | hasFP | MMIX | CPU | LLVM | 19,793 | 16 | 1 | [] |
[
"<s>",
"void",
"HSAILInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"unsigned",
"int",
"Opc",
"=",
"0",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"unsigned",
"BT",
";",
"switch",
"(",
"RC",
"->",
"getID",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"unrecognized TargetRegisterClass\"",
")",
";",
"break",
";",
"case",
"HSAIL",
"::",
"GPR32RegClassID",
":",
"Opc",
"=",
"HSAIL",
"::",
"ST_U32",
";",
"BT",
"=",
"BRIG_TYPE_U32",
";",
"break",
";",
"case",
"HSAIL",
"::",
"GPR64RegClassID",
":",
"Opc",
"=",
"HSAIL",
"::",
"ST_U64",
";",
"BT",
"=",
"BRIG_TYPE_U64",
";",
"break",
";",
"case",
"HSAIL",
"::",
"CRRegClassID",
":",
"{",
"HSAILMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"HSAILMachineFunctionInfo",
">",
"(",
")",
";",
"MFI",
"->",
"setHasSpilledCRs",
"(",
")",
";",
"Opc",
"=",
"HSAIL",
"::",
"SPILL_B1",
";",
"BT",
"=",
"BRIG_TYPE_B1",
";",
"break",
";",
"}",
"}",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"}",
"switch",
"(",
"RC",
"->",
"getID",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"unrecognized TargetRegisterClass\"",
")",
";",
"break",
";",
"case",
"HSAIL",
"::",
"CRRegClassID",
":",
"case",
"HSAIL",
"::",
"GPR32RegClassID",
":",
"case",
"HSAIL",
"::",
"GPR64RegClassID",
":",
"{",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FrameIndex",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FrameIndex",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addReg",
"(",
"HSAIL",
"::",
"NoRegister",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addImm",
"(",
"BT",
")",
".",
"addImm",
"(",
"HSAILAS",
"::",
"SPILL_ADDRESS",
")",
".",
"addImm",
"(",
"MMO",
"->",
"getAlignment",
"(",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"break",
";",
"}",
"}",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"HSAIL",
"HSAIL",
"0",
"\"unrecognized TargetRegisterClass\"",
"HSAIL::GPR32RegClassID",
"HSAIL::ST_U32",
"HSAIL::GPR64RegClassID",
"HSAIL::ST_U64",
"HSAIL::CRRegClassID",
"HSAIL",
"HSAIL",
"HSAIL::SPILL_B1",
"\"unrecognized TargetRegisterClass\"",
"HSAIL::CRRegClassID",
"HSAIL::GPR32RegClassID",
"HSAIL::GPR64RegClassID",
"HSAIL::NoRegister",
"0",
"HSAILAS::SPILL_ADDRESS"
] | HSAILInstrInfo | storeRegToStackSlot | HSAIL | Virtual ISA | LLVM | 19,794 | 322 | 1 | [] |
[
"<s>",
"void",
"applyFixup",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"char",
"*",
"Data",
",",
"unsigned",
"DataSize",
",",
"uint64_t",
"Value",
",",
"bool",
"IsPCRel",
",",
"MCContext",
"&",
"Ctx",
")",
"const",
"override",
"{",
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
".",
"getKind",
"(",
")",
",",
"Value",
")",
";",
"if",
"(",
"!",
"Value",
")",
"return",
";",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"4",
";",
"++",
"i",
")",
"{",
"unsigned",
"Idx",
"=",
"IsLittleEndian",
"?",
"i",
":",
"3",
"-",
"i",
";",
"Data",
"[",
"Offset",
"+",
"Idx",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"Sparc",
"0",
"4",
"3",
"8",
"0xff"
] | SparcAsmBackend10 | applyFixup | Sparc | CPU | LLVM | 19,795 | 107 | 1 | [] |
[
"<s>",
"static",
"tree",
"nios2_ftype",
"(",
"enum",
"nios2_ftcode",
"ftcode",
")",
"{",
"static",
"tree",
"types",
"[",
"(",
"int",
")",
"N2_FTYPE_MAX",
"]",
";",
"tree",
"N2_TYPE_SF",
"=",
"float_type_node",
";",
"tree",
"N2_TYPE_DF",
"=",
"double_type_node",
";",
"tree",
"N2_TYPE_SI",
"=",
"integer_type_node",
";",
"tree",
"N2_TYPE_UI",
"=",
"unsigned_type_node",
";",
"tree",
"N2_TYPE_VOID",
"=",
"void_type_node",
";",
"static",
"const_tree",
"N2_TYPE_CVPTR",
",",
"N2_TYPE_VPTR",
";",
"if",
"(",
"!",
"N2_TYPE_CVPTR",
")",
"{",
"N2_TYPE_CVPTR",
"=",
"build_pointer_type",
"(",
"build_qualified_type",
"(",
"void_type_node",
",",
"(",
"TYPE_QUAL_CONST",
"|",
"TYPE_QUAL_VOLATILE",
")",
")",
")",
";",
"N2_TYPE_VPTR",
"=",
"build_pointer_type",
"(",
"build_qualified_type",
"(",
"void_type_node",
",",
"TYPE_QUAL_VOLATILE",
")",
")",
";",
"}",
"if",
"(",
"types",
"[",
"(",
"int",
")",
"ftcode",
"]",
"==",
"NULL_TREE",
")",
"switch",
"(",
"ftcode",
")",
"{",
"case",
"N2_FTYPE_OP",
"##",
"N",
"ARGS",
":",
"\\",
"types",
"[",
"(",
"int",
")",
"ftcode",
"]",
"\\",
"=",
"build_function_type_list",
"(",
"N2_FTYPE_ARGS",
"##",
"N",
"ARGS",
",",
"NULL_TREE",
")",
";",
"\\",
"break",
";",
"N2_FTYPES",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"types",
"[",
"(",
"int",
")",
"ftcode",
"]",
";",
"}",
"</s>"
] | [
"Return",
"the",
"tree",
"function",
"type",
",",
"based",
"on",
"the",
"ftcode",
"."
] | [
"nios2"
] | nios2 | nios2_ftype | nios2 | MPU | GCC | 19,796 | 149 | 1 | [] |
[
"<s>",
"void",
"SIFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedVGPRs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedVGPRs",
",",
"RS",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"MFI",
"->",
"isEntryFunction",
"(",
")",
")",
"return",
";",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"GCNSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"SavedVGPRs",
".",
"clearBitsNotInMask",
"(",
"TRI",
"->",
"getAllVectorRegMask",
"(",
")",
")",
";",
"if",
"(",
"!",
"ST",
".",
"hasGFX90AInsts",
"(",
")",
")",
"SavedVGPRs",
".",
"clearBitsInMask",
"(",
"TRI",
"->",
"getAllAGPRRegMask",
"(",
")",
")",
";",
"const",
"bool",
"WillHaveFP",
"=",
"FrameInfo",
".",
"hasCalls",
"(",
")",
"&&",
"(",
"SavedVGPRs",
".",
"any",
"(",
")",
"||",
"!",
"allStackObjectsAreDead",
"(",
"FrameInfo",
")",
")",
";",
"for",
"(",
"auto",
"SSpill",
":",
"MFI",
"->",
"getSGPRSpillVGPRs",
"(",
")",
")",
"SavedVGPRs",
".",
"reset",
"(",
"SSpill",
".",
"VGPR",
")",
";",
"LivePhysRegs",
"LiveRegs",
";",
"LiveRegs",
".",
"init",
"(",
"*",
"TRI",
")",
";",
"if",
"(",
"WillHaveFP",
"||",
"hasFP",
"(",
"MF",
")",
")",
"{",
"assert",
"(",
"!",
"MFI",
"->",
"SGPRForFPSaveRestoreCopy",
"&&",
"!",
"MFI",
"->",
"FramePointerSaveIndex",
"&&",
"\"Re-reserving spill slot for FP\"",
")",
";",
"getVGPRSpillLaneOrTempRegister",
"(",
"MF",
",",
"LiveRegs",
",",
"MFI",
"->",
"SGPRForFPSaveRestoreCopy",
",",
"MFI",
"->",
"FramePointerSaveIndex",
",",
"true",
")",
";",
"}",
"if",
"(",
"TRI",
"->",
"hasBasePointer",
"(",
"MF",
")",
")",
"{",
"if",
"(",
"MFI",
"->",
"SGPRForFPSaveRestoreCopy",
")",
"LiveRegs",
".",
"addReg",
"(",
"MFI",
"->",
"SGPRForFPSaveRestoreCopy",
")",
";",
"assert",
"(",
"!",
"MFI",
"->",
"SGPRForBPSaveRestoreCopy",
"&&",
"!",
"MFI",
"->",
"BasePointerSaveIndex",
"&&",
"\"Re-reserving spill slot for BP\"",
")",
";",
"getVGPRSpillLaneOrTempRegister",
"(",
"MF",
",",
"LiveRegs",
",",
"MFI",
"->",
"SGPRForBPSaveRestoreCopy",
",",
"MFI",
"->",
"BasePointerSaveIndex",
",",
"false",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"\"Re-reserving spill slot for FP\"",
"\"Re-reserving spill slot for BP\""
] | SIFrameLowering12 | determineCalleeSaves | AMDGPU | GPU | LLVM | 19,797 | 276 | 1 | [] |
[
"<s>",
"bool",
"MSP430BSel",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"mf",
")",
"{",
"MF",
"=",
"&",
"mf",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"MSP430InstrInfo",
"*",
">",
"(",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"if",
"(",
"!",
"BranchSelectEnabled",
")",
"return",
"false",
";",
"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\""
] | MSP430BranchSelector14 | runOnMachineFunction | MSP430 | MPU | LLVM | 19,798 | 101 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addMachineSSAOptimization",
"(",
")",
"{",
"TargetPassConfig",
"::",
"addMachineSSAOptimization",
"(",
")",
";",
"addPass",
"(",
"&",
"SIFoldOperandsID",
")",
";",
"addPass",
"(",
"&",
"DeadMachineInstructionElimID",
")",
";",
"}",
"</s>"
] | [
"Methods",
"with",
"trivial",
"inline",
"returns",
"are",
"convenient",
"points",
"in",
"the",
"common",
"codegen",
"pass",
"pipeline",
"where",
"targets",
"may",
"insert",
"passes",
"."
] | [
"AMDGPU",
"SI"
] | AMDGPUTargetMachine103 | addMachineSSAOptimization | AMDGPU | GPU | LLVM | 19,799 | 26 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.