ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"bool",
"isFPImm",
"(",
")",
"const",
"{",
"return",
"Kind",
"==",
"Float",
";",
"}",
"</s>"
] | [
"isFPImm",
"-",
"Tests",
"if",
"this",
"is",
"a",
"MO_FPImmediate",
"operand",
"."
] | [
"WebAssembly"
] | WebAssemblyAsmParser | isFPImm | WebAssembly | Virtual ISA | LLVM | 20,200 | 12 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUTargetLowering",
"::",
"ComputeNumSignBitsForTargetNode",
"(",
"SDValue",
"Op",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPUISD",
"::",
"BFE_I32",
":",
"{",
"ConstantSDNode",
"*",
"Width",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
";",
"if",
"(",
"!",
"Width",
")",
"return",
"1",
";",
"unsigned",
"SignBits",
"=",
"32",
"-",
"Width",
"->",
"getZExtValue",
"(",
")",
"+",
"1",
";",
"ConstantSDNode",
"*",
"Offset",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"if",
"(",
"!",
"Offset",
"||",
"!",
"Offset",
"->",
"isNullValue",
"(",
")",
")",
"return",
"SignBits",
";",
"unsigned",
"Op0SignBits",
"=",
"DAG",
".",
"ComputeNumSignBits",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
",",
"Depth",
"+",
"1",
")",
";",
"return",
"std",
"::",
"max",
"(",
"SignBits",
",",
"Op0SignBits",
")",
";",
"}",
"case",
"AMDGPUISD",
"::",
"BFE_U32",
":",
"{",
"ConstantSDNode",
"*",
"Width",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
";",
"return",
"Width",
"?",
"32",
"-",
"(",
"Width",
"->",
"getZExtValue",
"(",
")",
"&",
"0x1f",
")",
":",
"1",
";",
"}",
"default",
":",
"return",
"1",
";",
"}",
"}",
"</s>"
] | [
"Determine",
"the",
"number",
"of",
"bits",
"in",
"the",
"operation",
"that",
"are",
"sign",
"bits",
"."
] | [
"R600",
"AMDGPUISD::BFE_I32",
"2",
"1",
"32",
"1",
"1",
"0",
"1",
"AMDGPUISD::BFE_U32",
"2",
"32",
"0x1f",
"1",
"1"
] | AMDGPUISelLowering100 | ComputeNumSignBitsForTargetNode | R600 | GPU | LLVM | 20,201 | 181 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"doInitialization",
"(",
"Module",
"&",
"M",
")",
"override",
"{",
"if",
"(",
"!",
"TOC",
".",
"empty",
"(",
")",
")",
"TOC",
".",
"clear",
"(",
")",
";",
"return",
"AsmPrinter",
"::",
"doInitialization",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"PowerPC"
] | PPCAsmPrinter (2)1 | doInitialization | PowerPC | CPU | LLVM | 20,202 | 34 | 1 | [] |
[
"<s>",
"static",
"tree",
"rs6000_get_function_versions_dispatcher",
"(",
"void",
"*",
"decl",
")",
"{",
"tree",
"fn",
"=",
"(",
"tree",
")",
"decl",
";",
"struct",
"cgraph_node",
"*",
"node",
"=",
"NULL",
";",
"struct",
"cgraph_node",
"*",
"default_node",
"=",
"NULL",
";",
"struct",
"cgraph_function_version_info",
"*",
"node_v",
"=",
"NULL",
";",
"struct",
"cgraph_function_version_info",
"*",
"first_v",
"=",
"NULL",
";",
"tree",
"dispatch_decl",
"=",
"NULL",
";",
"struct",
"cgraph_function_version_info",
"*",
"default_version_info",
"=",
"NULL",
";",
"gcc_assert",
"(",
"fn",
"!=",
"NULL",
"&&",
"DECL_FUNCTION_VERSIONED",
"(",
"fn",
")",
")",
";",
"if",
"(",
"TARGET_DEBUG_TARGET",
")",
"fprintf",
"(",
"stderr",
",",
"\"rs6000_get_function_versions_dispatcher (%s)\\n\"",
",",
"get_decl_name",
"(",
"fn",
")",
")",
";",
"node",
"=",
"cgraph_node",
"::",
"get",
"(",
"fn",
")",
";",
"gcc_assert",
"(",
"node",
"!=",
"NULL",
")",
";",
"node_v",
"=",
"node",
"->",
"function_version",
"(",
")",
";",
"gcc_assert",
"(",
"node_v",
"!=",
"NULL",
")",
";",
"if",
"(",
"node_v",
"->",
"dispatcher_resolver",
"!=",
"NULL",
")",
"return",
"node_v",
"->",
"dispatcher_resolver",
";",
"first_v",
"=",
"node_v",
";",
"while",
"(",
"first_v",
"->",
"prev",
"!=",
"NULL",
")",
"first_v",
"=",
"first_v",
"->",
"prev",
";",
"default_version_info",
"=",
"first_v",
";",
"while",
"(",
"default_version_info",
"!=",
"NULL",
")",
"{",
"const",
"tree",
"decl2",
"=",
"default_version_info",
"->",
"this_node",
"->",
"decl",
";",
"if",
"(",
"is_function_default_version",
"(",
"decl2",
")",
")",
"break",
";",
"default_version_info",
"=",
"default_version_info",
"->",
"next",
";",
"}",
"if",
"(",
"default_version_info",
"==",
"NULL",
")",
"return",
"NULL",
";",
"if",
"(",
"first_v",
"!=",
"default_version_info",
")",
"{",
"default_version_info",
"->",
"prev",
"->",
"next",
"=",
"default_version_info",
"->",
"next",
";",
"if",
"(",
"default_version_info",
"->",
"next",
")",
"default_version_info",
"->",
"next",
"->",
"prev",
"=",
"default_version_info",
"->",
"prev",
";",
"first_v",
"->",
"prev",
"=",
"default_version_info",
";",
"default_version_info",
"->",
"next",
"=",
"first_v",
";",
"default_version_info",
"->",
"prev",
"=",
"NULL",
";",
"}",
"default_node",
"=",
"default_version_info",
"->",
"this_node",
";",
"error_at",
"(",
"DECL_SOURCE_LOCATION",
"(",
"default_node",
"->",
"decl",
")",
",",
"\"%<target_clones%> attribute needs GLIBC (2.23 and newer) that \"",
"\"exports hardware capability bits\"",
")",
";",
"if",
"(",
"targetm",
".",
"has_ifunc_p",
"(",
")",
")",
"{",
"struct",
"cgraph_function_version_info",
"*",
"it_v",
"=",
"NULL",
";",
"struct",
"cgraph_node",
"*",
"dispatcher_node",
"=",
"NULL",
";",
"struct",
"cgraph_function_version_info",
"*",
"dispatcher_version_info",
"=",
"NULL",
";",
"dispatch_decl",
"=",
"make_dispatcher_decl",
"(",
"default_node",
"->",
"decl",
")",
";",
"dispatcher_node",
"=",
"cgraph_node",
"::",
"get_create",
"(",
"dispatch_decl",
")",
";",
"gcc_assert",
"(",
"dispatcher_node",
"!=",
"NULL",
")",
";",
"dispatcher_node",
"->",
"dispatcher_function",
"=",
"1",
";",
"dispatcher_version_info",
"=",
"dispatcher_node",
"->",
"insert_new_function_version",
"(",
")",
";",
"dispatcher_version_info",
"->",
"next",
"=",
"default_version_info",
";",
"dispatcher_node",
"->",
"definition",
"=",
"1",
";",
"it_v",
"=",
"default_version_info",
";",
"while",
"(",
"it_v",
"!=",
"NULL",
")",
"{",
"it_v",
"->",
"dispatcher_resolver",
"=",
"dispatch_decl",
";",
"it_v",
"=",
"it_v",
"->",
"next",
";",
"}",
"}",
"else",
"{",
"error_at",
"(",
"DECL_SOURCE_LOCATION",
"(",
"default_node",
"->",
"decl",
")",
",",
"\"multiversioning needs %<ifunc%> which is not supported \"",
"\"on this target\"",
")",
";",
"}",
"return",
"dispatch_decl",
";",
"}",
"</s>"
] | [
"Make",
"a",
"dispatcher",
"declaration",
"for",
"the",
"multi-versioned",
"function",
"DECL",
".",
"Calls",
"to",
"DECL",
"function",
"will",
"be",
"replaced",
"with",
"calls",
"to",
"the",
"dispatcher",
"by",
"the",
"front-end",
".",
"Returns",
"the",
"decl",
"of",
"the",
"dispatcher",
"function",
"."
] | [
"rs6000",
"\"rs6000_get_function_versions_dispatcher (%s)\\n\"",
"\"%<target_clones%> attribute needs GLIBC (2.23 and newer) that \"",
"\"exports hardware capability bits\"",
"1",
"1",
"\"multiversioning needs %<ifunc%> which is not supported \"",
"\"on this target\""
] | rs6000 | rs6000_get_function_versions_dispatcher | rs6000 | CPU | GCC | 20,203 | 390 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_handle_attr_tune",
"(",
"const",
"char",
"*",
"str",
",",
"const",
"char",
"*",
"pragma_or_attr",
")",
"{",
"const",
"struct",
"processor",
"*",
"tmp_tune",
"=",
"NULL",
";",
"enum",
"aarch64_parse_opt_result",
"parse_res",
"=",
"aarch64_parse_tune",
"(",
"str",
",",
"&",
"tmp_tune",
")",
";",
"if",
"(",
"parse_res",
"==",
"AARCH64_PARSE_OK",
")",
"{",
"gcc_assert",
"(",
"tmp_tune",
")",
";",
"selected_tune",
"=",
"tmp_tune",
";",
"explicit_tune_core",
"=",
"selected_tune",
"->",
"ident",
";",
"return",
"true",
";",
"}",
"switch",
"(",
"parse_res",
")",
"{",
"case",
"AARCH64_PARSE_INVALID_ARG",
":",
"error",
"(",
"\"unknown value %qs for 'tune' target %s\"",
",",
"str",
",",
"pragma_or_attr",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Handle",
"the",
"argument",
"STR",
"to",
"the",
"tune=",
"target",
"attribute",
".",
"PRAGMA_OR_ATTR",
"is",
"used",
"in",
"potential",
"error",
"messages",
"."
] | [
"aarch64",
"\"unknown value %qs for 'tune' target %s\""
] | aarch643 | aarch64_handle_attr_tune | aarch64 | CPU | GCC | 20,204 | 91 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"SNESFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"const",
"SNESSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"SNESSubtarget",
">",
"(",
")",
";",
"const",
"TargetFrameLowering",
"&",
"TFI",
"=",
"*",
"STI",
".",
"getFrameLowering",
"(",
")",
";",
"const",
"SNESInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"if",
"(",
"TFI",
".",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"fixStackStores",
"(",
"MBB",
",",
"MI",
",",
"TII",
",",
"false",
")",
";",
"return",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"int",
"Opcode",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"int",
"Amount",
"=",
"TII",
".",
"getFrameSize",
"(",
"*",
"MI",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"assert",
"(",
"TFI",
".",
"getStackAlignment",
"(",
")",
"==",
"1",
"&&",
"\"Unsupported stack alignment\"",
")",
";",
"if",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameSetupOpcode",
"(",
")",
")",
"{",
"fixStackStores",
"(",
"MBB",
",",
"MI",
",",
"TII",
",",
"true",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
";",
"unsigned",
"addOpcode",
";",
"addOpcode",
"=",
"SNES",
"::",
"SUBIWRdK",
";",
"Amount",
"=",
"-",
"Amount",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"SNES",
"::",
"SPREAD",
")",
",",
"SNES",
"::",
"A",
")",
".",
"addReg",
"(",
"SNES",
"::",
"SP",
")",
";",
"MachineInstr",
"*",
"New",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"addOpcode",
")",
",",
"SNES",
"::",
"A",
")",
".",
"addReg",
"(",
"SNES",
"::",
"A",
",",
"RegState",
"::",
"Kill",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"SNES",
"::",
"SPWRITE",
")",
",",
"SNES",
"::",
"SP",
")",
".",
"addReg",
"(",
"SNES",
"::",
"A",
",",
"RegState",
"::",
"Kill",
")",
";",
"}",
"}",
"return",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"SNES",
"SNES",
"SNES",
"SNES",
"SNES",
"0",
"1",
"\"Unsupported stack alignment\"",
"SNES::SUBIWRdK",
"SNES::SPREAD",
"SNES::A",
"SNES::SP",
"SNES::A",
"SNES::A",
"3",
"SNES::SPWRITE",
"SNES::SP",
"SNES::A"
] | SNESFrameLowering | eliminateCallFramePseudoInstr | SNES | DSP | LLVM | 20,205 | 314 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_expand_vector_init_one_var",
"(",
"bool",
"mmx_ok",
",",
"machine_mode",
"mode",
",",
"rtx",
"target",
",",
"rtx",
"vals",
",",
"int",
"one_var",
")",
"{",
"rtx",
"var",
"=",
"XVECEXP",
"(",
"vals",
",",
"0",
",",
"one_var",
")",
";",
"machine_mode",
"wmode",
";",
"rtx",
"const_vec",
",",
"x",
";",
"const_vec",
"=",
"copy_rtx",
"(",
"vals",
")",
";",
"XVECEXP",
"(",
"const_vec",
",",
"0",
",",
"one_var",
")",
"=",
"CONST0_RTX",
"(",
"GET_MODE_INNER",
"(",
"mode",
")",
")",
";",
"const_vec",
"=",
"gen_rtx_CONST_VECTOR",
"(",
"mode",
",",
"XVEC",
"(",
"const_vec",
",",
"0",
")",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_V2DFmode",
":",
"case",
"E_V2DImode",
":",
"case",
"E_V2SFmode",
":",
"case",
"E_V2SImode",
":",
"return",
"false",
";",
"case",
"E_V4DImode",
":",
"if",
"(",
"!",
"TARGET_64BIT",
")",
"return",
"false",
";",
"case",
"E_V8HFmode",
":",
"case",
"E_V16HFmode",
":",
"case",
"E_V8BFmode",
":",
"case",
"E_V16BFmode",
":",
"case",
"E_V4DFmode",
":",
"case",
"E_V8SFmode",
":",
"case",
"E_V8SImode",
":",
"case",
"E_V16HImode",
":",
"case",
"E_V32QImode",
":",
"case",
"E_V4SFmode",
":",
"case",
"E_V4SImode",
":",
"case",
"E_V8HImode",
":",
"case",
"E_V4HImode",
":",
"break",
";",
"case",
"E_V16QImode",
":",
"if",
"(",
"TARGET_SSE4_1",
")",
"break",
";",
"wmode",
"=",
"V8HImode",
";",
"goto",
"widen",
";",
"case",
"E_V8QImode",
":",
"if",
"(",
"TARGET_MMX_WITH_SSE",
"&&",
"TARGET_SSE4_1",
")",
"break",
";",
"wmode",
"=",
"V4HImode",
";",
"goto",
"widen",
";",
"case",
"E_V4QImode",
":",
"if",
"(",
"TARGET_SSE4_1",
")",
"break",
";",
"wmode",
"=",
"V2HImode",
";",
"widen",
":",
"x",
"=",
"XVECEXP",
"(",
"vals",
",",
"0",
",",
"one_var",
"^",
"1",
")",
";",
"if",
"(",
"one_var",
"&",
"1",
")",
"{",
"var",
"=",
"convert_modes",
"(",
"HImode",
",",
"QImode",
",",
"var",
",",
"true",
")",
";",
"var",
"=",
"expand_simple_binop",
"(",
"HImode",
",",
"ASHIFT",
",",
"var",
",",
"GEN_INT",
"(",
"8",
")",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_LIB_WIDEN",
")",
";",
"x",
"=",
"GEN_INT",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"0xff",
")",
";",
"}",
"else",
"{",
"var",
"=",
"convert_modes",
"(",
"HImode",
",",
"QImode",
",",
"var",
",",
"true",
")",
";",
"x",
"=",
"gen_int_mode",
"(",
"UINTVAL",
"(",
"x",
")",
"<<",
"8",
",",
"HImode",
")",
";",
"}",
"if",
"(",
"x",
"!=",
"const0_rtx",
")",
"var",
"=",
"expand_simple_binop",
"(",
"HImode",
",",
"IOR",
",",
"var",
",",
"x",
",",
"var",
",",
"1",
",",
"OPTAB_LIB_WIDEN",
")",
";",
"x",
"=",
"gen_reg_rtx",
"(",
"wmode",
")",
";",
"emit_move_insn",
"(",
"x",
",",
"gen_lowpart",
"(",
"wmode",
",",
"const_vec",
")",
")",
";",
"ix86_expand_vector_set",
"(",
"mmx_ok",
",",
"x",
",",
"var",
",",
"one_var",
">>",
"1",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"gen_lowpart",
"(",
"mode",
",",
"x",
")",
")",
";",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"emit_move_insn",
"(",
"target",
",",
"const_vec",
")",
";",
"ix86_expand_vector_set",
"(",
"mmx_ok",
",",
"target",
",",
"var",
",",
"one_var",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"ix86_expand_vector_init",
".",
"Store",
"into",
"TARGET",
"a",
"vector",
"consisting",
"of",
"the",
"values",
"in",
"VALS",
".",
"It",
"is",
"known",
"that",
"all",
"elements",
"except",
"ONE_VAR",
"are",
"constants",
".",
"Return",
"true",
"if",
"successful",
"."
] | [
"i386",
"0",
"0",
"0",
"0",
"1",
"1",
"8",
"1",
"0xff",
"8",
"1",
"1"
] | i386-expand1 | ix86_expand_vector_init_one_var | i386 | CPU | GCC | 20,206 | 397 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_init_libfuncs",
"(",
"void",
")",
"{",
"if",
"(",
"TARGET_FIX_VR4120",
")",
"{",
"set_optab_libfunc",
"(",
"sdiv_optab",
",",
"SImode",
",",
"\"__vr4120_divsi3\"",
")",
";",
"set_optab_libfunc",
"(",
"smod_optab",
",",
"SImode",
",",
"\"__vr4120_modsi3\"",
")",
";",
"}",
"if",
"(",
"TARGET_MIPS16",
"&&",
"mips16_hard_float",
")",
"{",
"set_optab_libfunc",
"(",
"add_optab",
",",
"SFmode",
",",
"\"__mips16_addsf3\"",
")",
";",
"set_optab_libfunc",
"(",
"sub_optab",
",",
"SFmode",
",",
"\"__mips16_subsf3\"",
")",
";",
"set_optab_libfunc",
"(",
"smul_optab",
",",
"SFmode",
",",
"\"__mips16_mulsf3\"",
")",
";",
"set_optab_libfunc",
"(",
"sdiv_optab",
",",
"SFmode",
",",
"\"__mips16_divsf3\"",
")",
";",
"set_optab_libfunc",
"(",
"eq_optab",
",",
"SFmode",
",",
"\"__mips16_eqsf2\"",
")",
";",
"set_optab_libfunc",
"(",
"ne_optab",
",",
"SFmode",
",",
"\"__mips16_nesf2\"",
")",
";",
"set_optab_libfunc",
"(",
"gt_optab",
",",
"SFmode",
",",
"\"__mips16_gtsf2\"",
")",
";",
"set_optab_libfunc",
"(",
"ge_optab",
",",
"SFmode",
",",
"\"__mips16_gesf2\"",
")",
";",
"set_optab_libfunc",
"(",
"lt_optab",
",",
"SFmode",
",",
"\"__mips16_ltsf2\"",
")",
";",
"set_optab_libfunc",
"(",
"le_optab",
",",
"SFmode",
",",
"\"__mips16_lesf2\"",
")",
";",
"set_conv_libfunc",
"(",
"sfix_optab",
",",
"SImode",
",",
"SFmode",
",",
"\"__mips16_fix_truncsfsi\"",
")",
";",
"set_conv_libfunc",
"(",
"sfloat_optab",
",",
"SFmode",
",",
"SImode",
",",
"\"__mips16_floatsisf\"",
")",
";",
"if",
"(",
"TARGET_DOUBLE_FLOAT",
")",
"{",
"set_optab_libfunc",
"(",
"add_optab",
",",
"DFmode",
",",
"\"__mips16_adddf3\"",
")",
";",
"set_optab_libfunc",
"(",
"sub_optab",
",",
"DFmode",
",",
"\"__mips16_subdf3\"",
")",
";",
"set_optab_libfunc",
"(",
"smul_optab",
",",
"DFmode",
",",
"\"__mips16_muldf3\"",
")",
";",
"set_optab_libfunc",
"(",
"sdiv_optab",
",",
"DFmode",
",",
"\"__mips16_divdf3\"",
")",
";",
"set_optab_libfunc",
"(",
"eq_optab",
",",
"DFmode",
",",
"\"__mips16_eqdf2\"",
")",
";",
"set_optab_libfunc",
"(",
"ne_optab",
",",
"DFmode",
",",
"\"__mips16_nedf2\"",
")",
";",
"set_optab_libfunc",
"(",
"gt_optab",
",",
"DFmode",
",",
"\"__mips16_gtdf2\"",
")",
";",
"set_optab_libfunc",
"(",
"ge_optab",
",",
"DFmode",
",",
"\"__mips16_gedf2\"",
")",
";",
"set_optab_libfunc",
"(",
"lt_optab",
",",
"DFmode",
",",
"\"__mips16_ltdf2\"",
")",
";",
"set_optab_libfunc",
"(",
"le_optab",
",",
"DFmode",
",",
"\"__mips16_ledf2\"",
")",
";",
"set_conv_libfunc",
"(",
"sext_optab",
",",
"DFmode",
",",
"SFmode",
",",
"\"__mips16_extendsfdf2\"",
")",
";",
"set_conv_libfunc",
"(",
"trunc_optab",
",",
"SFmode",
",",
"DFmode",
",",
"\"__mips16_truncdfsf2\"",
")",
";",
"set_conv_libfunc",
"(",
"sfix_optab",
",",
"SImode",
",",
"DFmode",
",",
"\"__mips16_fix_truncdfsi\"",
")",
";",
"set_conv_libfunc",
"(",
"sfloat_optab",
",",
"DFmode",
",",
"SImode",
",",
"\"__mips16_floatsidf\"",
")",
";",
"}",
"}",
"else",
"gofast_maybe_init_libfuncs",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_INIT_LIBFUNCS",
"."
] | [
"mips",
"\"__vr4120_divsi3\"",
"\"__vr4120_modsi3\"",
"\"__mips16_addsf3\"",
"\"__mips16_subsf3\"",
"\"__mips16_mulsf3\"",
"\"__mips16_divsf3\"",
"\"__mips16_eqsf2\"",
"\"__mips16_nesf2\"",
"\"__mips16_gtsf2\"",
"\"__mips16_gesf2\"",
"\"__mips16_ltsf2\"",
"\"__mips16_lesf2\"",
"\"__mips16_fix_truncsfsi\"",
"\"__mips16_floatsisf\"",
"\"__mips16_adddf3\"",
"\"__mips16_subdf3\"",
"\"__mips16_muldf3\"",
"\"__mips16_divdf3\"",
"\"__mips16_eqdf2\"",
"\"__mips16_nedf2\"",
"\"__mips16_gtdf2\"",
"\"__mips16_gedf2\"",
"\"__mips16_ltdf2\"",
"\"__mips16_ledf2\"",
"\"__mips16_extendsfdf2\"",
"\"__mips16_truncdfsf2\"",
"\"__mips16_fix_truncdfsi\"",
"\"__mips16_floatsidf\""
] | mips3 | mips_init_libfuncs | mips | CPU | GCC | 20,207 | 297 | 1 | [] |
[
"<s>",
"JVMSubtarget",
"&",
"JVMSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"FS",
")",
"{",
"if",
"(",
"CPUString",
".",
"empty",
"(",
")",
")",
"CPUString",
"=",
"\"jvm\"",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"JVM",
"JVM",
"JVM",
"\"jvm\""
] | JVMSubtarget | initializeSubtargetDependencies | JVM | Virtual ISA | LLVM | 20,208 | 27 | 1 | [] |
[
"<s>",
"void",
"MipsTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"return",
"LowerOperationWrapper",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"Mips",
"Mips"
] | MipsISelLowering (2) | ReplaceNodeResults | Mips | CPU | LLVM | 20,209 | 33 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"isKnownNeverNaNForTargetNode",
"(",
"SDValue",
"Op",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"bool",
"SNaN",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"if",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"==",
"AMDGPUISD",
"::",
"CLAMP",
")",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"const",
"SIMachineFunctionInfo",
"*",
"Info",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"Info",
"->",
"getMode",
"(",
")",
".",
"DX10Clamp",
")",
"return",
"true",
";",
"return",
"DAG",
".",
"isKnownNeverNaN",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
",",
"SNaN",
",",
"Depth",
"+",
"1",
")",
";",
"}",
"return",
"AMDGPUTargetLowering",
"::",
"isKnownNeverNaNForTargetNode",
"(",
"Op",
",",
"DAG",
",",
"SNaN",
",",
"Depth",
")",
";",
"}",
"</s>"
] | [
"If",
"SNaN",
"is",
"false",
",",
"."
] | [
"AMDGPU",
"SI",
"AMDGPUISD::CLAMP",
"SI",
"SI",
"0",
"1",
"AMDGPU"
] | SIISelLowering10 | isKnownNeverNaNForTargetNode | AMDGPU | GPU | LLVM | 20,210 | 107 | 1 | [] |
[
"<s>",
"static",
"void",
"load_reg",
"(",
"int",
"reg",
",",
"HOST_WIDE_INT",
"disp",
",",
"int",
"base",
")",
"{",
"rtx",
"dest",
"=",
"gen_rtx_REG",
"(",
"word_mode",
",",
"reg",
")",
";",
"rtx",
"basereg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"base",
")",
";",
"rtx",
"src",
";",
"if",
"(",
"VAL_14_BITS_P",
"(",
"disp",
")",
")",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"plus_constant",
"(",
"basereg",
",",
"disp",
")",
")",
";",
"else",
"if",
"(",
"TARGET_64BIT",
"&&",
"!",
"VAL_32_BITS_P",
"(",
"disp",
")",
")",
"{",
"rtx",
"delta",
"=",
"GEN_INT",
"(",
"disp",
")",
";",
"rtx",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"1",
")",
";",
"emit_move_insn",
"(",
"tmpreg",
",",
"delta",
")",
";",
"if",
"(",
"TARGET_DISABLE_INDEXING",
")",
"{",
"emit_move_insn",
"(",
"tmpreg",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"tmpreg",
",",
"basereg",
")",
")",
";",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"tmpreg",
")",
";",
"}",
"else",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"tmpreg",
",",
"basereg",
")",
")",
";",
"}",
"else",
"{",
"rtx",
"delta",
"=",
"GEN_INT",
"(",
"disp",
")",
";",
"rtx",
"high",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"basereg",
",",
"gen_rtx_HIGH",
"(",
"Pmode",
",",
"delta",
")",
")",
";",
"rtx",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"1",
")",
";",
"emit_move_insn",
"(",
"tmpreg",
",",
"high",
")",
";",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"tmpreg",
",",
"delta",
")",
")",
";",
"}",
"emit_move_insn",
"(",
"dest",
",",
"src",
")",
";",
"}",
"</s>"
] | [
"Emit",
"RTL",
"to",
"load",
"REG",
"from",
"the",
"memory",
"location",
"specified",
"by",
"BASE+DISP",
".",
"Handle",
"case",
"where",
"DISP",
">",
"8k",
"by",
"using",
"the",
"add_high_const",
"patterns",
"."
] | [
"pa",
"1",
"1"
] | pa3 | load_reg | pa | CPU | GCC | 20,211 | 211 | 1 | [] |
[
"<s>",
"static",
"rtx",
"frame_stack_add",
"(",
"HOST_WIDE_INT",
"offset",
")",
"{",
"return",
"frame_add",
"(",
"stack_pointer_rtx",
",",
"offset",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"frame",
"insn",
"which",
"adjusts",
"stack",
"pointer",
"by",
"OFFSET",
"."
] | [
"arc"
] | arc | frame_stack_add | arc | MPU | GCC | 20,212 | 17 | 1 | [] |
[
"<s>",
"unsigned",
"MSP430RegisterInfo",
"::",
"getRARegister",
"(",
")",
"const",
"{",
"return",
"MSP430",
"::",
"PCW",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"return",
"the",
"register",
"where",
"the",
"return",
"address",
"can",
"be",
"found",
"."
] | [
"MSP430",
"MSP430",
"MSP430::PCW"
] | MSP430RegisterInfo10 | getRARegister | MSP430 | MPU | LLVM | 20,213 | 14 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"SystemZTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"OPCODE",
"(",
"RET_FLAG",
")",
";",
"OPCODE",
"(",
"CALL",
")",
";",
"OPCODE",
"(",
"SIBCALL",
")",
";",
"OPCODE",
"(",
"PCREL_WRAPPER",
")",
";",
"OPCODE",
"(",
"ICMP",
")",
";",
"OPCODE",
"(",
"FCMP",
")",
";",
"OPCODE",
"(",
"TM",
")",
";",
"OPCODE",
"(",
"BR_CCMASK",
")",
";",
"OPCODE",
"(",
"SELECT_CCMASK",
")",
";",
"OPCODE",
"(",
"ADJDYNALLOC",
")",
";",
"OPCODE",
"(",
"EXTRACT_ACCESS",
")",
";",
"OPCODE",
"(",
"UMUL_LOHI64",
")",
";",
"OPCODE",
"(",
"SDIVREM64",
")",
";",
"OPCODE",
"(",
"UDIVREM32",
")",
";",
"OPCODE",
"(",
"UDIVREM64",
")",
";",
"OPCODE",
"(",
"MVC",
")",
";",
"OPCODE",
"(",
"MVC_LOOP",
")",
";",
"OPCODE",
"(",
"NC",
")",
";",
"OPCODE",
"(",
"NC_LOOP",
")",
";",
"OPCODE",
"(",
"OC",
")",
";",
"OPCODE",
"(",
"OC_LOOP",
")",
";",
"OPCODE",
"(",
"XC",
")",
";",
"OPCODE",
"(",
"XC_LOOP",
")",
";",
"OPCODE",
"(",
"CLC",
")",
";",
"OPCODE",
"(",
"CLC_LOOP",
")",
";",
"OPCODE",
"(",
"STRCMP",
")",
";",
"OPCODE",
"(",
"STPCPY",
")",
";",
"OPCODE",
"(",
"SEARCH_STRING",
")",
";",
"OPCODE",
"(",
"IPM",
")",
";",
"OPCODE",
"(",
"ATOMIC_SWAPW",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_ADD",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_SUB",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_AND",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_OR",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_XOR",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_NAND",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_MIN",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_MAX",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_UMIN",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_UMAX",
")",
";",
"OPCODE",
"(",
"ATOMIC_CMP_SWAPW",
")",
";",
"OPCODE",
"(",
"PREFETCH",
")",
";",
"}",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"SystemZ",
"SystemZ"
] | SystemZISelLowering19 | getTargetNodeName | SystemZ | CPU | LLVM | 20,214 | 232 | 1 | [] |
[
"<s>",
"BitVector",
"AArch64RegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"XZR",
")",
";",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"WSP",
")",
";",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"WZR",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"||",
"TT",
".",
"isOSDarwin",
"(",
")",
")",
"{",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"FP",
")",
";",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"W29",
")",
";",
"}",
"if",
"(",
"TT",
".",
"isOSDarwin",
"(",
")",
"||",
"ReserveX18",
")",
"{",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"X18",
")",
";",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"W18",
")",
";",
"}",
"if",
"(",
"hasBasePointer",
"(",
"MF",
")",
")",
"{",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"X19",
")",
";",
"Reserved",
".",
"set",
"(",
"AArch64",
"::",
"W19",
")",
";",
"}",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"AArch64",
"AArch64",
"AArch64::SP",
"AArch64::XZR",
"AArch64::WSP",
"AArch64::WZR",
"AArch64::FP",
"AArch64::W29",
"AArch64::X18",
"AArch64::W18",
"AArch64::X19",
"AArch64::W19"
] | AArch64RegisterInfo34 | getReservedRegs | AArch64 | CPU | LLVM | 20,215 | 167 | 1 | [] |
[
"<s>",
"static",
"rtx",
"zero_all_vector_registers",
"(",
"HARD_REG_SET",
"need_zeroed_hardregs",
")",
"{",
"if",
"(",
"!",
"TARGET_AVX",
")",
"return",
"NULL",
";",
"for",
"(",
"unsigned",
"int",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"(",
"IN_RANGE",
"(",
"regno",
",",
"FIRST_SSE_REG",
",",
"LAST_SSE_REG",
")",
"||",
"(",
"TARGET_64BIT",
"&&",
"(",
"REX_SSE_REGNO_P",
"(",
"regno",
")",
"||",
"(",
"TARGET_AVX512F",
"&&",
"EXT_REX_SSE_REGNO_P",
"(",
"regno",
")",
")",
")",
")",
")",
"&&",
"!",
"TEST_HARD_REG_BIT",
"(",
"need_zeroed_hardregs",
",",
"regno",
")",
")",
"return",
"NULL",
";",
"return",
"gen_avx_vzeroall",
"(",
")",
";",
"}",
"</s>"
] | [
"Generate",
"a",
"rtx",
"to",
"zero",
"all",
"vector",
"registers",
"together",
"if",
"possible",
",",
"otherwise",
",",
"return",
"NULL",
"."
] | [
"i386",
"0"
] | i3861 | zero_all_vector_registers | i386 | CPU | GCC | 20,216 | 81 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Patmos Single-Path Mark (machine code)\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Patmos",
"\"Patmos Single-Path Mark (machine code)\""
] | PatmosSPMark1 | getPassName | Patmos | VLIW | LLVM | 20,217 | 11 | 1 | [] |
[
"<s>",
"static",
"void",
"frv_extract_membar",
"(",
"struct",
"frv_io",
"*",
"io",
",",
"rtx",
"insn",
")",
"{",
"extract_insn",
"(",
"insn",
")",
";",
"io",
"->",
"type",
"=",
"INTVAL",
"(",
"recog_data",
".",
"operand",
"[",
"2",
"]",
")",
";",
"io",
"->",
"const_address",
"=",
"INTVAL",
"(",
"recog_data",
".",
"operand",
"[",
"1",
"]",
")",
";",
"io",
"->",
"var_address",
"=",
"XEXP",
"(",
"recog_data",
".",
"operand",
"[",
"0",
"]",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"Fill",
"IO",
"with",
"information",
"about",
"the",
"load",
"or",
"store",
"associated",
"with",
"membar",
"instruction",
"INSN",
"."
] | [
"frv",
"2",
"1",
"0",
"0"
] | frv2 | frv_extract_membar | frv | VLIW | GCC | 20,218 | 63 | 1 | [] |
[
"<s>",
"void",
"gen_conditional_branch",
"(",
"rtx",
"*",
"operands",
",",
"enum",
"rtx_code",
"code",
")",
"{",
"rtx",
"op0",
",",
"op1",
",",
"target",
";",
"mips_emit_compare",
"(",
"&",
"code",
",",
"&",
"op0",
",",
"&",
"op1",
",",
"TARGET_MIPS16",
")",
";",
"target",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"GET_MODE",
"(",
"op0",
")",
",",
"op0",
",",
"op1",
")",
",",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"operands",
"[",
"0",
"]",
")",
",",
"pc_rtx",
")",
";",
"emit_jump_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"target",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"the",
"common",
"code",
"for",
"doing",
"conditional",
"branches",
".",
"operand",
"[",
"0",
"]",
"is",
"the",
"label",
"to",
"jump",
"to",
".",
"The",
"comparison",
"operands",
"are",
"saved",
"away",
"by",
"cmp",
"{",
"si",
",",
"di",
",",
"sf",
",",
"df",
"}",
"."
] | [
"mips",
"0"
] | mips3 | gen_conditional_branch | mips | CPU | GCC | 20,219 | 79 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"uint16_t",
",",
"uint16_t",
">",
"X86InstrInfo",
"::",
"getExecutionDomain",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"uint16_t",
"domain",
"=",
"(",
"MI",
"->",
"getDesc",
"(",
")",
".",
"TSFlags",
">>",
"X86II",
"::",
"SSEDomainShift",
")",
"&",
"3",
";",
"return",
"std",
"::",
"make_pair",
"(",
"domain",
",",
"domain",
"&&",
"lookup",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
",",
"domain",
")",
"?",
"0xe",
":",
"0",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"current",
"execution",
"domain",
"and",
"bit",
"mask",
"of",
"possible",
"domains",
"for",
"instruction",
"."
] | [
"X86",
"X86",
"X86II::SSEDomainShift",
"3",
"0xe",
"0"
] | X86InstrInfo139 | getExecutionDomain | X86 | CPU | LLVM | 20,220 | 64 | 1 | [] |
[
"<s>",
"unsigned",
"RISCVInstrInfo",
"::",
"insertBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"TBB",
",",
"MachineBasicBlock",
"*",
"FBB",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"int",
"*",
"BytesAdded",
")",
"const",
"{",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"=",
"0",
";",
"assert",
"(",
"TBB",
"&&",
"\"insertBranch must not be told to insert a fallthrough\"",
")",
";",
"assert",
"(",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"3",
"||",
"Cond",
".",
"size",
"(",
")",
"==",
"0",
")",
"&&",
"\"RISCV branch conditions have two components!\"",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"RISCVSubtarget",
"&",
"ST",
"=",
"MF",
"->",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
";",
"unsigned",
"PseudoOpcode",
";",
"if",
"(",
"RISCVABI",
"::",
"isCheriPureCapABI",
"(",
"ST",
".",
"getTargetABI",
"(",
")",
")",
")",
"PseudoOpcode",
"=",
"RISCV",
"::",
"PseudoCBR",
";",
"else",
"PseudoOpcode",
"=",
"RISCV",
"::",
"PseudoBR",
";",
"if",
"(",
"Cond",
".",
"empty",
"(",
")",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"PseudoOpcode",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"+=",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"return",
"1",
";",
"}",
"unsigned",
"Opc",
"=",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
";",
"MachineInstr",
"&",
"CondMI",
"=",
"*",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
".",
"add",
"(",
"Cond",
"[",
"1",
"]",
")",
".",
"add",
"(",
"Cond",
"[",
"2",
"]",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"+=",
"getInstSizeInBytes",
"(",
"CondMI",
")",
";",
"if",
"(",
"!",
"FBB",
")",
"return",
"1",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"PseudoOpcode",
")",
")",
".",
"addMBB",
"(",
"FBB",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"+=",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"return",
"2",
";",
"}",
"</s>"
] | [
"Insert",
"branch",
"code",
"into",
"the",
"end",
"of",
"the",
"specified",
"MachineBasicBlock",
"."
] | [
"RISCV",
"RISCV",
"0",
"\"insertBranch must not be told to insert a fallthrough\"",
"3",
"0",
"\"RISCV branch conditions have two components!\"",
"RISCV",
"RISCV",
"RISCVABI::isCheriPureCapABI",
"RISCV::PseudoCBR",
"RISCV::PseudoBR",
"1",
"0",
"1",
"2",
"1",
"2"
] | RISCVInstrInfo26 | insertBranch | RISCV | CPU | LLVM | 20,221 | 284 | 1 | [] |
[
"<s>",
"bool",
"PPCAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getIdentifier",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".word\"",
")",
"return",
"ParseDirectiveWord",
"(",
"4",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".tc\"",
")",
"return",
"ParseDirectiveTC",
"(",
"isPPC64",
"(",
")",
"?",
"8",
":",
"4",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"PowerPC",
"PPC",
"\".word\"",
"4",
"\".tc\"",
"PPC",
"8",
"4"
] | PPCAsmParser1 | ParseDirective | PowerPC | CPU | LLVM | 20,222 | 64 | 1 | [] |
[
"<s>",
"static",
"cond_type",
"is_cond_candidate",
"(",
"rtx",
"insn",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"INSN",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"rtx",
"src",
",",
"dst",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"!=",
"SET",
")",
"return",
"COND_NO",
";",
"dst",
"=",
"XEXP",
"(",
"pat",
",",
"0",
")",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"dst",
")",
"!=",
"REG",
"&&",
"GET_CODE",
"(",
"dst",
")",
"!=",
"SUBREG",
")",
"||",
"GET_MODE",
"(",
"dst",
")",
"!=",
"SImode",
")",
"return",
"COND_NO",
";",
"src",
"=",
"XEXP",
"(",
"pat",
",",
"1",
")",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"REG",
"||",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"SUBREG",
"&&",
"GET_CODE",
"(",
"SUBREG_REG",
"(",
"src",
")",
")",
"==",
"REG",
")",
")",
"&&",
"GET_MODE",
"(",
"src",
")",
"==",
"SImode",
")",
"return",
"COND_MOV_INSN",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"src",
")",
"==",
"0",
")",
"return",
"COND_CLR_INSN",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"PLUS",
"&&",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
"==",
"REG",
"||",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
"==",
"SUBREG",
"&&",
"GET_CODE",
"(",
"SUBREG_REG",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
")",
"==",
"REG",
")",
")",
"&&",
"GET_MODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
"==",
"SImode",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"src",
",",
"1",
")",
")",
"==",
"1",
")",
"return",
"COND_INC_INSN",
";",
"else",
"if",
"(",
"(",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"MINUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"src",
",",
"1",
")",
")",
"==",
"1",
")",
"||",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"src",
",",
"1",
")",
")",
"==",
"-",
"1",
")",
")",
"&&",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
"==",
"REG",
"||",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
"==",
"SUBREG",
"&&",
"GET_CODE",
"(",
"SUBREG_REG",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
")",
"==",
"REG",
")",
")",
"&&",
"GET_MODE",
"(",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
"==",
"SImode",
")",
"return",
"COND_DEC_INSN",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"JUMP_INSN",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"SET",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"1",
")",
")",
"==",
"LABEL_REF",
")",
"return",
"COND_BRANCH_INSN",
";",
"return",
"COND_NO",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"insn",
"is",
"a",
"candidate",
"for",
"a",
"conditional",
"."
] | [
"mcore",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"1",
"0",
"0",
"0",
"0",
"1"
] | mcore3 | is_cond_candidate | mcore | MPU | GCC | 20,223 | 414 | 1 | [] |
[
"<s>",
"bool",
"R600InstrInfo",
"::",
"SubsumesPredicate",
"(",
"const",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Pred1",
",",
"const",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Pred2",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"first",
"specified",
"predicate",
"subsumes",
"the",
"second",
",",
"e.g",
"."
] | [
"R600"
] | R600InstrInfo | SubsumesPredicate | R600 | GPU | LLVM | 20,224 | 27 | 1 | [] |
[
"<s>",
"Function",
"*",
"AMDGPULibFunc",
"::",
"getOrInsertFunction",
"(",
"Module",
"*",
"M",
",",
"const",
"AMDGPULibFunc",
"&",
"fInfo",
")",
"{",
"std",
"::",
"string",
"const",
"FuncName",
"=",
"fInfo",
".",
"mangle",
"(",
")",
";",
"Function",
"*",
"F",
"=",
"dyn_cast_or_null",
"<",
"Function",
">",
"(",
"M",
"->",
"getValueSymbolTable",
"(",
")",
".",
"lookup",
"(",
"FuncName",
")",
")",
";",
"if",
"(",
"F",
"&&",
"!",
"F",
"->",
"isDeclaration",
"(",
")",
"&&",
"!",
"F",
"->",
"isVarArg",
"(",
")",
"&&",
"F",
"->",
"arg_size",
"(",
")",
"==",
"fInfo",
".",
"getNumArgs",
"(",
")",
")",
"{",
"return",
"F",
";",
"}",
"FunctionType",
"*",
"FuncTy",
"=",
"fInfo",
".",
"getFunctionType",
"(",
"*",
"M",
")",
";",
"bool",
"hasPtr",
"=",
"false",
";",
"for",
"(",
"FunctionType",
"::",
"param_iterator",
"PI",
"=",
"FuncTy",
"->",
"param_begin",
"(",
")",
",",
"PE",
"=",
"FuncTy",
"->",
"param_end",
"(",
")",
";",
"PI",
"!=",
"PE",
";",
"++",
"PI",
")",
"{",
"const",
"Type",
"*",
"argTy",
"=",
"static_cast",
"<",
"const",
"Type",
"*",
">",
"(",
"*",
"PI",
")",
";",
"if",
"(",
"argTy",
"->",
"isPointerTy",
"(",
")",
")",
"{",
"hasPtr",
"=",
"true",
";",
"break",
";",
"}",
"}",
"Constant",
"*",
"C",
"=",
"nullptr",
";",
"if",
"(",
"hasPtr",
")",
"{",
"C",
"=",
"M",
"->",
"getOrInsertFunction",
"(",
"FuncName",
",",
"FuncTy",
")",
";",
"}",
"else",
"{",
"AttributeList",
"Attr",
";",
"LLVMContext",
"&",
"Ctx",
"=",
"M",
"->",
"getContext",
"(",
")",
";",
"Attr",
"=",
"Attr",
".",
"addAttribute",
"(",
"Ctx",
",",
"AttributeList",
"::",
"FunctionIndex",
",",
"Attribute",
"::",
"ReadOnly",
")",
";",
"Attr",
"=",
"Attr",
".",
"addAttribute",
"(",
"Ctx",
",",
"AttributeList",
"::",
"FunctionIndex",
",",
"Attribute",
"::",
"NoUnwind",
")",
";",
"C",
"=",
"M",
"->",
"getOrInsertFunction",
"(",
"FuncName",
",",
"FuncTy",
",",
"Attr",
")",
";",
"}",
"return",
"cast",
"<",
"Function",
">",
"(",
"C",
")",
";",
"}",
"</s>"
] | [
"Look",
"up",
"the",
"specified",
"function",
"in",
"the",
"module",
"symbol",
"table",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPULibFunc1 | getOrInsertFunction | AMDGPU | GPU | LLVM | 20,225 | 259 | 1 | [] |
[
"<s>",
"SparcTargetMachine",
"::",
"SparcTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"is64bit",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"TLOF",
"(",
"make_unique",
"<",
"SparcELFTargetObjectFile",
">",
"(",
")",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"*",
"this",
",",
"is64bit",
")",
"{",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"Sparc"
] | SparcTargetMachine46 | SparcTargetMachine | Sparc | CPU | LLVM | 20,226 | 90 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"isToken",
"(",
")",
"const",
"LLVM_OVERRIDE",
"{",
"return",
"Kind",
"==",
"KindToken",
";",
"}",
"</s>"
] | [
"isToken",
"-",
"Is",
"this",
"a",
"token",
"operand",
"?"
] | [
"Videocore"
] | VideocoreAsmParser | isToken | Videocore | DSP | LLVM | 20,227 | 14 | 1 | [] |
[
"<s>",
"NodeId",
"getNext",
"(",
")",
"const",
"{",
"return",
"Next",
";",
"}",
"</s>"
] | [
"Get",
"the",
"next",
"SDUse",
"in",
"the",
"use",
"list",
"."
] | [
"Hexagon"
] | RDFGraph | getNext | Hexagon | DSP | LLVM | 20,228 | 10 | 1 | [] |
[
"<s>",
"void",
"ix86_expand_round_sse4",
"(",
"rtx",
"op0",
",",
"rtx",
"op1",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"op0",
")",
";",
"rtx",
"e1",
",",
"e2",
",",
"res",
",",
"half",
";",
"const",
"struct",
"real_format",
"*",
"fmt",
";",
"REAL_VALUE_TYPE",
"pred_half",
",",
"half_minus_pred_half",
";",
"rtx",
"(",
"*",
"gen_copysign",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"rtx",
"(",
"*",
"gen_round",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_SFmode",
":",
"gen_copysign",
"=",
"gen_copysignsf3",
";",
"gen_round",
"=",
"gen_sse4_1_roundsf2",
";",
"break",
";",
"case",
"E_DFmode",
":",
"gen_copysign",
"=",
"gen_copysigndf3",
";",
"gen_round",
"=",
"gen_sse4_1_rounddf2",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"fmt",
"=",
"REAL_MODE_FORMAT",
"(",
"mode",
")",
";",
"real_2expN",
"(",
"&",
"half_minus_pred_half",
",",
"-",
"(",
"fmt",
"->",
"p",
")",
"-",
"1",
",",
"mode",
")",
";",
"real_arithmetic",
"(",
"&",
"pred_half",
",",
"MINUS_EXPR",
",",
"&",
"dconsthalf",
",",
"&",
"half_minus_pred_half",
")",
";",
"half",
"=",
"const_double_from_real_value",
"(",
"pred_half",
",",
"mode",
")",
";",
"e1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_insn",
"(",
"gen_copysign",
"(",
"e1",
",",
"half",
",",
"op1",
")",
")",
";",
"e2",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"PLUS",
",",
"op1",
",",
"e1",
",",
"NULL_RTX",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"res",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_insn",
"(",
"gen_round",
"(",
"res",
",",
"e2",
",",
"GEN_INT",
"(",
"ROUND_TRUNC",
")",
")",
")",
";",
"emit_move_insn",
"(",
"op0",
",",
"res",
")",
";",
"}",
"</s>"
] | [
"Expand",
"SSE",
"sequence",
"for",
"computing",
"round",
"from",
"OP1",
"storing",
"into",
"OP0",
"using",
"sse4",
"round",
"insn",
"."
] | [
"i386",
"1",
"0"
] | i386-expand | ix86_expand_round_sse4 | i386 | CPU | GCC | 20,229 | 217 | 1 | [] |
[
"<s>",
"void",
"AMDGPUPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"disablePass",
"(",
"&",
"StackMapLivenessID",
")",
";",
"disablePass",
"(",
"&",
"FuncletLayoutID",
")",
";",
"disablePass",
"(",
"&",
"PatchableFunctionID",
")",
";",
"addPass",
"(",
"createAMDGPULowerIntrinsicsPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUAlwaysInlinePass",
"(",
")",
")",
";",
"addPass",
"(",
"createAlwaysInlinerLegacyPass",
"(",
")",
")",
";",
"addPass",
"(",
"createBarrierNoopPass",
"(",
")",
")",
";",
"const",
"AMDGPUTargetMachine",
"&",
"TM",
"=",
"getAMDGPUTargetMachine",
"(",
")",
";",
"if",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"amdgcn",
")",
"{",
"addPass",
"(",
"createAMDGPUCodeGenPreparePass",
"(",
"static_cast",
"<",
"const",
"GCNTargetMachine",
"*",
">",
"(",
"&",
"TM",
")",
")",
")",
";",
"}",
"addPass",
"(",
"createAMDGPUOpenCLImageTypeLoweringPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
".",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"createInferAddressSpacesPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUPromoteAlloca",
"(",
"&",
"TM",
")",
")",
";",
"if",
"(",
"EnableSROA",
")",
"addPass",
"(",
"createSROAPass",
"(",
")",
")",
";",
"addStraightLineScalarOptimizationPasses",
"(",
")",
";",
"if",
"(",
"EnableAMDGPUAliasAnalysis",
")",
"{",
"addPass",
"(",
"createAMDGPUAAWrapperPass",
"(",
")",
")",
";",
"addPass",
"(",
"createExternalAAWrapperPass",
"(",
"[",
"]",
"(",
"Pass",
"&",
"P",
",",
"Function",
"&",
",",
"AAResults",
"&",
"AAR",
")",
"{",
"if",
"(",
"auto",
"*",
"WrapperPass",
"=",
"P",
".",
"getAnalysisIfAvailable",
"<",
"AMDGPUAAWrapperPass",
">",
"(",
")",
")",
"AAR",
".",
"addAAResult",
"(",
"WrapperPass",
"->",
"getResult",
"(",
")",
")",
";",
"}",
")",
")",
";",
"}",
"}",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addEarlyCSEOrGVNPass",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPUTargetMachine85 | addIRPasses | AMDGPU | GPU | LLVM | 20,230 | 232 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"{",
"assert",
"(",
"Kind",
"==",
"Register",
"&&",
"\"Invalid access!\"",
")",
";",
"return",
"Reg",
".",
"RegNum",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"ARM",
"\"Invalid access!\""
] | ARMAsmParser13 | getReg | ARM | CPU | LLVM | 20,231 | 21 | 1 | [] |
[
"<s>",
"static",
"int",
"tilepro_sched_adjust_cost",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"link",
",",
"rtx_insn",
"*",
"dep_insn",
",",
"int",
"cost",
")",
"{",
"if",
"(",
"CALL_P",
"(",
"insn",
")",
"&&",
"REG_NOTE_KIND",
"(",
"link",
")",
"==",
"REG_DEP_TRUE",
")",
"{",
"rtx",
"target",
"=",
"get_jump_target",
"(",
"insn",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"target",
")",
"||",
"!",
"set_of",
"(",
"target",
",",
"dep_insn",
")",
")",
"return",
"0",
";",
"}",
"return",
"cost",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_SCHED_ADJUST_COST",
"."
] | [
"tilepro",
"0"
] | tilepro2 | tilepro_sched_adjust_cost | tilepro | VLIW | GCC | 20,232 | 66 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"ARM MVE VPT Optimisation Pass\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM",
"\"ARM MVE VPT Optimisation Pass\""
] | MVEVPTOptimisationsPass | getPassName | ARM | CPU | LLVM | 20,233 | 11 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isZExtFree",
"(",
"SDValue",
"Val",
",",
"EVT",
"VT2",
")",
"const",
"{",
"if",
"(",
"auto",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"Val",
")",
")",
"{",
"EVT",
"MemVT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"if",
"(",
"(",
"MemVT",
"==",
"MVT",
"::",
"i8",
"||",
"MemVT",
"==",
"MVT",
"::",
"i16",
"||",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"MemVT",
"==",
"MVT",
"::",
"i32",
")",
")",
"&&",
"(",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"NON_EXTLOAD",
"||",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"ZEXTLOAD",
")",
")",
"return",
"true",
";",
"}",
"return",
"TargetLowering",
"::",
"isZExtFree",
"(",
"Val",
",",
"VT2",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"zero-extending",
"the",
"specific",
"node",
"Val",
"to",
"type",
"VT2",
"is",
"free",
"(",
"either",
"because",
"it",
"'s",
"implicitly",
"zero-extended",
"such",
"as",
"ARM",
"ldrb",
"/",
"ldrh",
"or",
"because",
"it",
"'s",
"folded",
"such",
"as",
"X86",
"zero-extending",
"loads",
")",
"."
] | [
"RISCV",
"RISCV",
"MVT::i8",
"MVT::i16",
"MVT::i32",
"ISD::NON_EXTLOAD",
"ISD::ZEXTLOAD"
] | RISCVISelLowering | isZExtFree | RISCV | CPU | LLVM | 20,234 | 104 | 1 | [] |
[
"<s>",
"bool",
"ix86_expand_int_addcc",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"rtx",
"flags",
";",
"rtx",
"(",
"*",
"insn",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"rtx",
"compare_op",
";",
"rtx",
"val",
"=",
"const0_rtx",
";",
"bool",
"fpcmp",
"=",
"false",
";",
"machine_mode",
"mode",
";",
"rtx",
"op0",
"=",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"1",
")",
";",
"if",
"(",
"operands",
"[",
"3",
"]",
"!=",
"const1_rtx",
"&&",
"operands",
"[",
"3",
"]",
"!=",
"constm1_rtx",
")",
"return",
"false",
";",
"if",
"(",
"!",
"ix86_expand_carry_flag_compare",
"(",
"code",
",",
"op0",
",",
"op1",
",",
"&",
"compare_op",
")",
")",
"return",
"false",
";",
"code",
"=",
"GET_CODE",
"(",
"compare_op",
")",
";",
"flags",
"=",
"XEXP",
"(",
"compare_op",
",",
"0",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"flags",
")",
"==",
"CCFPmode",
"||",
"GET_MODE",
"(",
"flags",
")",
"==",
"CCFPUmode",
")",
"{",
"fpcmp",
"=",
"true",
";",
"code",
"=",
"ix86_fp_compare_code_to_integer",
"(",
"code",
")",
";",
"}",
"if",
"(",
"code",
"!=",
"LTU",
")",
"{",
"val",
"=",
"constm1_rtx",
";",
"if",
"(",
"fpcmp",
")",
"PUT_CODE",
"(",
"compare_op",
",",
"reverse_condition_maybe_unordered",
"(",
"GET_CODE",
"(",
"compare_op",
")",
")",
")",
";",
"else",
"PUT_CODE",
"(",
"compare_op",
",",
"reverse_condition",
"(",
"GET_CODE",
"(",
"compare_op",
")",
")",
")",
";",
"}",
"mode",
"=",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"if",
"(",
"(",
"code",
"==",
"LTU",
")",
"==",
"(",
"operands",
"[",
"3",
"]",
"==",
"constm1_rtx",
")",
")",
"{",
"switch",
"(",
"mode",
")",
"{",
"case",
"QImode",
":",
"insn",
"=",
"gen_subqi3_carry",
";",
"break",
";",
"case",
"HImode",
":",
"insn",
"=",
"gen_subhi3_carry",
";",
"break",
";",
"case",
"SImode",
":",
"insn",
"=",
"gen_subsi3_carry",
";",
"break",
";",
"case",
"DImode",
":",
"insn",
"=",
"gen_subdi3_carry",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"else",
"{",
"switch",
"(",
"mode",
")",
"{",
"case",
"QImode",
":",
"insn",
"=",
"gen_addqi3_carry",
";",
"break",
";",
"case",
"HImode",
":",
"insn",
"=",
"gen_addhi3_carry",
";",
"break",
";",
"case",
"SImode",
":",
"insn",
"=",
"gen_addsi3_carry",
";",
"break",
";",
"case",
"DImode",
":",
"insn",
"=",
"gen_adddi3_carry",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"emit_insn",
"(",
"insn",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"2",
"]",
",",
"val",
",",
"flags",
",",
"compare_op",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Expand",
"conditional",
"increment",
"or",
"decrement",
"using",
"adb/sbb",
"instructions",
".",
"The",
"default",
"case",
"using",
"setcc",
"followed",
"by",
"the",
"conditional",
"move",
"can",
"be",
"done",
"by",
"generic",
"code",
"."
] | [
"i386",
"1",
"1",
"0",
"1",
"1",
"3",
"3",
"0",
"0",
"3",
"0",
"2"
] | i3864 | ix86_expand_int_addcc | i386 | CPU | GCC | 20,235 | 362 | 1 | [] |
[
"<s>",
"void",
"AVRTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"Base",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"ProgmemDataSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"\".progmem.data\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"Progmem1DataSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"\".progmem1.data\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"Progmem2DataSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"\".progmem2.data\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"Progmem3DataSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"\".progmem3.data\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"Progmem4DataSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"\".progmem4.data\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"Progmem5DataSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"\".progmem5.data\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"AVR",
"AVR",
"\".progmem.data\"",
"\".progmem1.data\"",
"\".progmem2.data\"",
"\".progmem3.data\"",
"\".progmem4.data\"",
"\".progmem5.data\""
] | AVRTargetObjectFile4 | Initialize | AVR | MPU | LLVM | 20,236 | 127 | 1 | [] |
[
"<s>",
"static",
"void",
"handle_attr_preserve",
"(",
"function",
"*",
"fn",
")",
"{",
"basic_block",
"bb",
";",
"rtx_insn",
"*",
"insn",
";",
"rtx_code_label",
"*",
"label",
";",
"FOR_EACH_BB_FN",
"(",
"bb",
",",
"fn",
")",
"{",
"FOR_BB_INSNS",
"(",
"bb",
",",
"insn",
")",
"{",
"if",
"(",
"!",
"NONJUMP_INSN_P",
"(",
"insn",
")",
")",
"continue",
";",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"!=",
"SET",
")",
"continue",
";",
"start_sequence",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"2",
";",
"i",
"++",
")",
"{",
"rtx",
"mem",
"=",
"XEXP",
"(",
"pat",
",",
"i",
")",
";",
"if",
"(",
"MEM_P",
"(",
"mem",
")",
")",
"{",
"tree",
"expr",
"=",
"MEM_EXPR",
"(",
"mem",
")",
";",
"if",
"(",
"!",
"expr",
")",
"continue",
";",
"if",
"(",
"TREE_CODE",
"(",
"expr",
")",
"==",
"MEM_REF",
"&&",
"TREE_CODE",
"(",
"TREE_OPERAND",
"(",
"expr",
",",
"0",
")",
")",
"==",
"SSA_NAME",
")",
"{",
"gimple",
"*",
"def_stmt",
"=",
"SSA_NAME_DEF_STMT",
"(",
"TREE_OPERAND",
"(",
"expr",
",",
"0",
")",
")",
";",
"if",
"(",
"def_stmt",
"&&",
"is_gimple_assign",
"(",
"def_stmt",
")",
")",
"expr",
"=",
"gimple_assign_rhs1",
"(",
"def_stmt",
")",
";",
"}",
"if",
"(",
"is_attr_preserve_access",
"(",
"expr",
")",
")",
"{",
"auto_vec",
"<",
"unsigned",
"int",
",",
"16",
">",
"accessors",
";",
"tree",
"container",
"=",
"bpf_core_compute",
"(",
"expr",
",",
"&",
"accessors",
")",
";",
"if",
"(",
"accessors",
".",
"length",
"(",
")",
"<",
"1",
")",
"continue",
";",
"accessors",
".",
"reverse",
"(",
")",
";",
"container",
"=",
"TREE_TYPE",
"(",
"container",
")",
";",
"const",
"char",
"*",
"section_name",
";",
"if",
"(",
"DECL_SECTION_NAME",
"(",
"fn",
"->",
"decl",
")",
")",
"section_name",
"=",
"DECL_SECTION_NAME",
"(",
"fn",
"->",
"decl",
")",
";",
"else",
"section_name",
"=",
"\".text\"",
";",
"label",
"=",
"gen_label_rtx",
"(",
")",
";",
"LABEL_PRESERVE_P",
"(",
"label",
")",
"=",
"1",
";",
"emit_label",
"(",
"label",
")",
";",
"bpf_core_reloc_add",
"(",
"container",
",",
"section_name",
",",
"&",
"accessors",
",",
"label",
")",
";",
"}",
"}",
"}",
"rtx_insn",
"*",
"seq",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"emit_insn_before",
"(",
"seq",
",",
"insn",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"The",
"body",
"of",
"pass_bpf_core_attr",
".",
"Scan",
"RTL",
"for",
"accesses",
"to",
"structs/unions",
"marked",
"with",
"__attribute__",
"(",
"(",
"preserve_access_index",
")",
")",
"and",
"generate",
"a",
"CO-RE",
"relocation",
"for",
"any",
"such",
"access",
"."
] | [
"bpf",
"0",
"2",
"0",
"0",
"16",
"1",
"\".text\"",
"1"
] | bpf | handle_attr_preserve | bpf | Virtual ISA | GCC | 20,237 | 304 | 1 | [] |
[
"<s>",
"enum",
"machine_mode",
"select_cc_mode",
"(",
"enum",
"rtx_code",
"op",
",",
"rtx",
"x",
",",
"rtx",
"y",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"x",
")",
")",
"==",
"MODE_FLOAT",
")",
"{",
"switch",
"(",
"op",
")",
"{",
"case",
"EQ",
":",
"case",
"NE",
":",
"case",
"UNORDERED",
":",
"case",
"ORDERED",
":",
"case",
"UNLT",
":",
"case",
"UNLE",
":",
"case",
"UNGT",
":",
"case",
"UNGE",
":",
"case",
"UNEQ",
":",
"case",
"LTGT",
":",
"return",
"CCFPmode",
";",
"case",
"LT",
":",
"case",
"LE",
":",
"case",
"GT",
":",
"case",
"GE",
":",
"return",
"CCFPEmode",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"MINUS",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"NEG",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"ASHIFT",
")",
"{",
"if",
"(",
"TARGET_ARCH64",
"&&",
"GET_MODE",
"(",
"x",
")",
"==",
"DImode",
")",
"return",
"CCX_NOOVmode",
";",
"else",
"return",
"CC_NOOVmode",
";",
"}",
"else",
"{",
"if",
"(",
"TARGET_ARCH64",
"&&",
"GET_MODE",
"(",
"x",
")",
"==",
"DImode",
")",
"return",
"CCXmode",
";",
"else",
"return",
"CCmode",
";",
"}",
"}",
"</s>"
] | [
"Given",
"a",
"comparison",
"code",
"(",
"EQ",
",",
"NE",
",",
"etc",
".",
")",
"and",
"the",
"first",
"operand",
"of",
"a",
"COMPARE",
",",
"return",
"the",
"mode",
"to",
"be",
"used",
"for",
"the",
"comparison",
".",
"For",
"floating-point",
",",
"CCFP",
"[",
"E",
"]",
"mode",
"is",
"used",
".",
"CC_NOOVmode",
"should",
"be",
"used",
"when",
"the",
"first",
"operand",
"is",
"a",
"PLUS",
",",
"MINUS",
",",
"NEG",
",",
"or",
"ASHIFT",
".",
"CCmode",
"should",
"be",
"used",
"when",
"no",
"special",
"processing",
"is",
"needed",
"."
] | [
"sparc"
] | sparc3 | select_cc_mode | sparc | CPU | GCC | 20,238 | 163 | 1 | [] |
[
"<s>",
"void",
"relaxInstruction",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"override",
"{",
"llvm_unreachable",
"(",
"\"relaxInstruction() unimplemented\"",
")",
";",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"VE",
"\"relaxInstruction() unimplemented\""
] | VEAsmBackend1 | relaxInstruction | VE | CPU | LLVM | 20,239 | 21 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"assert",
"(",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getObjectSize",
"(",
"FrameIdx",
")",
">=",
"RC",
"->",
"getSize",
"(",
")",
"&&",
"\"Stack slot too small for store\"",
")",
";",
"bool",
"isAligned",
"=",
"(",
"RI",
".",
"getStackAlignment",
"(",
")",
">=",
"16",
")",
"||",
"RI",
".",
"canRealignStack",
"(",
"MF",
")",
";",
"unsigned",
"Opc",
"=",
"getStoreRegOpcode",
"(",
"SrcReg",
",",
"RC",
",",
"isAligned",
",",
"TM",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
",",
"FrameIdx",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"X86",
"X86",
"\"Stack slot too small for store\"",
"16"
] | X86InstrInfo12 | storeRegToStackSlot | X86 | CPU | LLVM | 20,240 | 143 | 1 | [] |
[
"<s>",
"virtual",
"const",
"ARMBaseInstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"getInstrInfo not implemented\"",
")",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"ARM",
"ARM",
"\"getInstrInfo not implemented\""
] | ARMTargetMachine51 | getInstrInfo | ARM | CPU | LLVM | 20,241 | 15 | 1 | [] |
[
"<s>",
"void",
"SystemZPostRASchedStrategy",
"::",
"schedNode",
"(",
"SUnit",
"*",
"SU",
",",
"bool",
"IsTopNode",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"+++ Scheduling SU(\"",
"<<",
"SU",
"->",
"NodeNum",
"<<",
"\")\\n\"",
";",
")",
";",
"Available",
".",
"erase",
"(",
"SU",
")",
";",
"HazardRec",
"->",
"EmitInstruction",
"(",
"SU",
")",
";",
"}",
"</s>"
] | [
"ScheduleDAGMI",
"has",
"scheduled",
"an",
"instruction",
"-",
"tell",
"HazardRec",
"about",
"it",
"."
] | [
"SystemZ",
"SystemZ",
"\"+++ Scheduling SU(\"",
"\")\\n\""
] | SystemZMachineScheduler14 | schedNode | SystemZ | CPU | LLVM | 20,242 | 44 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUTargetLowering",
"::",
"isFNegFree",
"(",
"EVT",
"VT",
")",
"const",
"{",
"assert",
"(",
"VT",
".",
"isFloatingPoint",
"(",
")",
")",
";",
"VT",
"=",
"VT",
".",
"getScalarType",
"(",
")",
";",
"return",
"VT",
"==",
"MVT",
"::",
"f32",
"||",
"VT",
"==",
"MVT",
"::",
"f64",
"||",
"VT",
"==",
"MVT",
"::",
"f16",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"an",
"fneg",
"operation",
"is",
"free",
"to",
"the",
"point",
"where",
"it",
"is",
"never",
"worthwhile",
"to",
"replace",
"it",
"with",
"a",
"bitwise",
"operation",
"."
] | [
"AMDGPU",
"AMDGPU",
"MVT::f32",
"MVT::f64",
"MVT::f16"
] | AMDGPUISelLowering (2)1 | isFNegFree | AMDGPU | GPU | LLVM | 20,243 | 47 | 1 | [] |
[
"<s>",
"MCObjectWriter",
"*",
"BPFAsmBackend",
"::",
"createObjectWriter",
"(",
"raw_pwrite_stream",
"&",
"OS",
")",
"const",
"{",
"return",
"createBPFELFObjectWriter",
"(",
"OS",
",",
"0",
",",
"IsLittleEndian",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"BPF",
"BPF",
"BPF",
"0"
] | BPFAsmBackend | createObjectWriter | BPF | Virtual ISA | LLVM | 20,244 | 23 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"NVPTXTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"const",
"std",
"::",
"string",
"&",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'b'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"NVPTX",
"::",
"Int1RegsRegClass",
")",
";",
"case",
"'c'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"NVPTX",
"::",
"Int16RegsRegClass",
")",
";",
"case",
"'h'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"NVPTX",
"::",
"Int16RegsRegClass",
")",
";",
"case",
"'r'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"NVPTX",
"::",
"Int32RegsRegClass",
")",
";",
"case",
"'l'",
":",
"case",
"'N'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"NVPTX",
"::",
"Int64RegsRegClass",
")",
";",
"case",
"'f'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"NVPTX",
"::",
"Float32RegsRegClass",
")",
";",
"case",
"'d'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"NVPTX",
"::",
"Float64RegsRegClass",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"NVPTX",
"NVPTX",
"1",
"0",
"0U",
"NVPTX::Int1RegsRegClass",
"0U",
"NVPTX::Int16RegsRegClass",
"0U",
"NVPTX::Int16RegsRegClass",
"0U",
"NVPTX::Int32RegsRegClass",
"0U",
"NVPTX::Int64RegsRegClass",
"0U",
"NVPTX::Float32RegsRegClass",
"0U",
"NVPTX::Float64RegsRegClass"
] | NVPTXISelLowering53 | getRegForInlineAsmConstraint | NVPTX | GPU | LLVM | 20,245 | 180 | 1 | [] |
[
"<s>",
"void",
"SPUTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"(",
"unsigned",
")",
"N",
"->",
"getOpcode",
"(",
")",
";",
"EVT",
"OpVT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"{",
"errs",
"(",
")",
"<<",
"\"SPUTargetLowering::ReplaceNodeResults(): need to fix this!\\n\"",
";",
"errs",
"(",
")",
"<<",
"\"Op.getOpcode() = \"",
"<<",
"Opc",
"<<",
"\"\\n\"",
";",
"errs",
"(",
")",
"<<",
"\"*Op.getNode():\\n\"",
";",
"N",
"->",
"dump",
"(",
")",
";",
"abort",
"(",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"CellSPU",
"SPU",
"0",
"\"SPUTargetLowering::ReplaceNodeResults(): need to fix this!\\n\"",
"\"Op.getOpcode() = \"",
"\"\\n\"",
"\"*Op.getNode():\\n\""
] | SPUISelLowering11 | ReplaceNodeResults | CellSPU | MPU | LLVM | 20,246 | 87 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"ARMBaseInstrInfo",
"::",
"commuteInstructionImpl",
"(",
"MachineInstr",
"&",
"MI",
",",
"bool",
"NewMI",
",",
"unsigned",
"OpIdx1",
",",
"unsigned",
"OpIdx2",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ARM",
"::",
"MOVCCr",
":",
"case",
"ARM",
"::",
"t2MOVCCr",
":",
"{",
"Register",
"PredReg",
";",
"ARMCC",
"::",
"CondCodes",
"CC",
"=",
"getInstrPredicate",
"(",
"MI",
",",
"PredReg",
")",
";",
"if",
"(",
"CC",
"==",
"ARMCC",
"::",
"AL",
"||",
"PredReg",
"!=",
"ARM",
"::",
"CPSR",
")",
"return",
"nullptr",
";",
"MachineInstr",
"*",
"CommutedMI",
"=",
"TargetInstrInfo",
"::",
"commuteInstructionImpl",
"(",
"MI",
",",
"NewMI",
",",
"OpIdx1",
",",
"OpIdx2",
")",
";",
"if",
"(",
"!",
"CommutedMI",
")",
"return",
"nullptr",
";",
"CommutedMI",
"->",
"getOperand",
"(",
"CommutedMI",
"->",
"findFirstPredOperandIdx",
"(",
")",
")",
".",
"setImm",
"(",
"ARMCC",
"::",
"getOppositeCondition",
"(",
"CC",
")",
")",
";",
"return",
"CommutedMI",
";",
"}",
"}",
"return",
"TargetInstrInfo",
"::",
"commuteInstructionImpl",
"(",
"MI",
",",
"NewMI",
",",
"OpIdx1",
",",
"OpIdx2",
")",
";",
"}",
"</s>"
] | [
"Commutes",
"the",
"operands",
"in",
"the",
"given",
"instruction",
"by",
"changing",
"the",
"operands",
"order",
"and/or",
"changing",
"the",
"instruction",
"'s",
"opcode",
"and/or",
"the",
"immediate",
"value",
"operand",
"."
] | [
"ARM",
"ARM",
"ARM::MOVCCr",
"ARM::t2MOVCCr",
"ARMCC::CondCodes",
"ARMCC::AL",
"ARM::CPSR",
"ARMCC::getOppositeCondition"
] | ARMBaseInstrInfo110 | commuteInstructionImpl | ARM | CPU | LLVM | 20,247 | 139 | 1 | [] |
[
"<s>",
"bool",
"ARCompactTargetMachine",
"::",
"addInstSelector",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"PM",
".",
"add",
"(",
"createARCompactISelDag",
"(",
"*",
"this",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"ARCompact",
"ARC",
"ARC"
] | ARCompactTargetMachine | addInstSelector | ARCompact | MPU | LLVM | 20,248 | 30 | 1 | [] |
[
"<s>",
"void",
"arm_option_reconfigure_globals",
"(",
"void",
")",
"{",
"sprintf",
"(",
"arm_arch_name",
",",
"\"__ARM_ARCH_%s__\"",
",",
"arm_active_target",
".",
"arch_pp_name",
")",
";",
"arm_base_arch",
"=",
"arm_active_target",
".",
"base_arch",
";",
"arm_arch4",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv4",
")",
";",
"arm_arch4t",
"=",
"arm_arch4",
"&&",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_thumb",
")",
";",
"arm_arch5t",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv5t",
")",
";",
"arm_arch5te",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv5te",
")",
";",
"arm_arch6",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv6",
")",
";",
"arm_arch6k",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv6k",
")",
";",
"arm_arch_notm",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_notm",
")",
";",
"arm_arch6m",
"=",
"arm_arch6",
"&&",
"!",
"arm_arch_notm",
";",
"arm_arch7",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv7",
")",
";",
"arm_arch7em",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv7em",
")",
";",
"arm_arch8",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv8",
")",
";",
"arm_arch8_1",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv8_1",
")",
";",
"arm_arch8_2",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv8_2",
")",
";",
"arm_arch8_3",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv8_3",
")",
";",
"arm_arch8_4",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv8_4",
")",
";",
"arm_arch8_1m_main",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_armv8_1m_main",
")",
";",
"arm_arch_thumb1",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_thumb",
")",
";",
"arm_arch_thumb2",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_thumb2",
")",
";",
"arm_arch_xscale",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_xscale",
")",
";",
"arm_arch_iwmmxt",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_iwmmxt",
")",
";",
"arm_arch_iwmmxt2",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_iwmmxt2",
")",
";",
"arm_arch_thumb_hwdiv",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_tdiv",
")",
";",
"arm_arch_arm_hwdiv",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_adiv",
")",
";",
"arm_arch_crc",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_crc32",
")",
";",
"arm_arch_cmse",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_cmse",
")",
";",
"arm_arch_lpae",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_lpae",
")",
";",
"arm_arch_i8mm",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_i8mm",
")",
";",
"arm_arch_bf16",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_bf16",
")",
";",
"arm_fp16_inst",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_fp16",
")",
";",
"if",
"(",
"arm_fp16_inst",
")",
"{",
"if",
"(",
"arm_fp16_format",
"==",
"ARM_FP16_FORMAT_ALTERNATIVE",
")",
"error",
"(",
"\"selected fp16 options are incompatible\"",
")",
";",
"arm_fp16_format",
"=",
"ARM_FP16_FORMAT_IEEE",
";",
"}",
"arm_arch_cde",
"=",
"0",
";",
"arm_arch_cde_coproc",
"=",
"0",
";",
"int",
"cde_bits",
"[",
"]",
"=",
"{",
"isa_bit_cdecp0",
",",
"isa_bit_cdecp1",
",",
"isa_bit_cdecp2",
",",
"isa_bit_cdecp3",
",",
"isa_bit_cdecp4",
",",
"isa_bit_cdecp5",
",",
"isa_bit_cdecp6",
",",
"isa_bit_cdecp7",
"}",
";",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"e",
"=",
"ARRAY_SIZE",
"(",
"cde_bits",
")",
";",
"i",
"<",
"e",
";",
"i",
"++",
")",
"{",
"int",
"cde_bit",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"cde_bits",
"[",
"i",
"]",
")",
";",
"if",
"(",
"cde_bit",
")",
"{",
"arm_arch_cde",
"|=",
"cde_bit",
";",
"arm_arch_cde_coproc",
"|=",
"arm_arch_cde_coproc_bits",
"[",
"i",
"]",
";",
"}",
"}",
"arm_arch_no_volatile_ce",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_quirk_no_volatile_ce",
")",
";",
"arm_arch6kz",
"=",
"arm_arch6k",
"&&",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_quirk_armv6kz",
")",
";",
"if",
"(",
"target_thread_pointer",
"==",
"TP_AUTO",
")",
"{",
"if",
"(",
"arm_arch6k",
"&&",
"!",
"TARGET_THUMB1",
")",
"target_thread_pointer",
"=",
"TP_CP15",
";",
"else",
"target_thread_pointer",
"=",
"TP_SOFT",
";",
"}",
"if",
"(",
"!",
"TARGET_HARD_TP",
"&&",
"arm_stack_protector_guard",
"==",
"SSP_TLSREG",
")",
"error",
"(",
"\"%<-mstack-protector-guard=tls%> needs a hardware TLS register\"",
")",
";",
"}",
"</s>"
] | [
"Reconfigure",
"global",
"status",
"flags",
"from",
"the",
"active_target.isa",
"."
] | [
"arm",
"\"__ARM_ARCH_%s__\"",
"\"selected fp16 options are incompatible\"",
"0",
"0",
"0",
"\"%<-mstack-protector-guard=tls%> needs a hardware TLS register\""
] | arm | arm_option_reconfigure_globals | arm | CPU | GCC | 20,249 | 510 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"SIRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"CallingConv",
"::",
"ID",
"CC",
"=",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getCallingConv",
"(",
")",
";",
"switch",
"(",
"CC",
")",
"{",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"return",
"CSR_AMDGPU_HighRegs_SaveList",
";",
"default",
":",
"{",
"static",
"const",
"MCPhysReg",
"NoCalleeSavedReg",
"=",
"AMDGPU",
"::",
"NoRegister",
";",
"return",
"&",
"NoCalleeSavedReg",
";",
"}",
"}",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU::NoRegister"
] | AMDGPURegisterInfo15 | getCalleeSavedRegs | AMDGPU | GPU | LLVM | 20,250 | 66 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"override",
"{",
"assert",
"(",
"Kind",
"==",
"Register",
"&&",
"\"Invalid type access!\"",
")",
";",
"return",
"Reg",
".",
"RegNum",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"BPF",
"\"Invalid type access!\""
] | BPFAsmParser | getReg | BPF | Virtual ISA | LLVM | 20,251 | 22 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_init_mve_builtins",
"(",
"void",
")",
"{",
"volatile",
"unsigned",
"int",
"i",
",",
"fcode",
"=",
"ARM_BUILTIN_MVE_PATTERN_START",
";",
"arm_init_simd_builtin_scalar_types",
"(",
")",
";",
"arm_init_simd_builtin_types",
"(",
")",
";",
"tree",
"get_fpscr_nzcvqc",
"=",
"build_function_type_list",
"(",
"intSI_type_node",
",",
"NULL",
")",
";",
"tree",
"set_fpscr_nzcvqc",
"=",
"build_function_type_list",
"(",
"void_type_node",
",",
"intSI_type_node",
",",
"NULL",
")",
";",
"arm_builtin_decls",
"[",
"ARM_BUILTIN_GET_FPSCR_NZCVQC",
"]",
"=",
"add_builtin_function",
"(",
"\"__builtin_arm_get_fpscr_nzcvqc\"",
",",
"get_fpscr_nzcvqc",
",",
"ARM_BUILTIN_GET_FPSCR_NZCVQC",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"arm_builtin_decls",
"[",
"ARM_BUILTIN_SET_FPSCR_NZCVQC",
"]",
"=",
"add_builtin_function",
"(",
"\"__builtin_arm_set_fpscr_nzcvqc\"",
",",
"set_fpscr_nzcvqc",
",",
"ARM_BUILTIN_SET_FPSCR_NZCVQC",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"mve_builtin_data",
")",
";",
"i",
"++",
",",
"fcode",
"++",
")",
"{",
"arm_builtin_datum",
"*",
"d",
"=",
"&",
"mve_builtin_data",
"[",
"i",
"]",
";",
"arm_init_builtin",
"(",
"fcode",
",",
"d",
",",
"\"__builtin_mve\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Set",
"up",
"all",
"the",
"MVE",
"builtins",
"mentioned",
"in",
"arm_mve_builtins.def",
"file",
"."
] | [
"arm",
"\"__builtin_arm_get_fpscr_nzcvqc\"",
"\"__builtin_arm_set_fpscr_nzcvqc\"",
"0",
"\"__builtin_mve\""
] | arm-builtins | arm_init_mve_builtins | arm | CPU | GCC | 20,252 | 127 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUCommonSubtarget",
"::",
"makeLIDRangeMetadata",
"(",
"Instruction",
"*",
"I",
")",
"const",
"{",
"Function",
"*",
"Kernel",
"=",
"I",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"unsigned",
"MinSize",
"=",
"0",
";",
"unsigned",
"MaxSize",
"=",
"getFlatWorkGroupSizes",
"(",
"*",
"Kernel",
")",
".",
"second",
";",
"bool",
"IdQuery",
"=",
"false",
";",
"if",
"(",
"auto",
"*",
"CI",
"=",
"dyn_cast",
"<",
"CallInst",
">",
"(",
"I",
")",
")",
"{",
"const",
"Function",
"*",
"F",
"=",
"CI",
"->",
"getCalledFunction",
"(",
")",
";",
"if",
"(",
"F",
")",
"{",
"unsigned",
"Dim",
"=",
"UINT_MAX",
";",
"switch",
"(",
"F",
"->",
"getIntrinsicID",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"amdgcn_workitem_id_x",
":",
"case",
"Intrinsic",
"::",
"r600_read_tidig_x",
":",
"IdQuery",
"=",
"true",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"Intrinsic",
"::",
"r600_read_local_size_x",
":",
"Dim",
"=",
"0",
";",
"break",
";",
"case",
"Intrinsic",
"::",
"amdgcn_workitem_id_y",
":",
"case",
"Intrinsic",
"::",
"r600_read_tidig_y",
":",
"IdQuery",
"=",
"true",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"Intrinsic",
"::",
"r600_read_local_size_y",
":",
"Dim",
"=",
"1",
";",
"break",
";",
"case",
"Intrinsic",
"::",
"amdgcn_workitem_id_z",
":",
"case",
"Intrinsic",
"::",
"r600_read_tidig_z",
":",
"IdQuery",
"=",
"true",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"Intrinsic",
"::",
"r600_read_local_size_z",
":",
"Dim",
"=",
"2",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"if",
"(",
"Dim",
"<=",
"3",
")",
"{",
"if",
"(",
"auto",
"Node",
"=",
"Kernel",
"->",
"getMetadata",
"(",
"\"reqd_work_group_size\"",
")",
")",
"if",
"(",
"Node",
"->",
"getNumOperands",
"(",
")",
"==",
"3",
")",
"MinSize",
"=",
"MaxSize",
"=",
"mdconst",
"::",
"extract",
"<",
"ConstantInt",
">",
"(",
"Node",
"->",
"getOperand",
"(",
"Dim",
")",
")",
"->",
"getZExtValue",
"(",
")",
";",
"}",
"}",
"}",
"if",
"(",
"!",
"MaxSize",
")",
"return",
"false",
";",
"if",
"(",
"IdQuery",
")",
"MinSize",
"=",
"0",
";",
"else",
"++",
"MaxSize",
";",
"MDBuilder",
"MDB",
"(",
"I",
"->",
"getContext",
"(",
")",
")",
";",
"MDNode",
"*",
"MaxWorkGroupSizeRange",
"=",
"MDB",
".",
"createRange",
"(",
"APInt",
"(",
"32",
",",
"MinSize",
")",
",",
"APInt",
"(",
"32",
",",
"MaxSize",
")",
")",
";",
"I",
"->",
"setMetadata",
"(",
"LLVMContext",
"::",
"MD_range",
",",
"MaxWorkGroupSizeRange",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Creates",
"value",
"range",
"metadata",
"on",
"an",
"workitemid",
".",
"*",
"intrinsic",
"call",
"or",
"load",
"."
] | [
"AMDGPU",
"AMDGPU",
"0",
"Intrinsic::amdgcn_workitem_id_x",
"Intrinsic::r600_read_tidig_x",
"Intrinsic::r600_read_local_size_x",
"0",
"Intrinsic::amdgcn_workitem_id_y",
"Intrinsic::r600_read_tidig_y",
"Intrinsic::r600_read_local_size_y",
"1",
"Intrinsic::amdgcn_workitem_id_z",
"Intrinsic::r600_read_tidig_z",
"Intrinsic::r600_read_local_size_z",
"2",
"3",
"\"reqd_work_group_size\"",
"3",
"0",
"32",
"32"
] | AMDGPUSubtarget76 | makeLIDRangeMetadata | AMDGPU | GPU | LLVM | 20,253 | 300 | 1 | [] |
[
"<s>",
"void",
"pdp11_expand_prologue",
"(",
"void",
")",
"{",
"HOST_WIDE_INT",
"fsize",
"=",
"get_frame_size",
"(",
")",
";",
"unsigned",
"regno",
";",
"rtx",
"x",
",",
"via_ac",
"=",
"NULL",
";",
"if",
"(",
"MAIN_NAME_P",
"(",
"DECL_NAME",
"(",
"current_function_decl",
")",
")",
"&&",
"TARGET_FPU",
")",
"{",
"emit_insn",
"(",
"gen_setd",
"(",
")",
")",
";",
"emit_insn",
"(",
"gen_seti",
"(",
")",
")",
";",
"}",
"for",
"(",
"regno",
"=",
"R0_REGNUM",
";",
"regno",
"<=",
"PC_REGNUM",
";",
"regno",
"++",
")",
"if",
"(",
"pdp11_saved_regno",
"(",
"regno",
")",
")",
"{",
"x",
"=",
"gen_rtx_PRE_DEC",
"(",
"Pmode",
",",
"stack_pointer_rtx",
")",
";",
"x",
"=",
"gen_frame_mem",
"(",
"Pmode",
",",
"x",
")",
";",
"emit_move_insn",
"(",
"x",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"regno",
")",
")",
";",
"}",
"for",
"(",
"regno",
"=",
"AC0_REGNUM",
";",
"regno",
"<=",
"AC3_REGNUM",
";",
"regno",
"++",
")",
"if",
"(",
"pdp11_saved_regno",
"(",
"regno",
")",
")",
"{",
"x",
"=",
"gen_rtx_PRE_DEC",
"(",
"Pmode",
",",
"stack_pointer_rtx",
")",
";",
"x",
"=",
"gen_frame_mem",
"(",
"DFmode",
",",
"x",
")",
";",
"via_ac",
"=",
"gen_rtx_REG",
"(",
"DFmode",
",",
"regno",
")",
";",
"emit_move_insn",
"(",
"x",
",",
"via_ac",
")",
";",
"}",
"for",
"(",
"regno",
"=",
"AC4_REGNUM",
";",
"regno",
"<=",
"AC5_REGNUM",
";",
"regno",
"++",
")",
"if",
"(",
"pdp11_saved_regno",
"(",
"regno",
")",
")",
"{",
"gcc_assert",
"(",
"via_ac",
"!=",
"NULL",
")",
";",
"emit_move_insn",
"(",
"via_ac",
",",
"gen_rtx_REG",
"(",
"DFmode",
",",
"regno",
")",
")",
";",
"x",
"=",
"gen_rtx_PRE_DEC",
"(",
"Pmode",
",",
"stack_pointer_rtx",
")",
";",
"x",
"=",
"gen_frame_mem",
"(",
"DFmode",
",",
"x",
")",
";",
"emit_move_insn",
"(",
"x",
",",
"via_ac",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"emit_move_insn",
"(",
"frame_pointer_rtx",
",",
"stack_pointer_rtx",
")",
";",
"if",
"(",
"fsize",
")",
"emit_insn",
"(",
"gen_addhi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"fsize",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"function",
"prologue",
"."
] | [
"pdp11"
] | pdp11 | pdp11_expand_prologue | pdp11 | MPU | GCC | 20,254 | 257 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Hexagon generate predicate operations\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Hexagon",
"\"Hexagon generate predicate operations\""
] | HexagonGenPredicate1 | getPassName | Hexagon | DSP | LLVM | 20,255 | 11 | 1 | [] |
[
"<s>",
"void",
"cris_asm_output_label_ref",
"(",
"FILE",
"*",
"file",
",",
"char",
"*",
"buf",
")",
"{",
"if",
"(",
"flag_pic",
"&&",
"in_code",
">",
"0",
")",
"{",
"assemble_name",
"(",
"file",
",",
"buf",
")",
";",
"if",
"(",
"!",
"current_function_uses_pic_offset_table",
")",
"internal_error",
"(",
"\"emitting PIC operand, but PIC register isn't set up\"",
")",
";",
"}",
"else",
"assemble_name",
"(",
"file",
",",
"buf",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"ASM_OUTPUT_LABEL_REF",
"."
] | [
"cris",
"0",
"\"emitting PIC operand, but PIC register isn't set up\""
] | cris3 | cris_asm_output_label_ref | cris | MPU | GCC | 20,256 | 48 | 1 | [] |
[
"<s>",
"void",
"SITargetLowering",
"::",
"computeKnownBitsForTargetInstr",
"(",
"GISelKnownBits",
"&",
"KB",
",",
"Register",
"R",
",",
"KnownBits",
"&",
"Known",
",",
"const",
"APInt",
"&",
"DemandedElts",
",",
"const",
"MachineRegisterInfo",
"&",
"MRI",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"const",
"MachineInstr",
"*",
"MI",
"=",
"MRI",
".",
"getVRegDef",
"(",
"R",
")",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPU",
"::",
"G_INTRINSIC",
":",
"{",
"switch",
"(",
"MI",
"->",
"getIntrinsicID",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"amdgcn_workitem_id_x",
":",
"knownBitsForWorkitemID",
"(",
"*",
"getSubtarget",
"(",
")",
",",
"KB",
",",
"Known",
",",
"0",
")",
";",
"break",
";",
"case",
"Intrinsic",
"::",
"amdgcn_workitem_id_y",
":",
"knownBitsForWorkitemID",
"(",
"*",
"getSubtarget",
"(",
")",
",",
"KB",
",",
"Known",
",",
"1",
")",
";",
"break",
";",
"case",
"Intrinsic",
"::",
"amdgcn_workitem_id_z",
":",
"knownBitsForWorkitemID",
"(",
"*",
"getSubtarget",
"(",
")",
",",
"KB",
",",
"Known",
",",
"2",
")",
";",
"break",
";",
"case",
"Intrinsic",
"::",
"amdgcn_mbcnt_lo",
":",
"case",
"Intrinsic",
"::",
"amdgcn_mbcnt_hi",
":",
"{",
"unsigned",
"Size",
"=",
"MRI",
".",
"getType",
"(",
"R",
")",
".",
"getSizeInBits",
"(",
")",
";",
"Known",
".",
"Zero",
".",
"setHighBits",
"(",
"Size",
"-",
"getSubtarget",
"(",
")",
"->",
"getWavefrontSizeLog2",
"(",
")",
")",
";",
"break",
";",
"}",
"case",
"Intrinsic",
"::",
"amdgcn_groupstaticsize",
":",
"{",
"Known",
".",
"Zero",
".",
"setHighBits",
"(",
"countLeadingZeros",
"(",
"getSubtarget",
"(",
")",
"->",
"getLocalMemorySize",
"(",
")",
")",
")",
";",
"break",
";",
"}",
"default",
":",
"break",
";",
"}",
"}",
"}",
"}",
"</s>"
] | [
"Determine",
"which",
"of",
"the",
"bits",
"specified",
"in",
"Mask",
"are",
"known",
"to",
"be",
"either",
"zero",
"or",
"one",
"and",
"return",
"them",
"in",
"the",
"KnownZero/KnownOne",
"bitsets",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::G_INTRINSIC",
"Intrinsic::amdgcn_workitem_id_x",
"0",
"Intrinsic::amdgcn_workitem_id_y",
"1",
"Intrinsic::amdgcn_workitem_id_z",
"2",
"Intrinsic::amdgcn_mbcnt_lo",
"Intrinsic::amdgcn_mbcnt_hi",
"Intrinsic::amdgcn_groupstaticsize"
] | SIISelLowering120 | computeKnownBitsForTargetInstr | AMDGPU | GPU | LLVM | 20,257 | 210 | 1 | [] |
[
"<s>",
"static",
"void",
"frv_registers_update_1",
"(",
"rtx",
"x",
",",
"rtx",
"pat",
"ATTRIBUTE_UNUSED",
",",
"void",
"*",
"data",
")",
"{",
"unsigned",
"int",
"regno",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"REG",
")",
"FOR_EACH_REGNO",
"(",
"regno",
",",
"x",
")",
"frv_packet",
".",
"regstate",
"[",
"regno",
"]",
"|=",
"*",
"(",
"regstate_t",
"*",
")",
"data",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"MEM",
")",
"{",
"if",
"(",
"frv_packet",
".",
"num_mems",
"<",
"ARRAY_SIZE",
"(",
"frv_packet",
".",
"mems",
")",
")",
"{",
"frv_packet",
".",
"mems",
"[",
"frv_packet",
".",
"num_mems",
"]",
".",
"mem",
"=",
"x",
";",
"frv_packet",
".",
"mems",
"[",
"frv_packet",
".",
"num_mems",
"]",
".",
"cond",
"=",
"*",
"(",
"regstate_t",
"*",
")",
"data",
";",
"}",
"frv_packet",
".",
"num_mems",
"++",
";",
"}",
"}",
"</s>"
] | [
"A",
"note_stores",
"callback",
".",
"DATA",
"points",
"to",
"the",
"regstate_t",
"condition",
"under",
"which",
"X",
"is",
"modified",
".",
"Update",
"FRV_PACKET",
"accordingly",
"."
] | [
"frv"
] | frv2 | frv_registers_update_1 | frv | VLIW | GCC | 20,258 | 112 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"auto",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"assert",
"(",
"MFI",
".",
"getCalleeSavedInfo",
"(",
")",
".",
"empty",
"(",
")",
"&&",
"\"WebAssembly should not have callee-saved registers\"",
")",
";",
"if",
"(",
"!",
"needsSP",
"(",
"MF",
",",
"MFI",
")",
")",
"return",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"const",
"auto",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"InsertPt",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"const",
"TargetRegisterClass",
"*",
"PtrRC",
"=",
"MRI",
".",
"getTargetRegisterInfo",
"(",
")",
"->",
"getPointerRegClass",
"(",
"MF",
")",
";",
"unsigned",
"Zero",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"PtrRC",
")",
";",
"unsigned",
"SPReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"PtrRC",
")",
";",
"const",
"char",
"*",
"ES",
"=",
"\"__stack_pointer\"",
";",
"auto",
"*",
"SPSymbol",
"=",
"MF",
".",
"createExternalSymbolName",
"(",
"ES",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"CONST_I32",
")",
",",
"Zero",
")",
".",
"addImm",
"(",
"0",
")",
";",
"MachineMemOperand",
"*",
"LoadMMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"(",
"MF",
".",
"getPSVManager",
"(",
")",
".",
"getExternalSymbolCallEntry",
"(",
"ES",
")",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"4",
",",
"4",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"LOAD_I32",
")",
",",
"StackSize",
"?",
"SPReg",
":",
"(",
"unsigned",
")",
"WebAssembly",
"::",
"SP32",
")",
".",
"addExternalSymbol",
"(",
"SPSymbol",
")",
".",
"addReg",
"(",
"Zero",
")",
".",
"addImm",
"(",
"2",
")",
".",
"addMemOperand",
"(",
"LoadMMO",
")",
";",
"if",
"(",
"StackSize",
")",
"{",
"unsigned",
"OffsetReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"PtrRC",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"CONST_I32",
")",
",",
"OffsetReg",
")",
".",
"addImm",
"(",
"StackSize",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"SUB_I32",
")",
",",
"WebAssembly",
"::",
"SP32",
")",
".",
"addReg",
"(",
"SPReg",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
";",
"}",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"COPY",
")",
",",
"WebAssembly",
"::",
"FP32",
")",
".",
"addReg",
"(",
"WebAssembly",
"::",
"SP32",
")",
";",
"}",
"if",
"(",
"StackSize",
"&&",
"needsSPWriteback",
"(",
"MF",
",",
"MFI",
")",
")",
"{",
"writeSPToMemory",
"(",
"WebAssembly",
"::",
"SP32",
",",
"MF",
",",
"MBB",
",",
"InsertPt",
",",
"InsertPt",
",",
"DL",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"WebAssembly should not have callee-saved registers\"",
"WebAssembly",
"\"__stack_pointer\"",
"WebAssembly::CONST_I32",
"0",
"4",
"4",
"WebAssembly::LOAD_I32",
"WebAssembly::SP32",
"2",
"WebAssembly::CONST_I32",
"WebAssembly::SUB_I32",
"WebAssembly::SP32",
"WebAssembly::COPY",
"WebAssembly::FP32",
"WebAssembly::SP32",
"WebAssembly::SP32"
] | WebAssemblyFrameLowering31 | emitPrologue | WebAssembly | Virtual ISA | LLVM | 20,259 | 402 | 1 | [] |
[
"<s>",
"void",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"override",
"{",
"switch",
"(",
"Kind",
")",
"{",
"case",
"KindTy",
"::",
"Immediate",
":",
"OS",
"<<",
"*",
"getImm",
"(",
")",
";",
"break",
";",
"case",
"KindTy",
"::",
"Register",
":",
"OS",
"<<",
"\"<register x\"",
";",
"OS",
"<<",
"getReg",
"(",
")",
"<<",
"\">\"",
";",
"break",
";",
"case",
"KindTy",
"::",
"Token",
":",
"OS",
"<<",
"\"'\"",
"<<",
"getToken",
"(",
")",
"<<",
"\"'\"",
";",
"break",
";",
"case",
"KindTy",
"::",
"SystemRegister",
":",
"OS",
"<<",
"\"<sysreg: \"",
"<<",
"getSysReg",
"(",
")",
"<<",
"'>'",
";",
"break",
";",
"case",
"KindTy",
"::",
"VectorRegister",
":",
"OS",
"<<",
"\"<vecreg: \"",
"<<",
"getVecReg",
"(",
")",
"<<",
"'>'",
";",
"break",
";",
"case",
"KindTy",
"::",
"VTypeImm",
":",
"SmallVector",
"<",
"char",
",",
"8",
">",
"VTypeBuf",
";",
"OS",
"<<",
"\"<vtypei: \"",
"<<",
"getVTypeImm",
"(",
"VTypeBuf",
")",
"<<",
"'>'",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"RISCV",
"\"<register x\"",
"\">\"",
"\"'\"",
"\"'\"",
"\"<sysreg: \"",
"\"<vecreg: \"",
"8",
"\"<vtypei: \""
] | RISCVAsmParser43 | print | RISCV | CPU | LLVM | 20,260 | 127 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_function_arg_advance",
"(",
"cumulative_args_t",
"cum_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"HOST_WIDE_INT",
"param_size",
"=",
"arg",
".",
"promoted_size_in_bytes",
"(",
")",
";",
"gcc_assert",
"(",
"param_size",
">=",
"0",
")",
";",
"param_size",
"=",
"(",
"UNITS_PER_WORD",
"-",
"1",
"+",
"param_size",
")",
"/",
"UNITS_PER_WORD",
";",
"if",
"(",
"cum",
"->",
"regs_used",
"+",
"param_size",
">",
"NUM_ARG_REGS",
")",
"cum",
"->",
"regs_used",
"=",
"NUM_ARG_REGS",
";",
"else",
"cum",
"->",
"regs_used",
"+=",
"param_size",
";",
"}",
"</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",
"."
] | [
"nios2",
"0",
"1"
] | nios2 | nios2_function_arg_advance | nios2 | MPU | GCC | 20,261 | 74 | 1 | [] |
[
"<s>",
"Value",
"*",
"X86TargetLowering",
"::",
"getIRStackGuard",
"(",
"IRBuilder",
"<",
">",
"&",
"IRB",
")",
"const",
"{",
"if",
"(",
"hasStackGuardSlotTLS",
"(",
"Subtarget",
".",
"getTargetTriple",
"(",
")",
")",
")",
"{",
"if",
"(",
"Subtarget",
".",
"isTargetFuchsia",
"(",
")",
")",
"{",
"return",
"SegmentOffset",
"(",
"IRB",
",",
"0x10",
",",
"getAddressSpace",
"(",
")",
")",
";",
"}",
"else",
"{",
"unsigned",
"AddressSpace",
"=",
"getAddressSpace",
"(",
")",
";",
"int",
"Offset",
"=",
"getTargetMachine",
"(",
")",
".",
"Options",
".",
"StackProtectorGuardOffset",
";",
"if",
"(",
"Offset",
"==",
"INT_MAX",
")",
"Offset",
"=",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
")",
"?",
"0x28",
":",
"0x14",
";",
"const",
"auto",
"&",
"GuardReg",
"=",
"getTargetMachine",
"(",
")",
".",
"Options",
".",
"StackProtectorGuardReg",
";",
"if",
"(",
"GuardReg",
"==",
"\"fs\"",
")",
"AddressSpace",
"=",
"X86AS",
"::",
"FS",
";",
"else",
"if",
"(",
"GuardReg",
"==",
"\"gs\"",
")",
"AddressSpace",
"=",
"X86AS",
"::",
"GS",
";",
"return",
"SegmentOffset",
"(",
"IRB",
",",
"Offset",
",",
"AddressSpace",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getIRStackGuard",
"(",
"IRB",
")",
";",
"}",
"</s>"
] | [
"If",
"the",
"target",
"has",
"a",
"standard",
"location",
"for",
"the",
"stack",
"protector",
"cookie",
",",
"returns",
"the",
"address",
"of",
"that",
"location",
"."
] | [
"X86",
"X86",
"0x10",
"0x28",
"0x14",
"\"fs\"",
"X86AS::FS",
"\"gs\"",
"X86AS::GS"
] | X86ISelLowering159 | getIRStackGuard | X86 | CPU | LLVM | 20,262 | 147 | 1 | [] |
[
"<s>",
"SDValue",
"MipsSelectionDAGInfo",
"::",
"EmitTargetCodeForMemmove",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"Align",
"Alignment",
",",
"bool",
"isVolatile",
",",
"bool",
"MustPreserveCheriCapabilities",
",",
"MachinePointerInfo",
"DstPtrInfo",
",",
"MachinePointerInfo",
"SrcPtrInfo",
")",
"const",
"{",
"return",
"EmitTargetCodeForMemOp",
"(",
"DAG",
",",
"dl",
",",
"Chain",
",",
"Dst",
",",
"Src",
",",
"Size",
",",
"Alignment",
",",
"isVolatile",
",",
"false",
",",
"MustPreserveCheriCapabilities",
",",
"DstPtrInfo",
",",
"SrcPtrInfo",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memmove",
"."
] | [
"Mips",
"Mips"
] | MipsSelectionDAGInfo3 | EmitTargetCodeForMemmove | Mips | CPU | LLVM | 20,263 | 74 | 1 | [] |
[
"<s>",
"unsigned",
"PPCInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"PPC",
"::",
"LD",
":",
"case",
"PPC",
"::",
"LWZ",
":",
"case",
"PPC",
"::",
"LFS",
":",
"case",
"PPC",
"::",
"LFD",
":",
"case",
"PPC",
"::",
"RESTORE_CR",
":",
"case",
"PPC",
"::",
"LVX",
":",
"case",
"PPC",
"::",
"RESTORE_VRSAVE",
":",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isImm",
"(",
")",
"&&",
"!",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isFI",
"(",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"PowerPC",
"PPC",
"PPC::LD",
"PPC::LWZ",
"PPC::LFS",
"PPC::LFD",
"PPC::RESTORE_CR",
"PPC::LVX",
"PPC::RESTORE_VRSAVE",
"1",
"1",
"2",
"2",
"0",
"0"
] | PPCInstrInfo108 | isLoadFromStackSlot | PowerPC | CPU | LLVM | 20,264 | 134 | 1 | [] |
[
"<s>",
"void",
"RISCVAsmBackend",
"::",
"relaxInstruction",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"MCInst",
"Res",
";",
"switch",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Opcode not expected!\"",
")",
";",
"case",
"RISCV",
"::",
"C_BEQZ",
":",
"Res",
".",
"setOpcode",
"(",
"RISCV",
"::",
"BEQ",
")",
";",
"Res",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"0",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"RISCV",
"::",
"X0",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"break",
";",
"case",
"RISCV",
"::",
"C_BNEZ",
":",
"Res",
".",
"setOpcode",
"(",
"RISCV",
"::",
"BNE",
")",
";",
"Res",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"0",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"RISCV",
"::",
"X0",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"break",
";",
"case",
"RISCV",
"::",
"C_J",
":",
"Res",
".",
"setOpcode",
"(",
"RISCV",
"::",
"JAL",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"RISCV",
"::",
"X0",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"0",
")",
")",
";",
"break",
";",
"case",
"RISCV",
"::",
"C_JAL",
":",
"Res",
".",
"setOpcode",
"(",
"RISCV",
"::",
"JAL",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"RISCV",
"::",
"X1",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"0",
")",
")",
";",
"break",
";",
"}",
"Inst",
"=",
"std",
"::",
"move",
"(",
"Res",
")",
";",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"RI5CY",
"RISCV",
"\"Opcode not expected!\"",
"RISCV::C_BEQZ",
"RISCV::BEQ",
"0",
"RISCV::X0",
"1",
"RISCV::C_BNEZ",
"RISCV::BNE",
"0",
"RISCV::X0",
"1",
"RISCV::C_J",
"RISCV::JAL",
"RISCV::X0",
"0",
"RISCV::C_JAL",
"RISCV::JAL",
"RISCV::X1",
"0"
] | RISCVAsmBackend | relaxInstruction | RI5CY | CPU | LLVM | 20,265 | 238 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"getSubtargetImpl",
"(",
")",
"->",
"getInstrItineraryData",
"(",
")",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"ARM"
] | ARMTargetMachine5 | getInstrItineraryData | ARM | CPU | LLVM | 20,266 | 20 | 1 | [] |
[
"<s>",
"bool",
"TVMArgumentMove",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"********** Argument Move **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
";",
"}",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"MachineBasicBlock",
"&",
"EntryMBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"InsertPt",
"=",
"EntryMBB",
".",
"end",
"(",
")",
";",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"EntryMBB",
")",
"{",
"if",
"(",
"!",
"TVM",
"::",
"isArgument",
"(",
"MI",
")",
")",
"{",
"InsertPt",
"=",
"MI",
";",
"break",
";",
"}",
"}",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"llvm",
"::",
"make_range",
"(",
"InsertPt",
",",
"EntryMBB",
".",
"end",
"(",
")",
")",
")",
"{",
"if",
"(",
"TVM",
"::",
"isArgument",
"(",
"MI",
")",
")",
"{",
"EntryMBB",
".",
"insert",
"(",
"InsertPt",
",",
"MI",
".",
"removeFromParent",
"(",
")",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"TVM",
"TVM",
"\"********** Argument Move **********\\n\"",
"\"********** Function: \"",
"TVM::isArgument",
"TVM::isArgument"
] | TVMArgumentMove | runOnMachineFunction | TVM | Virtual ISA | LLVM | 20,267 | 139 | 1 | [] |
[
"<s>",
"void",
"c6x_final_prescan_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"opvec",
"ATTRIBUTE_UNUSED",
",",
"int",
"noperands",
"ATTRIBUTE_UNUSED",
")",
"{",
"c6x_current_insn",
"=",
"insn",
";",
"}",
"</s>"
] | [
"Implements",
"FINAL_PRESCAN_INSN",
"."
] | [
"c6x"
] | c6x | c6x_final_prescan_insn | c6x | VLIW | GCC | 20,268 | 22 | 1 | [] |
[
"<s>",
"SDValue",
"HexagonTargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"SDLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"SDValue",
"Callee",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_Hexagon",
")",
";",
"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",
"."
] | [
"Hexagon",
"Hexagon",
"ISD::InputArg",
"16",
"Hexagon",
"0",
"1",
"2",
"0"
] | HexagonISelLowering112 | LowerCallResult | Hexagon | DSP | LLVM | 20,269 | 181 | 1 | [] |
[
"<s>",
"static",
"bool",
"backward_propagate_worthwhile_p",
"(",
"const",
"basic_block",
"cfg_bb",
",",
"const",
"vector_block_info",
"block_info",
")",
"{",
"if",
"(",
"loop_basic_block_p",
"(",
"cfg_bb",
")",
")",
"{",
"if",
"(",
"block_info",
".",
"reaching_out",
".",
"valid_or_dirty_p",
"(",
")",
")",
"{",
"if",
"(",
"block_info",
".",
"local_dem",
".",
"compatible_p",
"(",
"block_info",
".",
"reaching_out",
")",
")",
"{",
"return",
"true",
";",
"}",
"else",
"{",
"if",
"(",
"support_relaxed_compatible_p",
"(",
"block_info",
".",
"reaching_out",
",",
"block_info",
".",
"local_dem",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"}",
"else",
"{",
"gcc_assert",
"(",
"block_info",
".",
"reaching_out",
".",
"unknown_p",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"block",
"is",
"worthwhile",
"backward",
"propagation",
"."
] | [
"riscv"
] | riscv-vsetvl | backward_propagate_worthwhile_p | riscv | CPU | GCC | 20,270 | 95 | 1 | [] |
[
"<s>",
"int",
"X86FrameLowering",
"::",
"getFrameIndexReference",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
",",
"unsigned",
"&",
"FrameReg",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"if",
"(",
"TRI",
"->",
"hasBasePointer",
"(",
"MF",
")",
")",
"FrameReg",
"=",
"TRI",
"->",
"getBaseRegister",
"(",
")",
";",
"else",
"if",
"(",
"TRI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
")",
"FrameReg",
"=",
"TRI",
"->",
"getStackRegister",
"(",
")",
";",
"else",
"FrameReg",
"=",
"TRI",
"->",
"getFrameRegister",
"(",
"MF",
")",
";",
"int",
"Offset",
"=",
"MFI",
".",
"getObjectOffset",
"(",
"FI",
")",
"-",
"getOffsetOfLocalArea",
"(",
")",
";",
"const",
"X86MachineFunctionInfo",
"*",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"CSSize",
"=",
"X86FI",
"->",
"getCalleeSavedFrameSize",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"bool",
"HasFP",
"=",
"hasFP",
"(",
"MF",
")",
";",
"bool",
"IsWin64Prologue",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
"->",
"usesWindowsCFI",
"(",
")",
";",
"int64_t",
"FPDelta",
"=",
"0",
";",
"if",
"(",
"IsWin64Prologue",
")",
"{",
"assert",
"(",
"!",
"MFI",
".",
"hasCalls",
"(",
")",
"||",
"(",
"StackSize",
"%",
"16",
")",
"==",
"8",
")",
";",
"uint64_t",
"FrameSize",
"=",
"StackSize",
"-",
"SlotSize",
";",
"if",
"(",
"X86FI",
"->",
"getRestoreBasePointer",
"(",
")",
")",
"FrameSize",
"+=",
"SlotSize",
";",
"uint64_t",
"NumBytes",
"=",
"FrameSize",
"-",
"CSSize",
";",
"uint64_t",
"SEHFrameOffset",
"=",
"calculateSetFPREG",
"(",
"NumBytes",
")",
";",
"if",
"(",
"FI",
"&&",
"FI",
"==",
"X86FI",
"->",
"getFAIndex",
"(",
")",
")",
"return",
"-",
"SEHFrameOffset",
";",
"FPDelta",
"=",
"FrameSize",
"-",
"SEHFrameOffset",
";",
"assert",
"(",
"(",
"!",
"MFI",
".",
"hasCalls",
"(",
")",
"||",
"(",
"FPDelta",
"%",
"16",
")",
"==",
"0",
")",
"&&",
"\"FPDelta isn't aligned per the Win64 ABI!\"",
")",
";",
"}",
"if",
"(",
"TRI",
"->",
"hasBasePointer",
"(",
"MF",
")",
")",
"{",
"assert",
"(",
"HasFP",
"&&",
"\"VLAs and dynamic stack realign, but no FP?!\"",
")",
";",
"if",
"(",
"FI",
"<",
"0",
")",
"{",
"return",
"Offset",
"+",
"SlotSize",
"+",
"FPDelta",
";",
"}",
"else",
"{",
"assert",
"(",
"(",
"-",
"(",
"Offset",
"+",
"StackSize",
")",
")",
"%",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
"==",
"0",
")",
";",
"return",
"Offset",
"+",
"StackSize",
";",
"}",
"}",
"else",
"if",
"(",
"TRI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
")",
"{",
"if",
"(",
"FI",
"<",
"0",
")",
"{",
"return",
"Offset",
"+",
"SlotSize",
"+",
"FPDelta",
";",
"}",
"else",
"{",
"assert",
"(",
"(",
"-",
"(",
"Offset",
"+",
"StackSize",
")",
")",
"%",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
"==",
"0",
")",
";",
"return",
"Offset",
"+",
"StackSize",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"!",
"HasFP",
")",
"return",
"Offset",
"+",
"StackSize",
";",
"Offset",
"+=",
"SlotSize",
";",
"int",
"TailCallReturnAddrDelta",
"=",
"X86FI",
"->",
"getTCReturnAddrDelta",
"(",
")",
";",
"if",
"(",
"TailCallReturnAddrDelta",
"<",
"0",
")",
"Offset",
"-=",
"TailCallReturnAddrDelta",
";",
"}",
"return",
"Offset",
"+",
"FPDelta",
";",
"}",
"</s>"
] | [
"getFrameIndexReference",
"-",
"This",
"method",
"should",
"return",
"the",
"base",
"register",
"and",
"offset",
"used",
"to",
"reference",
"a",
"frame",
"index",
"location",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"16",
"8",
"X86",
"X86",
"16",
"0",
"\"FPDelta isn't aligned per the Win64 ABI!\"",
"\"VLAs and dynamic stack realign, but no FP?!\"",
"0",
"0",
"0",
"0",
"X86",
"0"
] | X86FrameLowering102 | getFrameIndexReference | X86 | CPU | LLVM | 20,271 | 413 | 1 | [] |
[
"<s>",
"static",
"bool",
"isEqual",
"(",
"const",
"TOCKey",
"&",
"A",
",",
"const",
"TOCKey",
"&",
"B",
")",
"{",
"return",
"A",
"==",
"B",
";",
"}",
"</s>"
] | [
"isEqual",
"-",
"Compares",
"two",
"trees",
"for",
"structural",
"equality",
"and",
"returns",
"true",
"if",
"they",
"are",
"equal",
"."
] | [
"PowerPC"
] | PPCAsmPrinter (2)3 | isEqual | PowerPC | CPU | LLVM | 20,272 | 21 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"isOffsetFoldingLegal",
"(",
"const",
"GlobalAddressSDNode",
"*",
"GA",
")",
"const",
"{",
"return",
"(",
"GA",
"->",
"getAddressSpace",
"(",
")",
"==",
"AMDGPUAS",
"::",
"GLOBAL_ADDRESS",
"||",
"GA",
"->",
"getAddressSpace",
"(",
")",
"==",
"AMDGPUAS",
"::",
"CONSTANT_ADDRESS",
")",
"&&",
"!",
"shouldEmitGOTReloc",
"(",
"GA",
"->",
"getGlobal",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"folding",
"a",
"constant",
"offset",
"with",
"the",
"given",
"GlobalAddress",
"is",
"legal",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU"
] | SIISelLowering113 | isOffsetFoldingLegal | AMDGPU | GPU | LLVM | 20,273 | 46 | 1 | [] |
[
"<s>",
"rtx",
"create_TOC_reference",
"(",
"rtx",
"symbol",
",",
"rtx",
"largetoc_reg",
")",
"{",
"rtx",
"tocrel",
",",
"tocreg",
",",
"hi",
";",
"gcc_assert",
"(",
"TARGET_TOC",
")",
";",
"if",
"(",
"TARGET_DEBUG_ADDR",
")",
"{",
"if",
"(",
"SYMBOL_REF_P",
"(",
"symbol",
")",
")",
"fprintf",
"(",
"stderr",
",",
"\"\\ncreate_TOC_reference, (symbol_ref %s)\\n\"",
",",
"XSTR",
"(",
"symbol",
",",
"0",
")",
")",
";",
"else",
"{",
"fprintf",
"(",
"stderr",
",",
"\"\\ncreate_TOC_reference, code %s:\\n\"",
",",
"GET_RTX_NAME",
"(",
"GET_CODE",
"(",
"symbol",
")",
")",
")",
";",
"debug_rtx",
"(",
"symbol",
")",
";",
"}",
"}",
"if",
"(",
"!",
"can_create_pseudo_p",
"(",
")",
")",
"df_set_regs_ever_live",
"(",
"TOC_REGISTER",
",",
"true",
")",
";",
"tocreg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"TOC_REGISTER",
")",
";",
"tocrel",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"2",
",",
"symbol",
",",
"tocreg",
")",
",",
"UNSPEC_TOCREL",
")",
";",
"if",
"(",
"TARGET_CMODEL",
"==",
"CMODEL_SMALL",
"||",
"can_create_pseudo_p",
"(",
")",
")",
"return",
"tocrel",
";",
"hi",
"=",
"gen_rtx_HIGH",
"(",
"Pmode",
",",
"copy_rtx",
"(",
"tocrel",
")",
")",
";",
"if",
"(",
"largetoc_reg",
"!=",
"NULL",
")",
"{",
"emit_move_insn",
"(",
"largetoc_reg",
",",
"hi",
")",
";",
"hi",
"=",
"largetoc_reg",
";",
"}",
"return",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"hi",
",",
"tocrel",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"TOC",
"reference",
"for",
"symbol_ref",
"SYMBOL",
".",
"If",
"LARGETOC_REG",
"is",
"non-null",
",",
"use",
"that",
"as",
"the",
"register",
"to",
"put",
"the",
"HIGH",
"value",
"into",
"if",
"register",
"allocation",
"is",
"already",
"done",
"."
] | [
"rs6000",
"\"\\ncreate_TOC_reference, (symbol_ref %s)\\n\"",
"0",
"\"\\ncreate_TOC_reference, code %s:\\n\"",
"2"
] | rs6000 | create_TOC_reference | rs6000 | CPU | GCC | 20,274 | 168 | 1 | [] |
[
"<s>",
"bool",
"isMaskAndCmp0FoldingBeneficial",
"(",
"const",
"Instruction",
"&",
"AndI",
")",
"const",
"override",
"{",
"ConstantInt",
"*",
"Mask",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"AndI",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"return",
"Mask",
"&&",
"Mask",
"->",
"getValue",
"(",
")",
".",
"isIntN",
"(",
"16",
")",
";",
"}",
"</s>"
] | [
"Return",
"if",
"the",
"target",
"supports",
"combining",
"a",
"chain",
"like",
":"
] | [
"SystemZ",
"1",
"16"
] | SystemZISelLowering18 | isMaskAndCmp0FoldingBeneficial | SystemZ | CPU | LLVM | 20,275 | 43 | 1 | [] |
[
"<s>",
"void",
"CSKYInstPrinter",
"::",
"printRegName",
"(",
"raw_ostream",
"&",
"O",
",",
"unsigned",
"RegNo",
")",
"const",
"{",
"O",
"<<",
"getRegisterName",
"(",
"RegNo",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"assembler",
"register",
"name",
"."
] | [
"CSKY",
"CSKY"
] | CSKYInstPrinter | printRegName | CSKY | CPU | LLVM | 20,276 | 22 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isTruncateFree",
"(",
"const",
"Type",
"*",
"Ty1",
",",
"const",
"Type",
"*",
"Ty2",
")",
"const",
"{",
"if",
"(",
"!",
"Ty1",
"->",
"isIntegerTy",
"(",
")",
"||",
"!",
"Ty2",
"->",
"isIntegerTy",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"NumBits1",
"=",
"Ty1",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"unsigned",
"NumBits2",
"=",
"Ty2",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"NumBits1",
"<=",
"NumBits2",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"free",
"to",
"truncate",
"a",
"value",
"of",
"type",
"Ty1",
"to",
"type",
"Ty2",
"."
] | [
"X86",
"X86"
] | X86ISelLowering144 | isTruncateFree | X86 | CPU | LLVM | 20,277 | 67 | 1 | [] |
[
"<s>",
"static",
"void",
"sparc_atomic_assign_expand_fenv",
"(",
"tree",
"*",
"hold",
",",
"tree",
"*",
"clear",
",",
"tree",
"*",
"update",
")",
"{",
"if",
"(",
"!",
"TARGET_FPU",
")",
"return",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"accrued_exception_mask",
"=",
"0x1f",
"<<",
"5",
";",
"const",
"unsigned",
"HOST_WIDE_INT",
"trap_enable_mask",
"=",
"0x1f",
"<<",
"23",
";",
"tree",
"fenv_var",
"=",
"create_tmp_var",
"(",
"unsigned_type_node",
")",
";",
"mark_addressable",
"(",
"fenv_var",
")",
";",
"tree",
"fenv_addr",
"=",
"build_fold_addr_expr",
"(",
"fenv_var",
")",
";",
"tree",
"stfsr",
"=",
"sparc_builtins",
"[",
"SPARC_BUILTIN_STFSR",
"]",
";",
"tree",
"hold_stfsr",
"=",
"build_call_expr",
"(",
"stfsr",
",",
"1",
",",
"fenv_addr",
")",
";",
"tree",
"tmp1_var",
"=",
"create_tmp_var",
"(",
"unsigned_type_node",
")",
";",
"mark_addressable",
"(",
"tmp1_var",
")",
";",
"tree",
"masked_fenv_var",
"=",
"build2",
"(",
"BIT_AND_EXPR",
",",
"unsigned_type_node",
",",
"fenv_var",
",",
"build_int_cst",
"(",
"unsigned_type_node",
",",
"~",
"(",
"accrued_exception_mask",
"|",
"trap_enable_mask",
")",
")",
")",
";",
"tree",
"hold_mask",
"=",
"build2",
"(",
"MODIFY_EXPR",
",",
"void_type_node",
",",
"tmp1_var",
",",
"masked_fenv_var",
")",
";",
"tree",
"tmp1_addr",
"=",
"build_fold_addr_expr",
"(",
"tmp1_var",
")",
";",
"tree",
"ldfsr",
"=",
"sparc_builtins",
"[",
"SPARC_BUILTIN_LDFSR",
"]",
";",
"tree",
"hold_ldfsr",
"=",
"build_call_expr",
"(",
"ldfsr",
",",
"1",
",",
"tmp1_addr",
")",
";",
"*",
"hold",
"=",
"compound_expr",
"(",
"compound_expr",
"(",
"hold_stfsr",
",",
"hold_mask",
")",
",",
"hold_ldfsr",
")",
";",
"*",
"clear",
"=",
"build_call_expr",
"(",
"ldfsr",
",",
"1",
",",
"tmp1_addr",
")",
";",
"tree",
"tmp2_var",
"=",
"create_tmp_var",
"(",
"unsigned_type_node",
")",
";",
"mark_addressable",
"(",
"tmp2_var",
")",
";",
"tree",
"tmp3_addr",
"=",
"build_fold_addr_expr",
"(",
"tmp2_var",
")",
";",
"tree",
"update_stfsr",
"=",
"build_call_expr",
"(",
"stfsr",
",",
"1",
",",
"tmp3_addr",
")",
";",
"tree",
"update_ldfsr",
"=",
"build_call_expr",
"(",
"ldfsr",
",",
"1",
",",
"fenv_addr",
")",
";",
"tree",
"atomic_feraiseexcept",
"=",
"builtin_decl_implicit",
"(",
"BUILT_IN_ATOMIC_FERAISEEXCEPT",
")",
";",
"tree",
"update_call",
"=",
"build_call_expr",
"(",
"atomic_feraiseexcept",
",",
"1",
",",
"fold_convert",
"(",
"integer_type_node",
",",
"tmp2_var",
")",
")",
";",
"if",
"(",
"SPARC_LOW_FE_EXCEPT_VALUES",
")",
"{",
"tree",
"shifted_tmp2_var",
"=",
"build2",
"(",
"RSHIFT_EXPR",
",",
"unsigned_type_node",
",",
"tmp2_var",
",",
"build_int_cst",
"(",
"unsigned_type_node",
",",
"5",
")",
")",
";",
"tree",
"update_shift",
"=",
"build2",
"(",
"MODIFY_EXPR",
",",
"void_type_node",
",",
"tmp2_var",
",",
"shifted_tmp2_var",
")",
";",
"update_call",
"=",
"compound_expr",
"(",
"update_shift",
",",
"update_call",
")",
";",
"}",
"*",
"update",
"=",
"compound_expr",
"(",
"compound_expr",
"(",
"update_stfsr",
",",
"update_ldfsr",
")",
",",
"update_call",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ATOMIC_ASSIGN_EXPAND_FENV",
"hook",
"."
] | [
"sparc",
"0x1f",
"5",
"0x1f",
"23",
"1",
"1",
"1",
"1",
"1",
"1",
"5"
] | sparc4 | sparc_atomic_assign_expand_fenv | sparc | CPU | GCC | 20,278 | 323 | 1 | [] |
[
"<s>",
"virtual",
"const",
"OR1KInstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"OR1K",
"OR1K"
] | OR1KTargetMachine | getInstrInfo | OR1K | CPU | LLVM | 20,279 | 14 | 1 | [] |
[
"<s>",
"bool",
"SystemZAsmParser",
"::",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
"Info",
",",
"StringRef",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"{",
"applyMnemonicAliases",
"(",
"Name",
",",
"getAvailableFeatures",
"(",
")",
",",
"0",
")",
";",
"Operands",
".",
"push_back",
"(",
"SystemZOperand",
"::",
"createToken",
"(",
"Name",
",",
"NameLoc",
")",
")",
";",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"if",
"(",
"parseOperand",
"(",
"Operands",
",",
"Name",
")",
")",
"{",
"return",
"true",
";",
"}",
"while",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"parseOperand",
"(",
"Operands",
",",
"Name",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"unexpected token in argument list\"",
")",
";",
"}",
"}",
"Parser",
".",
"Lex",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"SystemZ",
"SystemZ",
"0",
"SystemZ",
"\"unexpected token in argument list\""
] | SystemZAsmParser31 | ParseInstruction | SystemZ | CPU | LLVM | 20,280 | 153 | 1 | [] |
[
"<s>",
"StackOffset",
"(",
"const",
"StackOffset",
"&",
"Other",
")",
":",
"Bytes",
"(",
"Other",
".",
"Bytes",
")",
",",
"ScalableBytes",
"(",
"Other",
".",
"ScalableBytes",
")",
"{",
"}",
"</s>"
] | [
"Offset",
"from",
"the",
"stack",
"pointer",
"."
] | [
"AArch64"
] | AArch64StackOffset | StackOffset | AArch64 | CPU | LLVM | 20,281 | 23 | 1 | [] |
[
"<s>",
"void",
"VEFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"VEMachineFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"VEMachineFunctionInfo",
">",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"VEInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"uint64_t",
"NumBytes",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"if",
"(",
"!",
"FuncInfo",
"->",
"isLeafProc",
"(",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"VE",
"::",
"ORri",
")",
",",
"VE",
"::",
"SX11",
")",
".",
"addReg",
"(",
"VE",
"::",
"SX9",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"else",
"{",
"emitSPAdjustment",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"NumBytes",
",",
"None",
")",
";",
"}",
"emitEpilogueInsns",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"NumBytes",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"VE",
"VE",
"VE",
"VE",
"VE",
"VE::ORri",
"VE::SX11",
"VE::SX9",
"0"
] | VEFrameLowering2 | emitEpilogue | VE | CPU | LLVM | 20,282 | 149 | 1 | [] |
[
"<s>",
"static",
"bool",
"nds32_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"(",
"!",
"TARGET_V3PUSH",
"&&",
"(",
"cfun",
"->",
"machine",
"->",
"va_args_size",
"==",
"0",
")",
"&&",
"decl",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"ok",
"to",
"do",
"sibling",
"call",
"optimization",
"."
] | [
"nds32",
"0"
] | nds325 | nds32_function_ok_for_sibcall | nds32 | CPU | GCC | 20,283 | 31 | 1 | [] |
[
"<s>",
"static",
"bool",
"timode_mem_p",
"(",
"rtx",
"x",
")",
"{",
"return",
"MEM_P",
"(",
"x",
")",
"&&",
"(",
"TARGET_SSE_UNALIGNED_LOAD_OPTIMAL",
"||",
"!",
"misaligned_operand",
"(",
"x",
",",
"TImode",
")",
")",
";",
"}",
"</s>"
] | [
"Check",
"for",
"a",
"suitable",
"TImode",
"memory",
"operand",
"."
] | [
"i386"
] | i386-features1 | timode_mem_p | i386 | CPU | GCC | 20,284 | 27 | 1 | [] |
[
"<s>",
"bool",
"GCNDownwardRPTracker",
"::",
"advance",
"(",
"MachineBasicBlock",
"::",
"const_iterator",
"Begin",
",",
"MachineBasicBlock",
"::",
"const_iterator",
"End",
",",
"const",
"LiveRegSet",
"*",
"LiveRegsCopy",
")",
"{",
"reset",
"(",
"*",
"Begin",
",",
"LiveRegsCopy",
")",
";",
"return",
"advance",
"(",
"End",
")",
";",
"}",
"</s>"
] | [
"Advance",
"across",
"the",
"current",
"instruction",
"."
] | [
"AMDGPU"
] | GCNRegPressure | advance | AMDGPU | GPU | LLVM | 20,285 | 36 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"AFI",
"->",
"getGlobalBaseReg",
"(",
")",
"==",
"0",
")",
"return",
"false",
";",
"const",
"ARMTargetMachine",
"*",
"TM",
"=",
"static_cast",
"<",
"const",
"ARMTargetMachine",
"*",
">",
"(",
"&",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"PIC_",
")",
"return",
"false",
";",
"LLVMContext",
"*",
"Context",
"=",
"&",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"GlobalValue",
"*",
"GV",
"=",
"new",
"GlobalVariable",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"*",
"Context",
")",
",",
"false",
",",
"GlobalValue",
"::",
"ExternalLinkage",
",",
"0",
",",
"\"_GLOBAL_OFFSET_TABLE_\"",
")",
";",
"unsigned",
"Id",
"=",
"AFI",
"->",
"createPICLabelUId",
"(",
")",
";",
"ARMConstantPoolValue",
"*",
"CPV",
"=",
"ARMConstantPoolConstant",
"::",
"Create",
"(",
"GV",
",",
"Id",
")",
";",
"unsigned",
"Align",
"=",
"TM",
"->",
"getDataLayout",
"(",
")",
"->",
"getPrefTypeAlignment",
"(",
"GV",
"->",
"getType",
"(",
")",
")",
";",
"unsigned",
"Idx",
"=",
"MF",
".",
"getConstantPool",
"(",
")",
"->",
"getConstantPoolIndex",
"(",
"CPV",
",",
"Align",
")",
";",
"MachineBasicBlock",
"&",
"FirstMBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"FirstMBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"FirstMBB",
".",
"findDebugLoc",
"(",
"MBBI",
")",
";",
"unsigned",
"GlobalBaseReg",
"=",
"AFI",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"TM",
"->",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
".",
"isThumb2",
"(",
")",
"?",
"ARM",
"::",
"t2LDRpci",
":",
"ARM",
"::",
"LDRcp",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"TM",
"->",
"getInstrInfo",
"(",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"GlobalBaseReg",
")",
".",
"addConstantPoolIndex",
"(",
"Idx",
")",
";",
"if",
"(",
"Opc",
"==",
"ARM",
"::",
"LDRcp",
")",
"MIB",
".",
"addImm",
"(",
"0",
")",
";",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"0",
"ARM",
"ARM",
"0",
"\"_GLOBAL_OFFSET_TABLE_\"",
"ARM",
"ARM",
"ARM",
"ARM::t2LDRpci",
"ARM::LDRcp",
"ARM::LDRcp",
"0"
] | ARMInstrInfo11 | runOnMachineFunction | ARM | CPU | LLVM | 20,286 | 293 | 1 | [] |
[
"<s>",
"void",
"HexagonDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"N",
")",
"{",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"N",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"Constant",
":",
"return",
"SelectConstant",
"(",
"N",
")",
";",
"case",
"ISD",
"::",
"ConstantFP",
":",
"return",
"SelectConstantFP",
"(",
"N",
")",
";",
"case",
"ISD",
"::",
"FrameIndex",
":",
"return",
"SelectFrameIndex",
"(",
"N",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"return",
"SelectSHL",
"(",
"N",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"SelectLoad",
"(",
"N",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"SelectStore",
"(",
"N",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
":",
"return",
"SelectIntrinsicWChain",
"(",
"N",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"SelectIntrinsicWOChain",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"VALIGN",
":",
"return",
"SelectVAlign",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"VALIGNADDR",
":",
"return",
"SelectVAlignAddr",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"TYPECAST",
":",
"return",
"SelectTypecast",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"P2D",
":",
"return",
"SelectP2D",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"D2P",
":",
"return",
"SelectD2P",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"Q2V",
":",
"return",
"SelectQ2V",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"V2Q",
":",
"return",
"SelectV2Q",
"(",
"N",
")",
";",
"}",
"if",
"(",
"HST",
"->",
"useHVXOps",
"(",
")",
")",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"VECTOR_SHUFFLE",
":",
"return",
"SelectHvxShuffle",
"(",
"N",
")",
";",
"case",
"HexagonISD",
"::",
"VROR",
":",
"return",
"SelectHvxRor",
"(",
"N",
")",
";",
"}",
"}",
"SelectCode",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Hexagon",
"Hexagon",
"1",
"ISD::Constant",
"ISD::ConstantFP",
"ISD::FrameIndex",
"ISD::SHL",
"ISD::LOAD",
"ISD::STORE",
"ISD::INTRINSIC_W_CHAIN",
"ISD::INTRINSIC_WO_CHAIN",
"HexagonISD::VALIGN",
"HexagonISD::VALIGNADDR",
"HexagonISD::TYPECAST",
"HexagonISD::P2D",
"HexagonISD::D2P",
"HexagonISD::Q2V",
"HexagonISD::V2Q",
"ISD::VECTOR_SHUFFLE",
"HexagonISD::VROR"
] | HexagonISelDAGToDAG18 | Select | Hexagon | DSP | LLVM | 20,287 | 250 | 1 | [] |
[
"<s>",
"unsigned",
"getNumFixupKinds",
"(",
")",
"const",
"{",
"return",
"X86",
"::",
"NumTargetFixupKinds",
";",
"}",
"</s>"
] | [
"Get",
"the",
"number",
"of",
"target",
"specific",
"fixup",
"kinds",
"."
] | [
"X86",
"X86::NumTargetFixupKinds"
] | X86AsmBackend20 | getNumFixupKinds | X86 | CPU | LLVM | 20,288 | 12 | 1 | [] |
[
"<s>",
"static",
"rtx",
"h8300_function_value",
"(",
"const_tree",
"ret_type",
",",
"const_tree",
"fn_decl_or_type",
"ATTRIBUTE_UNUSED",
",",
"bool",
"outgoing",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"TYPE_MODE",
"(",
"ret_type",
")",
",",
"R0_REG",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_FUNCTION_VALUE",
".",
"On",
"the",
"H8",
"the",
"return",
"value",
"is",
"in",
"R0/R1",
"."
] | [
"h8300"
] | h8300 | h8300_function_value | h8300 | MPU | GCC | 20,289 | 28 | 1 | [] |
[
"<s>",
"void",
"h8300_expand_branch",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"label",
")",
"{",
"rtx",
"tmp",
";",
"tmp",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"VOIDmode",
",",
"cc0_rtx",
",",
"const0_rtx",
")",
";",
"tmp",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"tmp",
",",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"label",
")",
",",
"pc_rtx",
")",
";",
"emit_jump_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"tmp",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"conditional",
"branch",
"."
] | [
"h8300"
] | h83003 | h8300_expand_branch | h8300 | MPU | GCC | 20,290 | 58 | 1 | [] |
[
"<s>",
"static",
"void",
"pru_print_operand_address",
"(",
"FILE",
"*",
"file",
",",
"machine_mode",
"mode",
",",
"rtx",
"op",
")",
"{",
"if",
"(",
"CONSTANT_ADDRESS_P",
"(",
"op",
")",
"&&",
"text_segment_operand",
"(",
"op",
",",
"VOIDmode",
")",
")",
"{",
"output_operand_lossage",
"(",
"\"unexpected text address:\"",
")",
";",
"return",
";",
"}",
"switch",
"(",
"GET_CODE",
"(",
"op",
")",
")",
"{",
"case",
"CONST",
":",
"case",
"LABEL_REF",
":",
"case",
"CONST_WIDE_INT",
":",
"case",
"SYMBOL_REF",
":",
"break",
";",
"case",
"CONST_INT",
":",
"{",
"unsigned",
"HOST_WIDE_INT",
"caddr",
"=",
"INTVAL",
"(",
"op",
")",
";",
"int",
"base",
"=",
"pru_get_ctable_base_index",
"(",
"caddr",
")",
";",
"int",
"offs",
"=",
"pru_get_ctable_base_offset",
"(",
"caddr",
")",
";",
"if",
"(",
"base",
"<",
"0",
")",
"{",
"output_operand_lossage",
"(",
"\"unsupported constant address:\"",
")",
";",
"return",
";",
"}",
"fprintf",
"(",
"file",
",",
"\"%d, %d\"",
",",
"base",
",",
"offs",
")",
";",
"return",
";",
"}",
"break",
";",
"case",
"PLUS",
":",
"{",
"int",
"base",
";",
"rtx",
"op0",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"XEXP",
"(",
"op",
",",
"1",
")",
";",
"if",
"(",
"REG_P",
"(",
"op0",
")",
"&&",
"CONST_INT_P",
"(",
"op1",
")",
"&&",
"pru_get_ctable_exact_base_index",
"(",
"INTVAL",
"(",
"op1",
")",
")",
">=",
"0",
")",
"{",
"base",
"=",
"pru_get_ctable_exact_base_index",
"(",
"INTVAL",
"(",
"op1",
")",
")",
";",
"fprintf",
"(",
"file",
",",
"\"%d, %s\"",
",",
"base",
",",
"pru_asm_regname",
"(",
"op0",
")",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"REG_P",
"(",
"op1",
")",
"&&",
"CONST_INT_P",
"(",
"op0",
")",
"&&",
"pru_get_ctable_exact_base_index",
"(",
"INTVAL",
"(",
"op0",
")",
")",
">=",
"0",
")",
"{",
"gcc_unreachable",
"(",
")",
";",
"}",
"else",
"if",
"(",
"REG_P",
"(",
"op0",
")",
"&&",
"CONSTANT_P",
"(",
"op1",
")",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s, \"",
",",
"pru_asm_regname",
"(",
"op0",
")",
")",
";",
"output_addr_const",
"(",
"file",
",",
"op1",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"REG_P",
"(",
"op1",
")",
"&&",
"CONSTANT_P",
"(",
"op0",
")",
")",
"{",
"gcc_unreachable",
"(",
")",
";",
"}",
"else",
"if",
"(",
"REG_P",
"(",
"op1",
")",
"&&",
"REG_P",
"(",
"op0",
")",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s, %s\"",
",",
"pru_asm_regname",
"(",
"op0",
")",
",",
"pru_asm_regname",
"(",
"op1",
")",
")",
";",
"return",
";",
"}",
"}",
"break",
";",
"case",
"REG",
":",
"fprintf",
"(",
"file",
",",
"\"%s, 0\"",
",",
"pru_asm_regname",
"(",
"op",
")",
")",
";",
"return",
";",
"case",
"MEM",
":",
"{",
"rtx",
"base",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"pru_print_operand_address",
"(",
"file",
",",
"mode",
",",
"base",
")",
";",
"return",
";",
"}",
"default",
":",
"break",
";",
"}",
"output_operand_lossage",
"(",
"\"unsupported memory expression:\"",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_PRINT_OPERAND_ADDRESS",
"."
] | [
"pru",
"\"unexpected text address:\"",
"0",
"\"unsupported constant address:\"",
"\"%d, %d\"",
"0",
"1",
"0",
"\"%d, %s\"",
"0",
"\"%s, \"",
"\"%s, %s\"",
"\"%s, 0\"",
"0",
"\"unsupported memory expression:\""
] | pru | pru_print_operand_address | pru | CPU | GCC | 20,291 | 372 | 1 | [] |
[
"<s>",
"void",
"MipsTargetStreamer",
"::",
"emitGPRestore",
"(",
"int",
"Offset",
",",
"SMLoc",
"IDLoc",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"{",
"emitLoadWithImmOffset",
"(",
"Mips",
"::",
"LW",
",",
"GPReg",
",",
"Mips",
"::",
"SP",
",",
"Offset",
",",
"GPReg",
",",
"IDLoc",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"Emit",
"the",
"$",
"gp",
"restore",
"operation",
"for",
".cprestore",
"."
] | [
"Mips",
"Mips",
"Mips::LW",
"Mips::SP"
] | MipsTargetStreamer (2)1 | emitGPRestore | Mips | CPU | LLVM | 20,292 | 39 | 1 | [] |
[
"<s>",
"unsigned",
"getNumBlocks",
"(",
")",
"const",
"override",
"{",
"return",
"Region",
"->",
"getNumBlocks",
"(",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"number",
"of",
"blocks",
"in",
"this",
"loop",
"in",
"constant",
"time",
"."
] | [
"WebAssembly"
] | WebAssemblyCFGSort | getNumBlocks | WebAssembly | Virtual ISA | LLVM | 20,293 | 15 | 1 | [] |
[
"<s>",
"bool",
"MBlazeFrameInfo",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"MBlaze",
"MBlaze"
] | MBlazeFrameInfo | hasFP | MBlaze | MPU | LLVM | 20,294 | 36 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isVectorShiftByScalarCheap",
"(",
"Type",
"*",
"Ty",
")",
"const",
"{",
"unsigned",
"Bits",
"=",
"Ty",
"->",
"getScalarSizeInBits",
"(",
")",
";",
"if",
"(",
"Bits",
"==",
"8",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
".",
"hasXOP",
"(",
")",
"&&",
"Ty",
"->",
"getPrimitiveSizeInBits",
"(",
")",
"==",
"128",
"&&",
"(",
"Bits",
"==",
"8",
"||",
"Bits",
"==",
"16",
"||",
"Bits",
"==",
"32",
"||",
"Bits",
"==",
"64",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
".",
"hasAVX2",
"(",
")",
"&&",
"(",
"Bits",
"==",
"32",
"||",
"Bits",
"==",
"64",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
".",
"hasBWI",
"(",
")",
"&&",
"Bits",
"==",
"16",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"is",
"used",
"to",
"enable",
"splatted",
"operand",
"transforms",
"for",
"vector",
"shifts",
"and",
"vector",
"funnel",
"shifts",
"."
] | [
"X86",
"X86",
"8",
"128",
"8",
"16",
"32",
"64",
"32",
"64",
"16"
] | X86ISelLowering (2)6 | isVectorShiftByScalarCheap | X86 | CPU | LLVM | 20,295 | 106 | 1 | [] |
[
"<s>",
"bool",
"X86TTIImpl",
"::",
"isLegalMaskedGather",
"(",
"Type",
"*",
"DataTy",
",",
"Align",
"Alignment",
")",
"{",
"if",
"(",
"!",
"(",
"ST",
"->",
"hasAVX512",
"(",
")",
"||",
"(",
"ST",
"->",
"hasFastGather",
"(",
")",
"&&",
"ST",
"->",
"hasAVX2",
"(",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"auto",
"*",
"DataVTy",
"=",
"dyn_cast",
"<",
"FixedVectorType",
">",
"(",
"DataTy",
")",
")",
"{",
"unsigned",
"NumElts",
"=",
"DataVTy",
"->",
"getNumElements",
"(",
")",
";",
"if",
"(",
"NumElts",
"==",
"1",
")",
"return",
"false",
";",
"if",
"(",
"ST",
"->",
"hasAVX512",
"(",
")",
"&&",
"(",
"NumElts",
"==",
"2",
"||",
"(",
"NumElts",
"==",
"4",
"&&",
"!",
"ST",
"->",
"hasVLX",
"(",
")",
")",
")",
")",
"return",
"false",
";",
"}",
"Type",
"*",
"ScalarTy",
"=",
"DataTy",
"->",
"getScalarType",
"(",
")",
";",
"if",
"(",
"ScalarTy",
"->",
"isPointerTy",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"ScalarTy",
"->",
"isFloatTy",
"(",
")",
"||",
"ScalarTy",
"->",
"isDoubleTy",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"ScalarTy",
"->",
"isIntegerTy",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"IntWidth",
"=",
"ScalarTy",
"->",
"getIntegerBitWidth",
"(",
")",
";",
"return",
"IntWidth",
"==",
"32",
"||",
"IntWidth",
"==",
"64",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"supports",
"masked",
"gather",
"."
] | [
"X86",
"X86",
"1",
"2",
"4",
"32",
"64"
] | X86TargetTransformInfo101 | isLegalMaskedGather | X86 | CPU | LLVM | 20,296 | 174 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUInliner",
"::",
"runOnSCC",
"(",
"CallGraphSCC",
"&",
"SCC",
")",
"{",
"TTIWP",
"=",
"&",
"getAnalysis",
"<",
"TargetTransformInfoWrapperPass",
">",
"(",
")",
";",
"return",
"LegacyInlinerBase",
"::",
"runOnSCC",
"(",
"SCC",
")",
";",
"}",
"</s>"
] | [
"runOnSCC",
"-",
"This",
"method",
"should",
"be",
"implemented",
"by",
"the",
"subclass",
"to",
"perform",
"whatever",
"action",
"is",
"necessary",
"for",
"the",
"specified",
"SCC",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUInline | runOnSCC | AMDGPU | GPU | LLVM | 20,297 | 29 | 1 | [] |
[
"<s>",
"bool",
"rs6000_discover_homogeneous_aggregate",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"machine_mode",
"*",
"elt_mode",
",",
"int",
"*",
"n_elts",
")",
"{",
"if",
"(",
"TARGET_HARD_FLOAT",
"&&",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
"&&",
"type",
"&&",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"machine_mode",
"field_mode",
"=",
"VOIDmode",
";",
"int",
"empty_base_seen",
"=",
"0",
";",
"int",
"zero_width_bf_seen",
"=",
"0",
";",
"int",
"field_count",
"=",
"rs6000_aggregate_candidate",
"(",
"type",
",",
"&",
"field_mode",
",",
"&",
"empty_base_seen",
",",
"&",
"zero_width_bf_seen",
")",
";",
"if",
"(",
"field_count",
">",
"0",
")",
"{",
"int",
"reg_size",
"=",
"ALTIVEC_OR_VSX_VECTOR_MODE",
"(",
"field_mode",
")",
"?",
"16",
":",
"8",
";",
"int",
"field_size",
"=",
"ROUND_UP",
"(",
"GET_MODE_SIZE",
"(",
"field_mode",
")",
",",
"reg_size",
")",
";",
"if",
"(",
"field_count",
"*",
"field_size",
"<=",
"AGGR_ARG_NUM_REG",
"*",
"reg_size",
")",
"{",
"if",
"(",
"elt_mode",
")",
"*",
"elt_mode",
"=",
"field_mode",
";",
"if",
"(",
"n_elts",
")",
"*",
"n_elts",
"=",
"field_count",
";",
"if",
"(",
"empty_base_seen",
"&&",
"warn_psabi",
")",
"{",
"static",
"unsigned",
"last_reported_type_uid",
";",
"unsigned",
"uid",
"=",
"TYPE_UID",
"(",
"TYPE_MAIN_VARIANT",
"(",
"type",
")",
")",
";",
"if",
"(",
"uid",
"!=",
"last_reported_type_uid",
")",
"{",
"const",
"char",
"*",
"url",
"=",
"CHANGES_ROOT_URL",
"\"gcc-10/changes.html#empty_base\"",
";",
"if",
"(",
"empty_base_seen",
"&",
"1",
")",
"inform",
"(",
"input_location",
",",
"\"parameter passing for argument of type %qT \"",
"\"when C++17 is enabled changed to match C++14 \"",
"\"%{in GCC 10.1%}\"",
",",
"type",
",",
"url",
")",
";",
"else",
"inform",
"(",
"input_location",
",",
"\"parameter passing for argument of type %qT \"",
"\"with %<[[no_unique_address]]%> members \"",
"\"changed %{in GCC 10.1%}\"",
",",
"type",
",",
"url",
")",
";",
"last_reported_type_uid",
"=",
"uid",
";",
"}",
"}",
"if",
"(",
"zero_width_bf_seen",
"&&",
"warn_psabi",
")",
"{",
"static",
"unsigned",
"last_reported_type_uid",
";",
"unsigned",
"uid",
"=",
"TYPE_UID",
"(",
"TYPE_MAIN_VARIANT",
"(",
"type",
")",
")",
";",
"if",
"(",
"uid",
"!=",
"last_reported_type_uid",
")",
"{",
"inform",
"(",
"input_location",
",",
"\"ELFv2 parameter passing for an argument \"",
"\"containing zero-width bit fields but that is \"",
"\"otherwise a homogeneous aggregate was \"",
"\"corrected in GCC 12\"",
")",
";",
"last_reported_type_uid",
"=",
"uid",
";",
"}",
"if",
"(",
"elt_mode",
")",
"*",
"elt_mode",
"=",
"mode",
";",
"if",
"(",
"n_elts",
")",
"*",
"n_elts",
"=",
"1",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"}",
"}",
"if",
"(",
"elt_mode",
")",
"*",
"elt_mode",
"=",
"mode",
";",
"if",
"(",
"n_elts",
")",
"*",
"n_elts",
"=",
"1",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"If",
"an",
"argument",
",",
"whose",
"type",
"is",
"described",
"by",
"TYPE",
"and",
"MODE",
",",
"is",
"a",
"homogeneous",
"float",
"or",
"vector",
"aggregate",
"that",
"shall",
"be",
"passed",
"in",
"FP/vector",
"registers",
"according",
"to",
"the",
"ELFv2",
"ABI",
",",
"return",
"the",
"homogeneous",
"element",
"mode",
"in",
"*",
"ELT_MODE",
"and",
"the",
"number",
"of",
"elements",
"in",
"*",
"N_ELTS",
",",
"and",
"return",
"TRUE",
".",
"Otherwise",
",",
"set",
"*",
"ELT_MODE",
"to",
"MODE",
"and",
"*",
"N_ELTS",
"to",
"1",
",",
"and",
"return",
"FALSE",
"."
] | [
"rs6000",
"0",
"0",
"0",
"16",
"8",
"\"gcc-10/changes.html#empty_base\"",
"1",
"\"parameter passing for argument of type %qT \"",
"\"when C++17 is enabled changed to match C++14 \"",
"\"%{in GCC 10.1%}\"",
"\"parameter passing for argument of type %qT \"",
"\"with %<[[no_unique_address]]%> members \"",
"\"changed %{in GCC 10.1%}\"",
"\"ELFv2 parameter passing for an argument \"",
"\"containing zero-width bit fields but that is \"",
"\"otherwise a homogeneous aggregate was \"",
"\"corrected in GCC 12\"",
"1",
"1"
] | rs6000-call | rs6000_discover_homogeneous_aggregate | rs6000 | CPU | GCC | 20,298 | 297 | 1 | [] |
[
"<s>",
"static",
"void",
"mmix_option_override",
"(",
"void",
")",
"{",
"if",
"(",
"flag_pic",
")",
"{",
"warning",
"(",
"0",
",",
"\"%<-f%s%> not supported: ignored\"",
",",
"(",
"flag_pic",
">",
"1",
")",
"?",
"\"PIC\"",
":",
"\"pic\"",
")",
";",
"flag_pic",
"=",
"0",
";",
"}",
"if",
"(",
"flag_verbose_asm",
"||",
"flag_debug_asm",
"||",
"flag_dump_rtl_in_asm",
")",
"{",
"targetm",
".",
"asm_out",
".",
"byte_op",
"=",
"\"\\t.byte\\t\"",
";",
"targetm",
".",
"asm_out",
".",
"aligned_op",
".",
"hi",
"=",
"\"\\t.short\\t\"",
";",
"targetm",
".",
"asm_out",
".",
"aligned_op",
".",
"si",
"=",
"\"\\t.long\\t\"",
";",
"targetm",
".",
"asm_out",
".",
"aligned_op",
".",
"di",
"=",
"\"\\t.dc.a\\t\"",
";",
"}",
"}",
"</s>"
] | [
"TARGET_OPTION_OVERRIDE",
"."
] | [
"mmix",
"0",
"\"%<-f%s%> not supported: ignored\"",
"1",
"\"PIC\"",
"\"pic\"",
"0",
"\"\\t.byte\\t\"",
"\"\\t.short\\t\"",
"\"\\t.long\\t\"",
"\"\\t.dc.a\\t\""
] | mmix | mmix_option_override | mmix | CPU | GCC | 20,299 | 83 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.