ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"static",
"rtx",
"tilepro_function_arg",
"(",
"cumulative_args_t",
"cum_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"cum",
"=",
"*",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"int",
"byte_size",
"=",
"arg",
".",
"promoted_size_in_bytes",
"(",
")",
";",
"bool",
"doubleword_aligned_p",
";",
"if",
"(",
"cum",
">=",
"TILEPRO_NUM_ARG_REGS",
")",
"return",
"NULL_RTX",
";",
"doubleword_aligned_p",
"=",
"tilepro_function_arg_boundary",
"(",
"arg",
".",
"mode",
",",
"arg",
".",
"type",
")",
">",
"BITS_PER_WORD",
";",
"if",
"(",
"doubleword_aligned_p",
")",
"cum",
"+=",
"cum",
"&",
"1",
";",
"if",
"(",
"(",
"cum",
"+",
"(",
"byte_size",
"+",
"UNITS_PER_WORD",
"-",
"1",
")",
"/",
"UNITS_PER_WORD",
")",
">",
"TILEPRO_NUM_ARG_REGS",
")",
"return",
"NULL_RTX",
";",
"return",
"gen_rtx_REG",
"(",
"arg",
".",
"mode",
",",
"cum",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG",
"."
] | [
"tilepro",
"1",
"1"
] | tilepro | tilepro_function_arg | tilepro | VLIW | GCC | 18,500 | 100 | 1 | [] |
[
"<s>",
"unsigned",
"X86TargetLowering",
"::",
"ComputeNumSignBitsForTargetNode",
"(",
"SDValue",
"Op",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"if",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"SETCC_CARRY",
")",
"return",
"Op",
".",
"getScalarValueSizeInBits",
"(",
")",
";",
"if",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"VSEXT",
")",
"{",
"EVT",
"VT",
"=",
"Op",
".",
"getValueType",
"(",
")",
";",
"EVT",
"SrcVT",
"=",
"Op",
".",
"getOperand",
"(",
"0",
")",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"Tmp",
"=",
"DAG",
".",
"ComputeNumSignBits",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
",",
"Depth",
"+",
"1",
")",
";",
"Tmp",
"+=",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
"-",
"SrcVT",
".",
"getScalarSizeInBits",
"(",
")",
";",
"return",
"Tmp",
";",
"}",
"return",
"1",
";",
"}",
"</s>"
] | [
"Determine",
"the",
"number",
"of",
"bits",
"in",
"the",
"operation",
"that",
"are",
"sign",
"bits",
"."
] | [
"X86",
"X86",
"X86ISD::SETCC_CARRY",
"X86ISD::VSEXT",
"0",
"0",
"1",
"1"
] | X86ISelLowering115 | ComputeNumSignBitsForTargetNode | X86 | CPU | LLVM | 18,501 | 114 | 1 | [] |
[
"<s>",
"Register",
"ARMTargetLowering",
"::",
"getExceptionSelectorRegister",
"(",
"const",
"Constant",
"*",
"PersonalityFn",
")",
"const",
"{",
"return",
"Subtarget",
"->",
"useSjLjEH",
"(",
")",
"?",
"Register",
"(",
")",
":",
"ARM",
"::",
"R1",
";",
"}",
"</s>"
] | [
"If",
"a",
"physical",
"register",
",",
"this",
"returns",
"the",
"register",
"that",
"receives",
"the",
"exception",
"typeid",
"on",
"entry",
"to",
"a",
"landing",
"pad",
"."
] | [
"ARM",
"ARM",
"ARM::R1"
] | ARMISelLowering (2)5 | getExceptionSelectorRegister | ARM | CPU | LLVM | 18,502 | 28 | 1 | [] |
[
"<s>",
"unsigned",
"SHUXIRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"SHUXI",
"::",
"SP",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"SHUXI",
"SHUXI",
"SHUXI::SP"
] | SHUXIRegisterInfo | getFrameRegister | SHUXI | CPU | LLVM | 18,503 | 18 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"ix86_mpx_bound_mode",
"(",
")",
"{",
"if",
"(",
"!",
"TARGET_MPX",
")",
"{",
"if",
"(",
"flag_check_pointer_bounds",
")",
"warning",
"(",
"0",
",",
"\"Pointer Checker requires MPX support on this target.\"",
"\" Use -mmpx options to enable MPX.\"",
")",
";",
"return",
"VOIDmode",
";",
"}",
"return",
"BNDmode",
";",
"}",
"</s>"
] | [
"Return",
"mode",
"to",
"be",
"used",
"for",
"bounds",
"or",
"VOIDmode",
"if",
"bounds",
"are",
"not",
"supported",
"."
] | [
"i386",
"0",
"\"Pointer Checker requires MPX support on this target.\"",
"\" Use -mmpx options to enable MPX.\""
] | i3867 | ix86_mpx_bound_mode | i386 | CPU | GCC | 18,504 | 32 | 1 | [] |
[
"<s>",
"bool",
"SparcInstrInfo",
"::",
"reverseBranchCondition",
"(",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
")",
"const",
"{",
"assert",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"1",
")",
";",
"SPCC",
"::",
"CondCodes",
"CC",
"=",
"static_cast",
"<",
"SPCC",
"::",
"CondCodes",
">",
"(",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
";",
"Cond",
"[",
"0",
"]",
".",
"setImm",
"(",
"GetOppositeBranchCondition",
"(",
"CC",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Reverses",
"the",
"branch",
"condition",
"of",
"the",
"specified",
"condition",
"list",
",",
"returning",
"false",
"on",
"success",
"and",
"true",
"if",
"it",
"can",
"not",
"be",
"reversed",
"."
] | [
"Sparc",
"Sparc",
"1",
"SPCC::CondCodes",
"SPCC::CondCodes",
"0",
"0"
] | SparcInstrInfo1 | reverseBranchCondition | Sparc | CPU | LLVM | 18,505 | 64 | 1 | [] |
[
"<s>",
"static",
"void",
"xtensa_conditional_register_usage",
"(",
"void",
")",
"{",
"unsigned",
"i",
",",
"c_mask",
";",
"c_mask",
"=",
"TARGET_WINDOWED_ABI",
"?",
"(",
"1",
"<<",
"1",
")",
":",
"(",
"1",
"<<",
"2",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
")",
"{",
"if",
"(",
"call_used_regs",
"[",
"i",
"]",
">",
"1",
")",
"call_used_regs",
"[",
"i",
"]",
"=",
"!",
"!",
"(",
"call_used_regs",
"[",
"i",
"]",
"&",
"c_mask",
")",
";",
"}",
"CLEAR_HARD_REG_BIT",
"(",
"reg_class_contents",
"[",
"(",
"int",
")",
"RL_REGS",
"]",
",",
"HARD_FRAME_POINTER_REGNUM",
")",
";",
"if",
"(",
"!",
"TARGET_WINDOWED_ABI",
")",
"fixed_regs",
"[",
"A0_REG",
"]",
"=",
"0",
";",
"}",
"</s>"
] | [
"Update",
"register",
"usage",
"after",
"having",
"seen",
"the",
"compiler",
"flags",
"."
] | [
"xtensa",
"1",
"1",
"1",
"2",
"0",
"1",
"0"
] | xtensa1 | xtensa_conditional_register_usage | xtensa | MPU | GCC | 18,506 | 94 | 1 | [] |
[
"<s>",
"bool",
"ARMSubtarget",
"::",
"enablePostRAScheduler",
"(",
")",
"const",
"{",
"return",
"(",
"!",
"isThumb",
"(",
")",
"||",
"hasThumb2",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"subtarget",
"should",
"run",
"a",
"scheduler",
"after",
"register",
"allocation",
"."
] | [
"ARM",
"ARM"
] | ARMSubtarget60 | enablePostRAScheduler | ARM | CPU | LLVM | 18,507 | 21 | 1 | [] |
[
"<s>",
"void",
"AArch64AsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
")",
"const",
"{",
"unsigned",
"NumBytes",
"=",
"getFixupKindNumBytes",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"if",
"(",
"!",
"Value",
")",
"return",
";",
"MCFixupKindInfo",
"Info",
"=",
"getFixupKindInfo",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"MCContext",
"&",
"Ctx",
"=",
"Asm",
".",
"getContext",
"(",
")",
";",
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
",",
"Value",
",",
"Ctx",
",",
"TheTriple",
",",
"IsResolved",
")",
";",
"Value",
"<<=",
"Info",
".",
"TargetOffset",
";",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"assert",
"(",
"Offset",
"+",
"NumBytes",
"<=",
"Data",
".",
"size",
"(",
")",
"&&",
"\"Invalid fixup offset!\"",
")",
";",
"unsigned",
"FulleSizeInBytes",
"=",
"getFixupKindContainereSizeInBytes",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"if",
"(",
"FulleSizeInBytes",
"==",
"0",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"Data",
"[",
"Offset",
"+",
"i",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"else",
"{",
"assert",
"(",
"(",
"Offset",
"+",
"FulleSizeInBytes",
")",
"<=",
"Data",
".",
"size",
"(",
")",
"&&",
"\"Invalid fixup size!\"",
")",
";",
"assert",
"(",
"NumBytes",
"<=",
"FulleSizeInBytes",
"&&",
"\"Invalid fixup size!\"",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"unsigned",
"Idx",
"=",
"FulleSizeInBytes",
"-",
"1",
"-",
"i",
";",
"Data",
"[",
"Offset",
"+",
"Idx",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"AArch64",
"AArch64",
"\"Invalid fixup offset!\"",
"0",
"0",
"8",
"0xff",
"\"Invalid fixup size!\"",
"\"Invalid fixup size!\"",
"0",
"1",
"8",
"0xff"
] | AArch64AsmBackend12 | applyFixup | AArch64 | CPU | LLVM | 18,508 | 255 | 1 | [] |
[
"<s>",
"bool",
"SystemZPassConfig",
"::",
"addPreSched2",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"getSystemZTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
"->",
"hasLoadStoreOnCond",
"(",
")",
")",
"addPass",
"(",
"&",
"IfConverterID",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"prolog-epilog",
"insertion",
"and",
"before",
"the",
"second",
"instruction",
"scheduling",
"pass",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ"
] | SystemZTargetMachine | addPreSched2 | SystemZ | CPU | LLVM | 18,509 | 39 | 1 | [] |
[
"<s>",
"void",
"s390_expand_atomic",
"(",
"machine_mode",
"mode",
",",
"enum",
"rtx_code",
"code",
",",
"rtx",
"target",
",",
"rtx",
"mem",
",",
"rtx",
"val",
",",
"bool",
"after",
")",
"{",
"struct",
"alignment_context",
"ac",
";",
"rtx",
"cmp",
";",
"rtx",
"new_rtx",
"=",
"gen_reg_rtx",
"(",
"SImode",
")",
";",
"rtx",
"orig",
"=",
"gen_reg_rtx",
"(",
"SImode",
")",
";",
"rtx_code_label",
"*",
"csloop",
"=",
"gen_label_rtx",
"(",
")",
";",
"gcc_assert",
"(",
"!",
"target",
"||",
"register_operand",
"(",
"target",
",",
"VOIDmode",
")",
")",
";",
"gcc_assert",
"(",
"MEM_P",
"(",
"mem",
")",
")",
";",
"init_alignment_context",
"(",
"&",
"ac",
",",
"mem",
",",
"mode",
")",
";",
"if",
"(",
"!",
"(",
"ac",
".",
"aligned",
"&&",
"code",
"==",
"SET",
"&&",
"MEM_P",
"(",
"val",
")",
")",
")",
"val",
"=",
"s390_expand_mask_and_shift",
"(",
"val",
",",
"mode",
",",
"ac",
".",
"shift",
")",
";",
"if",
"(",
"code",
"==",
"PLUS",
"||",
"code",
"==",
"MINUS",
")",
"emit_move_insn",
"(",
"orig",
",",
"val",
")",
";",
"else",
"if",
"(",
"code",
"==",
"MULT",
"||",
"code",
"==",
"AND",
")",
"val",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"XOR",
",",
"val",
",",
"ac",
".",
"modemaski",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"cmp",
"=",
"force_reg",
"(",
"SImode",
",",
"ac",
".",
"memsi",
")",
";",
"emit_label",
"(",
"csloop",
")",
";",
"emit_move_insn",
"(",
"new_rtx",
",",
"cmp",
")",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"PLUS",
":",
"case",
"MINUS",
":",
"val",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"code",
",",
"new_rtx",
",",
"orig",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"val",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"AND",
",",
"val",
",",
"ac",
".",
"modemask",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"case",
"SET",
":",
"if",
"(",
"ac",
".",
"aligned",
"&&",
"MEM_P",
"(",
"val",
")",
")",
"store_bit_field",
"(",
"new_rtx",
",",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
",",
"0",
",",
"0",
",",
"0",
",",
"SImode",
",",
"val",
",",
"false",
",",
"false",
")",
";",
"else",
"{",
"new_rtx",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"AND",
",",
"new_rtx",
",",
"ac",
".",
"modemaski",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"new_rtx",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"IOR",
",",
"new_rtx",
",",
"val",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"}",
"break",
";",
"case",
"AND",
":",
"case",
"IOR",
":",
"case",
"XOR",
":",
"new_rtx",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"code",
",",
"new_rtx",
",",
"val",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"case",
"MULT",
":",
"new_rtx",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"AND",
",",
"new_rtx",
",",
"val",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"new_rtx",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"XOR",
",",
"new_rtx",
",",
"ac",
".",
"modemask",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"s390_emit_jump",
"(",
"csloop",
",",
"s390_emit_compare_and_swap",
"(",
"NE",
",",
"cmp",
",",
"ac",
".",
"memsi",
",",
"cmp",
",",
"new_rtx",
",",
"CCZ1mode",
")",
")",
";",
"if",
"(",
"target",
")",
"convert_move",
"(",
"target",
",",
"expand_simple_binop",
"(",
"SImode",
",",
"LSHIFTRT",
",",
"after",
"?",
"new_rtx",
":",
"cmp",
",",
"ac",
".",
"shift",
",",
"NULL_RTX",
",",
"1",
",",
"OPTAB_DIRECT",
")",
",",
"1",
")",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"atomic",
"operation",
"CODE",
"of",
"mode",
"MODE",
".",
"MEM",
"is",
"the",
"memory",
"location",
"and",
"VAL",
"the",
"value",
"to",
"play",
"with",
".",
"If",
"AFTER",
"is",
"true",
"then",
"store",
"the",
"the",
"value",
"MEM",
"holds",
"after",
"the",
"operation",
",",
"if",
"AFTER",
"is",
"false",
"then",
"store",
"the",
"value",
"MEM",
"holds",
"before",
"the",
"operation",
".",
"If",
"TARGET",
"is",
"zero",
"then",
"discard",
"that",
"value",
",",
"else",
"store",
"it",
"to",
"TARGET",
"."
] | [
"s390",
"1",
"1",
"1",
"0",
"0",
"0",
"1",
"1",
"1",
"1",
"1",
"1",
"1"
] | s3901 | s390_expand_atomic | s390 | MPU | GCC | 18,510 | 461 | 1 | [] |
[
"<s>",
"void",
"AMDGPUAsmPrinter",
"::",
"emitBasicBlockStart",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
")",
"{",
"if",
"(",
"DumpCodeInstEmitter",
"&&",
"!",
"isBlockOnlyReachableByFallthrough",
"(",
"&",
"MBB",
")",
")",
"{",
"DisasmLines",
".",
"push_back",
"(",
"(",
"Twine",
"(",
"\"BB\"",
")",
"+",
"Twine",
"(",
"getFunctionNumber",
"(",
")",
")",
"+",
"\"_\"",
"+",
"Twine",
"(",
"MBB",
".",
"getNumber",
"(",
")",
")",
"+",
"\":\"",
")",
".",
"str",
"(",
")",
")",
";",
"DisasmLineMaxLen",
"=",
"std",
"::",
"max",
"(",
"DisasmLineMaxLen",
",",
"DisasmLines",
".",
"back",
"(",
")",
".",
"size",
"(",
")",
")",
";",
"HexLines",
".",
"push_back",
"(",
"\"\"",
")",
";",
"}",
"AsmPrinter",
"::",
"emitBasicBlockStart",
"(",
"MBB",
")",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"override",
"this",
"to",
"emit",
"stuff",
"at",
"the",
"start",
"of",
"a",
"basic",
"block",
"."
] | [
"AMDGPU",
"AMDGPU",
"\"BB\"",
"\"_\"",
"\":\"",
"\"\""
] | AMDGPUAsmPrinter | emitBasicBlockStart | AMDGPU | GPU | LLVM | 18,511 | 94 | 1 | [] |
[
"<s>",
"void",
"M68kInstrInfo",
"::",
"AddZExt",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"DebugLoc",
"DL",
",",
"unsigned",
"Reg",
",",
"MVT",
"From",
",",
"MVT",
"To",
")",
"const",
"{",
"unsigned",
"Mask",
",",
"And",
";",
"if",
"(",
"From",
"==",
"MVT",
"::",
"i8",
")",
"Mask",
"=",
"0xFF",
";",
"else",
"Mask",
"=",
"0xFFFF",
";",
"if",
"(",
"To",
"==",
"MVT",
"::",
"i16",
")",
"And",
"=",
"M68k",
"::",
"AND16di",
";",
"else",
"And",
"=",
"M68k",
"::",
"AND32di",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"And",
")",
",",
"Reg",
")",
".",
"addReg",
"(",
"Reg",
")",
".",
"addImm",
"(",
"Mask",
")",
";",
"}",
"</s>"
] | [
"Add",
"appropriate",
"ZExt",
"nodes",
"."
] | [
"M68k",
"M68k",
"MVT::i8",
"0xFF",
"0xFFFF",
"MVT::i16",
"M68k::AND16di",
"M68k::AND32di"
] | M68kInstrInfo (2) | AddZExt | M68k | MPU | LLVM | 18,512 | 98 | 1 | [] |
[
"<s>",
"static",
"bool",
"v2df_reduction_p",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"GET_MODE",
"(",
"op",
")",
"!=",
"V2DFmode",
")",
"return",
"false",
";",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"op",
")",
";",
"if",
"(",
"code",
"!=",
"PLUS",
"&&",
"code",
"!=",
"SMIN",
"&&",
"code",
"!=",
"SMAX",
")",
"return",
"false",
";",
"rtx",
"concat",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"concat",
")",
"!=",
"VEC_CONCAT",
")",
"return",
"false",
";",
"rtx",
"select0",
"=",
"XEXP",
"(",
"concat",
",",
"0",
")",
";",
"rtx",
"select1",
"=",
"XEXP",
"(",
"concat",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"select0",
")",
"!=",
"VEC_SELECT",
"||",
"GET_CODE",
"(",
"select1",
")",
"!=",
"VEC_SELECT",
")",
"return",
"false",
";",
"rtx",
"reg0",
"=",
"XEXP",
"(",
"select0",
",",
"0",
")",
";",
"rtx",
"reg1",
"=",
"XEXP",
"(",
"select1",
",",
"0",
")",
";",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"reg0",
",",
"reg1",
")",
"||",
"!",
"REG_P",
"(",
"reg0",
")",
")",
"return",
"false",
";",
"rtx",
"parallel0",
"=",
"XEXP",
"(",
"select0",
",",
"1",
")",
";",
"rtx",
"parallel1",
"=",
"XEXP",
"(",
"select1",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"parallel0",
")",
"!=",
"PARALLEL",
"||",
"GET_CODE",
"(",
"parallel1",
")",
"!=",
"PARALLEL",
")",
"return",
"false",
";",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"XVECEXP",
"(",
"parallel0",
",",
"0",
",",
"0",
")",
",",
"const1_rtx",
")",
"||",
"!",
"rtx_equal_p",
"(",
"XVECEXP",
"(",
"parallel1",
",",
"0",
",",
"0",
")",
",",
"const0_rtx",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"iff",
"OP",
"matches",
"a",
"V2DF",
"reduction",
"pattern",
".",
"See",
"the",
"definition",
"of",
"vsx_reduc_",
"<",
"VEC_reduc_name",
">",
"_v2df",
"in",
"vsx.md",
"."
] | [
"powerpcspe",
"0",
"0",
"1",
"0",
"0",
"1",
"1",
"0",
"0",
"0",
"0"
] | powerpcspe | v2df_reduction_p | powerpcspe | CPU | GCC | 18,513 | 224 | 1 | [] |
[
"<s>",
"ScheduleDAGInstrs",
"*",
"createMachineScheduler",
"(",
"MachineSchedContext",
"*",
"C",
")",
"const",
"override",
"{",
"ScheduleDAGMILive",
"*",
"DAG",
"=",
"createGenericSchedLive",
"(",
"C",
")",
";",
"DAG",
"->",
"addMutation",
"(",
"createMacroFusionDAGMutation",
"(",
"DAG",
"->",
"TII",
")",
")",
";",
"return",
"DAG",
";",
"}",
"</s>"
] | [
"Create",
"an",
"instance",
"of",
"ScheduleDAGInstrs",
"to",
"be",
"run",
"within",
"the",
"standard",
"MachineScheduler",
"pass",
"for",
"this",
"function",
"and",
"target",
"at",
"the",
"current",
"optimization",
"level",
"."
] | [
"X86"
] | X86TargetMachine45 | createMachineScheduler | X86 | CPU | LLVM | 18,514 | 36 | 1 | [] |
[
"<s>",
"void",
"PPCVSXSwapRemoval",
"::",
"initialize",
"(",
"MachineFunction",
"&",
"MFParm",
")",
"{",
"MF",
"=",
"&",
"MFParm",
";",
"MRI",
"=",
"&",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"TII",
"=",
"MF",
"->",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"int",
"InitialVectorSize",
"(",
"256",
")",
";",
"SwapVector",
".",
"clear",
"(",
")",
";",
"SwapVector",
".",
"reserve",
"(",
"InitialVectorSize",
")",
";",
"EC",
"=",
"new",
"EquivalenceClasses",
"<",
"int",
">",
";",
"}",
"</s>"
] | [
"Initialize",
"the",
"strategy",
"after",
"building",
"the",
"DAG",
"for",
"a",
"new",
"region",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"256"
] | PPCVSXSwapRemoval | initialize | PowerPC | CPU | LLVM | 18,515 | 68 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_emit_binary",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"target",
",",
"rtx",
"op0",
",",
"rtx",
"op1",
")",
"{",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"target",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"GET_MODE",
"(",
"target",
")",
",",
"op0",
",",
"op1",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"instruction",
"of",
"the",
"form",
"(",
"set",
"TARGET",
"(",
"CODE",
"OP0",
"OP1",
")",
")",
"."
] | [
"mips"
] | mips3 | mips_emit_binary | mips | CPU | GCC | 18,516 | 43 | 1 | [] |
[
"<s>",
"tree",
"find_instance",
"(",
"bool",
"*",
"unsupported_builtin",
",",
"ovlddata",
"*",
"*",
"instance",
",",
"rs6000_gen_builtins",
"instance_code",
",",
"rs6000_gen_builtins",
"fcode",
",",
"tree",
"*",
"types",
",",
"tree",
"*",
"args",
")",
"{",
"while",
"(",
"*",
"instance",
"&&",
"(",
"*",
"instance",
")",
"->",
"bifid",
"!=",
"instance_code",
")",
"*",
"instance",
"=",
"(",
"*",
"instance",
")",
"->",
"next",
";",
"ovlddata",
"*",
"inst",
"=",
"*",
"instance",
";",
"gcc_assert",
"(",
"inst",
"!=",
"NULL",
")",
";",
"if",
"(",
"!",
"inst",
"->",
"fntype",
")",
"return",
"error_mark_node",
";",
"tree",
"fntype",
"=",
"rs6000_builtin_info",
"[",
"inst",
"->",
"bifid",
"]",
".",
"fntype",
";",
"tree",
"parmtype0",
"=",
"TREE_VALUE",
"(",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
")",
";",
"tree",
"parmtype1",
"=",
"TREE_VALUE",
"(",
"TREE_CHAIN",
"(",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
")",
")",
";",
"if",
"(",
"rs6000_builtin_type_compatible",
"(",
"types",
"[",
"0",
"]",
",",
"parmtype0",
")",
"&&",
"rs6000_builtin_type_compatible",
"(",
"types",
"[",
"1",
"]",
",",
"parmtype1",
")",
")",
"{",
"if",
"(",
"rs6000_builtin_decl",
"(",
"inst",
"->",
"bifid",
",",
"false",
")",
"!=",
"error_mark_node",
"&&",
"rs6000_builtin_is_supported",
"(",
"inst",
"->",
"bifid",
")",
")",
"{",
"tree",
"ret_type",
"=",
"TREE_TYPE",
"(",
"inst",
"->",
"fntype",
")",
";",
"return",
"altivec_build_resolved_builtin",
"(",
"args",
",",
"2",
",",
"fntype",
",",
"ret_type",
",",
"inst",
"->",
"bifid",
",",
"fcode",
")",
";",
"}",
"else",
"*",
"unsupported_builtin",
"=",
"true",
";",
"}",
"return",
"error_mark_node",
";",
"}",
"</s>"
] | [
"Look",
"for",
"a",
"matching",
"instance",
"in",
"a",
"chain",
"of",
"instances",
".",
"INSTANCE",
"points",
"to",
"the",
"chain",
"of",
"instances",
";",
"INSTANCE_CODE",
"is",
"the",
"code",
"identifying",
"the",
"specific",
"built-in",
"being",
"searched",
"for",
";",
"FCODE",
"is",
"the",
"overloaded",
"function",
"code",
";",
"TYPES",
"contains",
"an",
"array",
"of",
"two",
"types",
"that",
"must",
"match",
"the",
"types",
"of",
"the",
"instance",
"'s",
"parameters",
";",
"and",
"ARGS",
"contains",
"an",
"array",
"of",
"two",
"arguments",
"to",
"be",
"passed",
"to",
"the",
"instance",
".",
"If",
"found",
",",
"resolve",
"the",
"built-in",
"and",
"return",
"it",
",",
"unless",
"the",
"built-in",
"is",
"not",
"supported",
"in",
"context",
".",
"In",
"that",
"case",
",",
"set",
"UNSUPPORTED_BUILTIN",
"to",
"true",
".",
"If",
"we",
"do",
"n't",
"match",
",",
"return",
"error_mark_node",
"and",
"leave",
"UNSUPPORTED_BUILTIN",
"alone",
"."
] | [
"rs6000",
"0",
"1",
"2"
] | rs6000-c | find_instance | rs6000 | CPU | GCC | 18,517 | 196 | 1 | [] |
[
"<s>",
"void",
"SparcELFTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"Sparc",
"Sparc"
] | SparcTargetObjectFile12 | Initialize | Sparc | CPU | LLVM | 18,518 | 25 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"lowerInterleavedStore",
"(",
"StoreInst",
"*",
"SI",
",",
"ShuffleVectorInst",
"*",
"SVI",
",",
"unsigned",
"Factor",
")",
"const",
"{",
"assert",
"(",
"Factor",
">=",
"2",
"&&",
"Factor",
"<=",
"getMaxSupportedInterleaveFactor",
"(",
")",
"&&",
"\"Invalid interleave factor\"",
")",
";",
"VectorType",
"*",
"VecTy",
"=",
"SVI",
"->",
"getType",
"(",
")",
";",
"assert",
"(",
"VecTy",
"->",
"getVectorNumElements",
"(",
")",
"%",
"Factor",
"==",
"0",
"&&",
"\"Invalid interleaved store\"",
")",
";",
"unsigned",
"NumSubElts",
"=",
"VecTy",
"->",
"getVectorNumElements",
"(",
")",
"/",
"Factor",
";",
"Type",
"*",
"EltTy",
"=",
"VecTy",
"->",
"getVectorElementType",
"(",
")",
";",
"VectorType",
"*",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"EltTy",
",",
"NumSubElts",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"SI",
"->",
"getModule",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"unsigned",
"SubVecSize",
"=",
"DL",
".",
"getTypeAllocSizeInBits",
"(",
"SubVecTy",
")",
";",
"bool",
"EltIs64Bits",
"=",
"DL",
".",
"getTypeAllocSizeInBits",
"(",
"EltTy",
")",
"==",
"64",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"||",
"(",
"SubVecSize",
"!=",
"64",
"&&",
"SubVecSize",
"!=",
"128",
")",
"||",
"EltIs64Bits",
")",
"return",
"false",
";",
"Value",
"*",
"Op0",
"=",
"SVI",
"->",
"getOperand",
"(",
"0",
")",
";",
"Value",
"*",
"Op1",
"=",
"SVI",
"->",
"getOperand",
"(",
"1",
")",
";",
"IRBuilder",
"<",
">",
"Builder",
"(",
"SI",
")",
";",
"if",
"(",
"EltTy",
"->",
"isPointerTy",
"(",
")",
")",
"{",
"Type",
"*",
"IntTy",
"=",
"DL",
".",
"getIntPtrType",
"(",
"EltTy",
")",
";",
"Type",
"*",
"IntVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"IntTy",
",",
"Op0",
"->",
"getType",
"(",
")",
"->",
"getVectorNumElements",
"(",
")",
")",
";",
"Op0",
"=",
"Builder",
".",
"CreatePtrToInt",
"(",
"Op0",
",",
"IntVecTy",
")",
";",
"Op1",
"=",
"Builder",
".",
"CreatePtrToInt",
"(",
"Op1",
",",
"IntVecTy",
")",
";",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"IntTy",
",",
"NumSubElts",
")",
";",
"}",
"static",
"Intrinsic",
"::",
"ID",
"StoreInts",
"[",
"3",
"]",
"=",
"{",
"Intrinsic",
"::",
"arm_neon_vst2",
",",
"Intrinsic",
"::",
"arm_neon_vst3",
",",
"Intrinsic",
"::",
"arm_neon_vst4",
"}",
";",
"SmallVector",
"<",
"Value",
"*",
",",
"6",
">",
"Ops",
";",
"Type",
"*",
"Int8Ptr",
"=",
"Builder",
".",
"getInt8PtrTy",
"(",
"SI",
"->",
"getPointerAddressSpace",
"(",
")",
")",
";",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateBitCast",
"(",
"SI",
"->",
"getPointerOperand",
"(",
")",
",",
"Int8Ptr",
")",
")",
";",
"Type",
"*",
"Tys",
"[",
"]",
"=",
"{",
"Int8Ptr",
",",
"SubVecTy",
"}",
";",
"Function",
"*",
"VstNFunc",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"SI",
"->",
"getModule",
"(",
")",
",",
"StoreInts",
"[",
"Factor",
"-",
"2",
"]",
",",
"Tys",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Factor",
";",
"i",
"++",
")",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateShuffleVector",
"(",
"Op0",
",",
"Op1",
",",
"getSequentialMask",
"(",
"Builder",
",",
"NumSubElts",
"*",
"i",
",",
"NumSubElts",
")",
")",
")",
";",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"getInt32",
"(",
"SI",
"->",
"getAlignment",
"(",
")",
")",
")",
";",
"Builder",
".",
"CreateCall",
"(",
"VstNFunc",
",",
"Ops",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Lower",
"interleaved",
"store",
"(",
"s",
")",
"into",
"target",
"specific",
"instructions/intrinsics",
"."
] | [
"ARM",
"ARM",
"2",
"\"Invalid interleave factor\"",
"0",
"\"Invalid interleaved store\"",
"64",
"64",
"128",
"0",
"1",
"Intrinsic::ID",
"3",
"Intrinsic::arm_neon_vst2",
"Intrinsic::arm_neon_vst3",
"Intrinsic::arm_neon_vst4",
"6",
"Intrinsic::getDeclaration",
"2",
"0"
] | ARMISelLowering | lowerInterleavedStore | ARM | CPU | LLVM | 18,519 | 427 | 1 | [] |
[
"<s>",
"bool",
"LanaiInstrInfo",
"::",
"areMemAccessesTriviallyDisjoint",
"(",
"const",
"MachineInstr",
"&",
"MIa",
",",
"const",
"MachineInstr",
"&",
"MIb",
")",
"const",
"{",
"assert",
"(",
"MIa",
".",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIa must be a load or store.\"",
")",
";",
"assert",
"(",
"MIb",
".",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIb must be a load or store.\"",
")",
";",
"if",
"(",
"MIa",
".",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIb",
".",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIa",
".",
"hasOrderedMemoryRef",
"(",
")",
"||",
"MIb",
".",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"&",
"getRegisterInfo",
"(",
")",
";",
"const",
"MachineOperand",
"*",
"BaseOpA",
"=",
"nullptr",
",",
"*",
"BaseOpB",
"=",
"nullptr",
";",
"int64_t",
"OffsetA",
"=",
"0",
",",
"OffsetB",
"=",
"0",
";",
"unsigned",
"int",
"WidthA",
"=",
"0",
",",
"WidthB",
"=",
"0",
";",
"if",
"(",
"getMemOperandWithOffsetWidth",
"(",
"MIa",
",",
"BaseOpA",
",",
"OffsetA",
",",
"WidthA",
",",
"TRI",
")",
"&&",
"getMemOperandWithOffsetWidth",
"(",
"MIb",
",",
"BaseOpB",
",",
"OffsetB",
",",
"WidthB",
",",
"TRI",
")",
")",
"{",
"if",
"(",
"BaseOpA",
"->",
"isIdenticalTo",
"(",
"*",
"BaseOpB",
")",
")",
"{",
"int",
"LowOffset",
"=",
"std",
"::",
"min",
"(",
"OffsetA",
",",
"OffsetB",
")",
";",
"int",
"HighOffset",
"=",
"std",
"::",
"max",
"(",
"OffsetA",
",",
"OffsetB",
")",
";",
"int",
"LowWidth",
"=",
"(",
"LowOffset",
"==",
"OffsetA",
")",
"?",
"WidthA",
":",
"WidthB",
";",
"if",
"(",
"LowOffset",
"+",
"LowWidth",
"<=",
"HighOffset",
")",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Sometimes",
",",
"it",
"is",
"possible",
"for",
"the",
"target",
"to",
"tell",
",",
"even",
"without",
"aliasing",
"information",
",",
"that",
"two",
"MIs",
"access",
"different",
"memory",
"addresses",
"."
] | [
"Lanai",
"Lanai",
"\"MIa must be a load or store.\"",
"\"MIb must be a load or store.\"",
"0",
"0",
"0",
"0"
] | LanaiInstrInfo1 | areMemAccessesTriviallyDisjoint | Lanai | CPU | LLVM | 18,520 | 203 | 1 | [] |
[
"<s>",
"static",
"rtx_insn",
"*",
"find_prev_insn_start",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"insn",
"=",
"PREV_INSN",
"(",
"insn",
")",
";",
"gcc_assert",
"(",
"GET_MODE",
"(",
"insn",
")",
"!=",
"SImode",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"insn",
")",
"==",
"QImode",
")",
"{",
"while",
"(",
"GET_MODE",
"(",
"PREV_INSN",
"(",
"insn",
")",
")",
"==",
"SImode",
")",
"insn",
"=",
"PREV_INSN",
"(",
"insn",
")",
";",
"}",
"return",
"insn",
";",
"}",
"</s>"
] | [
"This",
"function",
"acts",
"like",
"PREV_INSN",
",",
"but",
"is",
"aware",
"of",
"three-insn",
"bundles",
"and",
"skips",
"all",
"subsequent",
"parallel",
"instructions",
"if",
"INSN",
"is",
"the",
"start",
"of",
"such",
"a",
"group",
"."
] | [
"bfin"
] | bfin | find_prev_insn_start | bfin | DSP | GCC | 18,521 | 61 | 1 | [] |
[
"<s>",
"static",
"void",
"m32c_print_operand_address",
"(",
"FILE",
"*",
"stream",
",",
"rtx",
"address",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"address",
")",
"==",
"MEM",
")",
"address",
"=",
"XEXP",
"(",
"address",
",",
"0",
")",
";",
"else",
"gcc_assert",
"(",
"GET_CODE",
"(",
"address",
")",
"==",
"REG",
")",
";",
"m32c_print_operand",
"(",
"stream",
",",
"address",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"Implements",
"PRINT_OPERAND_ADDRESS",
".",
"Nothing",
"unusual",
"here",
"."
] | [
"m32c",
"0",
"0"
] | m32c3 | m32c_print_operand_address | m32c | MPU | GCC | 18,522 | 51 | 1 | [] |
[
"<s>",
"static",
"void",
"core2i7_first_cycle_multipass_backtrack",
"(",
"const",
"void",
"*",
"_data",
",",
"signed",
"char",
"*",
"ready_try",
",",
"int",
"n_ready",
"ATTRIBUTE_UNUSED",
")",
"{",
"const_ix86_first_cycle_multipass_data_t",
"data",
"=",
"(",
"const_ix86_first_cycle_multipass_data_t",
")",
"_data",
";",
"unsigned",
"int",
"i",
"=",
"0",
";",
"sbitmap_iterator",
"sbi",
";",
"gcc_assert",
"(",
"bitmap_last_set_bit",
"(",
"data",
"->",
"ready_try_change",
")",
"<",
"n_ready",
")",
";",
"EXECUTE_IF_SET_IN_BITMAP",
"(",
"data",
"->",
"ready_try_change",
",",
"0",
",",
"i",
",",
"sbi",
")",
"{",
"ready_try",
"[",
"i",
"]",
"=",
"0",
";",
"}",
"}",
"</s>"
] | [
"Revert",
"the",
"effect",
"on",
"ready_try",
"."
] | [
"i386",
"0",
"0",
"0"
] | i3864 | core2i7_first_cycle_multipass_backtrack | i386 | CPU | GCC | 18,523 | 70 | 1 | [] |
[
"<s>",
"SDValue",
"HexagonTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"Op",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"Op",
".",
"getNode",
"(",
")",
"->",
"dumpr",
"(",
"&",
"DAG",
")",
";",
"if",
"(",
"Opc",
">",
"HexagonISD",
"::",
"OP_BEGIN",
"&&",
"Opc",
"<",
"HexagonISD",
"::",
"OP_END",
")",
"errs",
"(",
")",
"<<",
"\"Check for a non-legal type in this operation\\n\"",
";",
"llvm_unreachable",
"(",
"\"Should not custom lower this!\"",
")",
";",
"case",
"ISD",
"::",
"CONCAT_VECTORS",
":",
"return",
"LowerCONCAT_VECTORS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INSERT_SUBVECTOR",
":",
"return",
"LowerINSERT_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INSERT_VECTOR_ELT",
":",
"return",
"LowerINSERT_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
":",
"return",
"LowerEXTRACT_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
":",
"return",
"LowerEXTRACT_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BUILD_VECTOR",
":",
"return",
"LowerBUILD_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VECTOR_SHUFFLE",
":",
"return",
"LowerVECTOR_SHUFFLE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRL",
":",
"return",
"LowerVECTOR_SHIFT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"LowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"LowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EH_RETURN",
":",
"return",
"LowerEH_RETURN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"return",
"LowerGlobalTLSAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ATOMIC_FENCE",
":",
"return",
"LowerATOMIC_FENCE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGLOBALADDRESS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"LowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GLOBAL_OFFSET_TABLE",
":",
"return",
"LowerGLOBAL_OFFSET_TABLE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SETCC",
":",
"return",
"LowerSETCC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VSELECT",
":",
"return",
"LowerVSELECT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_VOID",
":",
"return",
"LowerINTRINSIC_VOID",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INLINEASM",
":",
"return",
"LowerINLINEASM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"PREFETCH",
":",
"return",
"LowerPREFETCH",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"READCYCLECOUNTER",
":",
"return",
"LowerREADCYCLECOUNTER",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"Hexagon",
"Hexagon",
"HexagonISD::OP_BEGIN",
"HexagonISD::OP_END",
"\"Check for a non-legal type in this operation\\n\"",
"\"Should not custom lower this!\"",
"ISD::CONCAT_VECTORS",
"ISD::INSERT_SUBVECTOR",
"ISD::INSERT_VECTOR_ELT",
"ISD::EXTRACT_SUBVECTOR",
"ISD::EXTRACT_VECTOR_ELT",
"ISD::BUILD_VECTOR",
"ISD::VECTOR_SHUFFLE",
"ISD::SRA",
"ISD::SHL",
"ISD::SRL",
"ISD::ConstantPool",
"ISD::JumpTable",
"ISD::EH_RETURN",
"ISD::RETURNADDR",
"ISD::FRAMEADDR",
"ISD::GlobalTLSAddress",
"ISD::ATOMIC_FENCE",
"ISD::GlobalAddress",
"ISD::BlockAddress",
"ISD::GLOBAL_OFFSET_TABLE",
"ISD::VASTART",
"ISD::DYNAMIC_STACKALLOC",
"ISD::SETCC",
"ISD::VSELECT",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::INTRINSIC_VOID",
"ISD::INLINEASM",
"ISD::PREFETCH",
"ISD::READCYCLECOUNTER"
] | HexagonISelLowering22 | LowerOperation | Hexagon | DSP | LLVM | 18,524 | 430 | 1 | [] |
[
"<s>",
"bool",
"LC3TargetLowering",
"::",
"CanLowerReturn",
"(",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"MachineFunction",
"&",
"MF",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"LLVMContext",
"&",
"Context",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"MF",
",",
"RVLocs",
",",
"Context",
")",
";",
"if",
"(",
"!",
"CCInfo",
".",
"CheckReturn",
"(",
"Outs",
",",
"RetCC_LC3",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"CCInfo",
".",
"getNextStackOffset",
"(",
")",
"!=",
"0",
"&&",
"isVarArg",
")",
"{",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"should",
"be",
"implemented",
"to",
"check",
"whether",
"the",
"return",
"values",
"described",
"by",
"the",
"Outs",
"array",
"can",
"fit",
"into",
"the",
"return",
"registers",
"."
] | [
"LC3",
"LC3",
"ISD::OutputArg",
"16",
"LC3",
"0"
] | LC3ISelLowering | CanLowerReturn | LC3 | CPU | LLVM | 18,525 | 93 | 1 | [] |
[
"<s>",
"void",
"ThumbRegisterInfo",
"::",
"emitLoadConstPool",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"const",
"DebugLoc",
"&",
"dl",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SubIdx",
",",
"int",
"Val",
",",
"ARMCC",
"::",
"CondCodes",
"Pred",
",",
"unsigned",
"PredReg",
",",
"unsigned",
"MIFlags",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"if",
"(",
"STI",
".",
"isThumb1Only",
"(",
")",
")",
"{",
"assert",
"(",
"(",
"isARMLowRegister",
"(",
"DestReg",
")",
"||",
"Register",
"::",
"isVirtualRegister",
"(",
"DestReg",
")",
")",
"&&",
"\"Thumb1 does not have ldr to high register\"",
")",
";",
"return",
"emitThumb1LoadConstPool",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"DestReg",
",",
"SubIdx",
",",
"Val",
",",
"Pred",
",",
"PredReg",
",",
"MIFlags",
")",
";",
"}",
"return",
"emitThumb2LoadConstPool",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"DestReg",
",",
"SubIdx",
",",
"Val",
",",
"Pred",
",",
"PredReg",
",",
"MIFlags",
")",
";",
"}",
"</s>"
] | [
"emitLoadConstPool",
"-",
"Emits",
"a",
"load",
"from",
"constpool",
"to",
"materialize",
"the",
"specified",
"immediate",
"."
] | [
"ARM",
"ARMCC::CondCodes",
"ARM",
"ARM",
"ARM",
"\"Thumb1 does not have ldr to high register\""
] | ThumbRegisterInfo3 | emitLoadConstPool | ARM | CPU | LLVM | 18,526 | 141 | 1 | [] |
[
"<s>",
"uint64_t",
"SIMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"MRI",
".",
"getEncodingValue",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"MO",
".",
"getExpr",
"(",
")",
"->",
"getKind",
"(",
")",
"!=",
"MCExpr",
"::",
"Constant",
")",
"{",
"const",
"auto",
"*",
"Expr",
"=",
"dyn_cast",
"<",
"MCSymbolRefExpr",
">",
"(",
"MO",
".",
"getExpr",
"(",
")",
")",
";",
"MCFixupKind",
"Kind",
";",
"if",
"(",
"Expr",
"&&",
"Expr",
"->",
"getSymbol",
"(",
")",
".",
"isExternal",
"(",
")",
")",
"Kind",
"=",
"FK_Data_4",
";",
"else",
"Kind",
"=",
"FK_PCRel_4",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"4",
",",
"MO",
".",
"getExpr",
"(",
")",
",",
"Kind",
",",
"MI",
".",
"getLoc",
"(",
")",
")",
")",
";",
"}",
"unsigned",
"OpNo",
"=",
"0",
";",
"for",
"(",
"unsigned",
"e",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"OpNo",
"<",
"e",
";",
"++",
"OpNo",
")",
"{",
"if",
"(",
"&",
"MO",
"==",
"&",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
")",
"break",
";",
"}",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"AMDGPU",
"::",
"isSISrcOperand",
"(",
"Desc",
",",
"OpNo",
")",
")",
"{",
"uint32_t",
"Enc",
"=",
"getLitEncoding",
"(",
"MO",
",",
"Desc",
".",
"OpInfo",
"[",
"OpNo",
"]",
",",
"STI",
")",
";",
"if",
"(",
"Enc",
"!=",
"~",
"0U",
"&&",
"(",
"Enc",
"!=",
"255",
"||",
"Desc",
".",
"getSize",
"(",
")",
"==",
"4",
")",
")",
"return",
"Enc",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"llvm_unreachable",
"(",
"\"Encoding of this operand type is not supported yet.\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"AMDGPU",
"SI",
"4",
"0",
"AMDGPU::isSISrcOperand",
"0U",
"255",
"4",
"\"Encoding of this operand type is not supported yet.\"",
"0"
] | SIMCCodeEmitter2 | getMachineOpValue | AMDGPU | GPU | LLVM | 18,527 | 277 | 1 | [] |
[
"<s>",
"const",
"NVPTXFloatMCExpr",
"*",
"NVPTXFloatMCExpr",
"::",
"Create",
"(",
"VariantKind",
"Kind",
",",
"APFloat",
"Flt",
",",
"MCContext",
"&",
"Ctx",
")",
"{",
"return",
"new",
"(",
"Ctx",
")",
"NVPTXFloatMCExpr",
"(",
"Kind",
",",
"Flt",
")",
";",
"}",
"</s>"
] | [
"Construct",
"a",
"unary",
"instruction",
",",
"given",
"the",
"opcode",
"and",
"an",
"operand",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX"
] | NVPTXMCExpr | Create | NVPTX | GPU | LLVM | 18,528 | 31 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isLegalAddImmediate",
"(",
"int64_t",
"Imm",
")",
"const",
"{",
"int64_t",
"AbsImm",
"=",
"llvm",
"::",
"abs64",
"(",
"Imm",
")",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"ARM_AM",
"::",
"getSOImmVal",
"(",
"AbsImm",
")",
"!=",
"-",
"1",
";",
"if",
"(",
"Subtarget",
"->",
"isThumb2",
"(",
")",
")",
"return",
"ARM_AM",
"::",
"getT2SOImmVal",
"(",
"AbsImm",
")",
"!=",
"-",
"1",
";",
"return",
"AbsImm",
">=",
"0",
"&&",
"AbsImm",
"<=",
"255",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"immediate",
"is",
"legal",
"add",
"immediate",
",",
"that",
"is",
"the",
"target",
"has",
"add",
"instructions",
"which",
"can",
"add",
"a",
"register",
"and",
"the",
"immediate",
"without",
"having",
"to",
"materialize",
"the",
"immediate",
"into",
"a",
"register",
"."
] | [
"ARM",
"ARM",
"ARM_AM::getSOImmVal",
"1",
"ARM_AM::getT2SOImmVal",
"1",
"0",
"255"
] | ARMISelLowering (2) | isLegalAddImmediate | ARM | CPU | LLVM | 18,529 | 69 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_nsaved_sseregs",
"(",
"void",
")",
"{",
"int",
"nregs",
"=",
"0",
";",
"int",
"regno",
";",
"if",
"(",
"!",
"TARGET_64BIT_MS_ABI",
")",
"return",
"0",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"SSE_REGNO_P",
"(",
"regno",
")",
"&&",
"ix86_save_reg",
"(",
"regno",
",",
"true",
",",
"true",
")",
")",
"nregs",
"++",
";",
"return",
"nregs",
";",
"}",
"</s>"
] | [
"Return",
"number",
"of",
"saved",
"SSE",
"registrers",
"."
] | [
"i386",
"0",
"0",
"0"
] | i386 | ix86_nsaved_sseregs | i386 | CPU | GCC | 18,530 | 59 | 1 | [] |
[
"<s>",
"virtual",
"void",
"EmitInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
")",
"{",
"if",
"(",
"InstPrinter",
")",
"InstPrinter",
"->",
"printInst",
"(",
"&",
"Inst",
",",
"OS",
",",
"\"\"",
")",
";",
"else",
"Inst",
".",
"print",
"(",
"OS",
",",
"&",
"MAI",
")",
";",
"EmitEOL",
"(",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"Cpu0",
"\"\""
] | Cpu0AsmStreamer | EmitInstruction | Cpu0 | CPU | LLVM | 18,531 | 42 | 1 | [] |
[
"<s>",
"void",
"sh_emit_compare_and_branch",
"(",
"rtx",
"*",
"operands",
",",
"machine_mode",
"mode",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"enum",
"rtx_code",
"branch_code",
";",
"rtx",
"op0",
"=",
"operands",
"[",
"1",
"]",
";",
"rtx",
"op1",
"=",
"operands",
"[",
"2",
"]",
";",
"rtx",
"insn",
";",
"bool",
"need_ccmpeq",
"=",
"false",
";",
"if",
"(",
"TARGET_SH2E",
"&&",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_FLOAT",
")",
"{",
"op0",
"=",
"force_reg",
"(",
"mode",
",",
"op0",
")",
";",
"op1",
"=",
"force_reg",
"(",
"mode",
",",
"op1",
")",
";",
"}",
"else",
"{",
"if",
"(",
"code",
"!=",
"EQ",
"||",
"mode",
"==",
"DImode",
")",
"{",
"op0",
"=",
"force_reg",
"(",
"mode",
",",
"op0",
")",
";",
"if",
"(",
"op1",
"!=",
"const0_rtx",
"||",
"code",
"==",
"GTU",
"||",
"code",
"==",
"GEU",
")",
"op1",
"=",
"force_reg",
"(",
"mode",
",",
"op1",
")",
";",
"}",
"}",
"if",
"(",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_FLOAT",
")",
"{",
"if",
"(",
"code",
"==",
"LT",
"||",
"(",
"code",
"==",
"LE",
"&&",
"TARGET_IEEE",
"&&",
"TARGET_SH2E",
")",
"||",
"(",
"code",
"==",
"GE",
"&&",
"!",
"(",
"TARGET_IEEE",
"&&",
"TARGET_SH2E",
")",
")",
")",
"{",
"std",
"::",
"swap",
"(",
"op0",
",",
"op1",
")",
";",
"code",
"=",
"swap_condition",
"(",
"code",
")",
";",
"}",
"if",
"(",
"code",
"==",
"GE",
")",
"{",
"gcc_assert",
"(",
"TARGET_IEEE",
"&&",
"TARGET_SH2E",
")",
";",
"need_ccmpeq",
"=",
"true",
";",
"code",
"=",
"GT",
";",
"}",
"gcc_assert",
"(",
"code",
"==",
"EQ",
"||",
"code",
"==",
"GT",
"||",
"code",
"==",
"NE",
"||",
"code",
"==",
"LE",
")",
";",
"}",
"switch",
"(",
"code",
")",
"{",
"case",
"EQ",
":",
"case",
"GT",
":",
"case",
"GE",
":",
"case",
"GTU",
":",
"case",
"GEU",
":",
"branch_code",
"=",
"code",
";",
"break",
";",
"case",
"NE",
":",
"case",
"LT",
":",
"case",
"LE",
":",
"case",
"LTU",
":",
"case",
"LEU",
":",
"branch_code",
"=",
"reverse_condition",
"(",
"code",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"insn",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"get_t_reg_rtx",
"(",
")",
",",
"gen_rtx_fmt_ee",
"(",
"branch_code",
",",
"SImode",
",",
"op0",
",",
"op1",
")",
")",
";",
"sh_emit_set_t_insn",
"(",
"insn",
",",
"mode",
")",
";",
"if",
"(",
"need_ccmpeq",
")",
"sh_emit_set_t_insn",
"(",
"gen_ieee_ccmpeqsf_t",
"(",
"op0",
",",
"op1",
")",
",",
"mode",
")",
";",
"if",
"(",
"branch_code",
"==",
"code",
")",
"emit_jump_insn",
"(",
"gen_branch_true",
"(",
"operands",
"[",
"3",
"]",
")",
")",
";",
"else",
"emit_jump_insn",
"(",
"gen_branch_false",
"(",
"operands",
"[",
"3",
"]",
")",
")",
";",
"}",
"</s>"
] | [
"Called",
"from",
"the",
"md",
"file",
",",
"set",
"up",
"the",
"operands",
"of",
"a",
"compare",
"instruction",
"."
] | [
"sh",
"0",
"1",
"2",
"3",
"3"
] | sh4 | sh_emit_compare_and_branch | sh | CPU | GCC | 18,532 | 361 | 1 | [] |
[
"<s>",
"bool",
"ARCompactTargetMachine",
"::",
"addPreSched2",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"if",
"(",
"OptLevel",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"PM",
".",
"add",
"(",
"createIfConverterPass",
"(",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"prolog-epilog",
"insertion",
"and",
"before",
"the",
"second",
"instruction",
"scheduling",
"pass",
"."
] | [
"ARCompact",
"ARC"
] | ARCompactTargetMachine | addPreSched2 | ARCompact | MPU | LLVM | 18,533 | 38 | 1 | [] |
[
"<s>",
"void",
"SIFrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"GCNSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"FuncInfo",
"->",
"removeDeadFrameIndices",
"(",
"MFI",
")",
";",
"assert",
"(",
"allSGPRSpillsAreDead",
"(",
"MFI",
",",
"None",
",",
"None",
")",
"&&",
"\"SGPR spill should have been removed in SILowerSGPRSpills\"",
")",
";",
"if",
"(",
"!",
"allStackObjectsAreDead",
"(",
"MFI",
")",
")",
"{",
"assert",
"(",
"RS",
"&&",
"\"RegScavenger required if spilling\"",
")",
";",
"if",
"(",
"FuncInfo",
"->",
"isEntryFunction",
"(",
")",
")",
"{",
"int",
"ScavengeFI",
"=",
"MFI",
".",
"CreateFixedObject",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"AMDGPU",
"::",
"SGPR_32RegClass",
")",
",",
"0",
",",
"false",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"ScavengeFI",
")",
";",
"}",
"else",
"{",
"int",
"ScavengeFI",
"=",
"MFI",
".",
"CreateStackObject",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"AMDGPU",
"::",
"SGPR_32RegClass",
")",
",",
"TRI",
"->",
"getSpillAlignment",
"(",
"AMDGPU",
"::",
"SGPR_32RegClass",
")",
",",
"false",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"ScavengeFI",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"\"SGPR spill should have been removed in SILowerSGPRSpills\"",
"\"RegScavenger required if spilling\"",
"AMDGPU::SGPR_32RegClass",
"0",
"AMDGPU::SGPR_32RegClass",
"AMDGPU::SGPR_32RegClass"
] | SIFrameLowering1 | processFunctionBeforeFrameFinalized | AMDGPU | GPU | LLVM | 18,534 | 178 | 1 | [] |
[
"<s>",
"bool",
"SystemZShortenInst",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"F",
")",
"{",
"const",
"SystemZSubtarget",
"&",
"ST",
"=",
"F",
".",
"getSubtarget",
"<",
"SystemZSubtarget",
">",
"(",
")",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"LiveRegs",
".",
"init",
"(",
"TRI",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"F",
")",
"Changed",
"|=",
"processBlock",
"(",
"MBB",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ"
] | SystemZShortenInst2 | runOnMachineFunction | SystemZ | CPU | LLVM | 18,535 | 71 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"rs6000_starting_frame_offset",
"(",
"void",
")",
"{",
"if",
"(",
"FRAME_GROWS_DOWNWARD",
")",
"return",
"0",
";",
"return",
"RS6000_STARTING_FRAME_OFFSET",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_STARTING_FRAME_OFFSET",
"."
] | [
"rs6000",
"0"
] | rs6000 | rs6000_starting_frame_offset | rs6000 | CPU | GCC | 18,536 | 18 | 1 | [] |
[
"<s>",
"MCDisassembler",
"::",
"DecodeStatus",
"X86GenericDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"Instr",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"CStream",
")",
"const",
"{",
"CommentStream",
"=",
"&",
"CStream",
";",
"InternalInstruction",
"Insn",
";",
"memset",
"(",
"&",
"Insn",
",",
"0",
",",
"sizeof",
"(",
"InternalInstruction",
")",
")",
";",
"Insn",
".",
"bytes",
"=",
"Bytes",
";",
"Insn",
".",
"startLocation",
"=",
"Address",
";",
"Insn",
".",
"readerCursor",
"=",
"Address",
";",
"Insn",
".",
"mode",
"=",
"fMode",
";",
"if",
"(",
"Bytes",
".",
"empty",
"(",
")",
"||",
"readPrefixes",
"(",
"&",
"Insn",
")",
"||",
"readOpcode",
"(",
"&",
"Insn",
")",
"||",
"getInstructionID",
"(",
"&",
"Insn",
",",
"MII",
".",
"get",
"(",
")",
")",
"||",
"Insn",
".",
"instructionID",
"==",
"0",
"||",
"readOperands",
"(",
"&",
"Insn",
")",
")",
"{",
"Size",
"=",
"Insn",
".",
"readerCursor",
"-",
"Address",
";",
"return",
"Fail",
";",
"}",
"Insn",
".",
"operands",
"=",
"x86OperandSets",
"[",
"Insn",
".",
"spec",
"->",
"operands",
"]",
";",
"Insn",
".",
"length",
"=",
"Insn",
".",
"readerCursor",
"-",
"Insn",
".",
"startLocation",
";",
"Size",
"=",
"Insn",
".",
"length",
";",
"if",
"(",
"Size",
">",
"15",
")",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Instruction exceeds 15-byte limit\"",
")",
";",
"bool",
"Ret",
"=",
"translateInstruction",
"(",
"Instr",
",",
"Insn",
",",
"this",
")",
";",
"if",
"(",
"!",
"Ret",
")",
"{",
"unsigned",
"Flags",
"=",
"X86",
"::",
"IP_NO_PREFIX",
";",
"if",
"(",
"Insn",
".",
"hasAdSize",
")",
"Flags",
"|=",
"X86",
"::",
"IP_HAS_AD_SIZE",
";",
"if",
"(",
"!",
"Insn",
".",
"mandatoryPrefix",
")",
"{",
"if",
"(",
"Insn",
".",
"hasOpSize",
")",
"Flags",
"|=",
"X86",
"::",
"IP_HAS_OP_SIZE",
";",
"if",
"(",
"Insn",
".",
"repeatPrefix",
"==",
"0xf2",
")",
"Flags",
"|=",
"X86",
"::",
"IP_HAS_REPEAT_NE",
";",
"else",
"if",
"(",
"Insn",
".",
"repeatPrefix",
"==",
"0xf3",
"&&",
"Insn",
".",
"opcode",
"!=",
"0x90",
")",
"Flags",
"|=",
"X86",
"::",
"IP_HAS_REPEAT",
";",
"if",
"(",
"Insn",
".",
"hasLockPrefix",
")",
"Flags",
"|=",
"X86",
"::",
"IP_HAS_LOCK",
";",
"}",
"Instr",
".",
"setFlags",
"(",
"Flags",
")",
";",
"}",
"return",
"(",
"!",
"Ret",
")",
"?",
"Success",
":",
"Fail",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"X86",
"X86",
"0",
"0",
"15",
"\"Instruction exceeds 15-byte limit\"",
"X86::IP_NO_PREFIX",
"X86::IP_HAS_AD_SIZE",
"X86::IP_HAS_OP_SIZE",
"0xf2",
"X86::IP_HAS_REPEAT_NE",
"0xf3",
"0x90",
"X86::IP_HAS_REPEAT",
"X86::IP_HAS_LOCK"
] | X86Disassembler (2)2 | getInstruction | X86 | CPU | LLVM | 18,537 | 302 | 1 | [] |
[
"<s>",
"void",
"addPreSched2",
"(",
")",
"override",
"{",
"if",
"(",
"PatmosSinglePathInfo",
"::",
"isEnabled",
"(",
")",
")",
"{",
"addPass",
"(",
"createPatmosSinglePathInfoPass",
"(",
"getPatmosTargetMachine",
"(",
")",
")",
")",
";",
"addPass",
"(",
"createPatmosSPBundlingPass",
"(",
"getPatmosTargetMachine",
"(",
")",
")",
")",
";",
"addPass",
"(",
"createPatmosSPReducePass",
"(",
"getPatmosTargetMachine",
"(",
")",
")",
")",
";",
"addPass",
"(",
"createSPSchedulerPass",
"(",
"getPatmosTargetMachine",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"!",
"DisableIfConverter",
")",
"{",
"addPass",
"(",
"&",
"IfConverterID",
")",
";",
"addPass",
"(",
"&",
"UnreachableMachineBlockElimID",
")",
";",
"}",
"}",
"addPass",
"(",
"createPatmosStackCacheAnalysisInfo",
"(",
"getPatmosTargetMachine",
"(",
")",
")",
")",
";",
"if",
"(",
"EnableStackCacheAnalysis",
")",
"{",
"addPass",
"(",
"createPatmosStackCacheAnalysis",
"(",
"getPatmosTargetMachine",
"(",
")",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"prolog-epilog",
"insertion",
"and",
"before",
"the",
"second",
"instruction",
"scheduling",
"pass",
"."
] | [
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos",
"Patmos"
] | PatmosTargetMachine1 | addPreSched2 | Patmos | VLIW | LLVM | 18,538 | 113 | 1 | [] |
[
"<s>",
"int",
"expand_block_clear",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"orig_dest",
"=",
"operands",
"[",
"0",
"]",
";",
"rtx",
"bytes_rtx",
"=",
"operands",
"[",
"1",
"]",
";",
"rtx",
"align_rtx",
"=",
"operands",
"[",
"3",
"]",
";",
"bool",
"constp",
"=",
"(",
"GET_CODE",
"(",
"bytes_rtx",
")",
"==",
"CONST_INT",
")",
";",
"HOST_WIDE_INT",
"align",
";",
"HOST_WIDE_INT",
"bytes",
";",
"int",
"offset",
";",
"int",
"clear_bytes",
";",
"int",
"clear_step",
";",
"if",
"(",
"!",
"constp",
")",
"return",
"0",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"align_rtx",
")",
"==",
"CONST_INT",
")",
";",
"align",
"=",
"INTVAL",
"(",
"align_rtx",
")",
"*",
"BITS_PER_UNIT",
";",
"bytes",
"=",
"INTVAL",
"(",
"bytes_rtx",
")",
";",
"if",
"(",
"bytes",
"<=",
"0",
")",
"return",
"1",
";",
"if",
"(",
"TARGET_ALTIVEC",
"&&",
"align",
">=",
"128",
")",
"clear_step",
"=",
"16",
";",
"else",
"if",
"(",
"TARGET_POWERPC64",
"&&",
"(",
"align",
">=",
"64",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"clear_step",
"=",
"8",
";",
"else",
"if",
"(",
"TARGET_SPE",
"&&",
"align",
">=",
"64",
")",
"clear_step",
"=",
"8",
";",
"else",
"clear_step",
"=",
"4",
";",
"if",
"(",
"optimize_size",
"&&",
"bytes",
">",
"3",
"*",
"clear_step",
")",
"return",
"0",
";",
"if",
"(",
"!",
"optimize_size",
"&&",
"bytes",
">",
"8",
"*",
"clear_step",
")",
"return",
"0",
";",
"for",
"(",
"offset",
"=",
"0",
";",
"bytes",
">",
"0",
";",
"offset",
"+=",
"clear_bytes",
",",
"bytes",
"-=",
"clear_bytes",
")",
"{",
"machine_mode",
"mode",
"=",
"BLKmode",
";",
"rtx",
"dest",
";",
"if",
"(",
"bytes",
">=",
"16",
"&&",
"TARGET_ALTIVEC",
"&&",
"align",
">=",
"128",
")",
"{",
"clear_bytes",
"=",
"16",
";",
"mode",
"=",
"V4SImode",
";",
"}",
"else",
"if",
"(",
"bytes",
">=",
"8",
"&&",
"TARGET_SPE",
"&&",
"align",
">=",
"64",
")",
"{",
"clear_bytes",
"=",
"8",
";",
"mode",
"=",
"V2SImode",
";",
"}",
"else",
"if",
"(",
"bytes",
">=",
"8",
"&&",
"TARGET_POWERPC64",
"&&",
"(",
"align",
">=",
"64",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"{",
"clear_bytes",
"=",
"8",
";",
"mode",
"=",
"DImode",
";",
"if",
"(",
"offset",
"==",
"0",
"&&",
"align",
"<",
"64",
")",
"{",
"rtx",
"addr",
";",
"addr",
"=",
"XEXP",
"(",
"orig_dest",
",",
"0",
")",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"PLUS",
"||",
"GET_CODE",
"(",
"addr",
")",
"==",
"LO_SUM",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"&",
"3",
")",
"!=",
"0",
")",
"{",
"addr",
"=",
"copy_addr_to_reg",
"(",
"addr",
")",
";",
"orig_dest",
"=",
"replace_equiv_address",
"(",
"orig_dest",
",",
"addr",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"bytes",
">=",
"4",
"&&",
"(",
"align",
">=",
"32",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"{",
"clear_bytes",
"=",
"4",
";",
"mode",
"=",
"SImode",
";",
"}",
"else",
"if",
"(",
"bytes",
">=",
"2",
"&&",
"(",
"align",
">=",
"16",
"||",
"!",
"STRICT_ALIGNMENT",
")",
")",
"{",
"clear_bytes",
"=",
"2",
";",
"mode",
"=",
"HImode",
";",
"}",
"else",
"{",
"clear_bytes",
"=",
"1",
";",
"mode",
"=",
"QImode",
";",
"}",
"dest",
"=",
"adjust_address",
"(",
"orig_dest",
",",
"mode",
",",
"offset",
")",
";",
"emit_move_insn",
"(",
"dest",
",",
"CONST0_RTX",
"(",
"mode",
")",
")",
";",
"}",
"return",
"1",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"block",
"clear",
"operation",
",",
"and",
"return",
"1",
"if",
"successful",
".",
"Return",
"0",
"if",
"we",
"should",
"let",
"the",
"compiler",
"generate",
"normal",
"code",
".",
"operands",
"[",
"0",
"]",
"is",
"the",
"destination",
"operands",
"[",
"1",
"]",
"is",
"the",
"length",
"operands",
"[",
"3",
"]",
"is",
"the",
"alignment"
] | [
"powerpcspe",
"0",
"1",
"3",
"0",
"0",
"1",
"128",
"16",
"64",
"8",
"64",
"8",
"4",
"3",
"0",
"8",
"0",
"0",
"0",
"16",
"128",
"16",
"8",
"64",
"8",
"8",
"64",
"8",
"0",
"64",
"0",
"1",
"1",
"3",
"0",
"4",
"32",
"4",
"2",
"16",
"2",
"1",
"1"
] | powerpcspe | expand_block_clear | powerpcspe | CPU | GCC | 18,539 | 455 | 1 | [] |
[
"<s>",
"static",
"int",
"mips_symbol_insns_1",
"(",
"enum",
"mips_symbol_type",
"type",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"mips_use_pcrel_pool_p",
"[",
"(",
"int",
")",
"type",
"]",
")",
"{",
"if",
"(",
"mode",
"==",
"MAX_MACHINE_MODE",
")",
"type",
"=",
"SYMBOL_PC_RELATIVE",
";",
"else",
"return",
"0",
";",
"}",
"switch",
"(",
"type",
")",
"{",
"case",
"SYMBOL_ABSOLUTE",
":",
"return",
"ABI_HAS_64BIT_SYMBOLS",
"?",
"6",
":",
"TARGET_MIPS16",
"?",
"3",
":",
"2",
";",
"case",
"SYMBOL_GP_RELATIVE",
":",
"return",
"1",
";",
"case",
"SYMBOL_PC_RELATIVE",
":",
"if",
"(",
"mode",
"==",
"MAX_MACHINE_MODE",
"||",
"GET_MODE_SIZE",
"(",
"mode",
")",
"==",
"4",
"||",
"GET_MODE_SIZE",
"(",
"mode",
")",
"==",
"8",
")",
"return",
"1",
";",
"return",
"0",
";",
"case",
"SYMBOL_GOT_DISP",
":",
"if",
"(",
"mode",
"!=",
"MAX_MACHINE_MODE",
")",
"return",
"0",
";",
"case",
"SYMBOL_GOT_PAGE_OFST",
":",
"return",
"3",
";",
"case",
"SYMBOL_GOTOFF_PAGE",
":",
"case",
"SYMBOL_GOTOFF_DISP",
":",
"case",
"SYMBOL_GOTOFF_CALL",
":",
"case",
"SYMBOL_GOTOFF_LOADGP",
":",
"case",
"SYMBOL_64_HIGH",
":",
"case",
"SYMBOL_64_MID",
":",
"case",
"SYMBOL_64_LOW",
":",
"case",
"SYMBOL_TLSGD",
":",
"case",
"SYMBOL_TLSLDM",
":",
"case",
"SYMBOL_DTPREL",
":",
"case",
"SYMBOL_GOTTPREL",
":",
"case",
"SYMBOL_TPREL",
":",
"case",
"SYMBOL_HALF",
":",
"return",
"!",
"mips_split_p",
"[",
"type",
"]",
"?",
"1",
":",
"TARGET_MIPS16",
"?",
"3",
":",
"2",
";",
"case",
"SYMBOL_TLS",
":",
"return",
"0",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Like",
"mips_symbol_insns",
",",
"but",
"treat",
"extended",
"MIPS16",
"instructions",
"as",
"a",
"single",
"instruction",
".",
"We",
"rely",
"on",
"the",
"fact",
"that",
",",
"in",
"the",
"worst",
"case",
",",
"all",
"instructions",
"involved",
"in",
"a",
"MIPS16",
"address",
"calculation",
"are",
"usually",
"extended",
"ones",
"."
] | [
"mips",
"0",
"6",
"3",
"2",
"1",
"4",
"8",
"1",
"0",
"0",
"3",
"1",
"3",
"2",
"0"
] | mips | mips_symbol_insns_1 | mips | CPU | GCC | 18,540 | 176 | 1 | [] |
[
"<s>",
"Align",
"getStackAlignment",
"(",
")",
"const",
"{",
"return",
"stackAlignment",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"minimum",
"alignment",
"known",
"to",
"hold",
"of",
"the",
"stack",
"frame",
"on",
"entry",
"to",
"the",
"function",
"and",
"which",
"must",
"be",
"maintained",
"by",
"every",
"function",
"for",
"this",
"subtarget",
"."
] | [
"Mips"
] | MipsSubtarget (2)3 | getStackAlignment | Mips | CPU | LLVM | 18,541 | 10 | 1 | [] |
[
"<s>",
"void",
"output_global_address",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"x",
",",
"int",
"round_constant",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"HIGH",
")",
"x",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"&&",
"read_only_operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"&&",
"!",
"flag_pic",
")",
"{",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"fputs",
"(",
"\"-$global$\"",
",",
"file",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST",
")",
"{",
"const",
"char",
"*",
"sep",
"=",
"\"\"",
";",
"int",
"offset",
"=",
"0",
";",
"rtx",
"base",
"=",
"NULL_RTX",
";",
"switch",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
")",
"{",
"case",
"SYMBOL_REF",
":",
"base",
"=",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
";",
"output_addr_const",
"(",
"file",
",",
"base",
")",
";",
"break",
";",
"case",
"CONST_INT",
":",
"offset",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"switch",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"1",
")",
")",
")",
"{",
"case",
"SYMBOL_REF",
":",
"base",
"=",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"1",
")",
";",
"output_addr_const",
"(",
"file",
",",
"base",
")",
";",
"break",
";",
"case",
"CONST_INT",
":",
"offset",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"1",
")",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"round_constant",
")",
"offset",
"=",
"(",
"(",
"offset",
"+",
"0x1000",
")",
"&",
"~",
"0x1fff",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
")",
"{",
"case",
"PLUS",
":",
"if",
"(",
"offset",
"<",
"0",
")",
"{",
"offset",
"=",
"-",
"offset",
";",
"sep",
"=",
"\"-\"",
";",
"}",
"else",
"sep",
"=",
"\"+\"",
";",
"break",
";",
"case",
"MINUS",
":",
"gcc_assert",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
")",
";",
"sep",
"=",
"\"-\"",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"!",
"read_only_operand",
"(",
"base",
",",
"VOIDmode",
")",
"&&",
"!",
"flag_pic",
")",
"fputs",
"(",
"\"-$global$\"",
",",
"file",
")",
";",
"if",
"(",
"offset",
")",
"fprintf",
"(",
"file",
",",
"\"%s%d\"",
",",
"sep",
",",
"offset",
")",
";",
"}",
"else",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"output",
"a",
"SYMBOL_REF",
"or",
"a",
"CONST",
"expression",
"involving",
"a",
"SYMBOL_REF",
"."
] | [
"pa",
"0",
"\"-$global$\"",
"\"\"",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"1",
"0",
"1",
"0x1000",
"0x1fff",
"0",
"0",
"\"-\"",
"\"+\"",
"0",
"0",
"\"-\"",
"\"-$global$\"",
"\"%s%d\""
] | pa3 | output_global_address | pa | CPU | GCC | 18,542 | 396 | 1 | [] |
[
"<s>",
"static",
"int",
"mips_rewrite_small_data_1",
"(",
"rtx",
"*",
"loc",
",",
"void",
"*",
"data",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"mips_rewrite_small_data_p",
"(",
"*",
"loc",
")",
")",
"*",
"loc",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"pic_offset_table_rtx",
",",
"*",
"loc",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"*",
"loc",
")",
"==",
"LO_SUM",
")",
"return",
"-",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"A",
"for_each_rtx",
"callback",
",",
"used",
"by",
"mips_rewrite_small_data",
"."
] | [
"mips",
"1",
"0"
] | mips3 | mips_rewrite_small_data_1 | mips | CPU | GCC | 18,543 | 53 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Lower AMX intrinsics\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"Lower AMX intrinsics\""
] | X86LowerAMXIntrinsics | getPassName | X86 | CPU | LLVM | 18,544 | 11 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"rvexTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"rvexISD",
"::",
"JmpLink",
":",
"return",
"\"rvexISD::JmpLink\"",
";",
"case",
"rvexISD",
"::",
"Hi",
":",
"return",
"\"rvexISD::Hi\"",
";",
"case",
"rvexISD",
"::",
"Lo",
":",
"return",
"\"rvexISD::Lo\"",
";",
"case",
"rvexISD",
"::",
"GPRel",
":",
"return",
"\"rvexISD::GPRel\"",
";",
"case",
"rvexISD",
"::",
"Ret",
":",
"return",
"\"rvexISD::Ret\"",
";",
"case",
"rvexISD",
"::",
"DivRem",
":",
"return",
"\"rvexISD::DivRem\"",
";",
"case",
"rvexISD",
"::",
"DivRemU",
":",
"return",
"\"rvexISD::DivRemU\"",
";",
"case",
"rvexISD",
"::",
"Wrapper",
":",
"return",
"\"rvexISD::Wrapper\"",
";",
"default",
":",
"return",
"NULL",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"rvex",
"rvex",
"rvexISD::JmpLink",
"\"rvexISD::JmpLink\"",
"rvexISD::Hi",
"\"rvexISD::Hi\"",
"rvexISD::Lo",
"\"rvexISD::Lo\"",
"rvexISD::GPRel",
"\"rvexISD::GPRel\"",
"rvexISD::Ret",
"\"rvexISD::Ret\"",
"rvexISD::DivRem",
"\"rvexISD::DivRem\"",
"rvexISD::DivRemU",
"\"rvexISD::DivRemU\"",
"rvexISD::Wrapper",
"\"rvexISD::Wrapper\""
] | rvexISelLowering | getTargetNodeName | rvex | VLIW | LLVM | 18,545 | 88 | 1 | [] |
[
"<s>",
"bool",
"MSP430InstrInfo",
"::",
"reverseBranchCondition",
"(",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
")",
"const",
"{",
"assert",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"\"Invalid Xbranch condition!\"",
")",
";",
"MSP430CC",
"::",
"CondCodes",
"CC",
"=",
"static_cast",
"<",
"MSP430CC",
"::",
"CondCodes",
">",
"(",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
";",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Invalid branch condition!\"",
")",
";",
"case",
"MSP430CC",
"::",
"COND_E",
":",
"CC",
"=",
"MSP430CC",
"::",
"COND_NE",
";",
"break",
";",
"case",
"MSP430CC",
"::",
"COND_NE",
":",
"CC",
"=",
"MSP430CC",
"::",
"COND_E",
";",
"break",
";",
"case",
"MSP430CC",
"::",
"COND_L",
":",
"CC",
"=",
"MSP430CC",
"::",
"COND_GE",
";",
"break",
";",
"case",
"MSP430CC",
"::",
"COND_GE",
":",
"CC",
"=",
"MSP430CC",
"::",
"COND_L",
";",
"break",
";",
"case",
"MSP430CC",
"::",
"COND_HS",
":",
"CC",
"=",
"MSP430CC",
"::",
"COND_LO",
";",
"break",
";",
"case",
"MSP430CC",
"::",
"COND_LO",
":",
"CC",
"=",
"MSP430CC",
"::",
"COND_HS",
";",
"break",
";",
"}",
"Cond",
"[",
"0",
"]",
".",
"setImm",
"(",
"CC",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Reverses",
"the",
"branch",
"condition",
"of",
"the",
"specified",
"condition",
"list",
",",
"returning",
"false",
"on",
"success",
"and",
"true",
"if",
"it",
"can",
"not",
"be",
"reversed",
"."
] | [
"MSP430",
"MSP430",
"1",
"\"Invalid Xbranch condition!\"",
"MSP430CC::CondCodes",
"MSP430CC::CondCodes",
"0",
"\"Invalid branch condition!\"",
"MSP430CC::COND_E",
"MSP430CC::COND_NE",
"MSP430CC::COND_NE",
"MSP430CC::COND_E",
"MSP430CC::COND_L",
"MSP430CC::COND_GE",
"MSP430CC::COND_GE",
"MSP430CC::COND_L",
"MSP430CC::COND_HS",
"MSP430CC::COND_LO",
"MSP430CC::COND_LO",
"MSP430CC::COND_HS",
"0"
] | MSP430InstrInfo10 | reverseBranchCondition | MSP430 | MPU | LLVM | 18,546 | 154 | 1 | [] |
[
"<s>",
"int",
"AArch64TTIImpl",
"::",
"getArithmeticReductionCost",
"(",
"unsigned",
"Opcode",
",",
"VectorType",
"*",
"ValTy",
",",
"bool",
"IsPairwiseForm",
",",
"TTI",
"::",
"TargetCostKind",
"CostKind",
")",
"{",
"if",
"(",
"isa",
"<",
"ScalableVectorType",
">",
"(",
"ValTy",
")",
")",
"return",
"getArithmeticReductionCostSVE",
"(",
"Opcode",
",",
"ValTy",
",",
"IsPairwiseForm",
",",
"CostKind",
")",
";",
"if",
"(",
"IsPairwiseForm",
")",
"return",
"BaseT",
"::",
"getArithmeticReductionCost",
"(",
"Opcode",
",",
"ValTy",
",",
"IsPairwiseForm",
",",
"CostKind",
")",
";",
"std",
"::",
"pair",
"<",
"int",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"DL",
",",
"ValTy",
")",
";",
"MVT",
"MTy",
"=",
"LT",
".",
"second",
";",
"int",
"ISD",
"=",
"TLI",
"->",
"InstructionOpcodeToISD",
"(",
"Opcode",
")",
";",
"assert",
"(",
"ISD",
"&&",
"\"Invalid opcode\"",
")",
";",
"static",
"const",
"CostTblEntry",
"CostTblNoPairwise",
"[",
"]",
"{",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v8i8",
",",
"1",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v16i8",
",",
"1",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v4i16",
",",
"1",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v8i16",
",",
"1",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v4i32",
",",
"1",
"}",
",",
"}",
";",
"if",
"(",
"const",
"auto",
"*",
"Entry",
"=",
"CostTableLookup",
"(",
"CostTblNoPairwise",
",",
"ISD",
",",
"MTy",
")",
")",
"return",
"LT",
".",
"first",
"*",
"Entry",
"->",
"Cost",
";",
"return",
"BaseT",
"::",
"getArithmeticReductionCost",
"(",
"Opcode",
",",
"ValTy",
",",
"IsPairwiseForm",
",",
"CostKind",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"vector",
"reduction",
"intrinsics",
"."
] | [
"AArch64",
"AArch64",
"\"Invalid opcode\"",
"ISD::ADD",
"MVT::v8i8",
"1",
"ISD::ADD",
"MVT::v16i8",
"1",
"ISD::ADD",
"MVT::v4i16",
"1",
"ISD::ADD",
"MVT::v8i16",
"1",
"ISD::ADD",
"MVT::v4i32",
"1"
] | AArch64TargetTransformInfo36 | getArithmeticReductionCost | AArch64 | CPU | LLVM | 18,547 | 213 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips16_cfun_returns_in_fpr_p",
"(",
"void",
")",
"{",
"tree",
"return_type",
"=",
"DECL_RESULT",
"(",
"current_function_decl",
")",
";",
"return",
"(",
"TARGET_MIPS16",
"&&",
"TARGET_HARD_FLOAT_ABI",
"&&",
"!",
"aggregate_value_p",
"(",
"return_type",
",",
"current_function_decl",
")",
"&&",
"mips_return_mode_in_fpr_p",
"(",
"DECL_MODE",
"(",
"return_type",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"current",
"function",
"returns",
"its",
"value",
"in",
"a",
"floating-point",
"register",
"in",
"MIPS16",
"mode",
"."
] | [
"mips"
] | mips | mips16_cfun_returns_in_fpr_p | mips | CPU | GCC | 18,548 | 39 | 1 | [] |
[
"<s>",
"const_iterator",
"end",
"(",
")",
"const",
"{",
"return",
"Map",
".",
"end",
"(",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"const_iterator",
"to",
"the",
"end",
"of",
"the",
"symbol",
"table",
"."
] | [
"Hexagon"
] | HexagonConstPropagation | end | Hexagon | DSP | LLVM | 18,549 | 14 | 1 | [] |
[
"<s>",
"rtx",
"ix86_memtag_add_tag",
"(",
"rtx",
"base",
",",
"poly_int64",
"offset",
",",
"unsigned",
"char",
"tag_offset",
")",
"{",
"rtx",
"base_tag",
"=",
"gen_reg_rtx",
"(",
"QImode",
")",
";",
"rtx",
"base_addr",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"rtx",
"tagged_addr",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"rtx",
"new_tag",
"=",
"gen_reg_rtx",
"(",
"QImode",
")",
";",
"unsigned",
"HOST_WIDE_INT",
"and_imm",
"=",
"(",
"HOST_WIDE_INT_1U",
"<<",
"IX86_HWASAN_SHIFT",
")",
"-",
"1",
";",
"emit_move_insn",
"(",
"base_tag",
",",
"ix86_memtag_extract_tag",
"(",
"base",
",",
"NULL_RTX",
")",
")",
";",
"emit_move_insn",
"(",
"base_addr",
",",
"ix86_memtag_untagged_pointer",
"(",
"base",
",",
"NULL_RTX",
")",
")",
";",
"emit_insn",
"(",
"gen_add2_insn",
"(",
"base_tag",
",",
"gen_int_mode",
"(",
"tag_offset",
",",
"QImode",
")",
")",
")",
";",
"emit_move_insn",
"(",
"new_tag",
",",
"base_tag",
")",
";",
"emit_insn",
"(",
"gen_andqi3",
"(",
"new_tag",
",",
"new_tag",
",",
"gen_int_mode",
"(",
"and_imm",
",",
"QImode",
")",
")",
")",
";",
"emit_move_insn",
"(",
"tagged_addr",
",",
"ix86_memtag_set_tag",
"(",
"base_addr",
",",
"new_tag",
",",
"NULL_RTX",
")",
")",
";",
"return",
"plus_constant",
"(",
"Pmode",
",",
"tagged_addr",
",",
"offset",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MEMTAG_ADD_TAG",
"."
] | [
"i386",
"1"
] | i3861 | ix86_memtag_add_tag | i386 | CPU | GCC | 18,550 | 146 | 1 | [] |
[
"<s>",
"static",
"rtx",
"function_arg_32",
"(",
"const",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"machine_mode",
"mode",
",",
"machine_mode",
"orig_mode",
",",
"const_tree",
"type",
",",
"HOST_WIDE_INT",
"bytes",
",",
"HOST_WIDE_INT",
"words",
")",
"{",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"return",
"constm1_rtx",
";",
"switch",
"(",
"mode",
")",
"{",
"default",
":",
"break",
";",
"case",
"BLKmode",
":",
"if",
"(",
"bytes",
"<",
"0",
")",
"break",
";",
"case",
"DImode",
":",
"case",
"SImode",
":",
"case",
"HImode",
":",
"case",
"QImode",
":",
"if",
"(",
"words",
"<=",
"cum",
"->",
"nregs",
")",
"{",
"int",
"regno",
"=",
"cum",
"->",
"regno",
";",
"if",
"(",
"cum",
"->",
"fastcall",
")",
"{",
"if",
"(",
"mode",
"==",
"BLKmode",
"||",
"mode",
"==",
"DImode",
"||",
"(",
"type",
"&&",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
")",
"break",
";",
"if",
"(",
"regno",
"==",
"AX_REG",
")",
"regno",
"=",
"CX_REG",
";",
"}",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"}",
"break",
";",
"case",
"DFmode",
":",
"if",
"(",
"cum",
"->",
"float_in_sse",
"<",
"2",
")",
"break",
";",
"case",
"SFmode",
":",
"if",
"(",
"cum",
"->",
"float_in_sse",
"<",
"1",
")",
"break",
";",
"case",
"TImode",
":",
"case",
"V16QImode",
":",
"case",
"V8HImode",
":",
"case",
"V4SImode",
":",
"case",
"V2DImode",
":",
"case",
"V4SFmode",
":",
"case",
"V2DFmode",
":",
"if",
"(",
"!",
"type",
"||",
"!",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"if",
"(",
"cum",
"->",
"sse_nregs",
")",
"return",
"gen_reg_or_parallel",
"(",
"mode",
",",
"orig_mode",
",",
"cum",
"->",
"sse_regno",
"+",
"FIRST_SSE_REG",
")",
";",
"}",
"break",
";",
"case",
"OImode",
":",
"case",
"XImode",
":",
"gcc_unreachable",
"(",
")",
";",
"case",
"V64QImode",
":",
"case",
"V32HImode",
":",
"case",
"V16SImode",
":",
"case",
"V8DImode",
":",
"case",
"V16SFmode",
":",
"case",
"V8DFmode",
":",
"case",
"V8SFmode",
":",
"case",
"V8SImode",
":",
"case",
"V32QImode",
":",
"case",
"V16HImode",
":",
"case",
"V4DFmode",
":",
"case",
"V4DImode",
":",
"if",
"(",
"!",
"type",
"||",
"!",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"if",
"(",
"cum",
"->",
"sse_nregs",
")",
"return",
"gen_reg_or_parallel",
"(",
"mode",
",",
"orig_mode",
",",
"cum",
"->",
"sse_regno",
"+",
"FIRST_SSE_REG",
")",
";",
"}",
"break",
";",
"case",
"V8QImode",
":",
"case",
"V4HImode",
":",
"case",
"V2SImode",
":",
"case",
"V2SFmode",
":",
"case",
"V1TImode",
":",
"case",
"V1DImode",
":",
"if",
"(",
"!",
"type",
"||",
"!",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"if",
"(",
"cum",
"->",
"mmx_nregs",
")",
"return",
"gen_reg_or_parallel",
"(",
"mode",
",",
"orig_mode",
",",
"cum",
"->",
"mmx_regno",
"+",
"FIRST_MMX_REG",
")",
";",
"}",
"break",
";",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Define",
"where",
"to",
"put",
"the",
"arguments",
"to",
"a",
"function",
".",
"Value",
"is",
"zero",
"to",
"push",
"the",
"argument",
"on",
"the",
"stack",
",",
"or",
"a",
"hard",
"register",
"in",
"which",
"to",
"store",
"the",
"argument",
".",
"MODE",
"is",
"the",
"argument",
"'s",
"machine",
"mode",
".",
"TYPE",
"is",
"the",
"data",
"type",
"of",
"the",
"argument",
"(",
"as",
"a",
"tree",
")",
".",
"This",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
".",
"CUM",
"is",
"a",
"variable",
"of",
"type",
"CUMULATIVE_ARGS",
"which",
"gives",
"info",
"about",
"the",
"preceding",
"args",
"and",
"about",
"the",
"function",
"being",
"called",
".",
"NAMED",
"is",
"nonzero",
"if",
"this",
"argument",
"is",
"a",
"named",
"parameter",
"(",
"otherwise",
"it",
"is",
"an",
"extra",
"parameter",
"matching",
"an",
"ellipsis",
")",
"."
] | [
"i386",
"0",
"2",
"1"
] | i3864 | function_arg_32 | i386 | CPU | GCC | 18,551 | 353 | 1 | [] |
[
"<s>",
"static",
"bool",
"msp430_modes_tieable_p",
"(",
"machine_mode",
"mode1",
",",
"machine_mode",
"mode2",
")",
"{",
"if",
"(",
"(",
"mode1",
"==",
"PSImode",
"||",
"mode2",
"==",
"SImode",
")",
"||",
"(",
"mode1",
"==",
"SImode",
"||",
"mode2",
"==",
"PSImode",
")",
")",
"return",
"false",
";",
"return",
"(",
"(",
"GET_MODE_CLASS",
"(",
"mode1",
")",
"==",
"MODE_FLOAT",
"||",
"GET_MODE_CLASS",
"(",
"mode1",
")",
"==",
"MODE_COMPLEX_FLOAT",
")",
"==",
"(",
"GET_MODE_CLASS",
"(",
"mode2",
")",
"==",
"MODE_FLOAT",
"||",
"GET_MODE_CLASS",
"(",
"mode2",
")",
"==",
"MODE_COMPLEX_FLOAT",
")",
")",
";",
"}",
"</s>"
] | [
"Implements",
"MODES_TIEABLE_P",
"."
] | [
"msp430"
] | msp430 | msp430_modes_tieable_p | msp430 | MPU | GCC | 18,552 | 72 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"BPF Abstract Member Access\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"BPF",
"\"BPF Abstract Member Access\""
] | BPFAbstractMemberAccess | getPassName | BPF | Virtual ISA | LLVM | 18,553 | 11 | 1 | [] |
[
"<s>",
"unsigned",
"SparcRegisterInfo",
"::",
"getRARegister",
"(",
")",
"const",
"{",
"assert",
"(",
"0",
"&&",
"\"What is the return address register\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"return",
"the",
"register",
"where",
"the",
"return",
"address",
"can",
"be",
"found",
"."
] | [
"Sparc",
"Sparc",
"0",
"\"What is the return address register\"",
"0"
] | SparcRegisterInfo28 | getRARegister | Sparc | CPU | LLVM | 18,554 | 19 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"classifyLEAReg",
"(",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineOperand",
"&",
"Src",
",",
"unsigned",
"Opc",
",",
"bool",
"AllowSP",
",",
"unsigned",
"&",
"NewSrc",
",",
"bool",
"&",
"isKill",
",",
"bool",
"&",
"isUndef",
",",
"MachineOperand",
"&",
"ImplicitOp",
",",
"LiveVariables",
"*",
"LV",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
";",
"if",
"(",
"AllowSP",
")",
"{",
"RC",
"=",
"Opc",
"!=",
"X86",
"::",
"LEA32r",
"?",
"&",
"X86",
"::",
"GR64RegClass",
":",
"&",
"X86",
"::",
"GR32RegClass",
";",
"}",
"else",
"{",
"RC",
"=",
"Opc",
"!=",
"X86",
"::",
"LEA32r",
"?",
"&",
"X86",
"::",
"GR64_NOSPRegClass",
":",
"&",
"X86",
"::",
"GR32_NOSPRegClass",
";",
"}",
"unsigned",
"SrcReg",
"=",
"Src",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Opc",
"!=",
"X86",
"::",
"LEA64_32r",
")",
"{",
"NewSrc",
"=",
"SrcReg",
";",
"isKill",
"=",
"Src",
".",
"isKill",
"(",
")",
";",
"isUndef",
"=",
"Src",
".",
"isUndef",
"(",
")",
";",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"NewSrc",
")",
"&&",
"!",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"constrainRegClass",
"(",
"NewSrc",
",",
"RC",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"if",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"SrcReg",
")",
")",
"{",
"ImplicitOp",
"=",
"Src",
";",
"ImplicitOp",
".",
"setImplicit",
"(",
")",
";",
"NewSrc",
"=",
"getX86SubSuperRegister",
"(",
"Src",
".",
"getReg",
"(",
")",
",",
"64",
")",
";",
"MachineBasicBlock",
"::",
"LivenessQueryResult",
"LQR",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"computeRegisterLiveness",
"(",
"&",
"getRegisterInfo",
"(",
")",
",",
"NewSrc",
",",
"MI",
")",
";",
"switch",
"(",
"LQR",
")",
"{",
"case",
"MachineBasicBlock",
"::",
"LQR_Unknown",
":",
"return",
"false",
";",
"case",
"MachineBasicBlock",
"::",
"LQR_Live",
":",
"isKill",
"=",
"MI",
".",
"killsRegister",
"(",
"SrcReg",
")",
";",
"isUndef",
"=",
"false",
";",
"break",
";",
"default",
":",
"isKill",
"=",
"false",
";",
"isUndef",
"=",
"true",
";",
"break",
";",
"}",
"}",
"else",
"{",
"NewSrc",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"MachineInstr",
"*",
"Copy",
"=",
"BuildMI",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
")",
".",
"addReg",
"(",
"NewSrc",
",",
"RegState",
"::",
"Define",
"|",
"RegState",
"::",
"Undef",
",",
"X86",
"::",
"sub_32bit",
")",
".",
"addOperand",
"(",
"Src",
")",
";",
"isKill",
"=",
"true",
";",
"isUndef",
"=",
"false",
";",
"if",
"(",
"LV",
")",
"LV",
"->",
"replaceKillInstruction",
"(",
"SrcReg",
",",
"MI",
",",
"*",
"Copy",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Given",
"an",
"operand",
"within",
"a",
"MachineInstr",
",",
"insert",
"preceding",
"code",
"to",
"put",
"it",
"into",
"the",
"right",
"format",
"for",
"a",
"particular",
"kind",
"of",
"LEA",
"instruction",
"."
] | [
"X86",
"X86",
"X86::LEA32r",
"X86::GR64RegClass",
"X86::GR32RegClass",
"X86::LEA32r",
"X86::GR64_NOSPRegClass",
"X86::GR32_NOSPRegClass",
"X86::LEA64_32r",
"X86",
"64",
"X86::sub_32bit"
] | X86InstrInfo6 | classifyLEAReg | X86 | CPU | LLVM | 18,555 | 373 | 1 | [] |
[
"<s>",
"AArch64Subtarget",
"::",
"AArch64Subtarget",
"(",
"const",
"Triple",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"const",
"TargetMachine",
"&",
"TM",
",",
"bool",
"LittleEndian",
")",
":",
"AArch64GenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"ReserveX18",
"(",
"TT",
".",
"isOSDarwin",
"(",
")",
")",
",",
"IsLittle",
"(",
"LittleEndian",
")",
",",
"CPUString",
"(",
"CPU",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"FrameLowering",
"(",
")",
",",
"InstrInfo",
"(",
"initializeSubtargetDependencies",
"(",
"FS",
")",
")",
",",
"TSInfo",
"(",
")",
",",
"TLInfo",
"(",
"TM",
",",
"*",
"this",
")",
",",
"GISel",
"(",
")",
"{",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64Subtarget4 | AArch64Subtarget | AArch64 | CPU | LLVM | 18,556 | 94 | 1 | [] |
[
"<s>",
"bool",
"Cpu0TargetObjectFile",
"::",
"IsGlobalInSmallSection",
"(",
"const",
"GlobalObject",
"*",
"GO",
",",
"const",
"TargetMachine",
"&",
"TM",
",",
"SectionKind",
"Kind",
")",
"const",
"{",
"return",
"(",
"IsGlobalInSmallSectionImpl",
"(",
"GO",
",",
"TM",
")",
"&&",
"(",
"Kind",
".",
"isData",
"(",
")",
"||",
"Kind",
".",
"isBSS",
"(",
")",
"||",
"Kind",
".",
"isCommon",
"(",
")",
"||",
"Kind",
".",
"isReadOnly",
"(",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"global",
"address",
"should",
"be",
"placed",
"into",
"small",
"data/bss",
"section",
"."
] | [
"Cpu0",
"Cpu0"
] | Cpu0TargetObjectFile4 | IsGlobalInSmallSection | Cpu0 | CPU | LLVM | 18,557 | 57 | 1 | [] |
[
"<s>",
"bool",
"PPCSubtarget",
"::",
"enableSubRegLiveness",
"(",
")",
"const",
"{",
"return",
"UseSubRegLiveness",
";",
"}",
"</s>"
] | [
"Enable",
"tracking",
"of",
"subregister",
"liveness",
"in",
"register",
"allocator",
"."
] | [
"PowerPC",
"PPC"
] | PPCSubtarget (2) | enableSubRegLiveness | PowerPC | CPU | LLVM | 18,558 | 12 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
")",
"const",
"{",
"return",
"Imm",
".",
"isPosZero",
"(",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"RISCV",
"RISCV"
] | RISCVISelLowering (2)2 | isFPImmLegal | RISCV | CPU | LLVM | 18,559 | 23 | 1 | [] |
[
"<s>",
"ChangeStatus",
"updateImpl",
"(",
"Attributor",
"&",
"A",
")",
"override",
"{",
"Function",
"*",
"F",
"=",
"getAssociatedFunction",
"(",
")",
";",
"auto",
"OrigAssumed",
"=",
"getAssumed",
"(",
")",
";",
"const",
"AACallEdges",
"&",
"AAEdges",
"=",
"A",
".",
"getAAFor",
"<",
"AACallEdges",
">",
"(",
"*",
"this",
",",
"this",
"->",
"getIRPosition",
"(",
")",
",",
"DepClassTy",
"::",
"REQUIRED",
")",
";",
"if",
"(",
"AAEdges",
".",
"hasNonAsmUnknownCallee",
"(",
")",
")",
"return",
"indicatePessimisticFixpoint",
"(",
")",
";",
"bool",
"IsNonEntryFunc",
"=",
"!",
"AMDGPU",
"::",
"isEntryFunctionCC",
"(",
"F",
"->",
"getCallingConv",
"(",
")",
")",
";",
"bool",
"NeedsImplicit",
"=",
"false",
";",
"auto",
"&",
"InfoCache",
"=",
"static_cast",
"<",
"AMDGPUInformationCache",
"&",
">",
"(",
"A",
".",
"getInfoCache",
"(",
")",
")",
";",
"bool",
"HasApertureRegs",
"=",
"InfoCache",
".",
"hasApertureRegs",
"(",
"*",
"F",
")",
";",
"bool",
"SupportsGetDoorbellID",
"=",
"InfoCache",
".",
"supportsGetDoorbellID",
"(",
"*",
"F",
")",
";",
"for",
"(",
"Function",
"*",
"Callee",
":",
"AAEdges",
".",
"getOptimisticEdges",
"(",
")",
")",
"{",
"Intrinsic",
"::",
"ID",
"IID",
"=",
"Callee",
"->",
"getIntrinsicID",
"(",
")",
";",
"if",
"(",
"IID",
"==",
"Intrinsic",
"::",
"not_intrinsic",
")",
"{",
"const",
"AAAMDAttributes",
"&",
"AAAMD",
"=",
"A",
".",
"getAAFor",
"<",
"AAAMDAttributes",
">",
"(",
"*",
"this",
",",
"IRPosition",
"::",
"function",
"(",
"*",
"Callee",
")",
",",
"DepClassTy",
"::",
"REQUIRED",
")",
";",
"*",
"this",
"&=",
"AAAMD",
";",
"continue",
";",
"}",
"bool",
"NonKernelOnly",
"=",
"false",
";",
"ImplicitArgumentMask",
"AttrMask",
"=",
"intrinsicToAttrMask",
"(",
"IID",
",",
"NonKernelOnly",
",",
"NeedsImplicit",
",",
"HasApertureRegs",
",",
"SupportsGetDoorbellID",
")",
";",
"if",
"(",
"AttrMask",
"!=",
"NOT_IMPLICIT_INPUT",
")",
"{",
"if",
"(",
"(",
"IsNonEntryFunc",
"||",
"!",
"NonKernelOnly",
")",
")",
"removeAssumedBits",
"(",
"AttrMask",
")",
";",
"}",
"}",
"if",
"(",
"NeedsImplicit",
")",
"removeAssumedBits",
"(",
"IMPLICIT_ARG_PTR",
")",
";",
"if",
"(",
"isAssumed",
"(",
"QUEUE_PTR",
")",
"&&",
"checkForQueuePtr",
"(",
"A",
")",
")",
"{",
"if",
"(",
"AMDGPU",
"::",
"getAmdhsaCodeObjectVersion",
"(",
")",
"==",
"5",
")",
"removeAssumedBits",
"(",
"IMPLICIT_ARG_PTR",
")",
";",
"else",
"removeAssumedBits",
"(",
"QUEUE_PTR",
")",
";",
"}",
"if",
"(",
"funcRetrievesHostcallPtr",
"(",
"A",
")",
")",
"{",
"assert",
"(",
"!",
"isAssumed",
"(",
"IMPLICIT_ARG_PTR",
")",
"&&",
"\"hostcall needs implicitarg_ptr\"",
")",
";",
"removeAssumedBits",
"(",
"HOSTCALL_PTR",
")",
";",
"}",
"if",
"(",
"funcRetrievesHeapPtr",
"(",
"A",
")",
")",
"{",
"assert",
"(",
"!",
"isAssumed",
"(",
"IMPLICIT_ARG_PTR",
")",
"&&",
"\"heap_ptr needs implicitarg_ptr\"",
")",
";",
"removeAssumedBits",
"(",
"HEAP_PTR",
")",
";",
"}",
"if",
"(",
"isAssumed",
"(",
"QUEUE_PTR",
")",
"&&",
"funcRetrievesQueuePtr",
"(",
"A",
")",
")",
"{",
"assert",
"(",
"!",
"isAssumed",
"(",
"IMPLICIT_ARG_PTR",
")",
"&&",
"\"queue_ptr needs implicitarg_ptr\"",
")",
";",
"removeAssumedBits",
"(",
"QUEUE_PTR",
")",
";",
"}",
"return",
"getAssumed",
"(",
")",
"!=",
"OrigAssumed",
"?",
"ChangeStatus",
"::",
"CHANGED",
":",
"ChangeStatus",
"::",
"UNCHANGED",
";",
"}",
"</s>"
] | [
"The",
"actual",
"update/transfer",
"function",
"which",
"has",
"to",
"be",
"implemented",
"by",
"the",
"derived",
"classes",
"."
] | [
"AMDGPU",
"AMDGPU::isEntryFunctionCC",
"AMDGPU",
"Intrinsic::ID",
"Intrinsic::not_intrinsic",
"AMDGPU::getAmdhsaCodeObjectVersion",
"5",
"\"hostcall needs implicitarg_ptr\"",
"\"heap_ptr needs implicitarg_ptr\"",
"\"queue_ptr needs implicitarg_ptr\""
] | AMDGPUAttributor1 | updateImpl | AMDGPU | GPU | LLVM | 18,560 | 375 | 1 | [] |
[
"<s>",
"rtx",
"function_arg",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"enum",
"machine_mode",
"mode",
",",
"tree",
"type",
",",
"int",
"incoming_p",
")",
"{",
"int",
"regbase",
",",
"words",
",",
"max",
";",
"int",
"*",
"arg_words",
";",
"int",
"regno",
";",
"arg_words",
"=",
"&",
"cum",
"->",
"arg_words",
";",
"regbase",
"=",
"(",
"incoming_p",
"?",
"GP_ARG_FIRST",
":",
"GP_OUTGOING_ARG_FIRST",
")",
";",
"max",
"=",
"MAX_ARGS_IN_REGISTERS",
";",
"words",
"=",
"(",
"(",
"(",
"mode",
"!=",
"BLKmode",
")",
"?",
"(",
"int",
")",
"GET_MODE_SIZE",
"(",
"mode",
")",
":",
"int_size_in_bytes",
"(",
"type",
")",
")",
"+",
"UNITS_PER_WORD",
"-",
"1",
")",
"/",
"UNITS_PER_WORD",
";",
"if",
"(",
"type",
"&&",
"(",
"TYPE_ALIGN",
"(",
"type",
")",
">",
"BITS_PER_WORD",
")",
")",
"{",
"int",
"align",
"=",
"TYPE_ALIGN",
"(",
"type",
")",
"/",
"BITS_PER_WORD",
";",
"*",
"arg_words",
"=",
"(",
"*",
"arg_words",
"+",
"align",
"-",
"1",
")",
"&",
"-",
"align",
";",
"}",
"if",
"(",
"*",
"arg_words",
"+",
"words",
">",
"max",
")",
"return",
"(",
"rtx",
")",
"0",
";",
"regno",
"=",
"regbase",
"+",
"*",
"arg_words",
";",
"if",
"(",
"cum",
"->",
"incoming",
"&&",
"regno",
"<=",
"A7_REG",
"&&",
"regno",
"+",
"words",
">",
"A7_REG",
")",
"cfun",
"->",
"machine",
"->",
"need_a7_copy",
"=",
"true",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"}",
"</s>"
] | [
"Return",
"an",
"RTL",
"expression",
"containing",
"the",
"register",
"for",
"the",
"given",
"mode",
",",
"or",
"0",
"if",
"the",
"argument",
"is",
"to",
"be",
"passed",
"on",
"the",
"stack",
".",
"INCOMING_P",
"is",
"nonzero",
"if",
"this",
"is",
"an",
"incoming",
"argument",
"to",
"the",
"current",
"function",
"."
] | [
"xtensa",
"1",
"1",
"0"
] | xtensa3 | function_arg | xtensa | MPU | GCC | 18,561 | 179 | 1 | [] |
[
"<s>",
"unsigned",
"X86VectorTargetTransformInfo",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
")",
"const",
"{",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"MVT",
">",
"LT",
"=",
"getTypeLegalizationCost",
"(",
"Ty",
")",
";",
"int",
"ISD",
"=",
"InstructionOpcodeToISD",
"(",
"Opcode",
")",
";",
"assert",
"(",
"ISD",
"&&",
"\"Invalid opcode\"",
")",
";",
"const",
"X86Subtarget",
"&",
"ST",
"=",
"TLI",
"->",
"getTargetMachine",
"(",
")",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"static",
"const",
"X86CostTblEntry",
"AVX1CostTable",
"[",
"]",
"=",
"{",
"{",
"ISD",
"::",
"MUL",
",",
"MVT",
"::",
"v8i32",
",",
"4",
"}",
",",
"{",
"ISD",
"::",
"SUB",
",",
"MVT",
"::",
"v8i32",
",",
"4",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v8i32",
",",
"4",
"}",
",",
"{",
"ISD",
"::",
"MUL",
",",
"MVT",
"::",
"v4i64",
",",
"4",
"}",
",",
"{",
"ISD",
"::",
"SUB",
",",
"MVT",
"::",
"v4i64",
",",
"4",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v4i64",
",",
"4",
"}",
",",
"}",
";",
"if",
"(",
"ST",
".",
"hasAVX",
"(",
")",
")",
"{",
"int",
"Idx",
"=",
"FindInTable",
"(",
"AVX1CostTable",
",",
"array_lengthof",
"(",
"AVX1CostTable",
")",
",",
"ISD",
",",
"LT",
".",
"second",
")",
";",
"if",
"(",
"Idx",
"!=",
"-",
"1",
")",
"return",
"LT",
".",
"first",
"*",
"AVX1CostTable",
"[",
"Idx",
"]",
".",
"Cost",
";",
"}",
"return",
"VectorTargetTransformImpl",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
")",
";",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"X86",
"X86",
"\"Invalid opcode\"",
"X86",
"X86",
"X86",
"ISD::MUL",
"MVT::v8i32",
"4",
"ISD::SUB",
"MVT::v8i32",
"4",
"ISD::ADD",
"MVT::v8i32",
"4",
"ISD::MUL",
"MVT::v4i64",
"4",
"ISD::SUB",
"MVT::v4i64",
"4",
"ISD::ADD",
"MVT::v4i64",
"4",
"1"
] | X86ISelLowering142 | getArithmeticInstrCost | X86 | CPU | LLVM | 18,562 | 203 | 1 | [] |
[
"<s>",
"static",
"void",
"c6x_set_sched_flags",
"(",
"spec_info_t",
"spec_info",
")",
"{",
"unsigned",
"int",
"*",
"flags",
"=",
"&",
"(",
"current_sched_info",
"->",
"flags",
")",
";",
"if",
"(",
"*",
"flags",
"&",
"SCHED_EBB",
")",
"{",
"*",
"flags",
"|=",
"DO_BACKTRACKING",
"|",
"DO_PREDICATION",
";",
"}",
"if",
"(",
"in_hwloop",
")",
"*",
"flags",
"|=",
"DONT_BREAK_DEPENDENCIES",
";",
"spec_info",
"->",
"mask",
"=",
"0",
";",
"}",
"</s>"
] | [
"Provide",
"information",
"about",
"speculation",
"capabilities",
",",
"and",
"set",
"the",
"DO_BACKTRACKING",
"flag",
"."
] | [
"c6x",
"0"
] | c6x | c6x_set_sched_flags | c6x | VLIW | GCC | 18,563 | 52 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"PredicateInstruction",
"(",
"MachineInstr",
"*",
"MI",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
")",
"const",
"{",
"if",
"(",
"Cond",
".",
"empty",
"(",
")",
"||",
"isEndLoopN",
"(",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"\\nCannot predicate:\"",
";",
"MI",
"->",
"dump",
"(",
")",
";",
")",
";",
"return",
"false",
";",
"}",
"int",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"assert",
"(",
"isPredicable",
"(",
"MI",
")",
"&&",
"\"Expected predicable instruction\"",
")",
";",
"bool",
"invertJump",
"=",
"predOpcodeHasNot",
"(",
"Cond",
")",
";",
"MachineBasicBlock",
"&",
"B",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"PredOpc",
"=",
"getCondOpcode",
"(",
"Opc",
",",
"invertJump",
")",
";",
"MachineInstrBuilder",
"T",
"=",
"BuildMI",
"(",
"B",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"PredOpc",
")",
")",
";",
"unsigned",
"NOp",
"=",
"0",
",",
"NumOps",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
";",
"while",
"(",
"NOp",
"<",
"NumOps",
")",
"{",
"MachineOperand",
"&",
"Op",
"=",
"MI",
"->",
"getOperand",
"(",
"NOp",
")",
";",
"if",
"(",
"!",
"Op",
".",
"isReg",
"(",
")",
"||",
"!",
"Op",
".",
"isDef",
"(",
")",
"||",
"Op",
".",
"isImplicit",
"(",
")",
")",
"break",
";",
"T",
".",
"addOperand",
"(",
"Op",
")",
";",
"NOp",
"++",
";",
"}",
"unsigned",
"PredReg",
",",
"PredRegPos",
",",
"PredRegFlags",
";",
"bool",
"GotPredReg",
"=",
"getPredReg",
"(",
"Cond",
",",
"PredReg",
",",
"PredRegPos",
",",
"PredRegFlags",
")",
";",
"(",
"void",
")",
"GotPredReg",
";",
"assert",
"(",
"GotPredReg",
")",
";",
"T",
".",
"addReg",
"(",
"PredReg",
",",
"PredRegFlags",
")",
";",
"while",
"(",
"NOp",
"<",
"NumOps",
")",
"T",
".",
"addOperand",
"(",
"MI",
"->",
"getOperand",
"(",
"NOp",
"++",
")",
")",
";",
"MI",
"->",
"setDesc",
"(",
"get",
"(",
"PredOpc",
")",
")",
";",
"while",
"(",
"unsigned",
"n",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
")",
"MI",
"->",
"RemoveOperand",
"(",
"n",
"-",
"1",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"n",
"=",
"T",
"->",
"getNumOperands",
"(",
")",
";",
"i",
"<",
"n",
";",
"++",
"i",
")",
"MI",
"->",
"addOperand",
"(",
"T",
"->",
"getOperand",
"(",
"i",
")",
")",
";",
"MachineBasicBlock",
"::",
"instr_iterator",
"TI",
"=",
"T",
"->",
"getIterator",
"(",
")",
";",
"B",
".",
"erase",
"(",
"TI",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"B",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"clearKillFlags",
"(",
"PredReg",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Convert",
"the",
"instruction",
"into",
"a",
"predicated",
"instruction",
"."
] | [
"Hexagon",
"Hexagon",
"0",
"\"\\nCannot predicate:\"",
"\"Expected predicable instruction\"",
"0",
"1",
"0"
] | HexagonInstrInfo12 | PredicateInstruction | Hexagon | DSP | LLVM | 18,564 | 364 | 1 | [] |
[
"<s>",
"bool",
"isLittleEndian",
"(",
")",
"const",
"{",
"return",
"isLittle",
";",
"}",
"</s>"
] | [
"Tests",
"whether",
"the",
"target",
"triple",
"is",
"little",
"endian",
"."
] | [
"ARM"
] | ARMTargetMachine (2) | isLittleEndian | ARM | CPU | LLVM | 18,565 | 10 | 1 | [] |
[
"<s>",
"unsigned",
"char",
"X86Subtarget",
"::",
"classifyLocalReference",
"(",
"const",
"GlobalValue",
"*",
"GV",
")",
"const",
"{",
"if",
"(",
"!",
"isPositionIndependent",
"(",
")",
")",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"if",
"(",
"is64Bit",
"(",
")",
")",
"{",
"if",
"(",
"isTargetELF",
"(",
")",
")",
"{",
"switch",
"(",
"TM",
".",
"getCodeModel",
"(",
")",
")",
"{",
"case",
"CodeModel",
"::",
"Tiny",
":",
"llvm_unreachable",
"(",
"\"Tiny codesize model not supported on X86\"",
")",
";",
"case",
"CodeModel",
"::",
"Small",
":",
"case",
"CodeModel",
"::",
"Kernel",
":",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"case",
"CodeModel",
"::",
"Large",
":",
"return",
"X86II",
"::",
"MO_GOTOFF",
";",
"case",
"CodeModel",
"::",
"Medium",
":",
"if",
"(",
"isa_and_nonnull",
"<",
"Function",
">",
"(",
"GV",
")",
")",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"return",
"X86II",
"::",
"MO_GOTOFF",
";",
"}",
"llvm_unreachable",
"(",
"\"invalid code model\"",
")",
";",
"}",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"}",
"if",
"(",
"isTargetCOFF",
"(",
")",
")",
"return",
"X86II",
"::",
"MO_NO_FLAG",
";",
"if",
"(",
"isTargetDarwin",
"(",
")",
")",
"{",
"if",
"(",
"GV",
"&&",
"(",
"GV",
"->",
"isDeclarationForLinker",
"(",
")",
"||",
"GV",
"->",
"hasCommonLinkage",
"(",
")",
")",
")",
"return",
"X86II",
"::",
"MO_DARWIN_NONLAZY_PIC_BASE",
";",
"return",
"X86II",
"::",
"MO_PIC_BASE_OFFSET",
";",
"}",
"return",
"X86II",
"::",
"MO_GOTOFF",
";",
"}",
"</s>"
] | [
"Classify",
"a",
"global",
"variable",
"reference",
"for",
"the",
"current",
"subtarget",
"according",
"to",
"how",
"we",
"should",
"reference",
"it",
"in",
"a",
"non-pcrel",
"context",
"."
] | [
"X86",
"X86",
"X86II::MO_NO_FLAG",
"\"Tiny codesize model not supported on X86\"",
"X86II::MO_NO_FLAG",
"X86II::MO_GOTOFF",
"X86II::MO_NO_FLAG",
"X86II::MO_GOTOFF",
"\"invalid code model\"",
"X86II::MO_NO_FLAG",
"X86II::MO_NO_FLAG",
"X86II::MO_DARWIN_NONLAZY_PIC_BASE",
"X86II::MO_PIC_BASE_OFFSET",
"X86II::MO_GOTOFF"
] | X86Subtarget33 | classifyLocalReference | X86 | CPU | LLVM | 18,566 | 174 | 1 | [] |
[
"<s>",
"bool",
"LanaiInstrInfo",
"::",
"getMemOperandWithOffset",
"(",
"const",
"MachineInstr",
"&",
"LdSt",
",",
"const",
"MachineOperand",
"*",
"&",
"BaseOp",
",",
"int64_t",
"&",
"Offset",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"switch",
"(",
"LdSt",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"Lanai",
"::",
"LDW_RI",
":",
"case",
"Lanai",
"::",
"LDW_RR",
":",
"case",
"Lanai",
"::",
"SW_RR",
":",
"case",
"Lanai",
"::",
"SW_RI",
":",
"case",
"Lanai",
"::",
"LDHs_RI",
":",
"case",
"Lanai",
"::",
"LDHz_RI",
":",
"case",
"Lanai",
"::",
"STH_RI",
":",
"case",
"Lanai",
"::",
"LDBs_RI",
":",
"case",
"Lanai",
"::",
"LDBz_RI",
":",
"unsigned",
"Width",
";",
"return",
"getMemOperandWithOffsetWidth",
"(",
"LdSt",
",",
"BaseOp",
",",
"Offset",
",",
"Width",
",",
"TRI",
")",
";",
"}",
"}",
"</s>"
] | [
"Get",
"the",
"base",
"operand",
"and",
"byte",
"offset",
"of",
"an",
"instruction",
"that",
"reads/writes",
"memory",
"."
] | [
"Lanai",
"Lanai",
"Lanai::LDW_RI",
"Lanai::LDW_RR",
"Lanai::SW_RR",
"Lanai::SW_RI",
"Lanai::LDHs_RI",
"Lanai::LDHz_RI",
"Lanai::STH_RI",
"Lanai::LDBs_RI",
"Lanai::LDBz_RI"
] | LanaiInstrInfo10 | getMemOperandWithOffset | Lanai | CPU | LLVM | 18,567 | 105 | 1 | [] |
[
"<s>",
"void",
"MipsInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"GetMemOperand",
"(",
"MBB",
",",
"FI",
",",
"MachineMemOperand",
"::",
"MOLoad",
")",
";",
"unsigned",
"Opc",
"=",
"0",
";",
"if",
"(",
"RC",
"==",
"Mips",
"::",
"CPURegsRegisterClass",
")",
"Opc",
"=",
"IsN64",
"?",
"Mips",
"::",
"LW_P8",
":",
"Mips",
"::",
"LW",
";",
"else",
"if",
"(",
"RC",
"==",
"Mips",
"::",
"CPU64RegsRegisterClass",
")",
"Opc",
"=",
"IsN64",
"?",
"Mips",
"::",
"LD_P8",
":",
"Mips",
"::",
"LD",
";",
"else",
"if",
"(",
"RC",
"==",
"Mips",
"::",
"FGR32RegisterClass",
")",
"Opc",
"=",
"IsN64",
"?",
"Mips",
"::",
"LWC1_P8",
":",
"Mips",
"::",
"LWC1",
";",
"else",
"if",
"(",
"RC",
"==",
"Mips",
"::",
"AFGR64RegisterClass",
")",
"Opc",
"=",
"Mips",
"::",
"LDC1",
";",
"else",
"if",
"(",
"RC",
"==",
"Mips",
"::",
"FGR64RegisterClass",
")",
"Opc",
"=",
"IsN64",
"?",
"Mips",
"::",
"LDC164_P8",
":",
"Mips",
"::",
"LDC164",
";",
"assert",
"(",
"Opc",
"&&",
"\"Register class not handled!\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"Mips",
"Mips",
"0",
"Mips::CPURegsRegisterClass",
"Mips::LW_P8",
"Mips::LW",
"Mips::CPU64RegsRegisterClass",
"Mips::LD_P8",
"Mips::LD",
"Mips::FGR32RegisterClass",
"Mips::LWC1_P8",
"Mips::LWC1",
"Mips::AFGR64RegisterClass",
"Mips::LDC1",
"Mips::FGR64RegisterClass",
"Mips::LDC164_P8",
"Mips::LDC164",
"\"Register class not handled!\"",
"0"
] | MipsInstrInfo41 | loadRegFromStackSlot | Mips | CPU | LLVM | 18,568 | 210 | 1 | [] |
[
"<s>",
"outliner",
"::",
"OutlinedFunction",
"X86InstrInfo",
"::",
"getOutliningCandidateInfo",
"(",
"std",
"::",
"vector",
"<",
"outliner",
"::",
"Candidate",
">",
"&",
"RepeatedSequenceLocs",
")",
"const",
"{",
"unsigned",
"SequenceSize",
"=",
"std",
"::",
"accumulate",
"(",
"RepeatedSequenceLocs",
"[",
"0",
"]",
".",
"front",
"(",
")",
",",
"std",
"::",
"next",
"(",
"RepeatedSequenceLocs",
"[",
"0",
"]",
".",
"back",
"(",
")",
")",
",",
"0",
",",
"[",
"]",
"(",
"unsigned",
"Sum",
",",
"const",
"MachineInstr",
"&",
"MI",
")",
"{",
"if",
"(",
"MI",
".",
"isDebugInstr",
"(",
")",
"||",
"MI",
".",
"isKill",
"(",
")",
")",
"return",
"Sum",
";",
"return",
"Sum",
"+",
"1",
";",
"}",
")",
";",
"if",
"(",
"RepeatedSequenceLocs",
"[",
"0",
"]",
".",
"back",
"(",
")",
"->",
"isTerminator",
"(",
")",
")",
"{",
"for",
"(",
"outliner",
"::",
"Candidate",
"&",
"C",
":",
"RepeatedSequenceLocs",
")",
"C",
".",
"setCallInfo",
"(",
"MachineOutlinerTailCall",
",",
"1",
")",
";",
"return",
"outliner",
"::",
"OutlinedFunction",
"(",
"RepeatedSequenceLocs",
",",
"SequenceSize",
",",
"0",
",",
"MachineOutlinerTailCall",
")",
";",
"}",
"for",
"(",
"outliner",
"::",
"Candidate",
"&",
"C",
":",
"RepeatedSequenceLocs",
")",
"C",
".",
"setCallInfo",
"(",
"MachineOutlinerDefault",
",",
"1",
")",
";",
"return",
"outliner",
"::",
"OutlinedFunction",
"(",
"RepeatedSequenceLocs",
",",
"SequenceSize",
",",
"1",
",",
"MachineOutlinerDefault",
")",
";",
"}",
"</s>"
] | [
"Returns",
"a",
"outliner",
":",
":OutlinedFunction",
"struct",
"containing",
"target-specific",
"information",
"for",
"a",
"set",
"of",
"outlining",
"candidates",
"."
] | [
"X86",
"X86",
"0",
"0",
"0",
"1",
"0",
"1",
"0",
"1",
"1"
] | X86InstrInfo | getOutliningCandidateInfo | X86 | CPU | LLVM | 18,569 | 173 | 1 | [] |
[
"<s>",
"TargetIRAnalysis",
"XCoreTargetMachine",
"::",
"getTargetIRAnalysis",
"(",
")",
"{",
"return",
"TargetIRAnalysis",
"(",
"[",
"this",
"]",
"(",
"Function",
"&",
"F",
")",
"{",
"return",
"TargetTransformInfo",
"(",
"XCoreTTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetIRAnalysis",
"appropriate",
"for",
"the",
"target",
"."
] | [
"XCore",
"XCore",
"XCore"
] | XCoreTargetMachine42 | getTargetIRAnalysis | XCore | MPU | LLVM | 18,570 | 34 | 1 | [] |
[
"<s>",
"void",
"warn_once_call_ms2sysv_xlogues",
"(",
"const",
"char",
"*",
"feature",
")",
"{",
"static",
"bool",
"warned_once",
"=",
"false",
";",
"if",
"(",
"!",
"warned_once",
")",
"{",
"warning",
"(",
"0",
",",
"\"%<-mcall-ms2sysv-xlogues%> is not compatible with %s\"",
",",
"feature",
")",
";",
"warned_once",
"=",
"true",
";",
"}",
"}",
"</s>"
] | [
"Emits",
"a",
"warning",
"for",
"unsupported",
"msabi",
"to",
"sysv",
"pro/epilogues",
"."
] | [
"i386",
"0",
"\"%<-mcall-ms2sysv-xlogues%> is not compatible with %s\""
] | i386 | warn_once_call_ms2sysv_xlogues | i386 | CPU | GCC | 18,571 | 36 | 1 | [] |
[
"<s>",
"static",
"rtx",
"mips_expand_builtin_movtf",
"(",
"enum",
"mips_builtin_type",
"type",
",",
"enum",
"insn_code",
"icode",
",",
"enum",
"mips_fp_condition",
"cond",
",",
"rtx",
"target",
",",
"tree",
"exp",
")",
"{",
"struct",
"expand_operand",
"ops",
"[",
"4",
"]",
";",
"rtx",
"cmp_result",
";",
"cmp_result",
"=",
"mips_expand_builtin_compare_1",
"(",
"icode",
",",
"cond",
",",
"exp",
",",
"2",
")",
";",
"create_output_operand",
"(",
"&",
"ops",
"[",
"0",
"]",
",",
"target",
",",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"exp",
")",
")",
")",
";",
"if",
"(",
"type",
"==",
"MIPS_BUILTIN_MOVT",
")",
"{",
"mips_prepare_builtin_arg",
"(",
"&",
"ops",
"[",
"2",
"]",
",",
"exp",
",",
"2",
")",
";",
"mips_prepare_builtin_arg",
"(",
"&",
"ops",
"[",
"1",
"]",
",",
"exp",
",",
"3",
")",
";",
"}",
"else",
"{",
"mips_prepare_builtin_arg",
"(",
"&",
"ops",
"[",
"1",
"]",
",",
"exp",
",",
"2",
")",
";",
"mips_prepare_builtin_arg",
"(",
"&",
"ops",
"[",
"2",
"]",
",",
"exp",
",",
"3",
")",
";",
"}",
"create_fixed_operand",
"(",
"&",
"ops",
"[",
"3",
"]",
",",
"cmp_result",
")",
";",
"return",
"mips_expand_builtin_insn",
"(",
"CODE_FOR_mips_cond_move_tf_ps",
",",
"4",
",",
"ops",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"__builtin_mips_movt_",
"*",
"_ps",
"(",
")",
"or",
"__builtin_mips_movf_",
"*",
"_ps",
"(",
")",
"function",
"(",
"TYPE",
"says",
"which",
")",
".",
"ARGLIST",
"is",
"the",
"list",
"of",
"arguments",
"to",
"the",
"function",
",",
"ICODE",
"is",
"the",
"instruction",
"that",
"should",
"be",
"used",
"to",
"compare",
"the",
"first",
"two",
"arguments",
",",
"and",
"COND",
"is",
"the",
"condition",
"it",
"should",
"test",
".",
"TARGET",
",",
"if",
"nonnull",
",",
"suggests",
"a",
"good",
"place",
"to",
"put",
"the",
"result",
"."
] | [
"mips",
"4",
"2",
"0",
"2",
"2",
"1",
"3",
"1",
"2",
"2",
"3",
"3",
"4"
] | mips | mips_expand_builtin_movtf | mips | CPU | GCC | 18,572 | 152 | 1 | [] |
[
"<s>",
"bool",
"RISCVInstrInfo",
"::",
"isAsCheapAsAMove",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"const",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"RISCV",
"::",
"FSGNJ_D",
":",
"case",
"RISCV",
"::",
"FSGNJ_S",
":",
"return",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"case",
"RISCV",
"::",
"ADDI",
":",
"case",
"RISCV",
"::",
"ORI",
":",
"case",
"RISCV",
"::",
"XORI",
":",
"return",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"RISCV",
"::",
"X0",
")",
"||",
"(",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
";",
"}",
"return",
"MI",
".",
"isAsCheapAsAMove",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"instruction",
"is",
"as",
"cheap",
"as",
"a",
"move",
"instruction",
"."
] | [
"RI5CY",
"RISCV",
"RISCV::FSGNJ_D",
"RISCV::FSGNJ_S",
"1",
"2",
"1",
"2",
"RISCV::ADDI",
"RISCV::ORI",
"RISCV::XORI",
"1",
"1",
"RISCV::X0",
"2",
"2",
"0"
] | RISCVInstrInfo | isAsCheapAsAMove | RI5CY | CPU | LLVM | 18,573 | 165 | 1 | [] |
[
"<s>",
"unsigned",
"getNumRegisters",
"(",
"LLVMContext",
"&",
"Context",
",",
"EVT",
"VT",
",",
"Optional",
"<",
"MVT",
">",
"RegisterVT",
")",
"const",
"override",
"{",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i128",
"&&",
"RegisterVT",
".",
"hasValue",
"(",
")",
"&&",
"RegisterVT",
".",
"getValue",
"(",
")",
"==",
"MVT",
"::",
"Untyped",
")",
"return",
"1",
";",
"return",
"TargetLowering",
"::",
"getNumRegisters",
"(",
"Context",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"registers",
"that",
"this",
"ValueType",
"will",
"eventually",
"require",
"."
] | [
"SystemZ",
"MVT::i128",
"MVT::Untyped",
"1"
] | SystemZISelLowering18 | getNumRegisters | SystemZ | CPU | LLVM | 18,574 | 57 | 1 | [] |
[
"<s>",
"void",
"emitInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"override",
"{",
"if",
"(",
"IsThumb",
")",
"EmitThumbMappingSymbol",
"(",
")",
";",
"else",
"EmitARMMappingSymbol",
"(",
")",
";",
"MCELFStreamer",
"::",
"emitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"to",
"emit",
"instructions",
"."
] | [
"ARM",
"ARM"
] | ARMELFStreamer22 | emitInstruction | ARM | CPU | LLVM | 18,575 | 38 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyCallIndirectFixup",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** Fixing up CALL_INDIRECTs **********\\n\"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"const",
"WebAssemblyInstrInfo",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"MBB",
")",
"{",
"if",
"(",
"IsPseudoCallIndirect",
"(",
"MI",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Found call_indirect: \"",
"<<",
"MI",
"<<",
"'\\n'",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"TII",
"->",
"get",
"(",
"GetNonPseudoCallIndirectOpcode",
"(",
"MI",
")",
")",
";",
"MI",
".",
"setDesc",
"(",
"Desc",
")",
";",
"SmallVector",
"<",
"MachineOperand",
",",
"8",
">",
"Ops",
";",
"Ops",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"0",
")",
")",
";",
"Ops",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"0",
")",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"make_range",
"(",
"MI",
".",
"operands_begin",
"(",
")",
"+",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumDefs",
"(",
")",
"+",
"1",
",",
"MI",
".",
"operands_begin",
"(",
")",
"+",
"MI",
".",
"getNumExplicitOperands",
"(",
")",
")",
")",
"Ops",
".",
"push_back",
"(",
"MO",
")",
";",
"Ops",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumDefs",
"(",
")",
")",
")",
";",
"while",
"(",
"MI",
".",
"getNumOperands",
"(",
")",
">",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumDefs",
"(",
")",
")",
"MI",
".",
"RemoveOperand",
"(",
"MI",
".",
"getNumOperands",
"(",
")",
"-",
"1",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"Ops",
")",
"MI",
".",
"addOperand",
"(",
"MO",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\" After transform: \"",
"<<",
"MI",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"}",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"\\nDone fixing up CALL_INDIRECTs\\n\\n\"",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Fixing up CALL_INDIRECTs **********\\n\"",
"WebAssembly",
"WebAssembly",
"\"Found call_indirect: \"",
"8",
"0",
"0",
"1",
"1",
"\" After transform: \"",
"\"\\nDone fixing up CALL_INDIRECTs\\n\\n\""
] | WebAssemblyCallIndirectFixup16 | runOnMachineFunction | WebAssembly | Virtual ISA | LLVM | 18,576 | 288 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"STI",
"=",
"&",
"static_cast",
"<",
"const",
"M68kSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"STI",
"->",
"getRegisterInfo",
"(",
")",
";",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"M68kMachineFunctionInfo",
">",
"(",
")",
";",
"FL",
"=",
"STI",
"->",
"getFrameLowering",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"MOVEMState",
"State",
";",
"unsigned",
"Mask",
"=",
"0",
";",
"unsigned",
"Reg",
"=",
"0",
";",
"int",
"Offset",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"{",
"auto",
"MI",
"=",
"MBB",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"MI",
"!=",
"E",
")",
"{",
"auto",
"NMI",
"=",
"std",
"::",
"next",
"(",
"MI",
")",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"if",
"(",
"State",
".",
"hasBase",
"(",
")",
")",
"{",
"State",
".",
"setEnd",
"(",
"MI",
")",
";",
"Finish",
"(",
"MBB",
",",
"State",
")",
";",
"Modified",
"=",
"true",
";",
"}",
"break",
";",
"case",
"M68k",
"::",
"MOVM32jm",
":",
"Mask",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"Reg",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"Offset",
"=",
"0",
";",
"Modified",
"|=",
"ProcessMI",
"(",
"MBB",
",",
"MI",
",",
"State",
",",
"Mask",
",",
"Offset",
",",
"Reg",
",",
"true",
")",
";",
"break",
";",
"case",
"M68k",
"::",
"MOVM32pm",
":",
"Mask",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"Reg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"Offset",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"Modified",
"|=",
"ProcessMI",
"(",
"MBB",
",",
"MI",
",",
"State",
",",
"Mask",
",",
"Offset",
",",
"Reg",
",",
"true",
")",
";",
"break",
";",
"case",
"M68k",
"::",
"MOVM32mj",
":",
"Mask",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"Reg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"Offset",
"=",
"0",
";",
"Modified",
"|=",
"ProcessMI",
"(",
"MBB",
",",
"MI",
",",
"State",
",",
"Mask",
",",
"Offset",
",",
"Reg",
",",
"false",
")",
";",
"break",
";",
"case",
"M68k",
"::",
"MOVM32mp",
":",
"Mask",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"Reg",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"Offset",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"Modified",
"|=",
"ProcessMI",
"(",
"MBB",
",",
"MI",
",",
"State",
",",
"Mask",
",",
"Offset",
",",
"Reg",
",",
"false",
")",
";",
"break",
";",
"}",
"MI",
"=",
"NMI",
";",
"}",
"if",
"(",
"State",
".",
"hasBase",
"(",
")",
")",
"{",
"State",
".",
"setEnd",
"(",
"MI",
")",
";",
"Finish",
"(",
"MBB",
",",
"State",
")",
";",
"}",
"}",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"M68k",
"M68k",
"M68k",
"0",
"0",
"0",
"M68k::MOVM32jm",
"1",
"0",
"0",
"M68k::MOVM32pm",
"2",
"1",
"0",
"M68k::MOVM32mj",
"0",
"1",
"0",
"M68k::MOVM32mp",
"0",
"2",
"1"
] | M68kCollapseMOVEMPass | runOnMachineFunction | M68k | MPU | LLVM | 18,577 | 445 | 1 | [] |
[
"<s>",
"SDValue",
"WebAssemblyTargetLowering",
"::",
"LowerFormalArguments",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"if",
"(",
"!",
"CallingConvSupported",
"(",
"CallConv",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly doesn't support non-C calling conventions\"",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"auto",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
";",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"addLiveIn",
"(",
"WebAssembly",
"::",
"ARGUMENTS",
")",
";",
"for",
"(",
"const",
"ISD",
"::",
"InputArg",
"&",
"In",
":",
"Ins",
")",
"{",
"if",
"(",
"In",
".",
"Flags",
".",
"isInAlloca",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented inalloca arguments\"",
")",
";",
"if",
"(",
"In",
".",
"Flags",
".",
"isNest",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented nest arguments\"",
")",
";",
"if",
"(",
"In",
".",
"Flags",
".",
"isInConsecutiveRegs",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented cons regs arguments\"",
")",
";",
"if",
"(",
"In",
".",
"Flags",
".",
"isInConsecutiveRegsLast",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented cons regs last arguments\"",
")",
";",
"InVals",
".",
"push_back",
"(",
"In",
".",
"Used",
"?",
"DAG",
".",
"getNode",
"(",
"WebAssemblyISD",
"::",
"ARGUMENT",
",",
"DL",
",",
"In",
".",
"VT",
",",
"DAG",
".",
"getTargetConstant",
"(",
"InVals",
".",
"size",
"(",
")",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
":",
"DAG",
".",
"getUNDEF",
"(",
"In",
".",
"VT",
")",
")",
";",
"MFI",
"->",
"addParam",
"(",
"In",
".",
"VT",
")",
";",
"}",
"if",
"(",
"IsVarArg",
")",
"{",
"MVT",
"PtrVT",
"=",
"getPointerTy",
"(",
"MF",
".",
"getDataLayout",
"(",
")",
")",
";",
"unsigned",
"VarargVreg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"getRegClassFor",
"(",
"PtrVT",
")",
")",
";",
"MFI",
"->",
"setVarargBufferVreg",
"(",
"VarargVreg",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"VarargVreg",
",",
"DAG",
".",
"getNode",
"(",
"WebAssemblyISD",
"::",
"ARGUMENT",
",",
"DL",
",",
"PtrVT",
",",
"DAG",
".",
"getTargetConstant",
"(",
"Ins",
".",
"size",
"(",
")",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
")",
";",
"MFI",
"->",
"addParam",
"(",
"PtrVT",
")",
";",
"}",
"SmallVector",
"<",
"MVT",
",",
"4",
">",
"Params",
";",
"SmallVector",
"<",
"MVT",
",",
"4",
">",
"Results",
";",
"ComputeSignatureVTs",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"getFunctionType",
"(",
")",
",",
"MF",
".",
"getFunction",
"(",
")",
",",
"DAG",
".",
"getTarget",
"(",
")",
",",
"Params",
",",
"Results",
")",
";",
"for",
"(",
"MVT",
"VT",
":",
"Results",
")",
"MFI",
"->",
"addResult",
"(",
"VT",
")",
";",
"assert",
"(",
"MFI",
"->",
"getParams",
"(",
")",
".",
"size",
"(",
")",
"==",
"Params",
".",
"size",
"(",
")",
"&&",
"std",
"::",
"equal",
"(",
"MFI",
"->",
"getParams",
"(",
")",
".",
"begin",
"(",
")",
",",
"MFI",
"->",
"getParams",
"(",
")",
".",
"end",
"(",
")",
",",
"Params",
".",
"begin",
"(",
")",
")",
")",
";",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"the",
"Ins",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"WebAssembly",
"WebAssembly",
"ISD::InputArg",
"\"WebAssembly doesn't support non-C calling conventions\"",
"WebAssembly",
"WebAssembly::ARGUMENTS",
"ISD::InputArg",
"\"WebAssembly hasn't implemented inalloca arguments\"",
"\"WebAssembly hasn't implemented nest arguments\"",
"\"WebAssembly hasn't implemented cons regs arguments\"",
"\"WebAssembly hasn't implemented cons regs last arguments\"",
"WebAssemblyISD::ARGUMENT",
"MVT::i32",
"WebAssemblyISD::ARGUMENT",
"MVT::i32",
"4",
"4"
] | WebAssemblyISelLowering (2)1 | LowerFormalArguments | WebAssembly | Virtual ISA | LLVM | 18,578 | 450 | 1 | [] |
[
"<s>",
"bool",
"ProtectReturnSupportPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Func",
")",
"{",
"if",
"(",
"!",
"Func",
".",
"protectReturnPtr",
"(",
")",
")",
"return",
"false",
";",
"bool",
"modified",
"=",
"false",
";",
"if",
"(",
"!",
"Func",
".",
"getName",
"(",
")",
".",
"equals",
"(",
"\"main\"",
")",
")",
"{",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"Func",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"X86Subtarget",
"&",
"STI",
"=",
"Func",
".",
"getTarget",
"(",
")",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"unsigned",
"Reg",
"=",
"STI",
".",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"RBX",
":",
"X86",
"::",
"EBX",
";",
"unsigned",
"PushOpc",
"=",
"STI",
".",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"PUSH64r",
":",
"X86",
"::",
"PUSH32r",
";",
"MachineBasicBlock",
"*",
"MBB",
"=",
"Func",
".",
"begin",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MI",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PushOpc",
")",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Kill",
")",
";",
"modified",
"=",
"true",
";",
"for",
"(",
"auto",
"MBBI",
"=",
"Func",
".",
"begin",
"(",
")",
",",
"MBBE",
"=",
"Func",
".",
"end",
"(",
")",
";",
"MBBI",
"!=",
"MBBE",
";",
"MBBI",
"++",
")",
"{",
"if",
"(",
"!",
"isReturnBlock",
"(",
"MBBI",
")",
")",
"continue",
";",
"modified",
"|=",
"handleReturnInst",
"(",
"*",
"MBBI",
",",
"MBBI",
"->",
"getFirstTerminator",
"(",
")",
")",
";",
"}",
"}",
"SmallVector",
"<",
"MachineInstr",
"*",
",",
"16",
">",
"worklist",
";",
"for",
"(",
"auto",
"MBBI",
"=",
"Func",
".",
"begin",
"(",
")",
",",
"MBBE",
"=",
"Func",
".",
"end",
"(",
")",
";",
"MBBI",
"!=",
"MBBE",
";",
"MBBI",
"++",
")",
"{",
"for",
"(",
"auto",
"MI",
"=",
"MBBI",
"->",
"begin",
"(",
")",
",",
"ME",
"=",
"MBBI",
"->",
"end",
"(",
")",
";",
"MI",
"!=",
"ME",
";",
"MI",
"++",
")",
"if",
"(",
"MI",
"->",
"isCall",
"(",
")",
")",
"worklist",
".",
"push_back",
"(",
"MI",
")",
";",
"}",
"while",
"(",
"!",
"worklist",
".",
"empty",
"(",
")",
")",
"{",
"MachineInstr",
"*",
"mi",
"=",
"worklist",
".",
"pop_back_val",
"(",
")",
";",
"modified",
"|=",
"handleCallInst",
"(",
"mi",
")",
";",
"}",
"return",
"modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"\"main\"",
"X86",
"X86",
"X86::RBX",
"X86::EBX",
"X86::PUSH64r",
"X86::PUSH32r",
"16"
] | X86ProtectReturnSupport | runOnMachineFunction | X86 | CPU | LLVM | 18,579 | 335 | 1 | [] |
[
"<s>",
"void",
"ARMBaseRegisterInfo",
"::",
"resolveFrameIndex",
"(",
"MachineInstr",
"&",
"MI",
",",
"Register",
"BaseReg",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"ARMBaseInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"int",
"Off",
"=",
"Offset",
";",
"unsigned",
"i",
"=",
"0",
";",
"assert",
"(",
"!",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
"&&",
"\"This resolveFrameIndex does not support Thumb1!\"",
")",
";",
"while",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
")",
"{",
"++",
"i",
";",
"assert",
"(",
"i",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
"&&",
"\"Instr doesn't have FrameIndex operand!\"",
")",
";",
"}",
"bool",
"Done",
"=",
"false",
";",
"if",
"(",
"!",
"AFI",
"->",
"isThumbFunction",
"(",
")",
")",
"Done",
"=",
"rewriteARMFrameIndex",
"(",
"MI",
",",
"i",
",",
"BaseReg",
",",
"Off",
",",
"TII",
")",
";",
"else",
"{",
"assert",
"(",
"AFI",
"->",
"isThumb2Function",
"(",
")",
")",
";",
"Done",
"=",
"rewriteT2FrameIndex",
"(",
"MI",
",",
"i",
",",
"BaseReg",
",",
"Off",
",",
"TII",
",",
"this",
")",
";",
"}",
"assert",
"(",
"Done",
"&&",
"\"Unable to resolve frame index!\"",
")",
";",
"(",
"void",
")",
"Done",
";",
"}",
"</s>"
] | [
"Resolve",
"a",
"frame",
"index",
"operand",
"of",
"an",
"instruction",
"to",
"reference",
"the",
"indicated",
"base",
"register",
"plus",
"offset",
"instead",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"0",
"\"This resolveFrameIndex does not support Thumb1!\"",
"\"Instr doesn't have FrameIndex operand!\"",
"ARM",
"\"Unable to resolve frame index!\""
] | ARMBaseRegisterInfo | resolveFrameIndex | ARM | CPU | LLVM | 18,580 | 201 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"isPredicable",
"(",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"STI",
".",
"hasLoadStoreOnCond",
"(",
")",
"&&",
"getConditionalMove",
"(",
"Opcode",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"instruction",
"can",
"be",
"predicated",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZInstrInfo | isPredicable | SystemZ | CPU | LLVM | 18,581 | 40 | 1 | [] |
[
"<s>",
"void",
"ix86_bd_do_dispatch",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"mode",
")",
"{",
"if",
"(",
"mode",
"==",
"DISPATCH_INIT",
")",
"init_dispatch_sched",
"(",
")",
";",
"else",
"if",
"(",
"mode",
"==",
"ADD_TO_DISPATCH_WINDOW",
")",
"add_to_dispatch_window",
"(",
"insn",
")",
";",
"}",
"</s>"
] | [
"This",
"routine",
"is",
"the",
"driver",
"of",
"the",
"dispatch",
"scheduler",
"."
] | [
"i386"
] | x86-tune-sched-bd | ix86_bd_do_dispatch | i386 | CPU | GCC | 18,582 | 34 | 1 | [] |
[
"<s>",
"static",
"void",
"dump_minipool",
"(",
"rtx",
"scan",
")",
"{",
"Mnode",
"*",
"mp",
";",
"Mnode",
"*",
"nmp",
";",
"int",
"align64",
"=",
"0",
";",
"if",
"(",
"ARM_DOUBLEWORD_ALIGN",
")",
"for",
"(",
"mp",
"=",
"minipool_vector_head",
";",
"mp",
"!=",
"NULL",
";",
"mp",
"=",
"mp",
"->",
"next",
")",
"if",
"(",
"mp",
"->",
"refcount",
">",
"0",
"&&",
"mp",
"->",
"fix_size",
"==",
"8",
")",
"{",
"align64",
"=",
"1",
";",
"break",
";",
"}",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"\";; Emitting minipool after insn %u; address %ld; align %d (bytes)\\n\"",
",",
"INSN_UID",
"(",
"scan",
")",
",",
"(",
"unsigned",
"long",
")",
"minipool_barrier",
"->",
"address",
",",
"align64",
"?",
"8",
":",
"4",
")",
";",
"scan",
"=",
"emit_label_after",
"(",
"gen_label_rtx",
"(",
")",
",",
"scan",
")",
";",
"scan",
"=",
"emit_insn_after",
"(",
"align64",
"?",
"gen_align_8",
"(",
")",
":",
"gen_align_4",
"(",
")",
",",
"scan",
")",
";",
"scan",
"=",
"emit_label_after",
"(",
"minipool_vector_label",
",",
"scan",
")",
";",
"for",
"(",
"mp",
"=",
"minipool_vector_head",
";",
"mp",
"!=",
"NULL",
";",
"mp",
"=",
"nmp",
")",
"{",
"if",
"(",
"mp",
"->",
"refcount",
">",
"0",
")",
"{",
"if",
"(",
"dump_file",
")",
"{",
"fprintf",
"(",
"dump_file",
",",
"\";; Offset %u, min %ld, max %ld \"",
",",
"(",
"unsigned",
")",
"mp",
"->",
"offset",
",",
"(",
"unsigned",
"long",
")",
"mp",
"->",
"min_address",
",",
"(",
"unsigned",
"long",
")",
"mp",
"->",
"max_address",
")",
";",
"arm_print_value",
"(",
"dump_file",
",",
"mp",
"->",
"value",
")",
";",
"fputc",
"(",
"'\\n'",
",",
"dump_file",
")",
";",
"}",
"switch",
"(",
"mp",
"->",
"fix_size",
")",
"{",
"case",
"1",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_1",
"(",
"mp",
"->",
"value",
")",
",",
"scan",
")",
";",
"break",
";",
"case",
"2",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_2",
"(",
"mp",
"->",
"value",
")",
",",
"scan",
")",
";",
"break",
";",
"case",
"4",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_4",
"(",
"mp",
"->",
"value",
")",
",",
"scan",
")",
";",
"break",
";",
"case",
"8",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_8",
"(",
"mp",
"->",
"value",
")",
",",
"scan",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"nmp",
"=",
"mp",
"->",
"next",
";",
"free",
"(",
"mp",
")",
";",
"}",
"minipool_vector_head",
"=",
"minipool_vector_tail",
"=",
"NULL",
";",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_end",
"(",
")",
",",
"scan",
")",
";",
"scan",
"=",
"emit_barrier_after",
"(",
"scan",
")",
";",
"}",
"</s>"
] | [
"Output",
"the",
"literal",
"table"
] | [
"arm",
"0",
"0",
"8",
"1",
"\";; Emitting minipool after insn %u; address %ld; align %d (bytes)\\n\"",
"8",
"4",
"0",
"\";; Offset %u, min %ld, max %ld \"",
"1",
"2",
"4",
"8"
] | arm3 | dump_minipool | arm | CPU | GCC | 18,583 | 334 | 1 | [] |
[
"<s>",
"void",
"X86TargetLowering",
"::",
"insertSSPDeclarations",
"(",
"Module",
"&",
"M",
")",
"const",
"{",
"if",
"(",
"Subtarget",
".",
"getTargetTriple",
"(",
")",
".",
"isWindowsMSVCEnvironment",
"(",
")",
"||",
"Subtarget",
".",
"getTargetTriple",
"(",
")",
".",
"isWindowsItaniumEnvironment",
"(",
")",
")",
"{",
"M",
".",
"getOrInsertGlobal",
"(",
"\"__security_cookie\"",
",",
"Type",
"::",
"getInt8PtrTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
")",
";",
"auto",
"*",
"SecurityCheckCookie",
"=",
"cast",
"<",
"Function",
">",
"(",
"M",
".",
"getOrInsertFunction",
"(",
"\"__security_check_cookie\"",
",",
"Type",
"::",
"getVoidTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
",",
"Type",
"::",
"getInt8PtrTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
")",
")",
";",
"SecurityCheckCookie",
"->",
"setCallingConv",
"(",
"CallingConv",
"::",
"X86_FastCall",
")",
";",
"SecurityCheckCookie",
"->",
"addAttribute",
"(",
"1",
",",
"Attribute",
"::",
"AttrKind",
"::",
"InReg",
")",
";",
"return",
";",
"}",
"if",
"(",
"hasStackGuardSlotTLS",
"(",
"Subtarget",
".",
"getTargetTriple",
"(",
")",
")",
")",
"return",
";",
"TargetLowering",
"::",
"insertSSPDeclarations",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"Inserts",
"necessary",
"declarations",
"for",
"SSP",
"(",
"stack",
"protection",
")",
"purpose",
"."
] | [
"X86",
"X86",
"\"__security_cookie\"",
"\"__security_check_cookie\"",
"X86",
"1"
] | X86ISelLowering (2)8 | insertSSPDeclarations | X86 | CPU | LLVM | 18,584 | 137 | 1 | [] |
[
"<s>",
"XCoreTargetMachine",
"::",
"XCoreTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"DL",
"(",
"\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"",
"\"i16:16:32-i32:32:32-i64:32:32-n32\"",
")",
",",
"InstrInfo",
"(",
")",
",",
"FrameLowering",
"(",
"Subtarget",
")",
",",
"TLInfo",
"(",
"*",
"this",
")",
",",
"TSInfo",
"(",
"*",
"this",
")",
"{",
"}",
"</s>"
] | [
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"XCore",
"XCore",
"XCore",
"\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"",
"\"i16:16:32-i32:32:32-i64:32:32-n32\""
] | XCoreTargetMachine33 | XCoreTargetMachine | XCore | MPU | LLVM | 18,585 | 95 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_init_acle_builtins",
"(",
"void",
")",
"{",
"unsigned",
"int",
"i",
",",
"fcode",
"=",
"ARM_BUILTIN_ACLE_PATTERN_START",
";",
"tree",
"sat_check_fpr",
"=",
"build_function_type_list",
"(",
"void_type_node",
",",
"intSI_type_node",
",",
"intSI_type_node",
",",
"intSI_type_node",
",",
"NULL",
")",
";",
"arm_builtin_decls",
"[",
"ARM_BUILTIN_SAT_IMM_CHECK",
"]",
"=",
"add_builtin_function",
"(",
"\"__builtin_sat_imm_check\"",
",",
"sat_check_fpr",
",",
"ARM_BUILTIN_SAT_IMM_CHECK",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"acle_builtin_data",
")",
";",
"i",
"++",
",",
"fcode",
"++",
")",
"{",
"arm_builtin_datum",
"*",
"d",
"=",
"&",
"acle_builtin_data",
"[",
"i",
"]",
";",
"arm_init_builtin",
"(",
"fcode",
",",
"d",
",",
"\"__builtin_arm\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Set",
"up",
"ACLE",
"builtins",
",",
"even",
"builtins",
"for",
"instructions",
"that",
"are",
"not",
"in",
"the",
"current",
"target",
"ISA",
"to",
"allow",
"the",
"user",
"to",
"compile",
"particular",
"modules",
"with",
"different",
"target",
"specific",
"options",
"that",
"differ",
"from",
"the",
"command",
"line",
"options",
".",
"Such",
"builtins",
"will",
"be",
"rejected",
"in",
"arm_expand_builtin",
"."
] | [
"arm",
"\"__builtin_sat_imm_check\"",
"0",
"\"__builtin_arm\""
] | arm-builtins | arm_init_acle_builtins | arm | CPU | GCC | 18,586 | 92 | 1 | [] |
[
"<s>",
"virtual",
"const",
"DataLayout",
"*",
"getDataLayout",
"(",
")",
"const",
"{",
"return",
"&",
"DL",
";",
"}",
"</s>"
] | [
"Return",
"the",
"DataLayout",
"associated",
"with",
"the",
"module",
"this",
"SCEV",
"instance",
"is",
"operating",
"on",
"."
] | [
"Sparc"
] | SparcTargetMachine17 | getDataLayout | Sparc | CPU | LLVM | 18,587 | 14 | 1 | [] |
[
"<s>",
"Value",
"*",
"Simplifier",
"::",
"simplify",
"(",
"Context",
"&",
"C",
")",
"{",
"WorkListType",
"Q",
";",
"Q",
".",
"push_back",
"(",
"C",
".",
"Root",
")",
";",
"unsigned",
"Count",
"=",
"0",
";",
"const",
"unsigned",
"Limit",
"=",
"SimplifyLimit",
";",
"while",
"(",
"!",
"Q",
".",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"Count",
"++",
">=",
"Limit",
")",
"break",
";",
"Instruction",
"*",
"U",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"Q",
".",
"pop_front_val",
"(",
")",
")",
";",
"if",
"(",
"!",
"U",
"||",
"U",
"->",
"getParent",
"(",
")",
"||",
"!",
"C",
".",
"Used",
".",
"count",
"(",
"U",
")",
")",
"continue",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"Rule",
"&",
"R",
":",
"Rules",
")",
"{",
"Value",
"*",
"W",
"=",
"R",
"(",
"U",
",",
"C",
".",
"Ctx",
")",
";",
"if",
"(",
"!",
"W",
")",
"continue",
";",
"Changed",
"=",
"true",
";",
"C",
".",
"record",
"(",
"W",
")",
";",
"C",
".",
"replace",
"(",
"U",
",",
"W",
")",
";",
"Q",
".",
"push_back",
"(",
"C",
".",
"Root",
")",
";",
"break",
";",
"}",
"if",
"(",
"!",
"Changed",
")",
"{",
"for",
"(",
"Value",
"*",
"Op",
":",
"U",
"->",
"operands",
"(",
")",
")",
"Q",
".",
"push_back",
"(",
"Op",
")",
";",
"}",
"}",
"return",
"Count",
"<",
"Limit",
"?",
"C",
".",
"Root",
":",
"nullptr",
";",
"}",
"</s>"
] | [
"Go",
"through",
"all",
"the",
"nodes",
"in",
"the",
"graph",
"and",
"collapse",
"any",
"two",
"nodes",
"'",
"a",
"'",
"and",
"'",
"b",
"'",
"if",
"all",
"of",
"the",
"following",
"are",
"true",
":"
] | [
"Hexagon",
"0"
] | HexagonLoopIdiomRecognition3 | simplify | Hexagon | DSP | LLVM | 18,588 | 197 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_emit_ldrd_pop",
"(",
"unsigned",
"long",
"saved_regs_mask",
")",
"{",
"int",
"j",
"=",
"0",
";",
"int",
"offset",
"=",
"0",
";",
"rtx",
"par",
"=",
"NULL_RTX",
";",
"rtx",
"dwarf",
"=",
"NULL_RTX",
";",
"rtx",
"tmp",
",",
"mem",
";",
"gcc_assert",
"(",
"!",
"(",
"(",
"saved_regs_mask",
"&",
"(",
"1",
"<<",
"SP_REGNUM",
")",
")",
")",
")",
";",
"j",
"=",
"0",
";",
"while",
"(",
"j",
"<=",
"LAST_ARM_REGNUM",
")",
"if",
"(",
"saved_regs_mask",
"&",
"(",
"1",
"<<",
"j",
")",
")",
"{",
"if",
"(",
"(",
"j",
"%",
"2",
")",
"==",
"0",
"&&",
"(",
"saved_regs_mask",
"&",
"(",
"1",
"<<",
"(",
"j",
"+",
"1",
")",
")",
")",
"&&",
"(",
"j",
"+",
"1",
")",
"!=",
"PC_REGNUM",
")",
"{",
"if",
"(",
"offset",
">",
"0",
")",
"mem",
"=",
"gen_frame_mem",
"(",
"DImode",
",",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"offset",
")",
")",
";",
"else",
"mem",
"=",
"gen_frame_mem",
"(",
"DImode",
",",
"stack_pointer_rtx",
")",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"DImode",
",",
"gen_rtx_REG",
"(",
"DImode",
",",
"j",
")",
",",
"mem",
")",
";",
"tmp",
"=",
"emit_insn",
"(",
"tmp",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"tmp",
")",
"=",
"1",
";",
"dwarf",
"=",
"alloc_reg_note",
"(",
"REG_CFA_RESTORE",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"j",
")",
",",
"NULL_RTX",
")",
";",
"dwarf",
"=",
"alloc_reg_note",
"(",
"REG_CFA_RESTORE",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"j",
"+",
"1",
")",
",",
"dwarf",
")",
";",
"REG_NOTES",
"(",
"tmp",
")",
"=",
"dwarf",
";",
"offset",
"+=",
"8",
";",
"j",
"+=",
"2",
";",
"}",
"else",
"if",
"(",
"j",
"!=",
"PC_REGNUM",
")",
"{",
"if",
"(",
"offset",
">",
"0",
")",
"mem",
"=",
"gen_frame_mem",
"(",
"SImode",
",",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"offset",
")",
")",
";",
"else",
"mem",
"=",
"gen_frame_mem",
"(",
"SImode",
",",
"stack_pointer_rtx",
")",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"SImode",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"j",
")",
",",
"mem",
")",
";",
"tmp",
"=",
"emit_insn",
"(",
"tmp",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"tmp",
")",
"=",
"1",
";",
"REG_NOTES",
"(",
"tmp",
")",
"=",
"alloc_reg_note",
"(",
"REG_CFA_RESTORE",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"j",
")",
",",
"NULL_RTX",
")",
";",
"offset",
"+=",
"4",
";",
"j",
"+=",
"1",
";",
"}",
"else",
"j",
"++",
";",
"}",
"else",
"j",
"++",
";",
"if",
"(",
"offset",
">",
"0",
")",
"{",
"tmp",
"=",
"gen_rtx_SET",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"offset",
")",
")",
";",
"tmp",
"=",
"emit_insn",
"(",
"tmp",
")",
";",
"arm_add_cfa_adjust_cfa_note",
"(",
"tmp",
",",
"offset",
",",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
")",
";",
"offset",
"=",
"0",
";",
"}",
"if",
"(",
"saved_regs_mask",
"&",
"(",
"1",
"<<",
"PC_REGNUM",
")",
")",
"{",
"par",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"rtvec_alloc",
"(",
"2",
")",
")",
";",
"XVECEXP",
"(",
"par",
",",
"0",
",",
"0",
")",
"=",
"ret_rtx",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"SImode",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"PC_REGNUM",
")",
",",
"gen_frame_mem",
"(",
"SImode",
",",
"gen_rtx_POST_INC",
"(",
"SImode",
",",
"stack_pointer_rtx",
")",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"tmp",
")",
"=",
"1",
";",
"XVECEXP",
"(",
"par",
",",
"0",
",",
"1",
")",
"=",
"tmp",
";",
"par",
"=",
"emit_jump_insn",
"(",
"par",
")",
";",
"dwarf",
"=",
"alloc_reg_note",
"(",
"REG_CFA_RESTORE",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"PC_REGNUM",
")",
",",
"NULL_RTX",
")",
";",
"REG_NOTES",
"(",
"par",
")",
"=",
"dwarf",
";",
"arm_add_cfa_adjust_cfa_note",
"(",
"par",
",",
"UNITS_PER_WORD",
",",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
")",
";",
"}",
"}",
"</s>"
] | [
"LDRD",
"in",
"ARM",
"mode",
"needs",
"consecutive",
"registers",
"as",
"operands",
".",
"This",
"function",
"emits",
"LDRD",
"whenever",
"possible",
",",
"otherwise",
"it",
"emits",
"single-word",
"loads",
".",
"It",
"uses",
"offset",
"addressing",
"and",
"then",
"generates",
"one",
"separate",
"stack",
"udpate",
".",
"This",
"provides",
"more",
"scheduling",
"freedom",
",",
"compared",
"to",
"writeback",
"on",
"every",
"load",
".",
"However",
",",
"if",
"the",
"function",
"returns",
"using",
"load",
"into",
"PC",
"directly",
"(",
"i.e.",
",",
"if",
"PC",
"is",
"in",
"SAVED_REGS_MASK",
")",
",",
"the",
"stack",
"needs",
"to",
"be",
"updated",
"before",
"the",
"last",
"load",
".",
"TODO",
":",
"Add",
"a",
"peephole",
"optimization",
"to",
"recognize",
"the",
"new",
"epilogue",
"sequence",
"as",
"an",
"LDM",
"instruction",
"whenever",
"possible",
".",
"TODO",
":",
"Add",
"peephole",
"optimization",
"to",
"merge",
"the",
"load",
"at",
"stack-offset",
"zero",
"with",
"the",
"stack",
"update",
"instruction",
"using",
"load",
"with",
"writeback",
"in",
"post-index",
"addressing",
"mode",
"."
] | [
"arm",
"0",
"0",
"1",
"0",
"1",
"2",
"0",
"1",
"1",
"1",
"0",
"1",
"1",
"8",
"2",
"0",
"1",
"4",
"1",
"0",
"0",
"1",
"2",
"0",
"0",
"1",
"0",
"1"
] | arm4 | arm_emit_ldrd_pop | arm | CPU | GCC | 18,589 | 492 | 1 | [] |
[
"<s>",
"void",
"MetadataStreamer",
"::",
"verify",
"(",
"StringRef",
"YamlString",
")",
"const",
"{",
"errs",
"(",
")",
"<<",
"\"AMDGPU Code Object Metadata Parser Test: \"",
";",
"CodeObject",
"::",
"Metadata",
"FromYamlString",
";",
"if",
"(",
"Metadata",
"::",
"fromYamlString",
"(",
"YamlString",
",",
"FromYamlString",
")",
")",
"{",
"errs",
"(",
")",
"<<",
"\"FAIL\\n\"",
";",
"return",
";",
"}",
"std",
"::",
"string",
"ToYamlString",
";",
"if",
"(",
"Metadata",
"::",
"toYamlString",
"(",
"FromYamlString",
",",
"ToYamlString",
")",
")",
"{",
"errs",
"(",
")",
"<<",
"\"FAIL\\n\"",
";",
"return",
";",
"}",
"errs",
"(",
")",
"<<",
"(",
"YamlString",
"==",
"ToYamlString",
"?",
"\"PASS\"",
":",
"\"FAIL\"",
")",
"<<",
"'\\n'",
";",
"if",
"(",
"YamlString",
"!=",
"ToYamlString",
")",
"{",
"errs",
"(",
")",
"<<",
"\"Original input: \"",
"<<",
"YamlString",
"<<",
"'\\n'",
"<<",
"\"Produced output: \"",
"<<",
"ToYamlString",
"<<",
"'\\n'",
";",
"}",
"}",
"</s>"
] | [
"Check",
"if",
"this",
"register",
"bank",
"is",
"valid",
"."
] | [
"AMDGPU",
"\"AMDGPU Code Object Metadata Parser Test: \"",
"\"FAIL\\n\"",
"\"FAIL\\n\"",
"\"PASS\"",
"\"FAIL\"",
"\"Original input: \"",
"\"Produced output: \""
] | AMDGPUCodeObjectMetadataStreamer | verify | AMDGPU | GPU | LLVM | 18,590 | 109 | 1 | [] |
[
"<s>",
"void",
"setReg",
"(",
"unsigned",
"Reg",
")",
"{",
"assert",
"(",
"isRegBase",
"(",
")",
"&&",
"\"Invalid base register access!\"",
")",
";",
"assert",
"(",
"Base",
".",
"Reg",
"==",
"0",
"&&",
"\"Overwriting non-zero register\"",
")",
";",
"Base",
".",
"Reg",
"=",
"Reg",
";",
"}",
"</s>"
] | [
"Assigns",
"the",
"associated",
"register",
"for",
"this",
"edge",
"."
] | [
"WebAssembly",
"\"Invalid base register access!\"",
"0",
"\"Overwriting non-zero register\""
] | WebAssemblyFastISel11 | setReg | WebAssembly | Virtual ISA | LLVM | 18,591 | 34 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"AssumptionCacheTracker",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"DominatorTreeWrapperPass",
">",
"(",
")",
";",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"TPC"
] | MemoryToReg | getAnalysisUsage | TPC | Virtual ISA | LLVM | 18,592 | 35 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_indirect_branch_settings",
"(",
"tree",
"fndecl",
")",
"{",
"tree",
"attr",
";",
"if",
"(",
"!",
"fndecl",
")",
"return",
";",
"cfun",
"->",
"machine",
"->",
"indirect_branch_jump",
"=",
"s390_indirect_branch_jump",
";",
"cfun",
"->",
"machine",
"->",
"indirect_branch_call",
"=",
"s390_indirect_branch_call",
";",
"cfun",
"->",
"machine",
"->",
"function_return_reg",
"=",
"s390_function_return_reg",
";",
"cfun",
"->",
"machine",
"->",
"function_return_mem",
"=",
"s390_function_return_mem",
";",
"if",
"(",
"(",
"attr",
"=",
"lookup_attribute",
"(",
"\"indirect_branch\"",
",",
"DECL_ATTRIBUTES",
"(",
"fndecl",
")",
")",
")",
")",
"{",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"indirect_branch_jump",
")",
";",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"indirect_branch_call",
")",
";",
"}",
"if",
"(",
"(",
"attr",
"=",
"lookup_attribute",
"(",
"\"indirect_branch_jump\"",
",",
"DECL_ATTRIBUTES",
"(",
"fndecl",
")",
")",
")",
")",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"indirect_branch_jump",
")",
";",
"if",
"(",
"(",
"attr",
"=",
"lookup_attribute",
"(",
"\"indirect_branch_call\"",
",",
"DECL_ATTRIBUTES",
"(",
"fndecl",
")",
")",
")",
")",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"indirect_branch_call",
")",
";",
"if",
"(",
"(",
"attr",
"=",
"lookup_attribute",
"(",
"\"function_return\"",
",",
"DECL_ATTRIBUTES",
"(",
"fndecl",
")",
")",
")",
")",
"{",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"function_return_reg",
")",
";",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"function_return_mem",
")",
";",
"}",
"if",
"(",
"(",
"attr",
"=",
"lookup_attribute",
"(",
"\"function_return_reg\"",
",",
"DECL_ATTRIBUTES",
"(",
"fndecl",
")",
")",
")",
")",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"function_return_reg",
")",
";",
"if",
"(",
"(",
"attr",
"=",
"lookup_attribute",
"(",
"\"function_return_mem\"",
",",
"DECL_ATTRIBUTES",
"(",
"fndecl",
")",
")",
")",
")",
"s390_indirect_branch_attrvalue",
"(",
"attr",
",",
"&",
"cfun",
"->",
"machine",
"->",
"function_return_mem",
")",
";",
"}",
"</s>"
] | [
"Memorize",
"the",
"setting",
"for",
"-mindirect-branch",
"*",
"and",
"-mfunction-return",
"*",
"from",
"either",
"the",
"cmdline",
"or",
"the",
"function",
"attributes",
"in",
"cfun-",
">",
"machine",
"."
] | [
"s390",
"\"indirect_branch\"",
"\"indirect_branch_jump\"",
"\"indirect_branch_call\"",
"\"function_return\"",
"\"function_return_reg\"",
"\"function_return_mem\""
] | s390 | s390_indirect_branch_settings | s390 | MPU | GCC | 18,593 | 247 | 1 | [] |
[
"<s>",
"MachineInstrBuilder",
"SIInstrInfo",
"::",
"getAddNoCarry",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"Register",
"DestReg",
",",
"RegScavenger",
"&",
"RS",
")",
"const",
"{",
"if",
"(",
"ST",
".",
"hasAddNoCarry",
"(",
")",
")",
"return",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"V_ADD_U32_e32",
")",
",",
"DestReg",
")",
";",
"Register",
"UnusedCarry",
"=",
"RS",
".",
"scavengeRegister",
"(",
"RI",
".",
"getBoolRC",
"(",
")",
",",
"I",
",",
"0",
",",
"false",
")",
";",
"if",
"(",
"!",
"UnusedCarry",
".",
"isValid",
"(",
")",
")",
"return",
"MachineInstrBuilder",
"(",
")",
";",
"return",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"V_ADD_I32_e64",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"UnusedCarry",
",",
"RegState",
"::",
"Define",
"|",
"RegState",
"::",
"Dead",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"partially",
"built",
"integer",
"add",
"instruction",
"without",
"carry",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::V_ADD_U32_e32",
"0",
"AMDGPU::V_ADD_I32_e64"
] | SIInstrInfo134 | getAddNoCarry | AMDGPU | GPU | LLVM | 18,594 | 122 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"SparcDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"N",
")",
"{",
"SDLoc",
"dl",
"(",
"N",
")",
";",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"N",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
"nullptr",
";",
"}",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"SPISD",
"::",
"GLOBAL_BASE_REG",
":",
"return",
"getGlobalBaseReg",
"(",
")",
";",
"case",
"ISD",
"::",
"SDIV",
":",
"case",
"ISD",
"::",
"UDIV",
":",
"{",
"if",
"(",
"N",
"->",
"getValueType",
"(",
"0",
")",
"==",
"MVT",
"::",
"i64",
")",
"break",
";",
"SDValue",
"DivLHS",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"DivRHS",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"SDValue",
"TopPart",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
")",
"{",
"TopPart",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"SP",
"::",
"SRAri",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"DivLHS",
",",
"CurDAG",
"->",
"getTargetConstant",
"(",
"31",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"0",
")",
";",
"}",
"else",
"{",
"TopPart",
"=",
"CurDAG",
"->",
"getRegister",
"(",
"SP",
"::",
"G0",
",",
"MVT",
"::",
"i32",
")",
";",
"}",
"TopPart",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"SP",
"::",
"WRASRrr",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"TopPart",
",",
"CurDAG",
"->",
"getRegister",
"(",
"SP",
"::",
"G0",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"0",
")",
";",
"TopPart",
"=",
"CurDAG",
"->",
"getCopyToReg",
"(",
"TopPart",
",",
"dl",
",",
"SP",
"::",
"Y",
",",
"TopPart",
",",
"SDValue",
"(",
")",
")",
".",
"getValue",
"(",
"1",
")",
";",
"unsigned",
"Opcode",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
"?",
"SP",
"::",
"SDIVrr",
":",
"SP",
"::",
"UDIVrr",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"Opcode",
",",
"MVT",
"::",
"i32",
",",
"DivLHS",
",",
"DivRHS",
",",
"TopPart",
")",
";",
"}",
"case",
"ISD",
"::",
"MULHU",
":",
"case",
"ISD",
"::",
"MULHS",
":",
"{",
"SDValue",
"MulLHS",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"MulRHS",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"unsigned",
"Opcode",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"MULHU",
"?",
"SP",
"::",
"UMULrr",
":",
"SP",
"::",
"SMULrr",
";",
"SDNode",
"*",
"Mul",
"=",
"CurDAG",
"->",
"getMachineNode",
"(",
"Opcode",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Glue",
",",
"MulLHS",
",",
"MulRHS",
")",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"SP",
"::",
"RDASR",
",",
"MVT",
"::",
"i32",
",",
"CurDAG",
"->",
"getRegister",
"(",
"SP",
"::",
"Y",
",",
"MVT",
"::",
"i32",
")",
",",
"SDValue",
"(",
"Mul",
",",
"1",
")",
")",
";",
"}",
"}",
"return",
"SelectCode",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Sparc",
"Sparc",
"1",
"SPISD::GLOBAL_BASE_REG",
"ISD::SDIV",
"ISD::UDIV",
"0",
"MVT::i64",
"0",
"1",
"ISD::SDIV",
"SP::SRAri",
"MVT::i32",
"31",
"MVT::i32",
"0",
"SP::G0",
"MVT::i32",
"SP::WRASRrr",
"MVT::i32",
"SP::G0",
"MVT::i32",
"0",
"SP::Y",
"1",
"ISD::SDIV",
"SP::SDIVrr",
"SP::UDIVrr",
"MVT::i32",
"ISD::MULHU",
"ISD::MULHS",
"0",
"1",
"ISD::MULHU",
"SP::UMULrr",
"SP::SMULrr",
"MVT::i32",
"MVT::Glue",
"SP::RDASR",
"MVT::i32",
"SP::Y",
"MVT::i32",
"1"
] | SparcISelDAGToDAG28 | Select | Sparc | CPU | LLVM | 18,595 | 406 | 1 | [] |
[
"<s>",
"bool",
"PPCAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getIdentifier",
"(",
")",
";",
"if",
"(",
"!",
"isDarwin",
"(",
")",
")",
"{",
"if",
"(",
"IDVal",
"==",
"\".word\"",
")",
"return",
"ParseDirectiveWord",
"(",
"2",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".llong\"",
")",
"return",
"ParseDirectiveWord",
"(",
"8",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".tc\"",
")",
"return",
"ParseDirectiveTC",
"(",
"isPPC64",
"(",
")",
"?",
"8",
":",
"4",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".machine\"",
")",
"return",
"ParseDirectiveMachine",
"(",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"}",
"else",
"{",
"if",
"(",
"IDVal",
"==",
"\".machine\"",
")",
"return",
"ParseDarwinDirectiveMachine",
"(",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"PowerPC",
"PPC",
"\".word\"",
"2",
"\".llong\"",
"8",
"\".tc\"",
"PPC",
"8",
"4",
"\".machine\"",
"\".machine\""
] | PPCAsmParser (2) | ParseDirective | PowerPC | CPU | LLVM | 18,596 | 126 | 1 | [] |
[
"<s>",
"rtx",
"rs6000_libcall_value",
"(",
"machine_mode",
"mode",
")",
"{",
"unsigned",
"int",
"regno",
";",
"if",
"(",
"TARGET_32BIT",
"&&",
"TARGET_POWERPC64",
"&&",
"mode",
"==",
"DImode",
")",
"return",
"rs6000_parallel_return",
"(",
"mode",
",",
"2",
",",
"SImode",
",",
"GP_ARG_RETURN",
",",
"1",
")",
";",
"if",
"(",
"DECIMAL_FLOAT_MODE_P",
"(",
"mode",
")",
"&&",
"TARGET_HARD_FLOAT",
"&&",
"TARGET_FPRS",
")",
"regno",
"=",
"(",
"mode",
"==",
"TDmode",
")",
"?",
"FP_ARG_RETURN",
"+",
"1",
":",
"FP_ARG_RETURN",
";",
"else",
"if",
"(",
"SCALAR_FLOAT_MODE_NOT_VECTOR_P",
"(",
"mode",
")",
"&&",
"TARGET_HARD_FLOAT",
"&&",
"TARGET_FPRS",
"&&",
"(",
"(",
"TARGET_SINGLE_FLOAT",
"&&",
"mode",
"==",
"SFmode",
")",
"||",
"TARGET_DOUBLE_FLOAT",
")",
")",
"regno",
"=",
"FP_ARG_RETURN",
";",
"else",
"if",
"(",
"ALTIVEC_OR_VSX_VECTOR_MODE",
"(",
"mode",
")",
"&&",
"TARGET_ALTIVEC",
"&&",
"TARGET_ALTIVEC_ABI",
")",
"regno",
"=",
"ALTIVEC_ARG_RETURN",
";",
"else",
"if",
"(",
"COMPLEX_MODE_P",
"(",
"mode",
")",
"&&",
"targetm",
".",
"calls",
".",
"split_complex_arg",
")",
"return",
"rs6000_complex_function_value",
"(",
"mode",
")",
";",
"else",
"if",
"(",
"TARGET_E500_DOUBLE",
"&&",
"TARGET_HARD_FLOAT",
"&&",
"(",
"mode",
"==",
"DFmode",
"||",
"mode",
"==",
"DCmode",
"||",
"FLOAT128_IBM_P",
"(",
"mode",
")",
"||",
"mode",
"==",
"TCmode",
")",
")",
"return",
"spe_build_register_parallel",
"(",
"mode",
",",
"GP_ARG_RETURN",
")",
";",
"else",
"regno",
"=",
"GP_ARG_RETURN",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"}",
"</s>"
] | [
"Define",
"how",
"to",
"find",
"the",
"value",
"returned",
"by",
"a",
"library",
"function",
"assuming",
"the",
"value",
"has",
"mode",
"MODE",
"."
] | [
"powerpcspe",
"2",
"1",
"1"
] | powerpcspe | rs6000_libcall_value | powerpcspe | CPU | GCC | 18,597 | 172 | 1 | [] |
[
"<s>",
"int",
"PIC16RegisterInfo",
"::",
"getDwarfRegNum",
"(",
"unsigned",
"RegNum",
",",
"bool",
"isEH",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"Not keeping track of debug information yet!!\"",
")",
";",
"return",
"-",
"1",
";",
"}",
"</s>"
] | [
"Map",
"a",
"target",
"register",
"to",
"an",
"equivalent",
"dwarf",
"register",
"number",
"."
] | [
"PIC16",
"PIC16",
"\"Not keeping track of debug information yet!!\"",
"1"
] | PIC16RegisterInfo | getDwarfRegNum | PIC16 | MPU | LLVM | 18,598 | 23 | 1 | [] |
[
"<s>",
"bool",
"X86PassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"bool",
"ShouldPrint",
"=",
"false",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"getX86Subtarget",
"(",
")",
".",
"hasSSE2",
"(",
")",
")",
"{",
"PM",
".",
"add",
"(",
"createExecutionDependencyFixPass",
"(",
"&",
"X86",
"::",
"VR128RegClass",
")",
")",
";",
"ShouldPrint",
"=",
"true",
";",
"}",
"if",
"(",
"getX86Subtarget",
"(",
")",
".",
"hasAVX",
"(",
")",
"&&",
"UseVZeroUpper",
")",
"{",
"PM",
".",
"add",
"(",
"createX86IssueVZeroUpperPass",
"(",
")",
")",
";",
"ShouldPrint",
"=",
"true",
";",
"}",
"return",
"ShouldPrint",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"X86",
"X86",
"X86",
"X86::VR128RegClass",
"X86",
"X86"
] | X86TargetMachine43 | addPreEmitPass | X86 | CPU | LLVM | 18,599 | 80 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.