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>",
"void",
"ARMHazardRecognizer",
"::",
"AdvanceCycle",
"(",
")",
"{",
"if",
"(",
"FpMLxStalls",
"&&",
"--",
"FpMLxStalls",
"==",
"0",
")",
"LastMI",
"=",
"nullptr",
";",
"ScoreboardHazardRecognizer",
"::",
"AdvanceCycle",
"(",
")",
";",
"}",
"</s>"
] | [
"AdvanceCycle",
"-",
"This",
"callback",
"is",
"invoked",
"whenever",
"the",
"next",
"top-down",
"instruction",
"to",
"be",
"scheduled",
"can",
"not",
"issue",
"in",
"the",
"current",
"cycle",
",",
"either",
"because",
"of",
"latency",
"or",
"resource",
"conflicts",
"."
] | [
"ARM",
"ARM",
"0"
] | ARMHazardRecognizer (2) | AdvanceCycle | ARM | CPU | LLVM | 17,100 | 27 | 1 | [] |
[
"<s>",
"static",
"bool",
"frv_for_each_packet",
"(",
"void",
"(",
"*",
"handle_packet",
")",
"(",
"void",
")",
")",
"{",
"rtx",
"insn",
",",
"next_insn",
";",
"frv_packet",
".",
"issue_rate",
"=",
"frv_issue_rate",
"(",
")",
";",
"if",
"(",
"!",
"optimize",
"||",
"!",
"flag_schedule_insns_after_reload",
"||",
"!",
"TARGET_VLIW_BRANCH",
"||",
"frv_packet",
".",
"issue_rate",
"==",
"1",
")",
"return",
"false",
";",
"dfa_start",
"(",
")",
";",
"frv_packet",
".",
"dfa_state",
"=",
"alloca",
"(",
"state_size",
"(",
")",
")",
";",
"frv_start_packet_block",
"(",
")",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
"!=",
"0",
";",
"insn",
"=",
"next_insn",
")",
"{",
"enum",
"rtx_code",
"code",
";",
"bool",
"eh_insn_p",
";",
"code",
"=",
"GET_CODE",
"(",
"insn",
")",
";",
"next_insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
";",
"if",
"(",
"code",
"==",
"CODE_LABEL",
")",
"{",
"frv_finish_packet",
"(",
"handle_packet",
")",
";",
"frv_start_packet_block",
"(",
")",
";",
"}",
"if",
"(",
"INSN_P",
"(",
"insn",
")",
")",
"switch",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
")",
"{",
"case",
"USE",
":",
"case",
"CLOBBER",
":",
"case",
"ADDR_VEC",
":",
"case",
"ADDR_DIFF_VEC",
":",
"break",
";",
"default",
":",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"CALL_INSN",
"&&",
"frv_cpu_type",
"==",
"FRV_CPU_TOMCAT",
")",
"frv_finish_packet",
"(",
"handle_packet",
")",
";",
"eh_insn_p",
"=",
"(",
"find_reg_note",
"(",
"insn",
",",
"REG_EH_REGION",
",",
"NULL",
")",
"!=",
"NULL",
")",
";",
"if",
"(",
"eh_insn_p",
"&&",
"!",
"frv_issues_to_branch_unit_p",
"(",
"insn",
")",
")",
"frv_finish_packet",
"(",
"handle_packet",
")",
";",
"if",
"(",
"!",
"frv_pack_insn_p",
"(",
"insn",
")",
")",
"{",
"frv_finish_packet",
"(",
"handle_packet",
")",
";",
"while",
"(",
"!",
"frv_pack_insn_p",
"(",
"insn",
")",
")",
"state_transition",
"(",
"frv_packet",
".",
"dfa_state",
",",
"0",
")",
";",
"}",
"frv_add_insn_to_packet",
"(",
"insn",
")",
";",
"if",
"(",
"code",
"==",
"CALL_INSN",
"||",
"code",
"==",
"JUMP_INSN",
"||",
"eh_insn_p",
")",
"frv_finish_packet",
"(",
"handle_packet",
")",
";",
"break",
";",
"}",
"}",
"frv_finish_packet",
"(",
"handle_packet",
")",
";",
"dfa_finish",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"If",
"packing",
"is",
"enabled",
",",
"divide",
"the",
"instructions",
"into",
"packets",
"and",
"return",
"true",
".",
"Call",
"HANDLE_PACKET",
"for",
"each",
"complete",
"packet",
"."
] | [
"frv",
"1",
"0",
"0"
] | frv2 | frv_for_each_packet | frv | VLIW | GCC | 17,101 | 274 | 1 | [] |
[
"<s>",
"static",
"bool",
"call_ABI_of_interest",
"(",
"tree",
"fndecl",
")",
"{",
"if",
"(",
"symtab",
"->",
"state",
"==",
"EXPANSION",
")",
"{",
"struct",
"cgraph_node",
"*",
"c_node",
";",
"if",
"(",
"fndecl",
"==",
"NULL_TREE",
")",
"return",
"true",
";",
"if",
"(",
"DECL_EXTERNAL",
"(",
"fndecl",
")",
")",
"return",
"true",
";",
"c_node",
"=",
"cgraph_node",
"::",
"get",
"(",
"fndecl",
")",
";",
"c_node",
"=",
"c_node",
"->",
"ultimate_alias_target",
"(",
")",
";",
"return",
"!",
"c_node",
"->",
"only_called_directly_p",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"a",
"call",
"to",
"function",
"FNDECL",
"may",
"be",
"one",
"that",
"potentially",
"affects",
"the",
"function",
"calling",
"ABI",
"of",
"the",
"object",
"file",
"."
] | [
"rs6000"
] | rs60004 | call_ABI_of_interest | rs6000 | CPU | GCC | 17,102 | 71 | 1 | [] |
[
"<s>",
"static",
"rtx",
"bfin_expand_binop_builtin",
"(",
"enum",
"insn_code",
"icode",
",",
"tree",
"exp",
",",
"rtx",
"target",
",",
"int",
"macflag",
")",
"{",
"rtx",
"pat",
";",
"tree",
"arg0",
"=",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"0",
")",
";",
"tree",
"arg1",
"=",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"1",
")",
";",
"rtx",
"op0",
"=",
"expand_normal",
"(",
"arg0",
")",
";",
"rtx",
"op1",
"=",
"expand_normal",
"(",
"arg1",
")",
";",
"machine_mode",
"op0mode",
"=",
"GET_MODE",
"(",
"op0",
")",
";",
"machine_mode",
"op1mode",
"=",
"GET_MODE",
"(",
"op1",
")",
";",
"machine_mode",
"tmode",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"mode",
";",
"machine_mode",
"mode0",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"1",
"]",
".",
"mode",
";",
"machine_mode",
"mode1",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"2",
"]",
".",
"mode",
";",
"if",
"(",
"VECTOR_MODE_P",
"(",
"mode0",
")",
")",
"op0",
"=",
"safe_vector_operand",
"(",
"op0",
",",
"mode0",
")",
";",
"if",
"(",
"VECTOR_MODE_P",
"(",
"mode1",
")",
")",
"op1",
"=",
"safe_vector_operand",
"(",
"op1",
",",
"mode1",
")",
";",
"if",
"(",
"!",
"target",
"||",
"GET_MODE",
"(",
"target",
")",
"!=",
"tmode",
"||",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"predicate",
")",
"(",
"target",
",",
"tmode",
")",
")",
"target",
"=",
"gen_reg_rtx",
"(",
"tmode",
")",
";",
"if",
"(",
"(",
"op0mode",
"==",
"SImode",
"||",
"op0mode",
"==",
"VOIDmode",
")",
"&&",
"mode0",
"==",
"HImode",
")",
"{",
"op0mode",
"=",
"HImode",
";",
"op0",
"=",
"gen_lowpart",
"(",
"HImode",
",",
"op0",
")",
";",
"}",
"if",
"(",
"(",
"op1mode",
"==",
"SImode",
"||",
"op1mode",
"==",
"VOIDmode",
")",
"&&",
"mode1",
"==",
"HImode",
")",
"{",
"op1mode",
"=",
"HImode",
";",
"op1",
"=",
"gen_lowpart",
"(",
"HImode",
",",
"op1",
")",
";",
"}",
"gcc_assert",
"(",
"(",
"op0mode",
"==",
"mode0",
"||",
"op0mode",
"==",
"VOIDmode",
")",
"&&",
"(",
"op1mode",
"==",
"mode1",
"||",
"op1mode",
"==",
"VOIDmode",
")",
")",
";",
"if",
"(",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"1",
"]",
".",
"predicate",
")",
"(",
"op0",
",",
"mode0",
")",
")",
"op0",
"=",
"copy_to_mode_reg",
"(",
"mode0",
",",
"op0",
")",
";",
"if",
"(",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"2",
"]",
".",
"predicate",
")",
"(",
"op1",
",",
"mode1",
")",
")",
"op1",
"=",
"copy_to_mode_reg",
"(",
"mode1",
",",
"op1",
")",
";",
"if",
"(",
"macflag",
"==",
"-",
"1",
")",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"op1",
")",
";",
"else",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"op1",
",",
"GEN_INT",
"(",
"macflag",
")",
")",
";",
"if",
"(",
"!",
"pat",
")",
"return",
"0",
";",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Subroutine",
"of",
"bfin_expand_builtin",
"to",
"take",
"care",
"of",
"binop",
"insns",
".",
"MACFLAG",
"is",
"-1",
"if",
"this",
"is",
"a",
"normal",
"binary",
"op",
",",
"or",
"one",
"of",
"the",
"MACFLAG_xxx",
"constants",
"."
] | [
"bfin",
"0",
"1",
"0",
"1",
"2",
"0",
"1",
"2",
"1",
"0"
] | bfin | bfin_expand_binop_builtin | bfin | DSP | GCC | 17,103 | 397 | 1 | [] |
[
"<s>",
"void",
"ARCInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"Register",
"SrcReg",
",",
"bool",
"IsKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"I",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FrameIndex",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
",",
"MFI",
".",
"getObjectAlign",
"(",
"FrameIndex",
")",
")",
";",
"assert",
"(",
"MMO",
"&&",
"\"Couldn't get MachineMemOperand for store to stack.\"",
")",
";",
"assert",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
"==",
"4",
"&&",
"\"Only support 4-byte stores to stack now.\"",
")",
";",
"assert",
"(",
"ARC",
"::",
"GPR32RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"&&",
"\"Only support GPR32 stores to stack now.\"",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Created store reg=\"",
"<<",
"printReg",
"(",
"SrcReg",
",",
"TRI",
")",
"<<",
"\" to FrameIndex=\"",
"<<",
"FrameIndex",
"<<",
"\"\\n\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARC",
"::",
"ST_rs9",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"IsKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARC",
"ARC",
"\"Couldn't get MachineMemOperand for store to stack.\"",
"4",
"\"Only support 4-byte stores to stack now.\"",
"ARC::GPR32RegClass",
"\"Only support GPR32 stores to stack now.\"",
"\"Created store reg=\"",
"\" to FrameIndex=\"",
"\"\\n\"",
"ARC::ST_rs9",
"0"
] | ARCInstrInfo4 | storeRegToStackSlot | ARC | MPU | LLVM | 17,104 | 202 | 1 | [] |
[
"<s>",
"unsigned",
"SIInstrInfo",
"::",
"insertBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"TBB",
",",
"MachineBasicBlock",
"*",
"FBB",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"int",
"*",
"BytesAdded",
")",
"const",
"{",
"if",
"(",
"!",
"FBB",
"&&",
"Cond",
".",
"empty",
"(",
")",
")",
"{",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"S_BRANCH",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"=",
"4",
";",
"return",
"1",
";",
"}",
"if",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"Cond",
"[",
"0",
"]",
".",
"isReg",
"(",
")",
")",
"{",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"SI_NON_UNIFORM_BRCOND_PSEUDO",
")",
")",
".",
"add",
"(",
"Cond",
"[",
"0",
"]",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"return",
"1",
";",
"}",
"assert",
"(",
"TBB",
"&&",
"Cond",
"[",
"0",
"]",
".",
"isImm",
"(",
")",
")",
";",
"unsigned",
"Opcode",
"=",
"getBranchOpcode",
"(",
"static_cast",
"<",
"BranchPredicate",
">",
"(",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
")",
";",
"if",
"(",
"!",
"FBB",
")",
"{",
"Cond",
"[",
"1",
"]",
".",
"isUndef",
"(",
")",
";",
"MachineInstr",
"*",
"CondBr",
"=",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"preserveCondRegFlags",
"(",
"CondBr",
"->",
"getOperand",
"(",
"1",
")",
",",
"Cond",
"[",
"1",
"]",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"=",
"4",
";",
"return",
"1",
";",
"}",
"assert",
"(",
"TBB",
"&&",
"FBB",
")",
";",
"MachineInstr",
"*",
"CondBr",
"=",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"S_BRANCH",
")",
")",
".",
"addMBB",
"(",
"FBB",
")",
";",
"MachineOperand",
"&",
"CondReg",
"=",
"CondBr",
"->",
"getOperand",
"(",
"1",
")",
";",
"CondReg",
".",
"setIsUndef",
"(",
"Cond",
"[",
"1",
"]",
".",
"isUndef",
"(",
")",
")",
";",
"CondReg",
".",
"setIsKill",
"(",
"Cond",
"[",
"1",
"]",
".",
"isKill",
"(",
")",
")",
";",
"if",
"(",
"BytesAdded",
")",
"*",
"BytesAdded",
"=",
"8",
";",
"return",
"2",
";",
"}",
"</s>"
] | [
"Insert",
"branch",
"code",
"into",
"the",
"end",
"of",
"the",
"specified",
"MachineBasicBlock",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::S_BRANCH",
"4",
"1",
"1",
"0",
"AMDGPU::SI_NON_UNIFORM_BRCOND_PSEUDO",
"0",
"1",
"0",
"0",
"1",
"1",
"1",
"4",
"1",
"AMDGPU::S_BRANCH",
"1",
"1",
"1",
"8",
"2"
] | SIInstrInfo (2) | insertBranch | AMDGPU | GPU | LLVM | 17,105 | 332 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"getSectionForConstant",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"SectionKind",
"Kind",
",",
"const",
"Constant",
"*",
"C",
")",
"const",
"override",
"{",
"return",
"ReadOnlySection",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constant",
"with",
"the",
"SectionKind",
",",
"return",
"a",
"section",
"that",
"it",
"should",
"be",
"placed",
"in",
"."
] | [
"NVPTX"
] | NVPTXTargetObjectFile (2) | getSectionForConstant | NVPTX | GPU | LLVM | 17,106 | 24 | 1 | [] |
[
"<s>",
"void",
"PPCRegisterInfo",
"::",
"resolveFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"BaseReg",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"I",
";",
"unsigned",
"FIOperandNum",
"=",
"0",
";",
"while",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"isFI",
"(",
")",
")",
"{",
"++",
"FIOperandNum",
";",
"assert",
"(",
"FIOperandNum",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
"&&",
"\"Instr doesn't have FrameIndex operand!\"",
")",
";",
"}",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"BaseReg",
",",
"false",
")",
";",
"unsigned",
"OffsetOperandNo",
"=",
"getOffsetONFromFION",
"(",
"MI",
",",
"FIOperandNum",
")",
";",
"Offset",
"+=",
"MI",
".",
"getOperand",
"(",
"OffsetOperandNo",
")",
".",
"getImm",
"(",
")",
";",
"MI",
".",
"getOperand",
"(",
"OffsetOperandNo",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"}",
"</s>"
] | [
"Resolve",
"a",
"frame",
"index",
"operand",
"of",
"an",
"instruction",
"to",
"reference",
"the",
"indicated",
"base",
"register",
"plus",
"offset",
"instead",
"."
] | [
"PowerPC",
"PPC",
"0",
"\"Instr doesn't have FrameIndex operand!\""
] | PPCRegisterInfo (2) | resolveFrameIndex | PowerPC | CPU | LLVM | 17,107 | 112 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyPassConfig",
"::",
"addPostRegAlloc",
"(",
")",
"{",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"register",
"allocation",
"pass",
"pipeline",
"but",
"before",
"prolog-epilog",
"insertion",
"."
] | [
"WebAssembly",
"WebAssembly"
] | WebAssemblyTargetMachine2 | addPostRegAlloc | WebAssembly | Virtual ISA | LLVM | 17,108 | 8 | 1 | [] |
[
"<s>",
"MCInst",
"PPCInstrInfo",
"::",
"getNop",
"(",
")",
"const",
"{",
"MCInst",
"Nop",
";",
"Nop",
".",
"setOpcode",
"(",
"PPC",
"::",
"NOP",
")",
";",
"return",
"Nop",
";",
"}",
"</s>"
] | [
"Return",
"the",
"noop",
"instruction",
"to",
"use",
"for",
"a",
"noop",
"."
] | [
"PowerPC",
"PPC",
"PPC::NOP"
] | PPCInstrInfo | getNop | PowerPC | CPU | LLVM | 17,109 | 24 | 1 | [] |
[
"<s>",
"unsigned",
"MipsInstrInfo",
"::",
"removeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"int",
"*",
"BytesRemoved",
")",
"const",
"{",
"assert",
"(",
"!",
"BytesRemoved",
"&&",
"\"code size not handled\"",
")",
";",
"MachineBasicBlock",
"::",
"reverse_iterator",
"I",
"=",
"MBB",
".",
"rbegin",
"(",
")",
",",
"REnd",
"=",
"MBB",
".",
"rend",
"(",
")",
";",
"unsigned",
"removed",
";",
"while",
"(",
"I",
"!=",
"REnd",
"&&",
"I",
"->",
"isDebugValue",
"(",
")",
")",
"++",
"I",
";",
"if",
"(",
"I",
"==",
"REnd",
")",
"return",
"0",
";",
"MachineBasicBlock",
"::",
"iterator",
"FirstBr",
"=",
"++",
"I",
".",
"getReverse",
"(",
")",
";",
"for",
"(",
"removed",
"=",
"0",
";",
"I",
"!=",
"REnd",
"&&",
"removed",
"<",
"2",
";",
"++",
"I",
",",
"++",
"removed",
")",
"if",
"(",
"!",
"getAnalyzableBrOpc",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
")",
"break",
";",
"MBB",
".",
"erase",
"(",
"(",
"--",
"I",
")",
".",
"getReverse",
"(",
")",
",",
"FirstBr",
")",
";",
"return",
"removed",
";",
"}",
"</s>"
] | [
"Remove",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"the",
"specific",
"MBB",
"."
] | [
"Mips",
"Mips",
"\"code size not handled\"",
"0",
"0",
"2"
] | MipsInstrInfo16 | removeBranch | Mips | CPU | LLVM | 17,110 | 135 | 1 | [] |
[
"<s>",
"rtx",
"iq2000_function_value",
"(",
"tree",
"valtype",
",",
"tree",
"func",
"ATTRIBUTE_UNUSED",
")",
"{",
"int",
"reg",
"=",
"GP_RETURN",
";",
"enum",
"machine_mode",
"mode",
"=",
"TYPE_MODE",
"(",
"valtype",
")",
";",
"int",
"unsignedp",
"=",
"TYPE_UNSIGNED",
"(",
"valtype",
")",
";",
"mode",
"=",
"promote_mode",
"(",
"valtype",
",",
"mode",
",",
"&",
"unsignedp",
",",
"1",
")",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"reg",
")",
";",
"}",
"</s>"
] | [
"Return",
"register",
"to",
"use",
"for",
"a",
"function",
"return",
"value",
"with",
"VALTYPE",
"for",
"function",
"FUNC",
"."
] | [
"iq2000",
"1"
] | iq20002 | iq2000_function_value | iq2000 | CPU | GCC | 17,111 | 56 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isVectorLoadExtDesirable",
"(",
"SDValue",
"ExtVal",
")",
"const",
"{",
"EVT",
"VT",
"=",
"ExtVal",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"!",
"isTypeLegal",
"(",
"VT",
")",
")",
"return",
"false",
";",
"if",
"(",
"auto",
"*",
"Ld",
"=",
"dyn_cast",
"<",
"MaskedLoadSDNode",
">",
"(",
"ExtVal",
".",
"getOperand",
"(",
"0",
")",
")",
")",
"{",
"if",
"(",
"Ld",
"->",
"isExpandingLoad",
"(",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"Subtarget",
"->",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"ExtVal",
"->",
"use_empty",
"(",
")",
"||",
"!",
"ExtVal",
"->",
"use_begin",
"(",
")",
"->",
"isOnlyUserOf",
"(",
"ExtVal",
".",
"getNode",
"(",
")",
")",
")",
"return",
"true",
";",
"SDNode",
"*",
"U",
"=",
"*",
"ExtVal",
"->",
"use_begin",
"(",
")",
";",
"if",
"(",
"(",
"U",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"ADD",
"||",
"U",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SUB",
"||",
"U",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SHL",
"||",
"U",
"->",
"getOpcode",
"(",
")",
"==",
"ARMISD",
"::",
"VSHLIMM",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"folding",
"a",
"vector",
"load",
"into",
"ExtVal",
"(",
"a",
"sign",
",",
"zero",
",",
"or",
"any",
"extend",
"node",
")",
"is",
"profitable",
"."
] | [
"ARM",
"ARM",
"0",
"ISD::ADD",
"ISD::SUB",
"ISD::SHL",
"ARMISD::VSHLIMM"
] | ARMISelLowering (2)5 | isVectorLoadExtDesirable | ARM | CPU | LLVM | 17,112 | 162 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"name",
"(",
")",
"const",
"noexcept",
"override",
"{",
"return",
"\"switch\"",
";",
"}",
"</s>"
] | [
"Gets",
"the",
"name",
"of",
"the",
"pass",
"we",
"are",
"mixed",
"into",
"."
] | [
"TPC",
"\"switch\""
] | InstructionDB | name | TPC | Virtual ISA | LLVM | 17,113 | 14 | 1 | [] |
[
"<s>",
"bool",
"addInstSelector",
"(",
")",
"override",
"{",
"addPass",
"(",
"new",
"J2DAGToDAGISel",
"(",
"getJ2TargetMachine",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"J2",
"J2",
"J2"
] | J2TargetMachine | addInstSelector | J2 | MPU | LLVM | 17,114 | 21 | 1 | [] |
[
"<s>",
"bool",
"WaitInsert",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"!",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"StrictFP",
")",
")",
"return",
"false",
";",
"const",
"X86Subtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"const",
"X86InstrInfo",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
";",
"++",
"MI",
")",
"{",
"if",
"(",
"!",
"isX87Instruction",
"(",
"*",
"MI",
")",
")",
"continue",
";",
"if",
"(",
"!",
"(",
"MI",
"->",
"mayRaiseFPException",
"(",
")",
"||",
"MI",
"->",
"mayLoadOrStore",
"(",
")",
")",
"||",
"isX87ControlInstruction",
"(",
"*",
"MI",
")",
")",
"continue",
";",
"MachineBasicBlock",
"::",
"iterator",
"AfterMI",
"=",
"std",
"::",
"next",
"(",
"MI",
")",
";",
"if",
"(",
"AfterMI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"isX87Instruction",
"(",
"*",
"AfterMI",
")",
"&&",
"!",
"isX87NonWaitingControlInstruction",
"(",
"*",
"AfterMI",
")",
")",
"continue",
";",
"BuildMI",
"(",
"MBB",
",",
"AfterMI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"WAIT",
")",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"\\nInsert wait after:\\t\"",
"<<",
"*",
"MI",
")",
";",
"++",
"MI",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86::WAIT",
"\"\\nInsert wait after:\\t\""
] | X86InsertWait3 | runOnMachineFunction | X86 | CPU | LLVM | 17,115 | 213 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseRegisterInfo",
"::",
"canRealignStack",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineRegisterInfo",
"*",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"!",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"RealignStack",
")",
"return",
"false",
";",
"if",
"(",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MRI",
"->",
"canReserveReg",
"(",
"FramePtr",
")",
")",
"return",
"false",
";",
"if",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
"->",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"return",
"true",
";",
"return",
"MRI",
"->",
"canReserveReg",
"(",
"BasePtr",
")",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"stack",
"can",
"be",
"realigned",
"for",
"the",
"target",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMBaseRegisterInfo26 | canRealignStack | ARM | CPU | LLVM | 17,116 | 107 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"pru_output_sign_extend",
"(",
"rtx",
"*",
"operands",
")",
"{",
"static",
"char",
"buf",
"[",
"512",
"]",
";",
"int",
"bufi",
";",
"const",
"int",
"dst_sz",
"=",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
")",
";",
"const",
"int",
"src_sz",
"=",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"char",
"ext_start",
";",
"switch",
"(",
"src_sz",
")",
"{",
"case",
"1",
":",
"ext_start",
"=",
"'y'",
";",
"break",
";",
"case",
"2",
":",
"ext_start",
"=",
"'z'",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"gcc_assert",
"(",
"dst_sz",
">",
"src_sz",
")",
";",
"bufi",
"=",
"snprintf",
"(",
"buf",
",",
"sizeof",
"(",
"buf",
")",
",",
"\"mov\\t%%0, %%1\\n\\t\"",
"\"qbbc\\t.+8, %%0, %d\\n\\t\"",
"\"fill\\t%%%c0, %d\"",
",",
"sign_bit_position",
"(",
"operands",
"[",
"1",
"]",
")",
",",
"ext_start",
",",
"dst_sz",
"-",
"src_sz",
")",
";",
"gcc_assert",
"(",
"bufi",
">",
"0",
")",
";",
"gcc_assert",
"(",
"(",
"unsigned",
"int",
")",
"bufi",
"<",
"sizeof",
"(",
"buf",
")",
")",
";",
"return",
"buf",
";",
"}",
"</s>"
] | [
"Output",
"asm",
"code",
"for",
"sign_extend",
"operation",
"."
] | [
"pru",
"512",
"0",
"1",
"1",
"2",
"\"mov\\t%%0, %%1\\n\\t\"",
"\"qbbc\\t.+8, %%0, %d\\n\\t\"",
"\"fill\\t%%%c0, %d\"",
"1",
"0"
] | pru | pru_output_sign_extend | pru | CPU | GCC | 17,117 | 145 | 1 | [] |
[
"<s>",
"void",
"MSP430InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"Register",
"DestReg",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FrameIdx",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIdx",
")",
",",
"MFI",
".",
"getObjectAlign",
"(",
"FrameIdx",
")",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR16RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV16rm",
")",
")",
".",
"addReg",
"(",
"DestReg",
",",
"getDefRegState",
"(",
"true",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR8RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV8rm",
")",
")",
".",
"addReg",
"(",
"DestReg",
",",
"getDefRegState",
"(",
"true",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Cannot store this register to stack slot!\"",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"MSP430",
"MSP430",
"MSP430::GR16RegClass",
"MSP430::MOV16rm",
"0",
"MSP430::GR8RegClass",
"MSP430::MOV8rm",
"0",
"\"Cannot store this register to stack slot!\""
] | MSP430InstrInfo19 | loadRegFromStackSlot | MSP430 | MPU | LLVM | 17,118 | 218 | 1 | [] |
[
"<s>",
"virtual",
"const",
"TargetFrameInfo",
"*",
"getFrameInfo",
"(",
")",
"const",
"{",
"return",
"&",
"FrameInfo",
";",
"}",
"</s>"
] | [
"getFrameInfo",
"-",
"Return",
"the",
"frame",
"info",
"object",
"for",
"the",
"current",
"function",
"."
] | [
"IA64"
] | IA64TargetMachine | getFrameInfo | IA64 | CPU | LLVM | 17,119 | 14 | 1 | [] |
[
"<s>",
"static",
"void",
"loongarch_set_frame_expr",
"(",
"rtx",
"frame_pattern",
")",
"{",
"rtx",
"insn",
";",
"insn",
"=",
"get_last_insn",
"(",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"REG_NOTES",
"(",
"insn",
")",
"=",
"alloc_EXPR_LIST",
"(",
"REG_FRAME_RELATED_EXPR",
",",
"frame_pattern",
",",
"REG_NOTES",
"(",
"insn",
")",
")",
";",
"}",
"</s>"
] | [
"Make",
"the",
"last",
"instruction",
"frame-related",
"and",
"note",
"that",
"it",
"performs",
"the",
"operation",
"described",
"by",
"FRAME_PATTERN",
"."
] | [
"loongarch",
"1"
] | loongarch | loongarch_set_frame_expr | loongarch | CPU | GCC | 17,120 | 42 | 1 | [] |
[
"<s>",
"static",
"rtx",
"frv_expand_mclracc_builtin",
"(",
"tree",
"call",
")",
"{",
"enum",
"insn_code",
"icode",
"=",
"CODE_FOR_mclracc",
";",
"rtx",
"pat",
";",
"rtx",
"op0",
"=",
"frv_read_argument",
"(",
"call",
",",
"0",
")",
";",
"op0",
"=",
"frv_int_to_acc",
"(",
"icode",
",",
"0",
",",
"op0",
")",
";",
"if",
"(",
"!",
"op0",
")",
"return",
"NULL_RTX",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"op0",
")",
";",
"if",
"(",
"pat",
")",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"MCLRACC",
"builtin",
".",
"This",
"builtin",
"takes",
"a",
"single",
"accumulator",
"number",
"as",
"argument",
"."
] | [
"frv",
"0",
"0"
] | frv | frv_expand_mclracc_builtin | frv | VLIW | GCC | 17,121 | 69 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"rest_of_insert_endbranch",
"(",
"void",
")",
"{",
"timevar_push",
"(",
"TV_MACH_DEP",
")",
";",
"rtx",
"cet_eb",
";",
"rtx_insn",
"*",
"insn",
";",
"basic_block",
"bb",
";",
"if",
"(",
"!",
"lookup_attribute",
"(",
"\"nocf_check\"",
",",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"cfun",
"->",
"decl",
")",
")",
")",
"&&",
"!",
"cgraph_node",
"::",
"get",
"(",
"cfun",
"->",
"decl",
")",
"->",
"only_called_directly_p",
"(",
")",
")",
"{",
"cet_eb",
"=",
"gen_nop_endbr",
"(",
")",
";",
"bb",
"=",
"ENTRY_BLOCK_PTR_FOR_FN",
"(",
"cfun",
")",
"->",
"next_bb",
";",
"insn",
"=",
"BB_HEAD",
"(",
"bb",
")",
";",
"emit_insn_before",
"(",
"cet_eb",
",",
"insn",
")",
";",
"}",
"bb",
"=",
"0",
";",
"FOR_EACH_BB_FN",
"(",
"bb",
",",
"cfun",
")",
"{",
"for",
"(",
"insn",
"=",
"BB_HEAD",
"(",
"bb",
")",
";",
"insn",
"!=",
"NEXT_INSN",
"(",
"BB_END",
"(",
"bb",
")",
")",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"CALL_P",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"find_reg_note",
"(",
"insn",
",",
"REG_SETJMP",
",",
"NULL",
")",
"==",
"NULL",
")",
"continue",
";",
"cet_eb",
"=",
"gen_nop_endbr",
"(",
")",
";",
"emit_insn_after_setloc",
"(",
"cet_eb",
",",
"insn",
",",
"INSN_LOCATION",
"(",
"insn",
")",
")",
";",
"continue",
";",
"}",
"if",
"(",
"JUMP_P",
"(",
"insn",
")",
"&&",
"flag_cet_switch",
")",
"{",
"rtx",
"target",
"=",
"JUMP_LABEL",
"(",
"insn",
")",
";",
"if",
"(",
"target",
"==",
"NULL_RTX",
"||",
"ANY_RETURN_P",
"(",
"target",
")",
")",
"continue",
";",
"rtx_insn",
"*",
"label",
"=",
"as_a",
"<",
"rtx_insn",
"*",
">",
"(",
"target",
")",
";",
"rtx_insn",
"*",
"table",
"=",
"next_insn",
"(",
"label",
")",
";",
"if",
"(",
"table",
"==",
"NULL_RTX",
"||",
"!",
"JUMP_TABLE_DATA_P",
"(",
"table",
")",
")",
"continue",
";",
"edge_iterator",
"ei",
";",
"edge",
"e",
";",
"basic_block",
"dest_blk",
";",
"FOR_EACH_EDGE",
"(",
"e",
",",
"ei",
",",
"bb",
"->",
"succs",
")",
"{",
"rtx_insn",
"*",
"insn",
";",
"dest_blk",
"=",
"e",
"->",
"dest",
";",
"insn",
"=",
"BB_HEAD",
"(",
"dest_blk",
")",
";",
"gcc_assert",
"(",
"LABEL_P",
"(",
"insn",
")",
")",
";",
"cet_eb",
"=",
"gen_nop_endbr",
"(",
")",
";",
"emit_insn_after",
"(",
"cet_eb",
",",
"insn",
")",
";",
"}",
"continue",
";",
"}",
"if",
"(",
"(",
"LABEL_P",
"(",
"insn",
")",
"&&",
"LABEL_PRESERVE_P",
"(",
"insn",
")",
")",
"||",
"(",
"NOTE_P",
"(",
"insn",
")",
"&&",
"NOTE_KIND",
"(",
"insn",
")",
"==",
"NOTE_INSN_DELETED_LABEL",
")",
")",
"{",
"cet_eb",
"=",
"gen_nop_endbr",
"(",
")",
";",
"emit_insn_after",
"(",
"cet_eb",
",",
"insn",
")",
";",
"continue",
";",
"}",
"}",
"}",
"timevar_pop",
"(",
"TV_MACH_DEP",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Inserting",
"ENDBRANCH",
"instructions",
"."
] | [
"i386",
"\"nocf_check\"",
"0",
"0"
] | i3867 | rest_of_insert_endbranch | i386 | CPU | GCC | 17,122 | 353 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m68k_get_gp",
"(",
"void",
")",
"{",
"if",
"(",
"pic_offset_table_rtx",
"==",
"NULL_RTX",
")",
"pic_offset_table_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"PIC_REG",
")",
";",
"crtl",
"->",
"uses_pic_offset_table",
"=",
"1",
";",
"return",
"pic_offset_table_rtx",
";",
"}",
"</s>"
] | [
"Return",
"GOT",
"pointer",
"."
] | [
"m68k",
"1"
] | m68k | m68k_get_gp | m68k | MPU | GCC | 17,123 | 32 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"CJGFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"const",
"CJGInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"CJGInstrInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"unsigned",
"StackAlign",
"=",
"getStackAlignment",
"(",
")",
";",
"if",
"(",
"!",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"MachineInstr",
"&",
"Old",
"=",
"*",
"I",
";",
"uint64_t",
"Amount",
"=",
"Old",
".",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"Amount",
"=",
"(",
"Amount",
"+",
"StackAlign",
"-",
"1",
")",
"/",
"StackAlign",
"*",
"StackAlign",
";",
"MachineInstr",
"*",
"New",
"=",
"nullptr",
";",
"if",
"(",
"Old",
".",
"getOpcode",
"(",
")",
"==",
"TII",
".",
"getCallFrameSetupOpcode",
"(",
")",
")",
"{",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"CJG",
"::",
"SUBri",
")",
",",
"CJG",
"::",
"SP",
")",
".",
"addReg",
"(",
"CJG",
"::",
"SP",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Old",
".",
"getOpcode",
"(",
")",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
";",
"uint64_t",
"CalleeAmt",
"=",
"Old",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"Amount",
"-=",
"CalleeAmt",
";",
"if",
"(",
"Amount",
")",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"CJG",
"::",
"ADDri",
")",
",",
"CJG",
"::",
"SP",
")",
".",
"addReg",
"(",
"CJG",
"::",
"SP",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"if",
"(",
"New",
")",
"{",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
"{",
"if",
"(",
"uint64_t",
"CalleeAmt",
"=",
"I",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
")",
"{",
"MachineInstr",
"&",
"Old",
"=",
"*",
"I",
";",
"MachineInstr",
"*",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"CJG",
"::",
"SUBri",
")",
",",
"CJG",
"::",
"SP",
")",
".",
"addReg",
"(",
"CJG",
"::",
"SP",
")",
".",
"addImm",
"(",
"CalleeAmt",
")",
";",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"}",
"return",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"CJG",
"CJG",
"CJG",
"CJG",
"0",
"0",
"1",
"CJG::SUBri",
"CJG::SP",
"CJG::SP",
"1",
"CJG::ADDri",
"CJG::SP",
"CJG::SP",
"3",
"1",
"CJG::SUBri",
"CJG::SP",
"CJG::SP",
"3"
] | CJGFrameLowering | eliminateCallFramePseudoInstr | CJG | CPU | LLVM | 17,124 | 381 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"X86 FP Stackifier\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"X86 FP Stackifier\""
] | X86FloatingPoint14 | getPassName | X86 | CPU | LLVM | 17,125 | 13 | 1 | [] |
[
"<s>",
"static",
"int",
"c6x_sched_reorder_1",
"(",
"rtx_insn",
"*",
"*",
"ready",
",",
"int",
"*",
"pn_ready",
",",
"int",
"clock_var",
")",
"{",
"int",
"n_ready",
"=",
"*",
"pn_ready",
";",
"rtx_insn",
"*",
"*",
"e_ready",
"=",
"ready",
"+",
"n_ready",
";",
"rtx_insn",
"*",
"*",
"insnp",
";",
"int",
"first_jump",
";",
"for",
"(",
"insnp",
"=",
"ready",
";",
"insnp",
"<",
"e_ready",
";",
"insnp",
"++",
")",
"{",
"rtx_insn",
"*",
"insn",
"=",
"*",
"insnp",
";",
"int",
"icode",
"=",
"recog_memoized",
"(",
"insn",
")",
";",
"bool",
"is_asm",
"=",
"(",
"icode",
"<",
"0",
"&&",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"ASM_INPUT",
"||",
"asm_noperands",
"(",
"PATTERN",
"(",
"insn",
")",
")",
">=",
"0",
")",
")",
";",
"bool",
"no_parallel",
"=",
"(",
"is_asm",
"||",
"icode",
"==",
"CODE_FOR_sploop",
"||",
"(",
"icode",
">=",
"0",
"&&",
"get_attr_type",
"(",
"insn",
")",
"==",
"TYPE_ATOMIC",
")",
")",
";",
"if",
"(",
"(",
"no_parallel",
"&&",
"(",
"ss",
".",
"issued_this_cycle",
">",
"0",
"||",
"clock_var",
"<",
"ss",
".",
"delays_finished_at",
")",
")",
"||",
"c6x_registers_update",
"(",
"insn",
")",
"||",
"(",
"ss",
".",
"issued_this_cycle",
">",
"0",
"&&",
"icode",
"==",
"CODE_FOR_sploop",
")",
")",
"{",
"memmove",
"(",
"ready",
"+",
"1",
",",
"ready",
",",
"(",
"insnp",
"-",
"ready",
")",
"*",
"sizeof",
"(",
"rtx",
")",
")",
";",
"*",
"ready",
"=",
"insn",
";",
"n_ready",
"--",
";",
"ready",
"++",
";",
"}",
"else",
"if",
"(",
"shadow_p",
"(",
"insn",
")",
")",
"{",
"memmove",
"(",
"ready",
"+",
"1",
",",
"ready",
",",
"(",
"insnp",
"-",
"ready",
")",
"*",
"sizeof",
"(",
"rtx",
")",
")",
";",
"*",
"ready",
"=",
"insn",
";",
"}",
"}",
"first_jump",
"=",
"first_jump_index",
"(",
"clock_var",
")",
";",
"if",
"(",
"first_jump",
"!=",
"-",
"1",
")",
"{",
"int",
"first_cycle",
"=",
"get_jump_cycle",
"(",
"first_jump",
")",
";",
"rtx",
"first_cond",
"=",
"get_jump_cond",
"(",
"first_jump",
")",
";",
"int",
"second_cycle",
"=",
"0",
";",
"if",
"(",
"first_jump",
">",
"0",
")",
"second_cycle",
"=",
"get_jump_cycle",
"(",
"first_jump",
"-",
"1",
")",
";",
"for",
"(",
"insnp",
"=",
"ready",
";",
"insnp",
"<",
"e_ready",
";",
"insnp",
"++",
")",
"{",
"rtx_insn",
"*",
"insn",
"=",
"*",
"insnp",
";",
"int",
"icode",
"=",
"recog_memoized",
"(",
"insn",
")",
";",
"bool",
"is_asm",
"=",
"(",
"icode",
"<",
"0",
"&&",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"ASM_INPUT",
"||",
"asm_noperands",
"(",
"PATTERN",
"(",
"insn",
")",
")",
">=",
"0",
")",
")",
";",
"int",
"this_cycles",
",",
"rsrv_cycles",
";",
"enum",
"attr_type",
"type",
";",
"gcc_assert",
"(",
"!",
"is_asm",
")",
";",
"if",
"(",
"icode",
"<",
"0",
")",
"continue",
";",
"this_cycles",
"=",
"get_attr_cycles",
"(",
"insn",
")",
";",
"rsrv_cycles",
"=",
"get_attr_reserve_cycles",
"(",
"insn",
")",
";",
"type",
"=",
"get_attr_type",
"(",
"insn",
")",
";",
"if",
"(",
"type",
"==",
"TYPE_BRANCH",
"||",
"type",
"==",
"TYPE_CALL",
")",
"this_cycles",
"++",
";",
"if",
"(",
"clock_var",
"+",
"this_cycles",
"<=",
"first_cycle",
")",
"continue",
";",
"if",
"(",
"(",
"first_jump",
">",
"0",
"&&",
"clock_var",
"+",
"this_cycles",
">",
"second_cycle",
")",
"||",
"clock_var",
"+",
"rsrv_cycles",
">",
"first_cycle",
"||",
"!",
"predicate_insn",
"(",
"insn",
",",
"first_cond",
",",
"false",
")",
")",
"{",
"memmove",
"(",
"ready",
"+",
"1",
",",
"ready",
",",
"(",
"insnp",
"-",
"ready",
")",
"*",
"sizeof",
"(",
"rtx",
")",
")",
";",
"*",
"ready",
"=",
"insn",
";",
"n_ready",
"--",
";",
"ready",
"++",
";",
"}",
"}",
"}",
"return",
"n_ready",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"for",
"the",
"TARGET_SCHED_REORDER",
"and",
"TARGET_SCHED_REORDER2",
"hooks",
".",
"If",
"scheduling",
"an",
"insn",
"would",
"be",
"unsafe",
"in",
"the",
"current",
"cycle",
",",
"move",
"it",
"down",
"in",
"the",
"ready",
"list",
"and",
"return",
"the",
"number",
"of",
"non-unsafe",
"insns",
"."
] | [
"c6x",
"0",
"0",
"0",
"0",
"0",
"1",
"1",
"1",
"0",
"0",
"1",
"0",
"0",
"0",
"0",
"1"
] | c6x | c6x_sched_reorder_1 | c6x | VLIW | GCC | 17,126 | 477 | 1 | [] |
[
"<s>",
"bool",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
",",
"StringRef",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"override",
"{",
"Operands",
".",
"push_back",
"(",
"make_unique",
"<",
"WebAssemblyOperand",
">",
"(",
"WebAssemblyOperand",
"::",
"Token",
",",
"NameLoc",
",",
"SMLoc",
"::",
"getFromPointer",
"(",
"NameLoc",
".",
"getPointer",
"(",
")",
"+",
"Name",
".",
"size",
"(",
")",
")",
",",
"WebAssemblyOperand",
"::",
"TokOp",
"{",
"StringRef",
"(",
"NameLoc",
".",
"getPointer",
"(",
")",
",",
"Name",
".",
"size",
"(",
")",
")",
"}",
")",
")",
";",
"auto",
"NamePair",
"=",
"Name",
".",
"split",
"(",
"'.'",
")",
";",
"if",
"(",
"NamePair",
".",
"second",
".",
"empty",
"(",
")",
")",
"std",
"::",
"swap",
"(",
"NamePair",
".",
"first",
",",
"NamePair",
".",
"second",
")",
";",
"while",
"(",
"Lexer",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"auto",
"&",
"Tok",
"=",
"Lexer",
".",
"getTok",
"(",
")",
";",
"switch",
"(",
"Tok",
".",
"getKind",
"(",
")",
")",
"{",
"case",
"AsmToken",
"::",
"Identifier",
":",
"{",
"auto",
"&",
"Id",
"=",
"Lexer",
".",
"getTok",
"(",
")",
";",
"const",
"MCExpr",
"*",
"Val",
";",
"SMLoc",
"End",
";",
"if",
"(",
"Parser",
".",
"parsePrimaryExpr",
"(",
"Val",
",",
"End",
")",
")",
"return",
"Error",
"(",
"\"Cannot parse symbol: \"",
",",
"Lexer",
".",
"getTok",
"(",
")",
")",
";",
"Operands",
".",
"push_back",
"(",
"make_unique",
"<",
"WebAssemblyOperand",
">",
"(",
"WebAssemblyOperand",
"::",
"Symbol",
",",
"Id",
".",
"getLoc",
"(",
")",
",",
"Id",
".",
"getEndLoc",
"(",
")",
",",
"WebAssemblyOperand",
"::",
"SymOp",
"{",
"Val",
"}",
")",
")",
";",
"break",
";",
"}",
"case",
"AsmToken",
"::",
"Minus",
":",
"Parser",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"Lexer",
".",
"isNot",
"(",
"AsmToken",
"::",
"Integer",
")",
")",
"return",
"Error",
"(",
"\"Expected integer instead got: \"",
",",
"Lexer",
".",
"getTok",
"(",
")",
")",
";",
"if",
"(",
"ParseOperandStartingWithInteger",
"(",
"true",
",",
"Operands",
",",
"NamePair",
".",
"second",
")",
")",
"return",
"true",
";",
"break",
";",
"case",
"AsmToken",
"::",
"Integer",
":",
"if",
"(",
"ParseOperandStartingWithInteger",
"(",
"false",
",",
"Operands",
",",
"NamePair",
".",
"second",
")",
")",
"return",
"true",
";",
"break",
";",
"case",
"AsmToken",
"::",
"Real",
":",
"{",
"double",
"Val",
";",
"if",
"(",
"Tok",
".",
"getString",
"(",
")",
".",
"getAsDouble",
"(",
"Val",
",",
"false",
")",
")",
"return",
"Error",
"(",
"\"Cannot parse real: \"",
",",
"Tok",
")",
";",
"Operands",
".",
"push_back",
"(",
"make_unique",
"<",
"WebAssemblyOperand",
">",
"(",
"WebAssemblyOperand",
"::",
"Float",
",",
"Tok",
".",
"getLoc",
"(",
")",
",",
"Tok",
".",
"getEndLoc",
"(",
")",
",",
"WebAssemblyOperand",
"::",
"FltOp",
"{",
"Val",
"}",
")",
")",
";",
"Parser",
".",
"Lex",
"(",
")",
";",
"break",
";",
"}",
"default",
":",
"return",
"Error",
"(",
"\"Unexpected token in operand: \"",
",",
"Tok",
")",
";",
"}",
"if",
"(",
"Lexer",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"if",
"(",
"Expect",
"(",
"AsmToken",
"::",
"Comma",
",",
"\",\"",
")",
")",
"return",
"true",
";",
"}",
"}",
"Parser",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"NamePair",
".",
"second",
"==",
"\"block\"",
"||",
"NamePair",
".",
"second",
"==",
"\"loop\"",
")",
"{",
"Operands",
".",
"push_back",
"(",
"make_unique",
"<",
"WebAssemblyOperand",
">",
"(",
"WebAssemblyOperand",
"::",
"Integer",
",",
"NameLoc",
",",
"NameLoc",
",",
"WebAssemblyOperand",
"::",
"IntOp",
"{",
"-",
"1",
"}",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssemblyOperand::Token",
"WebAssemblyOperand::TokOp",
"\"Cannot parse symbol: \"",
"WebAssembly",
"WebAssemblyOperand::Symbol",
"WebAssemblyOperand::SymOp",
"\"Expected integer instead got: \"",
"\"Cannot parse real: \"",
"WebAssembly",
"WebAssemblyOperand::Float",
"WebAssemblyOperand::FltOp",
"\"Unexpected token in operand: \"",
"\",\"",
"\"block\"",
"\"loop\"",
"WebAssembly",
"WebAssemblyOperand::Integer",
"WebAssemblyOperand::IntOp",
"1"
] | WebAssemblyAsmParser4 | ParseInstruction | WebAssembly | Virtual ISA | LLVM | 17,127 | 462 | 1 | [] |
[
"<s>",
"unsigned",
"TPCInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"TPC",
"::",
"SPILL_ARF_RESTORE",
":",
"case",
"TPC",
"::",
"SPILL_DRF_RESTORE",
":",
"case",
"TPC",
"::",
"SPILL_VRF_RESTORE",
":",
"case",
"TPC",
"::",
"SPILL_VPRF_RESTORE",
":",
"case",
"TPC",
"::",
"SPILL_IRF_RESTORE",
":",
"case",
"TPC",
"::",
"SPILL_SRF_RESTORE",
":",
"case",
"TPC",
"::",
"SPILL_ZRF_RESTORE",
":",
"case",
"TPC",
"::",
"SPILL_SPRF_RESTORE",
":",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"TPC",
"TPC",
"TPC::SPILL_ARF_RESTORE",
"TPC::SPILL_DRF_RESTORE",
"TPC::SPILL_VRF_RESTORE",
"TPC::SPILL_VPRF_RESTORE",
"TPC::SPILL_IRF_RESTORE",
"TPC::SPILL_SRF_RESTORE",
"TPC::SPILL_ZRF_RESTORE",
"TPC::SPILL_SPRF_RESTORE",
"1",
"0",
"0"
] | TPCInstrInfo | isLoadFromStackSlot | TPC | Virtual ISA | LLVM | 17,128 | 95 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"NPEngineTargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"NPEnginePassConfig",
"(",
"this",
",",
"PM",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"NPEngine"
] | NPEngineTargetMachine | createPassConfig | NPEngine | Virtual ISA | LLVM | 17,129 | 21 | 1 | [] |
[
"<s>",
"bool",
"ix86_fp_jump_nontrivial_p",
"(",
"enum",
"rtx_code",
"code",
")",
"{",
"enum",
"rtx_code",
"bypass_code",
",",
"first_code",
",",
"second_code",
";",
"if",
"(",
"!",
"TARGET_CMOVE",
")",
"return",
"true",
";",
"ix86_fp_comparison_codes",
"(",
"code",
",",
"&",
"bypass_code",
",",
"&",
"first_code",
",",
"&",
"second_code",
")",
";",
"return",
"bypass_code",
"!=",
"UNKNOWN",
"||",
"second_code",
"!=",
"UNKNOWN",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"CODE",
"will",
"result",
"in",
"nontrivial",
"jump",
"sequence",
"."
] | [
"i386"
] | i3863 | ix86_fp_jump_nontrivial_p | i386 | CPU | GCC | 17,130 | 48 | 1 | [] |
[
"<s>",
"unsigned",
"SparcMCCodeEmitter",
"::",
"getBranchTargetOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
"||",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"getMachineOpValue",
"(",
"MI",
",",
"MO",
",",
"Fixups",
",",
"STI",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"MO",
".",
"getExpr",
"(",
")",
",",
"(",
"MCFixupKind",
")",
"Sparc",
"::",
"fixup_sparc_br22",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTargetOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"Sparc",
"Sparc",
"0",
"Sparc::fixup_sparc_br22",
"0"
] | SparcMCCodeEmitter | getBranchTargetOpValue | Sparc | CPU | LLVM | 17,131 | 94 | 1 | [] |
[
"<s>",
"void",
"X86PassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"&",
"LiveRangeShrinkID",
")",
";",
"addPass",
"(",
"createX86FixupSetCC",
"(",
")",
")",
";",
"addPass",
"(",
"createX86OptimizeLEAs",
"(",
")",
")",
";",
"addPass",
"(",
"createX86CallFrameOptimization",
"(",
")",
")",
";",
"addPass",
"(",
"createX86AvoidStoreForwardingBlocks",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createX86SpeculativeLoadHardeningPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86FlagsCopyLoweringPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86DynAllocaExpander",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createX86PreTileConfigPass",
"(",
")",
")",
";",
"else",
"addPass",
"(",
"createX86FastPreTileConfigPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine58 | addPreRegAlloc | X86 | CPU | LLVM | 17,132 | 100 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"ConstraintWeight",
"LanaiTargetLowering",
"::",
"getSingleConstraintMatchWeight",
"(",
"AsmOperandInfo",
"&",
"Info",
",",
"const",
"char",
"*",
"Constraint",
")",
"const",
"{",
"ConstraintWeight",
"Weight",
"=",
"CW_Invalid",
";",
"Value",
"*",
"CallOperandVal",
"=",
"Info",
".",
"CallOperandVal",
";",
"if",
"(",
"CallOperandVal",
"==",
"nullptr",
")",
"return",
"CW_Default",
";",
"switch",
"(",
"*",
"Constraint",
")",
"{",
"case",
"'I'",
":",
"case",
"'J'",
":",
"case",
"'K'",
":",
"case",
"'L'",
":",
"case",
"'M'",
":",
"case",
"'N'",
":",
"case",
"'O'",
":",
"if",
"(",
"isa",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"Weight",
"=",
"CW_Constant",
";",
"break",
";",
"default",
":",
"Weight",
"=",
"TargetLowering",
"::",
"getSingleConstraintMatchWeight",
"(",
"Info",
",",
"Constraint",
")",
";",
"break",
";",
"}",
"return",
"Weight",
";",
"}",
"</s>"
] | [
"Examine",
"constraint",
"string",
"and",
"operand",
"type",
"and",
"determine",
"a",
"weight",
"value",
"."
] | [
"Lanai",
"Lanai"
] | LanaiISelLowering | getSingleConstraintMatchWeight | Lanai | CPU | LLVM | 17,133 | 103 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"XNCMTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"NULL",
";",
"case",
"XNCMISD",
"::",
"RET_FLAG",
":",
"return",
"\"XNCMISD::RET_FLAG\"",
";",
"case",
"XNCMISD",
"::",
"RETI_FLAG",
":",
"return",
"\"XNCMISD::RETI_FLAG\"",
";",
"case",
"XNCMISD",
"::",
"RRA",
":",
"return",
"\"XNCMISD::RRA\"",
";",
"case",
"XNCMISD",
"::",
"RLA",
":",
"return",
"\"XNCMISD::RLA\"",
";",
"case",
"XNCMISD",
"::",
"RRC",
":",
"return",
"\"XNCMISD::RRC\"",
";",
"case",
"XNCMISD",
"::",
"CALL",
":",
"return",
"\"XNCMISD::CALL\"",
";",
"case",
"XNCMISD",
"::",
"Wrapper",
":",
"return",
"\"XNCMISD::Wrapper\"",
";",
"case",
"XNCMISD",
"::",
"BR_CC",
":",
"return",
"\"XNCMISD::BR_CC\"",
";",
"case",
"XNCMISD",
"::",
"CMP",
":",
"return",
"\"XNCMISD::CMP\"",
";",
"case",
"XNCMISD",
"::",
"SELECT_CC",
":",
"return",
"\"XNCMISD::SELECT_CC\"",
";",
"case",
"XNCMISD",
"::",
"SHL",
":",
"return",
"\"XNCMISD::SHL\"",
";",
"case",
"XNCMISD",
"::",
"SRA",
":",
"return",
"\"XNCMISD::SRA\"",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"XNCM",
"XNCM",
"XNCMISD::RET_FLAG",
"\"XNCMISD::RET_FLAG\"",
"XNCMISD::RETI_FLAG",
"\"XNCMISD::RETI_FLAG\"",
"XNCMISD::RRA",
"\"XNCMISD::RRA\"",
"XNCMISD::RLA",
"\"XNCMISD::RLA\"",
"XNCMISD::RRC",
"\"XNCMISD::RRC\"",
"XNCMISD::CALL",
"\"XNCMISD::CALL\"",
"XNCMISD::Wrapper",
"\"XNCMISD::Wrapper\"",
"XNCMISD::BR_CC",
"\"XNCMISD::BR_CC\"",
"XNCMISD::CMP",
"\"XNCMISD::CMP\"",
"XNCMISD::SELECT_CC",
"\"XNCMISD::SELECT_CC\"",
"XNCMISD::SHL",
"\"XNCMISD::SHL\"",
"XNCMISD::SRA",
"\"XNCMISD::SRA\""
] | XNCMISelLowering | getTargetNodeName | XNCM | CPU | LLVM | 17,134 | 120 | 1 | [] |
[
"<s>",
"void",
"PPCExpandISEL",
"::",
"initialize",
"(",
"MachineFunction",
"&",
"MFParam",
")",
"{",
"MF",
"=",
"&",
"MFParam",
";",
"TII",
"=",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"ISELInstructions",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"Initialize",
"the",
"strategy",
"after",
"building",
"the",
"DAG",
"for",
"a",
"new",
"region",
"."
] | [
"PowerPC",
"PPC"
] | PPCExpandISEL | initialize | PowerPC | CPU | LLVM | 17,135 | 34 | 1 | [] |
[
"<s>",
"MCObjectWriter",
"*",
"createObjectWriter",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"return",
"createELFObjectWriter",
"(",
"createELFObjectTargetWriter",
"(",
")",
",",
"OS",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"Mips"
] | MipsAsmBackend6 | createObjectWriter | Mips | CPU | LLVM | 17,136 | 23 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addFastRegAlloc",
"(",
"FunctionPass",
"*",
"RegAllocPass",
")",
"{",
"addPass",
"(",
"&",
"SIFixSGPRLiveRangesID",
")",
";",
"TargetPassConfig",
"::",
"addFastRegAlloc",
"(",
"RegAllocPass",
")",
";",
"}",
"</s>"
] | [
"addFastRegAlloc",
"-",
"Add",
"the",
"minimum",
"set",
"of",
"target-independent",
"passes",
"that",
"are",
"required",
"for",
"fast",
"register",
"allocation",
"."
] | [
"AMDGPU",
"SI"
] | AMDGPUTargetMachine (2) | addFastRegAlloc | AMDGPU | GPU | LLVM | 17,137 | 24 | 1 | [] |
[
"<s>",
"int",
"MBlazeRegisterInfo",
"::",
"getDwarfRegNum",
"(",
"unsigned",
"RegNum",
",",
"bool",
"isEH",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"What is the dwarf register number\"",
")",
";",
"return",
"-",
"1",
";",
"}",
"</s>"
] | [
"Map",
"a",
"target",
"register",
"to",
"an",
"equivalent",
"dwarf",
"register",
"number",
"."
] | [
"MBlaze",
"MBlaze",
"\"What is the dwarf register number\"",
"1"
] | MBlazeRegisterInfo12 | getDwarfRegNum | MBlaze | MPU | LLVM | 17,138 | 23 | 1 | [] |
[
"<s>",
"void",
"func_fma_steering",
"::",
"analyze_fma_fmul_insn",
"(",
"fma_forest",
"*",
"ref_forest",
",",
"du_chain",
"*",
"chain",
",",
"du_head_p",
"head",
")",
"{",
"fma_forest",
"*",
"forest",
";",
"fma_node",
"*",
"node",
"=",
"this",
"->",
"get_fma_node",
"(",
"chain",
"->",
"insn",
")",
";",
"if",
"(",
"!",
"node",
")",
"{",
"fma_root_node",
"*",
"root_node",
";",
"root_node",
"=",
"new",
"fma_root_node",
"(",
"this",
",",
"chain",
",",
"this",
"->",
"m_next_forest_id",
"++",
")",
";",
"forest",
"=",
"root_node",
"->",
"get_forest",
"(",
")",
";",
"node",
"=",
"root_node",
";",
"this",
"->",
"m_fma_forests",
".",
"push_back",
"(",
"forest",
")",
";",
"}",
"else",
"forest",
"=",
"node",
"->",
"get_forest",
"(",
")",
";",
"node",
"->",
"set_head",
"(",
"head",
")",
";",
"if",
"(",
"ref_forest",
")",
"{",
"ref_forest",
"->",
"merge_forest",
"(",
"forest",
")",
";",
"return",
";",
"}",
"for",
"(",
"chain",
"=",
"head",
"->",
"first",
";",
"chain",
";",
"chain",
"=",
"chain",
"->",
"next_use",
")",
"{",
"fma_node",
"*",
"child_fma",
";",
"rtx",
"fma_rtx",
",",
"*",
"accum_rtx_p",
";",
"if",
"(",
"!",
"is_fmul_fmac_insn",
"(",
"chain",
"->",
"insn",
",",
"false",
")",
")",
"continue",
";",
"fma_rtx",
"=",
"SET_SRC",
"(",
"PATTERN",
"(",
"chain",
"->",
"insn",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"fma_rtx",
")",
"==",
"NEG",
")",
"fma_rtx",
"=",
"XEXP",
"(",
"fma_rtx",
",",
"0",
")",
";",
"accum_rtx_p",
"=",
"&",
"XEXP",
"(",
"fma_rtx",
",",
"2",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"*",
"accum_rtx_p",
")",
")",
"accum_rtx_p",
"=",
"&",
"XEXP",
"(",
"*",
"accum_rtx_p",
",",
"0",
")",
";",
"if",
"(",
"accum_rtx_p",
"!=",
"chain",
"->",
"loc",
")",
"continue",
";",
"if",
"(",
"this",
"->",
"get_fma_node",
"(",
"chain",
"->",
"insn",
")",
")",
"continue",
";",
"child_fma",
"=",
"new",
"fma_node",
"(",
"node",
",",
"chain",
")",
";",
"node",
"->",
"add_child",
"(",
"child_fma",
")",
";",
"}",
"}",
"</s>"
] | [
"Allocate",
"and",
"initialize",
"fma_node",
"objects",
"for",
"the",
"FMUL",
"or",
"FMADD/FMSUB",
"instruction",
"in",
"CHAIN-",
">",
"insn",
"and",
"its",
"dependent",
"FMADD/FMSUB",
"instructions",
",",
"all",
"part",
"of",
"FOREST",
".",
"For",
"the",
"children",
",",
"the",
"associated",
"head",
"is",
"left",
"untouched",
"(",
"and",
"thus",
"null",
")",
"as",
"this",
"function",
"will",
"be",
"called",
"again",
"when",
"considering",
"the",
"chain",
"where",
"they",
"are",
"def",
".",
"For",
"the",
"parent",
",",
"the",
"chain",
"is",
"given",
"in",
"HEAD",
"."
] | [
"aarch64",
"0",
"2",
"0"
] | cortex-a57-fma-steering | analyze_fma_fmul_insn | aarch64 | CPU | GCC | 17,139 | 255 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonTTIImpl",
"::",
"getScalarizationOverhead",
"(",
"Type",
"*",
"Ty",
",",
"const",
"APInt",
"&",
"DemandedElts",
",",
"bool",
"Insert",
",",
"bool",
"Extract",
")",
"{",
"return",
"BaseT",
"::",
"getScalarizationOverhead",
"(",
"Ty",
",",
"DemandedElts",
",",
"Insert",
",",
"Extract",
")",
";",
"}",
"</s>"
] | [
"Estimate",
"the",
"overhead",
"of",
"scalarizing",
"an",
"instruction",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo24 | getScalarizationOverhead | Hexagon | DSP | LLVM | 17,140 | 36 | 1 | [] |
[
"<s>",
"static",
"rtx",
"emit_add",
"(",
"rtx",
"dest",
",",
"rtx",
"src0",
",",
"rtx",
"src1",
")",
"{",
"rtx",
"insn",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"dest",
",",
"src0",
",",
"src1",
")",
")",
";",
"return",
"insn",
";",
"}",
"</s>"
] | [
"Emit",
"insns",
"to",
"set",
"DSTREG",
"to",
"SRCREG",
"+",
"AMOUNT",
"during",
"the",
"prologue",
"or",
"epilogue",
"."
] | [
"lm32"
] | lm32 | emit_add | lm32 | MPU | GCC | 17,141 | 35 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUCallLowering",
"::",
"lowerReturn",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Value",
"*",
"Val",
",",
"ArrayRef",
"<",
"Register",
">",
"VRegs",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"MFI",
"->",
"setIfReturnsVoid",
"(",
"!",
"Val",
")",
";",
"if",
"(",
"!",
"Val",
")",
"{",
"MIRBuilder",
".",
"buildInstr",
"(",
"AMDGPU",
"::",
"S_ENDPGM",
")",
".",
"addImm",
"(",
"0",
")",
";",
"return",
"true",
";",
"}",
"Register",
"VReg",
"=",
"VRegs",
"[",
"0",
"]",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"auto",
"&",
"DL",
"=",
"F",
".",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"if",
"(",
"!",
"AMDGPU",
"::",
"isShader",
"(",
"F",
".",
"getCallingConv",
"(",
")",
")",
")",
"return",
"false",
";",
"const",
"AMDGPUTargetLowering",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"AMDGPUTargetLowering",
">",
"(",
")",
";",
"SmallVector",
"<",
"EVT",
",",
"4",
">",
"SplitVTs",
";",
"SmallVector",
"<",
"uint64_t",
",",
"4",
">",
"Offsets",
";",
"ArgInfo",
"OrigArg",
"{",
"VReg",
",",
"Val",
"->",
"getType",
"(",
")",
"}",
";",
"setArgFlags",
"(",
"OrigArg",
",",
"AttributeList",
"::",
"ReturnIndex",
",",
"DL",
",",
"F",
")",
";",
"ComputeValueVTs",
"(",
"TLI",
",",
"DL",
",",
"OrigArg",
".",
"Ty",
",",
"SplitVTs",
",",
"&",
"Offsets",
",",
"0",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"8",
">",
"SplitArgs",
";",
"CCAssignFn",
"*",
"AssignFn",
"=",
"CCAssignFnForReturn",
"(",
"F",
".",
"getCallingConv",
"(",
")",
",",
"false",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"Offsets",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"Type",
"*",
"SplitTy",
"=",
"SplitVTs",
"[",
"i",
"]",
".",
"getTypeForEVT",
"(",
"F",
".",
"getContext",
"(",
")",
")",
";",
"SplitArgs",
".",
"push_back",
"(",
"{",
"VRegs",
"[",
"i",
"]",
",",
"SplitTy",
",",
"OrigArg",
".",
"Flags",
",",
"OrigArg",
".",
"IsFixed",
"}",
")",
";",
"}",
"auto",
"RetInstr",
"=",
"MIRBuilder",
".",
"buildInstrNoInsert",
"(",
"AMDGPU",
"::",
"SI_RETURN_TO_EPILOG",
")",
";",
"OutgoingArgHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"RetInstr",
",",
"AssignFn",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"SplitArgs",
",",
"Handler",
")",
")",
"return",
"false",
";",
"MIRBuilder",
".",
"insertInstr",
"(",
"RetInstr",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"behaves",
"as",
"the",
"extended",
"lowerReturn",
"function",
",",
"but",
"for",
"targets",
"that",
"do",
"not",
"support",
"swifterror",
"value",
"promotion",
"."
] | [
"AMDGPU",
"AMDGPU",
"SI",
"SI",
"AMDGPU::S_ENDPGM",
"0",
"0",
"AMDGPU::isShader",
"AMDGPU",
"AMDGPU",
"4",
"4",
"0",
"8",
"0",
"AMDGPU::SI_RETURN_TO_EPILOG"
] | AMDGPUCallLowering24 | lowerReturn | AMDGPU | GPU | LLVM | 17,142 | 346 | 1 | [] |
[
"<s>",
"bool",
"Cpu0LongBranch",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"F",
")",
"{",
"const",
"Cpu0Subtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"Cpu0Subtarget",
"&",
">",
"(",
"F",
".",
"getSubtarget",
"(",
")",
")",
";",
"const",
"Cpu0InstrInfo",
"*",
"TII",
"=",
"static_cast",
"<",
"const",
"Cpu0InstrInfo",
"*",
">",
"(",
"STI",
".",
"getInstrInfo",
"(",
")",
")",
";",
"LongBranchSeqSize",
"=",
"!",
"IsPIC",
"?",
"2",
":",
"10",
";",
"if",
"(",
"!",
"STI",
".",
"enableLongBranchPass",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"IsPIC",
"&&",
"static_cast",
"<",
"const",
"Cpu0TargetMachine",
"&",
">",
"(",
"TM",
")",
".",
"getABI",
"(",
")",
".",
"IsO32",
"(",
")",
"&&",
"F",
".",
"getInfo",
"<",
"Cpu0MachineFunctionInfo",
">",
"(",
")",
"->",
"globalBaseRegSet",
"(",
")",
")",
"emitGPDisp",
"(",
"F",
",",
"TII",
")",
";",
"MF",
"=",
"&",
"F",
";",
"initMBBInfo",
"(",
")",
";",
"SmallVectorImpl",
"<",
"MBBInfo",
">",
"::",
"iterator",
"I",
",",
"E",
"=",
"MBBInfos",
".",
"end",
"(",
")",
";",
"bool",
"EverMadeChange",
"=",
"false",
",",
"MadeChange",
"=",
"true",
";",
"while",
"(",
"MadeChange",
")",
"{",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"I",
"=",
"MBBInfos",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"!",
"I",
"->",
"Br",
"||",
"I",
"->",
"HasLongBranch",
")",
"continue",
";",
"int",
"ShVal",
"=",
"4",
";",
"int64_t",
"Offset",
"=",
"computeOffset",
"(",
"I",
"->",
"Br",
")",
"/",
"ShVal",
";",
"if",
"(",
"!",
"ForceLongBranch",
"&&",
"isInt",
"<",
"16",
">",
"(",
"Offset",
")",
")",
"continue",
";",
"I",
"->",
"HasLongBranch",
"=",
"true",
";",
"I",
"->",
"Size",
"+=",
"LongBranchSeqSize",
"*",
"4",
";",
"++",
"LongBranches",
";",
"EverMadeChange",
"=",
"MadeChange",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"!",
"EverMadeChange",
")",
"return",
"true",
";",
"if",
"(",
"IsPIC",
")",
"{",
"uint64_t",
"Address",
"=",
"0",
";",
"for",
"(",
"I",
"=",
"MBBInfos",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"E",
";",
"Address",
"+=",
"I",
"->",
"Size",
",",
"++",
"I",
")",
"I",
"->",
"Address",
"=",
"Address",
";",
"}",
"for",
"(",
"I",
"=",
"MBBInfos",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"if",
"(",
"I",
"->",
"HasLongBranch",
")",
"expandToLongBranch",
"(",
"*",
"I",
")",
";",
"MF",
"->",
"RenumberBlocks",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Cpu0",
"Cpu0",
"Cpu0",
"Cpu0",
"Cpu0",
"Cpu0",
"2",
"10",
"Cpu0",
"Cpu0",
"4",
"16",
"4",
"0"
] | Cpu0LongBranch | runOnMachineFunction | Cpu0 | CPU | LLVM | 17,143 | 329 | 1 | [] |
[
"<s>",
"void",
"frv_split_double_load",
"(",
"rtx",
"dest",
",",
"rtx",
"source",
")",
"{",
"int",
"regno",
"=",
"REGNO",
"(",
"dest",
")",
";",
"rtx",
"dest1",
"=",
"gen_highpart",
"(",
"SImode",
",",
"dest",
")",
";",
"rtx",
"dest2",
"=",
"gen_lowpart",
"(",
"SImode",
",",
"dest",
")",
";",
"rtx",
"address",
"=",
"XEXP",
"(",
"source",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"address",
")",
"==",
"PRE_MODIFY",
"||",
"!",
"refers_to_regno_p",
"(",
"regno",
",",
"regno",
"+",
"1",
",",
"address",
",",
"NULL",
")",
")",
"{",
"emit_move_insn",
"(",
"dest1",
",",
"change_address",
"(",
"source",
",",
"SImode",
",",
"NULL",
")",
")",
";",
"emit_move_insn",
"(",
"dest2",
",",
"frv_index_memory",
"(",
"source",
",",
"SImode",
",",
"1",
")",
")",
";",
"}",
"else",
"{",
"emit_move_insn",
"(",
"dest2",
",",
"frv_index_memory",
"(",
"source",
",",
"SImode",
",",
"1",
")",
")",
";",
"emit_move_insn",
"(",
"dest1",
",",
"change_address",
"(",
"source",
",",
"SImode",
",",
"NULL",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Split",
"(",
"set",
"DEST",
"SOURCE",
")",
",",
"where",
"DEST",
"is",
"a",
"double",
"register",
"and",
"SOURCE",
"is",
"a",
"memory",
"location",
"that",
"is",
"not",
"known",
"to",
"be",
"dword-aligned",
"."
] | [
"frv",
"0",
"1",
"1",
"1"
] | frv2 | frv_split_double_load | frv | VLIW | GCC | 17,144 | 133 | 1 | [] |
[
"<s>",
"bool",
"SVEIntrinsicOpts",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"bool",
"Changed",
"=",
"false",
";",
"SmallSetVector",
"<",
"Function",
"*",
",",
"4",
">",
"Functions",
";",
"for",
"(",
"auto",
"&",
"F",
":",
"M",
".",
"getFunctionList",
"(",
")",
")",
"{",
"if",
"(",
"!",
"F",
".",
"isDeclaration",
"(",
")",
")",
"continue",
";",
"switch",
"(",
"F",
".",
"getIntrinsicID",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"aarch64_sve_convert_from_svbool",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_ptest_any",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_ptest_first",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_ptest_last",
":",
"for",
"(",
"auto",
"I",
"=",
"F",
".",
"user_begin",
"(",
")",
",",
"E",
"=",
"F",
".",
"user_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"auto",
"*",
"Inst",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"*",
"I",
"++",
")",
";",
"Functions",
".",
"insert",
"(",
"Inst",
"->",
"getFunction",
"(",
")",
")",
";",
"}",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"if",
"(",
"!",
"Functions",
".",
"empty",
"(",
")",
")",
"Changed",
"|=",
"optimizeFunctions",
"(",
"Functions",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"AArch64",
"4",
"Intrinsic::aarch64_sve_convert_from_svbool",
"Intrinsic::aarch64_sve_ptest_any",
"Intrinsic::aarch64_sve_ptest_first",
"Intrinsic::aarch64_sve_ptest_last"
] | SVEIntrinsicOpts | runOnModule | AArch64 | CPU | LLVM | 17,145 | 156 | 1 | [] |
[
"<s>",
"static",
"inline",
"int",
"startswith",
"(",
"const",
"char",
"*",
"str",
",",
"const",
"char",
"*",
"prefix",
")",
"{",
"return",
"strncmp",
"(",
"str",
",",
"prefix",
",",
"strlen",
"(",
"prefix",
")",
")",
"==",
"0",
";",
"}",
"</s>"
] | [
"Return",
"1",
"if",
"STR",
"string",
"starts",
"with",
"PREFIX",
"."
] | [
"vms",
"0"
] | vms-ld2 | startswith | vms | Virtual ISA | GCC | 17,146 | 32 | 1 | [] |
[
"<s>",
"bool",
"SystemZAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"unsigned",
"MatchResult",
";",
"MatchResult",
"=",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
";",
"switch",
"(",
"MatchResult",
")",
"{",
"case",
"Match_Success",
":",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"{",
"assert",
"(",
"ErrorInfo",
"&&",
"\"Unknown missing feature!\"",
")",
";",
"std",
"::",
"string",
"Msg",
"=",
"\"instruction requires:\"",
";",
"uint64_t",
"Mask",
"=",
"1",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
";",
"I",
"<",
"sizeof",
"(",
"ErrorInfo",
")",
"*",
"8",
"-",
"1",
";",
"++",
"I",
")",
"{",
"if",
"(",
"ErrorInfo",
"&",
"Mask",
")",
"{",
"Msg",
"+=",
"\" \"",
";",
"Msg",
"+=",
"getSubtargetFeatureName",
"(",
"ErrorInfo",
"&",
"Mask",
")",
";",
"}",
"Mask",
"<<=",
"1",
";",
"}",
"return",
"Error",
"(",
"IDLoc",
",",
"Msg",
")",
";",
"}",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0ULL",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"SystemZOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"invalid instruction\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Unexpected match type\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"SystemZ",
"SystemZ",
"\"Unknown missing feature!\"",
"\"instruction requires:\"",
"1",
"0",
"8",
"1",
"\" \"",
"1",
"0ULL",
"\"too few operands for instruction\"",
"SystemZ",
"\"invalid operand for instruction\"",
"\"invalid instruction\"",
"\"Unexpected match type\""
] | SystemZAsmParser | MatchAndEmitInstruction | SystemZ | CPU | LLVM | 17,147 | 247 | 1 | [] |
[
"<s>",
"bool",
"AArch64BranchFixup",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"mf",
")",
"{",
"MF",
"=",
"&",
"mf",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"***** AArch64BranchFixup ******\"",
")",
";",
"TII",
"=",
"(",
"const",
"AArch64InstrInfo",
"*",
")",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MF",
"->",
"getRegInfo",
"(",
")",
".",
"invalidateLiveness",
"(",
")",
";",
"MF",
"->",
"RenumberBlocks",
"(",
")",
";",
"initializeFunctionInfo",
"(",
")",
";",
"unsigned",
"NoBRIters",
"=",
"0",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"while",
"(",
"true",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Beginning iteration #\"",
"<<",
"NoBRIters",
"<<",
"'\\n'",
")",
";",
"bool",
"BRChange",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"ImmBranches",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"BRChange",
"|=",
"fixupImmediateBr",
"(",
"ImmBranches",
"[",
"i",
"]",
")",
";",
"if",
"(",
"BRChange",
"&&",
"++",
"NoBRIters",
">",
"30",
")",
"report_fatal_error",
"(",
"\"Branch Fix Up pass failed to converge!\"",
")",
";",
"DEBUG",
"(",
"dumpBBs",
"(",
")",
")",
";",
"if",
"(",
"!",
"BRChange",
")",
"break",
";",
"MadeChange",
"=",
"true",
";",
"}",
"verify",
"(",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"'\\n'",
";",
"dumpBBs",
"(",
")",
")",
";",
"BBInfo",
".",
"clear",
"(",
")",
";",
"ImmBranches",
".",
"clear",
"(",
")",
";",
"return",
"MadeChange",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64",
"\"***** AArch64BranchFixup ******\"",
"AArch64",
"0",
"\"Beginning iteration #\"",
"0",
"30",
"\"Branch Fix Up pass failed to converge!\""
] | AArch64BranchFixupPass1 | runOnMachineFunction | AArch64 | CPU | LLVM | 17,148 | 192 | 1 | [] |
[
"<s>",
"bool",
"isConstant",
"(",
"const",
"MachineFrameInfo",
"*",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"we",
"know",
"the",
"value",
"of",
"all",
"bits",
"."
] | [
"Hexagon"
] | HexagonInstrInfo14 | isConstant | Hexagon | DSP | LLVM | 17,149 | 14 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"R600 Packetizer\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"R600",
"\"R600 Packetizer\""
] | R600Packetizer | getPassName | R600 | GPU | LLVM | 17,150 | 12 | 1 | [] |
[
"<s>",
"rtx",
"mips_got_load",
"(",
"rtx",
"temp",
",",
"rtx",
"addr",
",",
"enum",
"mips_symbol_type",
"type",
")",
"{",
"rtx",
"base",
",",
"high",
",",
"lo_sum_symbol",
";",
"base",
"=",
"mips_pic_base_register",
"(",
"temp",
")",
";",
"if",
"(",
"temp",
"!=",
"NULL",
"&&",
"reg_overlap_mentioned_p",
"(",
"base",
",",
"temp",
")",
")",
"temp",
"=",
"NULL",
";",
"high",
"=",
"mips_unspec_offset_high",
"(",
"temp",
",",
"base",
",",
"addr",
",",
"type",
")",
";",
"lo_sum_symbol",
"=",
"mips_unspec_address",
"(",
"addr",
",",
"type",
")",
";",
"if",
"(",
"type",
"==",
"SYMBOL_GOTOFF_CALL",
")",
"return",
"mips_unspec_call",
"(",
"high",
",",
"lo_sum_symbol",
")",
";",
"else",
"return",
"PMODE_INSN",
"(",
"gen_unspec_got",
",",
"(",
"high",
",",
"lo_sum_symbol",
")",
")",
";",
"}",
"</s>"
] | [
"Create",
"and",
"return",
"a",
"GOT",
"reference",
"of",
"type",
"TYPE",
"for",
"address",
"ADDR",
".",
"TEMP",
",",
"if",
"nonnull",
",",
"is",
"a",
"scratch",
"Pmode",
"base",
"register",
"."
] | [
"mips"
] | mips | mips_got_load | mips | CPU | GCC | 17,151 | 95 | 1 | [] |
[
"<s>",
"bool",
"ARMPassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableGlobalMerge",
"&&",
"!",
"getARMSubtarget",
"(",
")",
".",
"isTargetNaCl",
"(",
")",
")",
"addPass",
"(",
"createGlobalMergePass",
"(",
"TM",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine88 | addPreISel | ARM | CPU | LLVM | 17,152 | 42 | 1 | [] |
[
"<s>",
"static",
"void",
"block_move_sequence",
"(",
"rtx",
"dst_mem",
",",
"rtx",
"src_mem",
",",
"int",
"size",
",",
"int",
"align",
")",
"{",
"rtx",
"temp",
"[",
"2",
"]",
";",
"machine_mode",
"mode",
"[",
"2",
"]",
";",
"int",
"amount",
"[",
"2",
"]",
";",
"bool",
"active",
"[",
"2",
"]",
";",
"int",
"phase",
"=",
"0",
";",
"int",
"next",
";",
"int",
"offset_ld",
"=",
"0",
";",
"int",
"offset_st",
"=",
"0",
";",
"rtx",
"x",
";",
"x",
"=",
"XEXP",
"(",
"dst_mem",
",",
"0",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"x",
")",
")",
"{",
"x",
"=",
"force_reg",
"(",
"Pmode",
",",
"x",
")",
";",
"dst_mem",
"=",
"replace_equiv_address",
"(",
"dst_mem",
",",
"x",
")",
";",
"}",
"x",
"=",
"XEXP",
"(",
"src_mem",
",",
"0",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"x",
")",
")",
"{",
"x",
"=",
"force_reg",
"(",
"Pmode",
",",
"x",
")",
";",
"src_mem",
"=",
"replace_equiv_address",
"(",
"src_mem",
",",
"x",
")",
";",
"}",
"active",
"[",
"0",
"]",
"=",
"active",
"[",
"1",
"]",
"=",
"false",
";",
"do",
"{",
"next",
"=",
"phase",
";",
"phase",
"^=",
"1",
";",
"if",
"(",
"size",
">",
"0",
")",
"{",
"int",
"next_amount",
";",
"next_amount",
"=",
"(",
"size",
">=",
"4",
"?",
"4",
":",
"(",
"size",
">=",
"2",
"?",
"2",
":",
"1",
")",
")",
";",
"next_amount",
"=",
"MIN",
"(",
"next_amount",
",",
"align",
")",
";",
"amount",
"[",
"next",
"]",
"=",
"next_amount",
";",
"mode",
"[",
"next",
"]",
"=",
"mode_from_align",
"[",
"next_amount",
"]",
";",
"temp",
"[",
"next",
"]",
"=",
"gen_reg_rtx",
"(",
"mode",
"[",
"next",
"]",
")",
";",
"x",
"=",
"adjust_address",
"(",
"src_mem",
",",
"mode",
"[",
"next",
"]",
",",
"offset_ld",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"temp",
"[",
"next",
"]",
",",
"x",
")",
")",
";",
"offset_ld",
"+=",
"next_amount",
";",
"size",
"-=",
"next_amount",
";",
"active",
"[",
"next",
"]",
"=",
"true",
";",
"}",
"if",
"(",
"active",
"[",
"phase",
"]",
")",
"{",
"active",
"[",
"phase",
"]",
"=",
"false",
";",
"x",
"=",
"adjust_address",
"(",
"dst_mem",
",",
"mode",
"[",
"phase",
"]",
",",
"offset_st",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"x",
",",
"temp",
"[",
"phase",
"]",
")",
")",
";",
"offset_st",
"+=",
"amount",
"[",
"phase",
"]",
";",
"}",
"}",
"while",
"(",
"active",
"[",
"next",
"]",
")",
";",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"perform",
"a",
"block",
"move",
"with",
"an",
"offset",
"sequence",
"of",
"ld/st",
"instructions",
"(",
"...",
",",
"ld",
"0",
",",
"st",
"1",
",",
"ld",
"1",
",",
"st",
"0",
",",
"...",
")",
".",
"SIZE",
"and",
"ALIGN",
"are",
"known",
"constants",
".",
"DEST",
"and",
"SRC",
"are",
"registers",
".",
"OFFSET",
"is",
"the",
"known",
"starting",
"point",
"for",
"the",
"output",
"pattern",
"."
] | [
"mcore",
"2",
"2",
"2",
"2",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"1",
"0",
"4",
"4",
"2",
"2",
"1"
] | mcore4 | block_move_sequence | mcore | MPU | GCC | 17,153 | 334 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"ARM64 Collect Linker Optimization Hint (LOH)\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM64",
"\"ARM64 Collect Linker Optimization Hint (LOH)\""
] | ARM64CollectLOH1 | getPassName | ARM64 | CPU | LLVM | 17,154 | 13 | 1 | [] |
[
"<s>",
"bool",
"Thumb2RegisterInfo",
"::",
"requiresRegisterScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"(",
"and",
"can",
"make",
"use",
"of",
")",
"the",
"register",
"scavenger",
"."
] | [
"ARM"
] | Thumb2RegisterInfo2 | requiresRegisterScavenging | ARM | CPU | LLVM | 17,155 | 16 | 1 | [] |
[
"<s>",
"static",
"rtx",
"s390_execute_label",
"(",
"rtx",
"insn",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"INSN",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"PARALLEL",
"&&",
"GET_CODE",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
",",
"0",
")",
")",
"==",
"UNSPEC",
"&&",
"XINT",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
",",
"0",
")",
",",
"1",
")",
"==",
"UNSPEC_EXECUTE",
")",
"return",
"XVECEXP",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
",",
"0",
")",
",",
"0",
",",
"2",
")",
";",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"INSN",
"is",
"an",
"execute",
".",
"Return",
"the",
"label_ref",
"to",
"its",
"execute",
"target",
"template",
"if",
"so",
",",
"NULL_RTX",
"otherwise",
"."
] | [
"s390",
"0",
"0",
"0",
"0",
"1",
"0",
"0",
"0",
"2"
] | s3903 | s390_execute_label | s390 | MPU | GCC | 17,156 | 87 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseTargetMachine",
"::",
"addPreRegAlloc",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"if",
"(",
"Subtarget",
".",
"hasNEON",
"(",
")",
")",
"PM",
".",
"add",
"(",
"createNEONPreAllocPass",
"(",
")",
")",
";",
"if",
"(",
"OptLevel",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"!",
"DisableLdStOpti",
"&&",
"!",
"Subtarget",
".",
"isThumb",
"(",
")",
")",
"PM",
".",
"add",
"(",
"createARMLoadStoreOptimizationPass",
"(",
"true",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine16 | addPreRegAlloc | ARM | CPU | LLVM | 17,157 | 64 | 1 | [] |
[
"<s>",
"static",
"std",
"::",
"unique_ptr",
"<",
"MINA32Operand",
">",
"CreateMem",
"(",
"unsigned",
"Base",
",",
"const",
"MCExpr",
"*",
"Off",
",",
"SMLoc",
"S",
",",
"SMLoc",
"E",
")",
"{",
"auto",
"Op",
"=",
"std",
"::",
"make_unique",
"<",
"MINA32Operand",
">",
"(",
"k_Memory",
")",
";",
"Op",
"->",
"Mem",
".",
"Base",
"=",
"Base",
";",
"Op",
"->",
"Mem",
".",
"Off",
"=",
"Off",
";",
"Op",
"->",
"StartLoc",
"=",
"S",
";",
"Op",
"->",
"EndLoc",
"=",
"E",
";",
"return",
"Op",
";",
"}",
"</s>"
] | [
"Create",
"a",
"generalized",
"memory",
"operand",
"."
] | [
"MINA32",
"MINA32",
"MINA32"
] | MINA32AsmParser | CreateMem | MINA32 | CPU | LLVM | 17,158 | 69 | 1 | [] |
[
"<s>",
"bool",
"ARMPreAllocLoadStoreOpt",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"if",
"(",
"AssumeMisalignedLoadStores",
"||",
"skipFunction",
"(",
"Fn",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"TD",
"=",
"&",
"Fn",
".",
"getDataLayout",
"(",
")",
";",
"STI",
"=",
"&",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"Fn",
".",
"getSubtarget",
"(",
")",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"STI",
"->",
"getRegisterInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"Fn",
".",
"getRegInfo",
"(",
")",
";",
"DT",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"MF",
"=",
"&",
"Fn",
";",
"AA",
"=",
"&",
"getAnalysis",
"<",
"AAResultsWrapperPass",
">",
"(",
")",
".",
"getAAResults",
"(",
")",
";",
"bool",
"Modified",
"=",
"DistributeIncrements",
"(",
")",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MFI",
":",
"Fn",
")",
"Modified",
"|=",
"RescheduleLoadStoreInstrs",
"(",
"&",
"MFI",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMLoadStoreOptimizer19 | runOnMachineFunction | ARM | CPU | LLVM | 17,159 | 133 | 1 | [] |
[
"<s>",
"EVT",
"GBZ80TargetLowering",
"::",
"getSetCCResultType",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"LLVMContext",
"&",
",",
"EVT",
"VT",
")",
"const",
"{",
"assert",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
"&&",
"\"No GBZ80 SetCC type for vectors!\"",
")",
";",
"return",
"MVT",
"::",
"i8",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"GBZ80",
"GB",
"\"No GBZ80 SetCC type for vectors!\"",
"MVT::i8"
] | GBZ80ISelLowering | getSetCCResultType | GBZ80 | MPU | LLVM | 17,160 | 36 | 1 | [] |
[
"<s>",
"static",
"void",
"dump_minipool",
"(",
"rtx_insn",
"*",
"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",
")",
";",
"}",
"rtx",
"val",
"=",
"copy_rtx",
"(",
"mp",
"->",
"value",
")",
";",
"switch",
"(",
"GET_MODE_SIZE",
"(",
"mp",
"->",
"mode",
")",
")",
"{",
"case",
"1",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_1",
"(",
"val",
")",
",",
"scan",
")",
";",
"break",
";",
"case",
"2",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_2",
"(",
"val",
")",
",",
"scan",
")",
";",
"break",
";",
"case",
"4",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_4",
"(",
"val",
")",
",",
"scan",
")",
";",
"break",
";",
"case",
"8",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_8",
"(",
"val",
")",
",",
"scan",
")",
";",
"break",
";",
"case",
"16",
":",
"scan",
"=",
"emit_insn_after",
"(",
"gen_consttable_16",
"(",
"val",
")",
",",
"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",
"16"
] | arm | dump_minipool | arm | CPU | GCC | 17,161 | 357 | 1 | [] |
[
"<s>",
"unsigned",
"TL45InstrInfo",
"::",
"removeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"int",
"*",
"BytesRemoved",
")",
"const",
"{",
"assert",
"(",
"!",
"BytesRemoved",
"&&",
"\"code size not handled\"",
")",
";",
"MachineBasicBlock",
"::",
"reverse_iterator",
"I",
"=",
"MBB",
".",
"rbegin",
"(",
")",
",",
"REnd",
"=",
"MBB",
".",
"rend",
"(",
")",
";",
"unsigned",
"removed",
"=",
"0",
";",
"while",
"(",
"I",
"!=",
"REnd",
"&&",
"removed",
"<",
"2",
")",
"{",
"if",
"(",
"I",
"->",
"isDebugInstr",
"(",
")",
")",
"{",
"++",
"I",
";",
"continue",
";",
"}",
"if",
"(",
"!",
"getAnalyzableBrOpc",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
")",
"break",
";",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"I",
"=",
"MBB",
".",
"rbegin",
"(",
")",
";",
"++",
"removed",
";",
"}",
"return",
"removed",
";",
"}",
"</s>"
] | [
"Remove",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"the",
"specific",
"MBB",
"."
] | [
"TL45",
"TL45",
"\"code size not handled\"",
"0",
"2"
] | TL45InstrInfo | removeBranch | TL45 | MPU | LLVM | 17,162 | 109 | 1 | [] |
[
"<s>",
"static",
"void",
"assign_fp_registers",
"(",
"const_tree",
"field",
",",
"HOST_WIDE_INT",
"bitpos",
",",
"assign_data_t",
"*",
"data",
")",
"{",
"int",
"nregs",
";",
"machine_mode",
"mode",
";",
"if",
"(",
"!",
"compute_fp_layout",
"(",
"field",
",",
"bitpos",
",",
"data",
",",
"&",
"nregs",
",",
"&",
"mode",
")",
")",
"return",
";",
"const",
"int",
"this_slotno",
"=",
"data",
"->",
"slotno",
"+",
"bitpos",
"/",
"BITS_PER_WORD",
";",
"int",
"regno",
"=",
"SPARC_FP_ARG_FIRST",
"+",
"this_slotno",
"*",
"2",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"4",
"&&",
"(",
"bitpos",
"&",
"32",
")",
"!=",
"0",
")",
"regno",
"++",
";",
"int",
"pos",
"=",
"bitpos",
"/",
"BITS_PER_UNIT",
";",
"do",
"{",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"XVECEXP",
"(",
"data",
"->",
"ret",
",",
"0",
",",
"data",
"->",
"stack",
"+",
"data",
"->",
"nregs",
")",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"reg",
",",
"GEN_INT",
"(",
"pos",
")",
")",
";",
"data",
"->",
"nregs",
"+=",
"1",
";",
"regno",
"+=",
"GET_MODE_SIZE",
"(",
"mode",
")",
"/",
"4",
";",
"pos",
"+=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"}",
"while",
"(",
"--",
"nregs",
">",
"0",
")",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"function_arg_record_value",
".",
"Assign",
"FIELD",
"at",
"position",
"BITPOS",
"to",
"FP",
"registers",
"."
] | [
"sparc",
"2",
"4",
"32",
"0",
"0",
"1",
"4",
"0"
] | sparc5 | assign_fp_registers | sparc | CPU | GCC | 17,163 | 162 | 1 | [] |
[
"<s>",
"static",
"rtx",
"loongarch_libcall_value",
"(",
"machine_mode",
"mode",
",",
"const_rtx",
"fun",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"loongarch_function_value_1",
"(",
"NULL_TREE",
",",
"NULL_TREE",
",",
"mode",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LIBCALL_VALUE",
"."
] | [
"loongarch"
] | loongarch | loongarch_libcall_value | loongarch | CPU | GCC | 17,164 | 23 | 1 | [] |
[
"<s>",
"void",
"d30v_init_expanders",
"(",
")",
"{",
"init_machine_status",
"=",
"d30v_init_machine_status",
";",
"mark_machine_status",
"=",
"d30v_mark_machine_status",
";",
"free_machine_status",
"=",
"d30v_free_machine_status",
";",
"}",
"</s>"
] | [
"Do",
"anything",
"needed",
"before",
"RTL",
"is",
"emitted",
"for",
"each",
"function",
"."
] | [
"d30v"
] | d30v | d30v_init_expanders | d30v | CPU | GCC | 17,165 | 18 | 1 | [] |
[
"<s>",
"void",
"MSP430InstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"MCRegister",
"DestReg",
",",
"MCRegister",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"unsigned",
"Opc",
";",
"if",
"(",
"MSP430",
"::",
"GR16RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"MSP430",
"::",
"MOV16rr",
";",
"else",
"if",
"(",
"MSP430",
"::",
"GR8RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"MSP430",
"::",
"MOV8rr",
";",
"else",
"llvm_unreachable",
"(",
"\"Impossible reg-to-reg copy\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"MSP430",
"MSP430",
"MSP430::GR16RegClass",
"MSP430::MOV16rr",
"MSP430::GR8RegClass",
"MSP430::MOV8rr",
"\"Impossible reg-to-reg copy\""
] | MSP430InstrInfo19 | copyPhysReg | MSP430 | MPU | LLVM | 17,166 | 105 | 1 | [] |
[
"<s>",
"void",
"CJGMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"Desc",
".",
"getSize",
"(",
")",
"!=",
"4",
")",
"{",
"llvm_unreachable",
"(",
"\"Unexpected instruction size!\"",
")",
";",
"}",
"const",
"uint32_t",
"Binary",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"emitConstant",
"(",
"Binary",
",",
"Desc",
".",
"getSize",
"(",
")",
",",
"OS",
")",
";",
"++",
"MCNumEmitted",
";",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"CJG",
"CJG",
"4",
"\"Unexpected instruction size!\""
] | CJGMCCodeEmitter | encodeInstruction | CJG | CPU | LLVM | 17,167 | 91 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_ior",
"(",
"rtx",
"*",
"operands",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"mask",
"=",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
";",
"int",
"bs0",
",",
"bs1",
",",
"p",
",",
"len",
";",
"if",
"(",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
"==",
"0",
")",
"return",
"\"copy %1,%0\"",
";",
"for",
"(",
"bs0",
"=",
"0",
";",
"bs0",
"<",
"32",
";",
"bs0",
"++",
")",
"if",
"(",
"(",
"mask",
"&",
"(",
"1",
"<<",
"bs0",
")",
")",
"!=",
"0",
")",
"break",
";",
"for",
"(",
"bs1",
"=",
"bs0",
";",
"bs1",
"<",
"32",
";",
"bs1",
"++",
")",
"if",
"(",
"(",
"mask",
"&",
"(",
"1",
"<<",
"bs1",
")",
")",
"==",
"0",
")",
"break",
";",
"gcc_assert",
"(",
"bs1",
"==",
"32",
"||",
"(",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"1",
"<<",
"bs1",
")",
">",
"mask",
")",
";",
"p",
"=",
"31",
"-",
"bs0",
";",
"len",
"=",
"bs1",
"-",
"bs0",
";",
"operands",
"[",
"2",
"]",
"=",
"GEN_INT",
"(",
"p",
")",
";",
"operands",
"[",
"3",
"]",
"=",
"GEN_INT",
"(",
"len",
")",
";",
"return",
"\"{depi|depwi} -1,%2,%3,%0\"",
";",
"}",
"</s>"
] | [
"Emit",
"the",
"code",
"to",
"do",
"an",
"inclusive",
"OR",
"operation",
"."
] | [
"pa",
"2",
"2",
"0",
"\"copy %1,%0\"",
"0",
"32",
"1",
"0",
"32",
"1",
"0",
"32",
"1",
"31",
"2",
"3",
"\"{depi|depwi} -1,%2,%3,%0\""
] | pa3 | output_ior | pa | CPU | GCC | 17,168 | 159 | 1 | [] |
[
"<s>",
"void",
"MOSInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"Register",
"DestReg",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"loadStoreRegStackSlot",
"(",
"MBB",
",",
"MI",
",",
"DestReg",
",",
"false",
",",
"FrameIndex",
",",
"RC",
",",
"TRI",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"MOS",
"MOS"
] | MOSInstrInfo | loadRegFromStackSlot | MOS | MPU | LLVM | 17,169 | 52 | 1 | [] |
[
"<s>",
"bool",
"Cpu0TargetLowering",
"::",
"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",
")",
";",
"return",
"CCInfo",
".",
"CheckReturn",
"(",
"Outs",
",",
"RetCC_Cpu0",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"should",
"be",
"implemented",
"to",
"check",
"whether",
"the",
"return",
"values",
"described",
"by",
"the",
"Outs",
"array",
"can",
"fit",
"into",
"the",
"return",
"registers",
"."
] | [
"Cpu0",
"Cpu0",
"ISD::OutputArg",
"16",
"Cpu0"
] | Cpu0ISelLowering | CanLowerReturn | Cpu0 | CPU | LLVM | 17,170 | 66 | 1 | [] |
[
"<s>",
"bool",
"PPCTargetLowering",
"::",
"getPreIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"DisablePPCPreinc",
")",
"return",
"false",
";",
"bool",
"isLoad",
"=",
"true",
";",
"SDValue",
"Ptr",
";",
"EVT",
"VT",
";",
"unsigned",
"Alignment",
";",
"if",
"(",
"LoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"LD",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"Alignment",
"=",
"LD",
"->",
"getAlignment",
"(",
")",
";",
"}",
"else",
"if",
"(",
"StoreSDNode",
"*",
"ST",
"=",
"dyn_cast",
"<",
"StoreSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"ST",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
";",
"Alignment",
"=",
"ST",
"->",
"getAlignment",
"(",
")",
";",
"isLoad",
"=",
"false",
";",
"}",
"else",
"return",
"false",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
")",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"hasQPX",
"(",
")",
"||",
"(",
"VT",
"!=",
"MVT",
"::",
"v4f64",
"&&",
"VT",
"!=",
"MVT",
"::",
"v4f32",
")",
")",
"{",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"SelectAddressRegRegOnly",
"(",
"Ptr",
",",
"Offset",
",",
"Base",
",",
"DAG",
")",
")",
"{",
"AM",
"=",
"ISD",
"::",
"PRE_INC",
";",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"SelectAddressRegReg",
"(",
"Ptr",
",",
"Base",
",",
"Offset",
",",
"DAG",
")",
")",
"{",
"bool",
"Swap",
"=",
"false",
";",
"if",
"(",
"isa",
"<",
"FrameIndexSDNode",
">",
"(",
"Base",
")",
"||",
"isa",
"<",
"RegisterSDNode",
">",
"(",
"Base",
")",
")",
"Swap",
"=",
"true",
";",
"else",
"if",
"(",
"!",
"isLoad",
")",
"{",
"SDValue",
"Val",
"=",
"cast",
"<",
"StoreSDNode",
">",
"(",
"N",
")",
"->",
"getValue",
"(",
")",
";",
"if",
"(",
"Val",
"==",
"Base",
"||",
"Base",
".",
"getNode",
"(",
")",
"->",
"isPredecessorOf",
"(",
"Val",
".",
"getNode",
"(",
")",
")",
")",
"Swap",
"=",
"true",
";",
"}",
"if",
"(",
"Swap",
")",
"std",
"::",
"swap",
"(",
"Base",
",",
"Offset",
")",
";",
"AM",
"=",
"ISD",
"::",
"PRE_INC",
";",
"return",
"true",
";",
"}",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"i64",
")",
"{",
"if",
"(",
"!",
"SelectAddressRegImm",
"(",
"Ptr",
",",
"Offset",
",",
"Base",
",",
"DAG",
",",
"0",
")",
")",
"return",
"false",
";",
"}",
"else",
"{",
"if",
"(",
"Alignment",
"<",
"4",
")",
"return",
"false",
";",
"if",
"(",
"!",
"SelectAddressRegImm",
"(",
"Ptr",
",",
"Offset",
",",
"Base",
",",
"DAG",
",",
"4",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"LoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"if",
"(",
"LD",
"->",
"getValueType",
"(",
"0",
")",
"==",
"MVT",
"::",
"i64",
"&&",
"LD",
"->",
"getMemoryVT",
"(",
")",
"==",
"MVT",
"::",
"i32",
"&&",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"SEXTLOAD",
"&&",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"Offset",
")",
")",
"return",
"false",
";",
"}",
"AM",
"=",
"ISD",
"::",
"PRE_INC",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"by",
"value",
",",
"base",
"pointer",
"and",
"offset",
"pointer",
"and",
"addressing",
"mode",
"by",
"reference",
"if",
"the",
"node",
"'s",
"address",
"can",
"be",
"legally",
"represented",
"as",
"pre-indexed",
"load",
"/",
"store",
"address",
"."
] | [
"PowerPC",
"PPC",
"ISD::MemIndexedMode",
"PPC",
"MVT::v4f64",
"MVT::v4f32",
"ISD::PRE_INC",
"ISD::PRE_INC",
"MVT::i64",
"0",
"4",
"4",
"0",
"MVT::i64",
"MVT::i32",
"ISD::SEXTLOAD",
"ISD::PRE_INC"
] | PPCISelLowering | getPreIndexedAddressParts | PowerPC | CPU | LLVM | 17,171 | 444 | 1 | [] |
[
"<s>",
"SDValue",
"XCoreTargetLowering",
"::",
"LowerFormalArguments",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"switch",
"(",
"CallConv",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unsupported calling convention\"",
")",
";",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"return",
"LowerCCCArguments",
"(",
"Chain",
",",
"CallConv",
",",
"isVarArg",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"InVals",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"the",
"Ins",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"XCore",
"XCore",
"ISD::InputArg",
"\"Unsupported calling convention\""
] | XCoreISelLowering | LowerFormalArguments | XCore | MPU | LLVM | 17,172 | 84 | 1 | [] |
[
"<s>",
"MCObjectWriter",
"*",
"createObjectWriter",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"return",
"createARMMachObjectWriter",
"(",
"OS",
",",
"false",
",",
"object",
"::",
"mach",
"::",
"CTM_ARM",
",",
"Subtype",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMAsmBackend (2) | createObjectWriter | ARM | CPU | LLVM | 17,173 | 27 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"Selecting: \"",
")",
";",
"DEBUG",
"(",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"== \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"Node",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
";",
"}",
"EVT",
"VT",
"=",
"Node",
"->",
"getValueType",
"(",
"0",
")",
";",
"switch",
"(",
"Node",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"(",
"void",
")",
"VT",
";",
"}",
"SelectCode",
"(",
"Node",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"Selecting: \"",
"\"\\n\"",
"\"== \"",
"\"\\n\"",
"1",
"0"
] | WebAssemblyISelDAGToDAG15 | Select | WebAssembly | Virtual ISA | LLVM | 17,174 | 115 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"analyzeCompare",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"Register",
"&",
"SrcReg",
",",
"Register",
"&",
"SrcReg2",
",",
"int64_t",
"&",
"Mask",
",",
"int64_t",
"&",
"Value",
")",
"const",
"{",
"assert",
"(",
"MI",
".",
"isCompare",
"(",
")",
"&&",
"\"Caller should have checked for a comparison\"",
")",
";",
"if",
"(",
"MI",
".",
"getNumExplicitOperands",
"(",
")",
"==",
"2",
"&&",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isImm",
"(",
")",
")",
"{",
"SrcReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"SrcReg2",
"=",
"0",
";",
"Value",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"Mask",
"=",
"~",
"0",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeCompare",
"-",
"For",
"a",
"comparison",
"instruction",
",",
"return",
"the",
"source",
"registers",
"in",
"SrcReg",
"and",
"SrcReg2",
"if",
"having",
"two",
"register",
"operands",
",",
"and",
"the",
"value",
"it",
"compares",
"against",
"in",
"CmpValue",
"."
] | [
"SystemZ",
"SystemZ",
"\"Caller should have checked for a comparison\"",
"2",
"0",
"1",
"0",
"0",
"1",
"0"
] | SystemZInstrInfo16 | analyzeCompare | SystemZ | CPU | LLVM | 17,175 | 115 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"HOST_WIDE_INT",
"ix86_memmodel_check",
"(",
"unsigned",
"HOST_WIDE_INT",
"val",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"model",
"=",
"val",
"&",
"MEMMODEL_MASK",
";",
"bool",
"strong",
";",
"if",
"(",
"val",
"&",
"~",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"(",
"IX86_HLE_ACQUIRE",
"|",
"IX86_HLE_RELEASE",
"|",
"MEMMODEL_MASK",
")",
"||",
"(",
"(",
"val",
"&",
"IX86_HLE_ACQUIRE",
")",
"&&",
"(",
"val",
"&",
"IX86_HLE_RELEASE",
")",
")",
")",
"{",
"warning",
"(",
"OPT_Winvalid_memory_model",
",",
"\"Unknown architecture specific memory model\"",
")",
";",
"return",
"MEMMODEL_SEQ_CST",
";",
"}",
"strong",
"=",
"(",
"model",
"==",
"MEMMODEL_ACQ_REL",
"||",
"model",
"==",
"MEMMODEL_SEQ_CST",
")",
";",
"if",
"(",
"val",
"&",
"IX86_HLE_ACQUIRE",
"&&",
"!",
"(",
"model",
"==",
"MEMMODEL_ACQUIRE",
"||",
"strong",
")",
")",
"{",
"warning",
"(",
"OPT_Winvalid_memory_model",
",",
"\"HLE_ACQUIRE not used with ACQUIRE or stronger memory model\"",
")",
";",
"return",
"MEMMODEL_SEQ_CST",
"|",
"IX86_HLE_ACQUIRE",
";",
"}",
"if",
"(",
"val",
"&",
"IX86_HLE_RELEASE",
"&&",
"!",
"(",
"model",
"==",
"MEMMODEL_RELEASE",
"||",
"strong",
")",
")",
"{",
"warning",
"(",
"OPT_Winvalid_memory_model",
",",
"\"HLE_RELEASE not used with RELEASE or stronger memory model\"",
")",
";",
"return",
"MEMMODEL_SEQ_CST",
"|",
"IX86_HLE_RELEASE",
";",
"}",
"return",
"val",
";",
"}",
"</s>"
] | [
"Validate",
"target",
"specific",
"memory",
"model",
"bits",
"in",
"VAL",
"."
] | [
"i386",
"\"Unknown architecture specific memory model\"",
"\"HLE_ACQUIRE not used with ACQUIRE or stronger memory model\"",
"\"HLE_RELEASE not used with RELEASE or stronger memory model\""
] | i3864 | ix86_memmodel_check | i386 | CPU | GCC | 17,176 | 138 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyAsmPrinter",
"::",
"emitEndOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"emitDecls",
"(",
"M",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"F",
":",
"M",
")",
"{",
"if",
"(",
"!",
"F",
".",
"isIntrinsic",
"(",
")",
"&&",
"F",
".",
"hasAddressTaken",
"(",
")",
")",
"{",
"MCSymbolWasm",
"*",
"FunctionTable",
"=",
"WebAssembly",
"::",
"getOrCreateFunctionTableSymbol",
"(",
"OutContext",
",",
"Subtarget",
")",
";",
"OutStreamer",
"->",
"emitSymbolAttribute",
"(",
"FunctionTable",
",",
"MCSA_NoDeadStrip",
")",
";",
"break",
";",
"}",
"}",
"for",
"(",
"const",
"auto",
"&",
"G",
":",
"M",
".",
"globals",
"(",
")",
")",
"{",
"if",
"(",
"!",
"G",
".",
"hasInitializer",
"(",
")",
"&&",
"G",
".",
"hasExternalLinkage",
"(",
")",
"&&",
"!",
"WebAssembly",
"::",
"isWasmVarAddressSpace",
"(",
"G",
".",
"getAddressSpace",
"(",
")",
")",
"&&",
"G",
".",
"getValueType",
"(",
")",
"->",
"isSized",
"(",
")",
")",
"{",
"uint16_t",
"Size",
"=",
"M",
".",
"getDataLayout",
"(",
")",
".",
"getTypeAllocSize",
"(",
"G",
".",
"getValueType",
"(",
")",
")",
";",
"OutStreamer",
"->",
"emitELFSize",
"(",
"getSymbol",
"(",
"&",
"G",
")",
",",
"MCConstantExpr",
"::",
"create",
"(",
"Size",
",",
"OutContext",
")",
")",
";",
"}",
"}",
"if",
"(",
"const",
"NamedMDNode",
"*",
"Named",
"=",
"M",
".",
"getNamedMetadata",
"(",
"\"wasm.custom_sections\"",
")",
")",
"{",
"for",
"(",
"const",
"Metadata",
"*",
"MD",
":",
"Named",
"->",
"operands",
"(",
")",
")",
"{",
"const",
"auto",
"*",
"Tuple",
"=",
"dyn_cast",
"<",
"MDTuple",
">",
"(",
"MD",
")",
";",
"if",
"(",
"!",
"Tuple",
"||",
"Tuple",
"->",
"getNumOperands",
"(",
")",
"!=",
"2",
")",
"continue",
";",
"const",
"MDString",
"*",
"Name",
"=",
"dyn_cast",
"<",
"MDString",
">",
"(",
"Tuple",
"->",
"getOperand",
"(",
"0",
")",
")",
";",
"const",
"MDString",
"*",
"Contents",
"=",
"dyn_cast",
"<",
"MDString",
">",
"(",
"Tuple",
"->",
"getOperand",
"(",
"1",
")",
")",
";",
"if",
"(",
"!",
"Name",
"||",
"!",
"Contents",
")",
"continue",
";",
"OutStreamer",
"->",
"PushSection",
"(",
")",
";",
"std",
"::",
"string",
"SectionName",
"=",
"(",
"\".custom_section.\"",
"+",
"Name",
"->",
"getString",
"(",
")",
")",
".",
"str",
"(",
")",
";",
"MCSectionWasm",
"*",
"MySection",
"=",
"OutContext",
".",
"getWasmSection",
"(",
"SectionName",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"MySection",
")",
";",
"OutStreamer",
"->",
"emitBytes",
"(",
"Contents",
"->",
"getString",
"(",
")",
")",
";",
"OutStreamer",
"->",
"PopSection",
"(",
")",
";",
"}",
"}",
"EmitProducerInfo",
"(",
"M",
")",
";",
"EmitTargetFeatures",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"end",
"of",
"their",
"file",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly::getOrCreateFunctionTableSymbol",
"WebAssembly::isWasmVarAddressSpace",
"\"wasm.custom_sections\"",
"2",
"0",
"1",
"\".custom_section.\""
] | WebAssemblyAsmPrinter22 | emitEndOfAsmFile | WebAssembly | Virtual ISA | LLVM | 17,177 | 341 | 1 | [] |
[
"<s>",
"bool",
"avr_casei_sequence_check_operands",
"(",
"rtx",
"*",
"xop",
")",
"{",
"rtx",
"sub_5",
"=",
"NULL_RTX",
";",
"if",
"(",
"AVR_HAVE_EIJMP_EICALL",
"&&",
"xop",
"[",
"8",
"]",
"==",
"all_regs_rtx",
"[",
"24",
"]",
")",
"{",
"sub_5",
"=",
"xop",
"[",
"6",
"]",
";",
"}",
"if",
"(",
"!",
"AVR_HAVE_EIJMP_EICALL",
"&&",
"PLUS",
"==",
"GET_CODE",
"(",
"xop",
"[",
"6",
"]",
")",
"&&",
"LABEL_REF",
"==",
"GET_CODE",
"(",
"XEXP",
"(",
"xop",
"[",
"6",
"]",
",",
"1",
")",
")",
"&&",
"rtx_equal_p",
"(",
"xop",
"[",
"3",
"]",
",",
"XEXP",
"(",
"XEXP",
"(",
"xop",
"[",
"6",
"]",
",",
"1",
")",
",",
"0",
")",
")",
"&&",
"xop",
"[",
"8",
"]",
"==",
"const0_rtx",
")",
"{",
"sub_5",
"=",
"XEXP",
"(",
"xop",
"[",
"6",
"]",
",",
"0",
")",
";",
"}",
"if",
"(",
"sub_5",
"&&",
"SUBREG_P",
"(",
"sub_5",
")",
"&&",
"SUBREG_BYTE",
"(",
"sub_5",
")",
"==",
"0",
"&&",
"rtx_equal_p",
"(",
"xop",
"[",
"5",
"]",
",",
"SUBREG_REG",
"(",
"sub_5",
")",
")",
")",
"return",
"true",
";",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"\"\\n;; Failed condition for casesi_<mode>_sequence\\n\\n\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Perform",
"some",
"extra",
"checks",
"on",
"operands",
"of",
"casesi_",
"<",
"mode",
">",
"_sequence",
".",
"Not",
"all",
"operand",
"dependencies",
"can",
"be",
"described",
"by",
"means",
"of",
"predicates",
".",
"This",
"function",
"performs",
"left",
"over",
"checks",
"and",
"should",
"always",
"return",
"true",
".",
"Returning",
"false",
"means",
"that",
"someone",
"changed",
"the",
"casesi",
"expander",
"but",
"did",
"not",
"adjust",
"casesi_",
"<",
"mode",
">",
"_sequence",
"."
] | [
"avr",
"8",
"24",
"6",
"6",
"6",
"1",
"3",
"6",
"1",
"0",
"8",
"6",
"0",
"0",
"5",
"\"\\n;; Failed condition for casesi_<mode>_sequence\\n\\n\""
] | avr | avr_casei_sequence_check_operands | avr | MPU | GCC | 17,178 | 157 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_file_start",
"(",
"void",
")",
"{",
"char",
"buffer",
"[",
"80",
"]",
";",
"const",
"char",
"*",
"start",
"=",
"buffer",
";",
"FILE",
"*",
"file",
"=",
"asm_out_file",
";",
"rs6000_default_cpu",
"=",
"TARGET_CPU_DEFAULT",
";",
"default_file_start",
"(",
")",
";",
"if",
"(",
"flag_verbose_asm",
")",
"{",
"sprintf",
"(",
"buffer",
",",
"\"\\n%s rs6000/powerpc options:\"",
",",
"ASM_COMMENT_START",
")",
";",
"if",
"(",
"rs6000_default_cpu",
"!=",
"0",
"&&",
"rs6000_default_cpu",
"[",
"0",
"]",
"!=",
"'\\0'",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s --with-cpu=%s\"",
",",
"start",
",",
"rs6000_default_cpu",
")",
";",
"start",
"=",
"\"\"",
";",
"}",
"if",
"(",
"global_options_set",
".",
"x_rs6000_cpu_index",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s -mcpu=%s\"",
",",
"start",
",",
"processor_target_table",
"[",
"rs6000_cpu_index",
"]",
".",
"name",
")",
";",
"start",
"=",
"\"\"",
";",
"}",
"if",
"(",
"global_options_set",
".",
"x_rs6000_tune_index",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s -mtune=%s\"",
",",
"start",
",",
"processor_target_table",
"[",
"rs6000_tune_index",
"]",
".",
"name",
")",
";",
"start",
"=",
"\"\"",
";",
"}",
"if",
"(",
"PPC405_ERRATUM77",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s PPC405CR_ERRATUM77\"",
",",
"start",
")",
";",
"start",
"=",
"\"\"",
";",
"}",
"switch",
"(",
"rs6000_sdata",
")",
"{",
"case",
"SDATA_NONE",
":",
"fprintf",
"(",
"file",
",",
"\"%s -msdata=none\"",
",",
"start",
")",
";",
"start",
"=",
"\"\"",
";",
"break",
";",
"case",
"SDATA_DATA",
":",
"fprintf",
"(",
"file",
",",
"\"%s -msdata=data\"",
",",
"start",
")",
";",
"start",
"=",
"\"\"",
";",
"break",
";",
"case",
"SDATA_SYSV",
":",
"fprintf",
"(",
"file",
",",
"\"%s -msdata=sysv\"",
",",
"start",
")",
";",
"start",
"=",
"\"\"",
";",
"break",
";",
"case",
"SDATA_EABI",
":",
"fprintf",
"(",
"file",
",",
"\"%s -msdata=eabi\"",
",",
"start",
")",
";",
"start",
"=",
"\"\"",
";",
"break",
";",
"}",
"if",
"(",
"rs6000_sdata",
"&&",
"g_switch_value",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s -G %d\"",
",",
"start",
",",
"g_switch_value",
")",
";",
"start",
"=",
"\"\"",
";",
"}",
"if",
"(",
"*",
"start",
"==",
"'\\0'",
")",
"putc",
"(",
"'\\n'",
",",
"file",
")",
";",
"}",
"if",
"(",
"rs6000_default_cpu",
"==",
"0",
"||",
"rs6000_default_cpu",
"[",
"0",
"]",
"==",
"'\\0'",
"||",
"!",
"global_options_set",
".",
"x_rs6000_cpu_index",
")",
"{",
"fputs",
"(",
"\"\\t.machine \"",
",",
"asm_out_file",
")",
";",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"OPTION_MASK_DIRECT_MOVE",
")",
"!=",
"0",
")",
"fputs",
"(",
"\"power8\\n\"",
",",
"asm_out_file",
")",
";",
"else",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"OPTION_MASK_POPCNTD",
")",
"!=",
"0",
")",
"fputs",
"(",
"\"power7\\n\"",
",",
"asm_out_file",
")",
";",
"else",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"OPTION_MASK_CMPB",
")",
"!=",
"0",
")",
"fputs",
"(",
"\"power6\\n\"",
",",
"asm_out_file",
")",
";",
"else",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"OPTION_MASK_POPCNTB",
")",
"!=",
"0",
")",
"fputs",
"(",
"\"power5\\n\"",
",",
"asm_out_file",
")",
";",
"else",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"OPTION_MASK_MFCRF",
")",
"!=",
"0",
")",
"fputs",
"(",
"\"power4\\n\"",
",",
"asm_out_file",
")",
";",
"else",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"OPTION_MASK_POWERPC64",
")",
"!=",
"0",
")",
"fputs",
"(",
"\"ppc64\\n\"",
",",
"asm_out_file",
")",
";",
"else",
"fputs",
"(",
"\"ppc\\n\"",
",",
"asm_out_file",
")",
";",
"}",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
")",
"fprintf",
"(",
"file",
",",
"\"\\t.abiversion 2\\n\"",
")",
";",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
"||",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
"||",
"(",
"TARGET_ELF",
"&&",
"flag_pic",
"==",
"2",
")",
")",
"{",
"switch_to_section",
"(",
"toc_section",
")",
";",
"switch_to_section",
"(",
"text_section",
")",
";",
"}",
"}",
"</s>"
] | [
"Do",
"anything",
"needed",
"at",
"the",
"start",
"of",
"the",
"asm",
"file",
"."
] | [
"rs6000",
"80",
"\"\\n%s rs6000/powerpc options:\"",
"0",
"0",
"\"%s --with-cpu=%s\"",
"\"\"",
"\"%s -mcpu=%s\"",
"\"\"",
"\"%s -mtune=%s\"",
"\"\"",
"\"%s PPC405CR_ERRATUM77\"",
"\"\"",
"\"%s -msdata=none\"",
"\"\"",
"\"%s -msdata=data\"",
"\"\"",
"\"%s -msdata=sysv\"",
"\"\"",
"\"%s -msdata=eabi\"",
"\"\"",
"\"%s -G %d\"",
"\"\"",
"0",
"0",
"\"\\t.machine \"",
"0",
"\"power8\\n\"",
"0",
"\"power7\\n\"",
"0",
"\"power6\\n\"",
"0",
"\"power5\\n\"",
"0",
"\"power4\\n\"",
"0",
"\"ppc64\\n\"",
"\"ppc\\n\"",
"\"\\t.abiversion 2\\n\"",
"2"
] | rs60004 | rs6000_file_start | rs6000 | CPU | GCC | 17,179 | 455 | 1 | [] |
[
"<s>",
"static",
"tree",
"bfin_handle_l1_text_attribute",
"(",
"tree",
"*",
"node",
",",
"tree",
"name",
",",
"tree",
"ARG_UNUSED",
"(",
"args",
")",
",",
"int",
"ARG_UNUSED",
"(",
"flags",
")",
",",
"bool",
"*",
"no_add_attrs",
")",
"{",
"tree",
"decl",
"=",
"*",
"node",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"FUNCTION_DECL",
")",
"{",
"error",
"(",
"\"%qE attribute only applies to functions\"",
",",
"name",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"DECL_SECTION_NAME",
"(",
"decl",
")",
"!=",
"NULL",
"&&",
"strcmp",
"(",
"DECL_SECTION_NAME",
"(",
"decl",
")",
",",
"\".l1.text\"",
")",
"!=",
"0",
")",
"{",
"error",
"(",
"\"section of %q+D conflicts with previous declaration\"",
",",
"decl",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"else",
"set_decl_section_name",
"(",
"decl",
",",
"\".l1.text\"",
")",
";",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Handle",
"a",
"``",
"l1_text",
"''",
"attribute",
";",
"arguments",
"as",
"in",
"struct",
"attribute_spec.handler",
"."
] | [
"bfin",
"\"%qE attribute only applies to functions\"",
"\".l1.text\"",
"0",
"\"section of %q+D conflicts with previous declaration\"",
"\".l1.text\""
] | bfin | bfin_handle_l1_text_attribute | bfin | DSP | GCC | 17,180 | 105 | 1 | [] |
[
"<s>",
"bool",
"PPCAIXAsmPrinter",
"::",
"doInitialization",
"(",
"Module",
"&",
"M",
")",
"{",
"if",
"(",
"M",
".",
"alias_size",
"(",
")",
">",
"0u",
")",
"report_fatal_error",
"(",
"\"module has aliases, which LLVM does not yet support for AIX\"",
")",
";",
"const",
"bool",
"Result",
"=",
"PPCAsmPrinter",
"::",
"doInitialization",
"(",
"M",
")",
";",
"auto",
"setCsectAlignment",
"=",
"[",
"this",
"]",
"(",
"const",
"GlobalObject",
"*",
"GO",
")",
"{",
"if",
"(",
"GO",
"->",
"isDeclarationForLinker",
"(",
")",
")",
"return",
";",
"SectionKind",
"GOKind",
"=",
"getObjFileLowering",
"(",
")",
".",
"getKindForGlobal",
"(",
"GO",
",",
"TM",
")",
";",
"MCSectionXCOFF",
"*",
"Csect",
"=",
"cast",
"<",
"MCSectionXCOFF",
">",
"(",
"getObjFileLowering",
"(",
")",
".",
"SectionForGlobal",
"(",
"GO",
",",
"GOKind",
",",
"TM",
")",
")",
";",
"Align",
"GOAlign",
"=",
"getGVAlignment",
"(",
"GO",
",",
"GO",
"->",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
")",
";",
"if",
"(",
"GOAlign",
">",
"Csect",
"->",
"getAlignment",
"(",
")",
")",
"Csect",
"->",
"setAlignment",
"(",
"GOAlign",
")",
";",
"}",
";",
"for",
"(",
"const",
"auto",
"&",
"G",
":",
"M",
".",
"globals",
"(",
")",
")",
"setCsectAlignment",
"(",
"&",
"G",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"F",
":",
"M",
")",
"setCsectAlignment",
"(",
"&",
"F",
")",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"PowerPC",
"PPC",
"0u",
"\"module has aliases, which LLVM does not yet support for AIX\"",
"PPC"
] | PPCAsmPrinter121 | doInitialization | PowerPC | CPU | LLVM | 17,181 | 171 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"hasUnscaledLdStOffset",
"(",
"unsigned",
"Opc",
")",
"{",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"AArch64",
"::",
"STURSi",
":",
"case",
"AArch64",
"::",
"STRSpre",
":",
"case",
"AArch64",
"::",
"STURDi",
":",
"case",
"AArch64",
"::",
"STRDpre",
":",
"case",
"AArch64",
"::",
"STURQi",
":",
"case",
"AArch64",
"::",
"STRQpre",
":",
"case",
"AArch64",
"::",
"STURBBi",
":",
"case",
"AArch64",
"::",
"STURHHi",
":",
"case",
"AArch64",
"::",
"STURWi",
":",
"case",
"AArch64",
"::",
"STRWpre",
":",
"case",
"AArch64",
"::",
"STURXi",
":",
"case",
"AArch64",
"::",
"STRXpre",
":",
"case",
"AArch64",
"::",
"LDURSi",
":",
"case",
"AArch64",
"::",
"LDRSpre",
":",
"case",
"AArch64",
"::",
"LDURDi",
":",
"case",
"AArch64",
"::",
"LDRDpre",
":",
"case",
"AArch64",
"::",
"LDURQi",
":",
"case",
"AArch64",
"::",
"LDRQpre",
":",
"case",
"AArch64",
"::",
"LDURWi",
":",
"case",
"AArch64",
"::",
"LDRWpre",
":",
"case",
"AArch64",
"::",
"LDURXi",
":",
"case",
"AArch64",
"::",
"LDRXpre",
":",
"case",
"AArch64",
"::",
"LDURSWi",
":",
"case",
"AArch64",
"::",
"LDURHHi",
":",
"case",
"AArch64",
"::",
"LDURBBi",
":",
"case",
"AArch64",
"::",
"LDURSBWi",
":",
"case",
"AArch64",
"::",
"LDURSHWi",
":",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"has",
"an",
"unscaled",
"load/store",
"offset",
"."
] | [
"AArch64",
"AArch64",
"AArch64::STURSi",
"AArch64::STRSpre",
"AArch64::STURDi",
"AArch64::STRDpre",
"AArch64::STURQi",
"AArch64::STRQpre",
"AArch64::STURBBi",
"AArch64::STURHHi",
"AArch64::STURWi",
"AArch64::STRWpre",
"AArch64::STURXi",
"AArch64::STRXpre",
"AArch64::LDURSi",
"AArch64::LDRSpre",
"AArch64::LDURDi",
"AArch64::LDRDpre",
"AArch64::LDURQi",
"AArch64::LDRQpre",
"AArch64::LDURWi",
"AArch64::LDRWpre",
"AArch64::LDURXi",
"AArch64::LDRXpre",
"AArch64::LDURSWi",
"AArch64::LDURHHi",
"AArch64::LDURBBi",
"AArch64::LDURSBWi",
"AArch64::LDURSHWi"
] | AArch64InstrInfo105 | hasUnscaledLdStOffset | AArch64 | CPU | LLVM | 17,182 | 159 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"findCommutedOpIndices",
"(",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"&",
"SrcOpIdx1",
",",
"unsigned",
"&",
"SrcOpIdx2",
")",
"const",
"{",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"if",
"(",
"!",
"MCID",
".",
"isCommutable",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"int",
"Src0Idx",
"=",
"AMDGPU",
"::",
"getNamedOperandIdx",
"(",
"Opc",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0",
")",
";",
"if",
"(",
"Src0Idx",
"==",
"-",
"1",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MI",
"->",
"getOperand",
"(",
"Src0Idx",
")",
".",
"isReg",
"(",
")",
")",
"return",
"false",
";",
"int",
"Src1Idx",
"=",
"AMDGPU",
"::",
"getNamedOperandIdx",
"(",
"Opc",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1",
")",
";",
"if",
"(",
"Src1Idx",
"==",
"-",
"1",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MI",
"->",
"getOperand",
"(",
"Src1Idx",
")",
".",
"isReg",
"(",
")",
")",
"return",
"false",
";",
"SrcOpIdx1",
"=",
"Src0Idx",
";",
"SrcOpIdx2",
"=",
"Src1Idx",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"iff",
"the",
"routine",
"could",
"find",
"two",
"commutable",
"operands",
"in",
"the",
"given",
"machine",
"instruction",
"."
] | [
"R600",
"SI",
"1",
"1"
] | SIInstrInfo49 | findCommutedOpIndices | R600 | GPU | LLVM | 17,183 | 149 | 1 | [] |
[
"<s>",
"bool",
"DeadCodeElimination",
"::",
"erase",
"(",
"const",
"SetVector",
"<",
"NodeId",
">",
"&",
"Nodes",
")",
"{",
"if",
"(",
"Nodes",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"NodeList",
"DRNs",
",",
"DINs",
";",
"for",
"(",
"auto",
"I",
":",
"Nodes",
")",
"{",
"auto",
"BA",
"=",
"DFG",
".",
"addr",
"<",
"NodeBase",
"*",
">",
"(",
"I",
")",
";",
"uint16_t",
"Type",
"=",
"BA",
".",
"Addr",
"->",
"getType",
"(",
")",
";",
"if",
"(",
"Type",
"==",
"NodeAttrs",
"::",
"Ref",
")",
"{",
"DRNs",
".",
"push_back",
"(",
"DFG",
".",
"addr",
"<",
"RefNode",
"*",
">",
"(",
"I",
")",
")",
";",
"continue",
";",
"}",
"uint16_t",
"Kind",
"=",
"BA",
".",
"Addr",
"->",
"getKind",
"(",
")",
";",
"if",
"(",
"Kind",
"==",
"NodeAttrs",
"::",
"Stmt",
"||",
"Kind",
"==",
"NodeAttrs",
"::",
"Phi",
")",
"{",
"append_range",
"(",
"DRNs",
",",
"NodeAddr",
"<",
"CodeNode",
"*",
">",
"(",
"BA",
")",
".",
"Addr",
"->",
"members",
"(",
"DFG",
")",
")",
";",
"DINs",
".",
"push_back",
"(",
"DFG",
".",
"addr",
"<",
"InstrNode",
"*",
">",
"(",
"I",
")",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Unexpected code node\"",
")",
";",
"return",
"false",
";",
"}",
"}",
"auto",
"UsesFirst",
"=",
"[",
"]",
"(",
"NodeAddr",
"<",
"RefNode",
"*",
">",
"A",
",",
"NodeAddr",
"<",
"RefNode",
"*",
">",
"B",
")",
"->",
"bool",
"{",
"uint16_t",
"KindA",
"=",
"A",
".",
"Addr",
"->",
"getKind",
"(",
")",
",",
"KindB",
"=",
"B",
".",
"Addr",
"->",
"getKind",
"(",
")",
";",
"if",
"(",
"KindA",
"==",
"NodeAttrs",
"::",
"Use",
"&&",
"KindB",
"==",
"NodeAttrs",
"::",
"Def",
")",
"return",
"true",
";",
"if",
"(",
"KindA",
"==",
"NodeAttrs",
"::",
"Def",
"&&",
"KindB",
"==",
"NodeAttrs",
"::",
"Use",
")",
"return",
"false",
";",
"return",
"A",
".",
"Id",
"<",
"B",
".",
"Id",
";",
"}",
";",
"llvm",
"::",
"sort",
"(",
"DRNs",
",",
"UsesFirst",
")",
";",
"if",
"(",
"trace",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"\"Removing dead ref nodes:\\n\"",
";",
"for",
"(",
"NodeAddr",
"<",
"RefNode",
"*",
">",
"RA",
":",
"DRNs",
")",
"{",
"if",
"(",
"trace",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"\" \"",
"<<",
"PrintNode",
"<",
"RefNode",
"*",
">",
"(",
"RA",
",",
"DFG",
")",
"<<",
"'\\n'",
";",
"if",
"(",
"DFG",
".",
"IsUse",
"(",
"RA",
")",
")",
"DFG",
".",
"unlinkUse",
"(",
"RA",
",",
"true",
")",
";",
"else",
"if",
"(",
"DFG",
".",
"IsDef",
"(",
"RA",
")",
")",
"DFG",
".",
"unlinkDef",
"(",
"RA",
",",
"true",
")",
";",
"}",
"for",
"(",
"NodeAddr",
"<",
"InstrNode",
"*",
">",
"IA",
":",
"DINs",
")",
"{",
"NodeAddr",
"<",
"BlockNode",
"*",
">",
"BA",
"=",
"IA",
".",
"Addr",
"->",
"getOwner",
"(",
"DFG",
")",
";",
"BA",
".",
"Addr",
"->",
"removeMember",
"(",
"IA",
",",
"DFG",
")",
";",
"if",
"(",
"!",
"DFG",
".",
"IsCode",
"<",
"NodeAttrs",
"::",
"Stmt",
">",
"(",
"IA",
")",
")",
"continue",
";",
"MachineInstr",
"*",
"MI",
"=",
"NodeAddr",
"<",
"StmtNode",
"*",
">",
"(",
"IA",
")",
".",
"Addr",
"->",
"getCode",
"(",
")",
";",
"if",
"(",
"trace",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"\"erasing: \"",
"<<",
"*",
"MI",
";",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"erase",
"-",
"Erases",
"an",
"element",
"identified",
"by",
"Key",
",",
"if",
"it",
"exists",
"."
] | [
"Hexagon",
"\"Unexpected code node\"",
"\"Removing dead ref nodes:\\n\"",
"\" \"",
"\"erasing: \""
] | RDFDeadCode4 | erase | Hexagon | DSP | LLVM | 17,184 | 453 | 1 | [] |
[
"<s>",
"void",
"visium_split_double_add",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"rtx",
"op2",
")",
"{",
"rtx",
"op3",
"=",
"gen_lowpart",
"(",
"SImode",
",",
"op0",
")",
";",
"rtx",
"op4",
"=",
"gen_lowpart",
"(",
"SImode",
",",
"op1",
")",
";",
"rtx",
"op5",
";",
"rtx",
"op6",
"=",
"gen_highpart",
"(",
"SImode",
",",
"op0",
")",
";",
"rtx",
"op7",
"=",
"(",
"op1",
"==",
"const0_rtx",
"?",
"op1",
":",
"gen_highpart",
"(",
"SImode",
",",
"op1",
")",
")",
";",
"rtx",
"op8",
";",
"rtx",
"x",
",",
"pat",
",",
"flags",
";",
"if",
"(",
"CONST_INT_P",
"(",
"op2",
")",
")",
"{",
"HOST_WIDE_INT",
"val",
"=",
"INTVAL",
"(",
"op2",
")",
";",
"if",
"(",
"val",
"<",
"0",
")",
"{",
"code",
"=",
"(",
"code",
"==",
"MINUS",
"?",
"PLUS",
":",
"MINUS",
")",
";",
"val",
"=",
"-",
"val",
";",
"}",
"op5",
"=",
"gen_int_mode",
"(",
"val",
",",
"SImode",
")",
";",
"op8",
"=",
"const0_rtx",
";",
"}",
"else",
"{",
"op5",
"=",
"gen_lowpart",
"(",
"SImode",
",",
"op2",
")",
";",
"op8",
"=",
"gen_highpart",
"(",
"SImode",
",",
"op2",
")",
";",
"}",
"if",
"(",
"op4",
"==",
"const0_rtx",
")",
"pat",
"=",
"gen_negsi2_insn_set_carry",
"(",
"op3",
",",
"op5",
")",
";",
"else",
"if",
"(",
"code",
"==",
"MINUS",
")",
"pat",
"=",
"gen_subsi3_insn_set_carry",
"(",
"op3",
",",
"op4",
",",
"op5",
")",
";",
"else",
"pat",
"=",
"gen_addsi3_insn_set_carry",
"(",
"op3",
",",
"op4",
",",
"op5",
")",
";",
"emit_insn",
"(",
"pat",
")",
";",
"if",
"(",
"op8",
"==",
"const0_rtx",
")",
"x",
"=",
"op7",
";",
"else",
"x",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"SImode",
",",
"op7",
",",
"op8",
")",
";",
"flags",
"=",
"gen_rtx_REG",
"(",
"CCCmode",
",",
"FLAGS_REGNUM",
")",
";",
"x",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"SImode",
",",
"x",
",",
"gen_rtx_LTU",
"(",
"SImode",
",",
"flags",
",",
"const0_rtx",
")",
")",
";",
"pat",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"rtvec_alloc",
"(",
"2",
")",
")",
";",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"0",
")",
"=",
"gen_rtx_SET",
"(",
"op6",
",",
"x",
")",
";",
"flags",
"=",
"gen_rtx_REG",
"(",
"CCmode",
",",
"FLAGS_REGNUM",
")",
";",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"1",
")",
"=",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"flags",
")",
";",
"emit_insn",
"(",
"pat",
")",
";",
"visium_flags_exposed",
"=",
"true",
";",
"}",
"</s>"
] | [
"Split",
"a",
"double",
"addition",
"or",
"subtraction",
"of",
"operands",
"."
] | [
"visium",
"0",
"2",
"0",
"0",
"0",
"1"
] | visium | visium_split_double_add | visium | Virtual ISA | GCC | 17,185 | 320 | 1 | [] |
[
"<s>",
"void",
"M68kAsmPrinter",
"::",
"emitFunctionBodyStart",
"(",
")",
"{",
"}",
"</s>"
] | [
"Targets",
"can",
"override",
"this",
"to",
"emit",
"stuff",
"before",
"the",
"first",
"basic",
"block",
"in",
"the",
"function",
"."
] | [
"M68k",
"M68k"
] | M68kAsmPrinter | emitFunctionBodyStart | M68k | MPU | LLVM | 17,186 | 8 | 1 | [] |
[
"<s>",
"TPCII",
"::",
"IType",
"TPCMCInstrInfo",
"::",
"getType",
"(",
"MCInstrInfo",
"const",
"&",
"MCII",
",",
"MCInst",
"const",
"&",
"MCI",
")",
"{",
"return",
"static_cast",
"<",
"TPCII",
"::",
"IType",
">",
"(",
"TPCII",
"::",
"getInstrType",
"(",
"getDesc",
"(",
"MCII",
",",
"MCI",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Overload",
"to",
"return",
"most",
"specific",
"vector",
"type",
"."
] | [
"TPC",
"TPC",
"TPC",
"TPC",
"TPC"
] | TPCMCInstrInfo | getType | TPC | Virtual ISA | LLVM | 17,187 | 40 | 1 | [] |
[
"<s>",
"void",
"PHILinearize",
"::",
"clear",
"(",
")",
"{",
"PHIInfo",
"=",
"PHIInfoT",
"(",
")",
";",
"}",
"</s>"
] | [
"Clear",
"all",
"timers",
"in",
"this",
"group",
"."
] | [
"AMDGPU"
] | AMDGPUMachineCFGStructurizer | clear | AMDGPU | GPU | LLVM | 17,188 | 14 | 1 | [] |
[
"<s>",
"bool",
"PPCFrameLowering",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"isSVR4ABI",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"PPCInstrInfo",
"&",
"TII",
"=",
"*",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"bool",
"CRSpilled",
"=",
"false",
";",
"MachineInstrBuilder",
"CRMIB",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
"==",
"PPC",
"::",
"VRSAVE",
"&&",
"!",
"Subtarget",
".",
"isDarwinABI",
"(",
")",
")",
"continue",
";",
"bool",
"IsCRField",
"=",
"PPC",
"::",
"CR2",
"<=",
"Reg",
"&&",
"Reg",
"<=",
"PPC",
"::",
"CR4",
";",
"MBB",
".",
"addLiveIn",
"(",
"Reg",
")",
";",
"if",
"(",
"CRSpilled",
"&&",
"IsCRField",
")",
"{",
"CRMIB",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitKill",
")",
";",
"continue",
";",
"}",
"if",
"(",
"IsCRField",
")",
"{",
"PPCFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
"->",
"getInfo",
"<",
"PPCFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"Subtarget",
".",
"isPPC64",
"(",
")",
")",
"{",
"FuncInfo",
"->",
"addMustSaveCR",
"(",
"Reg",
")",
";",
"}",
"else",
"{",
"CRSpilled",
"=",
"true",
";",
"FuncInfo",
"->",
"setSpillsCR",
"(",
")",
";",
"CRMIB",
"=",
"BuildMI",
"(",
"*",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"MFCR",
")",
",",
"PPC",
"::",
"R12",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitKill",
")",
";",
"MBB",
".",
"insert",
"(",
"MI",
",",
"CRMIB",
")",
";",
"MBB",
".",
"insert",
"(",
"MI",
",",
"addFrameReference",
"(",
"BuildMI",
"(",
"*",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"STW",
")",
")",
".",
"addReg",
"(",
"PPC",
"::",
"R12",
",",
"getKillRegState",
"(",
"true",
")",
")",
",",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
")",
")",
";",
"}",
"}",
"else",
"{",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"storeRegToStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"true",
",",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"spillCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"spill",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"store",
"instructions",
"via",
"storeRegToStackSlot",
"(",
")",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"0",
"PPC::VRSAVE",
"PPC::CR2",
"PPC::CR4",
"PPC",
"PPC",
"PPC",
"PPC::MFCR",
"PPC::R12",
"PPC::STW",
"PPC::R12"
] | PPCFrameLowering10 | spillCalleeSavedRegisters | PowerPC | CPU | LLVM | 17,189 | 355 | 1 | [] |
[
"<s>",
"void",
"M68kFrameLowering",
"::",
"emitSPUpdate",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"int64_t",
"NumBytes",
",",
"bool",
"InEpilogue",
")",
"const",
"{",
"bool",
"IsSub",
"=",
"NumBytes",
"<",
"0",
";",
"uint64_t",
"Offset",
"=",
"IsSub",
"?",
"-",
"NumBytes",
":",
"NumBytes",
";",
"uint64_t",
"Chunk",
"=",
"(",
"1LL",
"<<",
"31",
")",
"-",
"1",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MBBI",
")",
";",
"while",
"(",
"Offset",
")",
"{",
"if",
"(",
"Offset",
">",
"Chunk",
")",
"{",
"Register",
"Reg",
";",
"if",
"(",
"IsSub",
"&&",
"!",
"isRegLiveIn",
"(",
"MBB",
",",
"M68k",
"::",
"D0",
")",
")",
"Reg",
"=",
"M68k",
"::",
"D0",
";",
"else",
"Reg",
"=",
"findDeadCallerSavedReg",
"(",
"MBB",
",",
"MBBI",
",",
"TRI",
")",
";",
"if",
"(",
"Reg",
")",
"{",
"unsigned",
"Opc",
"=",
"M68k",
"::",
"MOV32ri",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"Reg",
")",
".",
"addImm",
"(",
"Offset",
")",
";",
"Opc",
"=",
"IsSub",
"?",
"M68k",
"::",
"SUB32rr",
":",
"M68k",
"::",
"ADD32rr",
";",
"MachineInstr",
"*",
"MI",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addReg",
"(",
"Reg",
")",
";",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"Offset",
"=",
"0",
";",
"continue",
";",
"}",
"}",
"uint64_t",
"ThisVal",
"=",
"std",
"::",
"min",
"(",
"Offset",
",",
"Chunk",
")",
";",
"MachineInstrBuilder",
"MI",
"=",
"BuildStackAdjustment",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"IsSub",
"?",
"-",
"ThisVal",
":",
"ThisVal",
",",
"InEpilogue",
")",
";",
"if",
"(",
"IsSub",
")",
"MI",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"else",
"MI",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"Offset",
"-=",
"ThisVal",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"a",
"series",
"of",
"instructions",
"to",
"increment",
"/",
"decrement",
"the",
"stack",
"pointer",
"by",
"a",
"constant",
"value",
"."
] | [
"M68k",
"M68k",
"0",
"1LL",
"31",
"1",
"M68k::D0",
"M68k::D0",
"M68k::MOV32ri",
"M68k::SUB32rr",
"M68k::ADD32rr",
"3",
"0"
] | M68kFrameLowering | emitSPUpdate | M68k | MPU | LLVM | 17,190 | 268 | 1 | [] |
[
"<s>",
"bool",
"ARMFrameLowering",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"ArrayRef",
"<",
"CalleeSavedInfo",
">",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"PushOpc",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
"?",
"ARM",
"::",
"t2STMDB_UPD",
":",
"ARM",
"::",
"STMDB_UPD",
";",
"unsigned",
"PushOneOpc",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
"?",
"ARM",
"::",
"t2STR_PRE",
":",
"ARM",
"::",
"STR_PRE_IMM",
";",
"unsigned",
"FltOpc",
"=",
"ARM",
"::",
"VSTMDDB_UPD",
";",
"unsigned",
"NumAlignedDPRCS2Regs",
"=",
"AFI",
"->",
"getNumAlignedDPRCS2Regs",
"(",
")",
";",
"if",
"(",
"llvm",
"::",
"any_of",
"(",
"CSI",
",",
"[",
"]",
"(",
"const",
"CalleeSavedInfo",
"&",
"C",
")",
"{",
"return",
"C",
".",
"getReg",
"(",
")",
"==",
"ARM",
"::",
"FPCXTNS",
";",
"}",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DebugLoc",
"(",
")",
",",
"STI",
".",
"getInstrInfo",
"(",
")",
"->",
"get",
"(",
"ARM",
"::",
"VSTR_FPCXTNS_pre",
")",
",",
"ARM",
"::",
"SP",
")",
".",
"addReg",
"(",
"ARM",
"::",
"SP",
")",
".",
"addImm",
"(",
"-",
"4",
")",
".",
"add",
"(",
"predOps",
"(",
"ARMCC",
"::",
"AL",
")",
")",
";",
"}",
"emitPushInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"PushOpc",
",",
"PushOneOpc",
",",
"false",
",",
"&",
"isARMArea1Register",
",",
"0",
",",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"emitPushInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"PushOpc",
",",
"PushOneOpc",
",",
"false",
",",
"&",
"isARMArea2Register",
",",
"0",
",",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"emitPushInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"FltOpc",
",",
"0",
",",
"true",
",",
"&",
"isARMArea3Register",
",",
"NumAlignedDPRCS2Regs",
",",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"if",
"(",
"NumAlignedDPRCS2Regs",
")",
"emitAlignedDPRCS2Spills",
"(",
"MBB",
",",
"MI",
",",
"NumAlignedDPRCS2Regs",
",",
"CSI",
",",
"TRI",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"spillCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"spill",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"store",
"instructions",
"via",
"storeRegToStackSlot",
"(",
")",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM::t2STMDB_UPD",
"ARM::STMDB_UPD",
"ARM::t2STR_PRE",
"ARM::STR_PRE_IMM",
"ARM::VSTMDDB_UPD",
"ARM::FPCXTNS",
"ARM::VSTR_FPCXTNS_pre",
"ARM::SP",
"ARM::SP",
"4",
"ARMCC::AL",
"ARM",
"0",
"ARM",
"0",
"0",
"ARM"
] | ARMFrameLowering103 | spillCalleeSavedRegisters | ARM | CPU | LLVM | 17,191 | 289 | 1 | [] |
[
"<s>",
"static",
"int",
"arm_get_strip_length",
"(",
"int",
"c",
")",
"{",
"switch",
"(",
"c",
")",
"{",
"ARM_NAME_ENCODING_LENGTHS",
"default",
":",
"return",
"0",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"length",
"of",
"a",
"function",
"name",
"prefix",
"that",
"starts",
"with",
"the",
"character",
"'",
"c",
"'",
"."
] | [
"arm",
"0"
] | arm | arm_get_strip_length | arm | CPU | GCC | 17,192 | 21 | 1 | [] |
[
"<s>",
"MVT",
"::",
"SimpleValueType",
"getCmpLibcallReturnType",
"(",
")",
"const",
"override",
"{",
"return",
"MVT",
"::",
"i8",
";",
"}",
"</s>"
] | [
"Return",
"the",
"ValueType",
"for",
"comparison",
"libcalls",
"."
] | [
"GBZ80",
"MVT::SimpleValueType",
"MVT::i8"
] | GBZ80ISelLowering | getCmpLibcallReturnType | GBZ80 | MPU | LLVM | 17,193 | 15 | 1 | [] |
[
"<s>",
"int",
"arc_hazard",
"(",
"rtx_insn",
"*",
"pred",
",",
"rtx_insn",
"*",
"succ",
")",
"{",
"if",
"(",
"!",
"pred",
"||",
"!",
"INSN_P",
"(",
"pred",
")",
"||",
"!",
"succ",
"||",
"!",
"INSN_P",
"(",
"succ",
")",
")",
"return",
"0",
";",
"if",
"(",
"arc_loop_hazard",
"(",
"pred",
",",
"succ",
")",
")",
"return",
"4",
";",
"if",
"(",
"TARGET_ARC600",
")",
"return",
"arc600_corereg_hazard",
"(",
"pred",
",",
"succ",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"For",
"ARC600",
":",
"A",
"write",
"to",
"a",
"core",
"reg",
"greater",
"or",
"equal",
"to",
"32",
"must",
"not",
"be",
"immediately",
"followed",
"by",
"a",
"use",
".",
"Anticipate",
"the",
"length",
"requirement",
"to",
"insert",
"a",
"nop",
"between",
"PRED",
"and",
"SUCC",
"to",
"prevent",
"a",
"hazard",
"."
] | [
"arc",
"0",
"4",
"0"
] | arc5 | arc_hazard | arc | MPU | GCC | 17,194 | 63 | 1 | [] |
[
"<s>",
"void",
"LanaiTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"SmallDataSection",
"=",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".sdata\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"SmallBSSSection",
"=",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".sbss\"",
",",
"ELF",
"::",
"SHT_NOBITS",
",",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"Lanai",
"Lanai",
"\".sdata\"",
"\".sbss\""
] | LanaiTargetObjectFile1 | Initialize | Lanai | CPU | LLVM | 17,195 | 71 | 1 | [] |
[
"<s>",
"static",
"bool",
"pass_in_memory",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"bool",
"for_return",
")",
"{",
"if",
"(",
"type",
")",
"{",
"if",
"(",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"return",
"true",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"VECTOR_TYPE",
")",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"for_return",
"&&",
"COMPLEX_MODE_P",
"(",
"mode",
")",
")",
"mode",
"=",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"if",
"(",
"GET_MODE_CLASS",
"(",
"mode",
")",
"!=",
"MODE_INT",
"&&",
"GET_MODE_CLASS",
"(",
"mode",
")",
"!=",
"MODE_FLOAT",
")",
"return",
"true",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
">",
"UNITS_PER_WORD",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"MODE",
"and",
"TYPE",
"(",
"possibly",
"NULL",
")",
"should",
"be",
"passed",
"or",
"returned",
"in",
"memory",
".",
"Integer",
"and",
"floating",
"types",
"supported",
"by",
"the",
"machine",
"are",
"passed",
"in",
"registers",
",",
"everything",
"else",
"is",
"passed",
"in",
"memory",
".",
"Complex",
"types",
"are",
"split",
"."
] | [
"nvptx"
] | nvptx | pass_in_memory | nvptx | GPU | GCC | 17,196 | 94 | 1 | [] |
[
"<s>",
"static",
"bool",
"isKnownNonNull",
"(",
"Register",
"Val",
",",
"MachineRegisterInfo",
"&",
"MRI",
",",
"const",
"AMDGPUTargetMachine",
"&",
"TM",
",",
"unsigned",
"AddrSpace",
")",
"{",
"MachineInstr",
"*",
"Def",
"=",
"MRI",
".",
"getVRegDef",
"(",
"Val",
")",
";",
"switch",
"(",
"Def",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPU",
"::",
"G_FRAME_INDEX",
":",
"case",
"AMDGPU",
"::",
"G_GLOBAL_VALUE",
":",
"case",
"AMDGPU",
"::",
"G_BLOCK_ADDR",
":",
"return",
"true",
";",
"case",
"AMDGPU",
"::",
"G_CONSTANT",
":",
"{",
"const",
"ConstantInt",
"*",
"CI",
"=",
"Def",
"->",
"getOperand",
"(",
"1",
")",
".",
"getCImm",
"(",
")",
";",
"return",
"CI",
"->",
"getSExtValue",
"(",
")",
"!=",
"TM",
".",
"getNullPointerValue",
"(",
"AddrSpace",
")",
";",
"}",
"default",
":",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"know",
"that",
"underlying",
"value",
"is",
"nonnull",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::G_FRAME_INDEX",
"AMDGPU::G_GLOBAL_VALUE",
"AMDGPU::G_BLOCK_ADDR",
"AMDGPU::G_CONSTANT",
"1"
] | AMDGPULegalizerInfo25 | isKnownNonNull | AMDGPU | GPU | LLVM | 17,197 | 105 | 1 | [] |
[
"<s>",
"bool",
"ARMCallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"&",
"F",
",",
"ArrayRef",
"<",
"unsigned",
">",
"VRegs",
")",
"const",
"{",
"if",
"(",
"F",
".",
"arg_empty",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"F",
".",
"isVarArg",
"(",
")",
")",
"return",
"false",
";",
"auto",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"auto",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"auto",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"ARMTargetLowering",
">",
"(",
")",
";",
"auto",
"Subtarget",
"=",
"TLI",
".",
"getSubtarget",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
"->",
"useSoftFloat",
"(",
")",
"||",
"!",
"Subtarget",
"->",
"hasVFP2",
"(",
")",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"if",
"(",
"!",
"isSupportedType",
"(",
"DL",
",",
"TLI",
",",
"Arg",
".",
"getType",
"(",
")",
")",
")",
"return",
"false",
";",
"CCAssignFn",
"*",
"AssignFn",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"F",
".",
"getCallingConv",
"(",
")",
",",
"F",
".",
"isVarArg",
"(",
")",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"8",
">",
"ArgInfos",
";",
"unsigned",
"Idx",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"{",
"ArgInfo",
"AInfo",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"Arg",
".",
"getType",
"(",
")",
")",
";",
"setArgFlags",
"(",
"AInfo",
",",
"Idx",
"+",
"1",
",",
"DL",
",",
"F",
")",
";",
"splitToValueTypes",
"(",
"AInfo",
",",
"ArgInfos",
",",
"DL",
",",
"MF",
".",
"getRegInfo",
"(",
")",
")",
";",
"Idx",
"++",
";",
"}",
"FormalArgHandler",
"ArgHandler",
"(",
"MIRBuilder",
",",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getRegInfo",
"(",
")",
",",
"AssignFn",
")",
";",
"return",
"handleAssignments",
"(",
"MIRBuilder",
",",
"ArgInfos",
",",
"ArgHandler",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"ARM",
"ARM",
"ARM",
"8",
"0",
"1"
] | ARMCallLowering38 | lowerFormalArguments | ARM | CPU | LLVM | 17,198 | 267 | 1 | [] |
[
"<s>",
"unsigned",
"PPCTTIImpl",
"::",
"getCacheLineSize",
"(",
")",
"const",
"{",
"if",
"(",
"CacheLineSize",
".",
"getNumOccurrences",
"(",
")",
">",
"0",
")",
"return",
"CacheLineSize",
";",
"unsigned",
"Directive",
"=",
"ST",
"->",
"getDarwinDirective",
"(",
")",
";",
"if",
"(",
"Directive",
"==",
"PPC",
"::",
"DIR_PWR7",
"||",
"Directive",
"==",
"PPC",
"::",
"DIR_PWR8",
"||",
"Directive",
"==",
"PPC",
"::",
"DIR_PWR9",
")",
"return",
"128",
";",
"return",
"64",
";",
"}",
"</s>"
] | [
"Return",
"the",
"target",
"cache",
"line",
"size",
"in",
"bytes",
"."
] | [
"PowerPC",
"PPC",
"0",
"PPC::DIR_PWR7",
"PPC::DIR_PWR8",
"PPC::DIR_PWR9",
"128",
"64"
] | PPCTargetTransformInfo41 | getCacheLineSize | PowerPC | CPU | LLVM | 17,199 | 57 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.