ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"bool",
"DeadCodeElimination",
"::",
"isDead",
"(",
"unsigned",
"R",
")",
"const",
"{",
"for",
"(",
"auto",
"I",
"=",
"MRI",
".",
"use_begin",
"(",
"R",
")",
",",
"E",
"=",
"MRI",
".",
"use_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"MachineInstr",
"*",
"UseI",
"=",
"I",
"->",
"getParent",
"(",
")",
";",
"if",
"(",
"UseI",
"->",
"isDebugValue",
"(",
")",
")",
"continue",
";",
"if",
"(",
"UseI",
"->",
"isPHI",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"UseI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getSubReg",
"(",
")",
")",
";",
"unsigned",
"DR",
"=",
"UseI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"DR",
"==",
"R",
")",
"continue",
";",
"}",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"isDead",
"-",
"Returns",
"true",
"if",
"this",
"is",
"a",
"dead",
"def",
"kill",
"slot",
"."
] | [
"Hexagon",
"0",
"0"
] | HexagonBitSimplify (2) | isDead | Hexagon | DSP | LLVM | 23,600 | 113 | 1 | [] |
[
"<s>",
"static",
"void",
"maybe_clobber_cond",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"clock_var",
")",
"{",
"int",
"n",
",",
"idx",
";",
"idx",
"=",
"ss",
".",
"jump_cycle_index",
";",
"for",
"(",
"n",
"=",
"0",
";",
"n",
"<",
"12",
";",
"n",
"++",
",",
"idx",
"++",
")",
"{",
"rtx",
"cond",
",",
"link",
";",
"int",
"cycle",
";",
"if",
"(",
"idx",
">=",
"12",
")",
"idx",
"-=",
"12",
";",
"cycle",
"=",
"ss",
".",
"jump_cycles",
"[",
"idx",
"]",
";",
"if",
"(",
"cycle",
"<=",
"clock_var",
")",
"return",
";",
"cond",
"=",
"ss",
".",
"jump_cond",
"[",
"idx",
"]",
";",
"if",
"(",
"cond",
"==",
"NULL_RTX",
")",
"continue",
";",
"if",
"(",
"CALL_P",
"(",
"insn",
")",
")",
"{",
"ss",
".",
"jump_cond",
"[",
"idx",
"]",
"=",
"NULL_RTX",
";",
"continue",
";",
"}",
"note_stores",
"(",
"insn",
",",
"clobber_cond_1",
",",
"ss",
".",
"jump_cond",
"+",
"idx",
")",
";",
"for",
"(",
"link",
"=",
"REG_NOTES",
"(",
"insn",
")",
";",
"link",
";",
"link",
"=",
"XEXP",
"(",
"link",
",",
"1",
")",
")",
"if",
"(",
"REG_NOTE_KIND",
"(",
"link",
")",
"==",
"REG_INC",
")",
"clobber_cond_1",
"(",
"XEXP",
"(",
"link",
",",
"0",
")",
",",
"NULL_RTX",
",",
"ss",
".",
"jump_cond",
"+",
"idx",
")",
";",
"}",
"}",
"</s>"
] | [
"Examine",
"INSN",
",",
"and",
"if",
"it",
"destroys",
"the",
"conditions",
"have",
"recorded",
"for",
"any",
"of",
"the",
"jumps",
"in",
"flight",
",",
"clear",
"that",
"condition",
"so",
"that",
"we",
"do",
"n't",
"predicate",
"any",
"more",
"insns",
".",
"CLOCK_VAR",
"helps",
"us",
"limit",
"the",
"search",
"to",
"only",
"those",
"jumps",
"which",
"are",
"still",
"in",
"flight",
"."
] | [
"c6x",
"0",
"12",
"12",
"12",
"1",
"0"
] | c6x | maybe_clobber_cond | c6x | VLIW | GCC | 23,601 | 174 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_init_sched_context",
"(",
"void",
"*",
"_sc",
",",
"bool",
"clean_p",
")",
"{",
"rs6000_sched_context_t",
"sc",
"=",
"(",
"rs6000_sched_context_t",
")",
"_sc",
";",
"if",
"(",
"clean_p",
")",
"{",
"sc",
"->",
"cached_can_issue_more",
"=",
"0",
";",
"sc",
"->",
"last_scheduled_insn",
"=",
"NULL_RTX",
";",
"sc",
"->",
"load_store_pendulum",
"=",
"0",
";",
"}",
"else",
"{",
"sc",
"->",
"cached_can_issue_more",
"=",
"cached_can_issue_more",
";",
"sc",
"->",
"last_scheduled_insn",
"=",
"last_scheduled_insn",
";",
"sc",
"->",
"load_store_pendulum",
"=",
"load_store_pendulum",
";",
"}",
"}",
"</s>"
] | [
"If",
"CLEAN_P",
"is",
"true",
"then",
"initializes",
"_SC",
"with",
"clean",
"data",
",",
"and",
"from",
"the",
"global",
"context",
"otherwise",
"."
] | [
"rs6000",
"0",
"0"
] | rs60004 | rs6000_init_sched_context | rs6000 | CPU | GCC | 23,602 | 66 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"WebAssembly Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"WebAssembly",
"\"WebAssembly Instruction Selection\""
] | WebAssemblyISelDAGToDAG (2)1 | getPassName | WebAssembly | Virtual ISA | LLVM | 23,603 | 11 | 1 | [] |
[
"<s>",
"SDValue",
"MipsSETargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"SDValue",
"Val",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"AND",
":",
"Val",
"=",
"performANDCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"OR",
":",
"Val",
"=",
"performORCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"performMULCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"this",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"Val",
"=",
"performSHLCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SRA",
":",
"return",
"performSRACombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SRL",
":",
"return",
"performSRLCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"VSELECT",
":",
"return",
"performVSELECTCombine",
"(",
"N",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"XOR",
":",
"Val",
"=",
"performXORCombine",
"(",
"N",
",",
"DAG",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SETCC",
":",
"Val",
"=",
"performSETCCCombine",
"(",
"N",
",",
"DAG",
")",
";",
"break",
";",
"}",
"if",
"(",
"Val",
".",
"getNode",
"(",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"\\nMipsSE DAG Combine:\\n\"",
";",
"N",
"->",
"printrWithDepth",
"(",
"dbgs",
"(",
")",
",",
"&",
"DAG",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"\\n=> \\n\"",
";",
"Val",
".",
"getNode",
"(",
")",
"->",
"printrWithDepth",
"(",
"dbgs",
"(",
")",
",",
"&",
"DAG",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"return",
"Val",
";",
"}",
"return",
"MipsTargetLowering",
"::",
"PerformDAGCombine",
"(",
"N",
",",
"DCI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"Mips",
"Mips",
"ISD::AND",
"ISD::OR",
"ISD::MUL",
"ISD::SHL",
"ISD::SRA",
"ISD::SRL",
"ISD::VSELECT",
"ISD::XOR",
"ISD::SETCC",
"\"\\nMipsSE DAG Combine:\\n\"",
"\"\\n=> \\n\"",
"\"\\n\"",
"Mips"
] | MipsSEISelLowering15 | PerformDAGCombine | Mips | CPU | LLVM | 23,604 | 269 | 1 | [] |
[
"<s>",
"const",
"AVRSubtarget",
"*",
"AVRTargetMachine",
"::",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
")",
"const",
"{",
"return",
"&",
"SubTarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"AVR",
"AVR",
"AVR"
] | AVRTargetMachine | getSubtargetImpl | AVR | MPU | LLVM | 23,605 | 18 | 1 | [] |
[
"<s>",
"bool",
"ARMSubtarget",
"::",
"enableMachinePipeliner",
"(",
")",
"const",
"{",
"return",
"getSchedModel",
"(",
")",
".",
"hasInstrSchedModel",
"(",
")",
"&&",
"useMachinePipeliner",
"(",
")",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"subtarget",
"should",
"run",
"MachinePipeliner",
"."
] | [
"ARM",
"ARM"
] | ARMSubtarget45 | enableMachinePipeliner | ARM | CPU | LLVM | 23,606 | 22 | 1 | [] |
[
"<s>",
"bool",
"XCoreFrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"XCore",
"XCore"
] | XCoreFrameLowering12 | hasFP | XCore | MPU | LLVM | 23,607 | 37 | 1 | [] |
[
"<s>",
"bool",
"PPCRegisterInfo",
"::",
"trackLivenessAfterRegAlloc",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"requiresRegisterScavenging",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"live-ins",
"should",
"be",
"tracked",
"after",
"register",
"allocation",
"."
] | [
"PowerPC",
"PPC"
] | PPCRegisterInfo14 | trackLivenessAfterRegAlloc | PowerPC | CPU | LLVM | 23,608 | 19 | 1 | [] |
[
"<s>",
"void",
"SITargetLowering",
"::",
"finalizeLowering",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"Info",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"SISubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"SISubtarget",
">",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"Info",
"->",
"isEntryFunction",
"(",
")",
")",
"{",
"reservePrivateMemoryRegs",
"(",
"getTargetMachine",
"(",
")",
",",
"MF",
",",
"*",
"TRI",
",",
"*",
"Info",
")",
";",
"}",
"bool",
"NeedSP",
"=",
"!",
"Info",
"->",
"isEntryFunction",
"(",
")",
"||",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
".",
"hasCalls",
"(",
")",
";",
"if",
"(",
"NeedSP",
")",
"{",
"unsigned",
"ReservedStackPtrOffsetReg",
"=",
"TRI",
"->",
"reservedStackPtrOffsetReg",
"(",
"MF",
")",
";",
"Info",
"->",
"setStackPtrOffsetReg",
"(",
"ReservedStackPtrOffsetReg",
")",
";",
"assert",
"(",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
"!=",
"Info",
"->",
"getFrameOffsetReg",
"(",
")",
")",
";",
"assert",
"(",
"!",
"TRI",
"->",
"isSubRegister",
"(",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
")",
";",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"SP_REG",
",",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
";",
"}",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"PRIVATE_RSRC_REG",
",",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
")",
";",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"FP_REG",
",",
"Info",
"->",
"getFrameOffsetReg",
"(",
")",
")",
";",
"MRI",
".",
"replaceRegWith",
"(",
"AMDGPU",
"::",
"SCRATCH_WAVE_OFFSET_REG",
",",
"Info",
"->",
"getScratchWaveOffsetReg",
"(",
")",
")",
";",
"TargetLoweringBase",
"::",
"finalizeLowering",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Execute",
"target",
"specific",
"actions",
"to",
"finalize",
"target",
"lowering",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"AMDGPU::SP_REG",
"AMDGPU::PRIVATE_RSRC_REG",
"AMDGPU::FP_REG",
"AMDGPU::SCRATCH_WAVE_OFFSET_REG"
] | SIISelLowering115 | finalizeLowering | AMDGPU | GPU | LLVM | 23,609 | 244 | 1 | [] |
[
"<s>",
"static",
"bool",
"avr_use_by_pieces_infrastructure_p",
"(",
"unsigned",
"HOST_WIDE_INT",
"size",
",",
"unsigned",
"int",
"align",
"ATTRIBUTE_UNUSED",
",",
"enum",
"by_pieces_operation",
"op",
",",
"bool",
"speed_p",
")",
"{",
"if",
"(",
"op",
"!=",
"MOVE_BY_PIECES",
"||",
"(",
"speed_p",
"&&",
"(",
"size",
">",
"(",
"MOVE_MAX_PIECES",
")",
")",
")",
")",
"return",
"default_use_by_pieces_infrastructure_p",
"(",
"size",
",",
"align",
",",
"op",
",",
"speed_p",
")",
";",
"return",
"size",
"<=",
"(",
"MOVE_MAX_PIECES",
")",
";",
"}",
"</s>"
] | [
"Prefer",
"sequence",
"of",
"loads/stores",
"for",
"moves",
"of",
"size",
"upto",
"two",
"-",
"two",
"pairs",
"of",
"load/store",
"instructions",
"are",
"always",
"better",
"than",
"the",
"5",
"instruction",
"sequence",
"for",
"a",
"loop",
"(",
"1",
"instruction",
"for",
"loop",
"counter",
"setup",
",",
"and",
"4",
"for",
"the",
"body",
"of",
"the",
"loop",
")",
"."
] | [
"avr"
] | avr5 | avr_use_by_pieces_infrastructure_p | avr | MPU | GCC | 23,610 | 59 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"reMaterialize",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SubIdx",
",",
"const",
"MachineInstr",
"*",
"Orig",
",",
"const",
"TargetRegisterInfo",
"&",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"Orig",
"->",
"getDebugLoc",
"(",
")",
";",
"bool",
"Clone",
"=",
"true",
";",
"unsigned",
"Opc",
"=",
"Orig",
"->",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"break",
";",
"case",
"X86",
"::",
"MOV8r0",
":",
"case",
"X86",
"::",
"MOV16r0",
":",
"case",
"X86",
"::",
"MOV32r0",
":",
"case",
"X86",
"::",
"MOV64r0",
":",
"{",
"if",
"(",
"!",
"isSafeToClobberEFLAGS",
"(",
"MBB",
",",
"I",
")",
")",
"{",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unreachable!\"",
")",
";",
"case",
"X86",
"::",
"MOV8r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV8ri",
";",
"break",
";",
"case",
"X86",
"::",
"MOV16r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV16ri",
";",
"break",
";",
"case",
"X86",
"::",
"MOV32r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV32ri",
";",
"break",
";",
"case",
"X86",
"::",
"MOV64r0",
":",
"Opc",
"=",
"X86",
"::",
"MOV64ri64i32",
";",
"break",
";",
"}",
"Clone",
"=",
"false",
";",
"}",
"break",
";",
"}",
"}",
"if",
"(",
"Clone",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"CloneMachineInstr",
"(",
"Orig",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"MI",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
".",
"addOperand",
"(",
"Orig",
"->",
"getOperand",
"(",
"0",
")",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"MachineInstr",
"*",
"NewMI",
"=",
"prior",
"(",
"I",
")",
";",
"NewMI",
"->",
"substituteRegister",
"(",
"Orig",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
",",
"DestReg",
",",
"SubIdx",
",",
"TRI",
")",
";",
"}",
"</s>"
] | [
"Re-issue",
"the",
"specified",
"'original",
"'",
"instruction",
"at",
"the",
"specific",
"location",
"targeting",
"a",
"new",
"destination",
"register",
"."
] | [
"X86",
"X86",
"X86::MOV8r0",
"X86::MOV16r0",
"X86::MOV32r0",
"X86::MOV64r0",
"\"Unreachable!\"",
"X86::MOV8r0",
"X86::MOV8ri",
"X86::MOV16r0",
"X86::MOV16ri",
"X86::MOV32r0",
"X86::MOV32ri",
"X86::MOV64r0",
"X86::MOV64ri64i32",
"0",
"0",
"0"
] | X86InstrInfo116 | reMaterialize | X86 | CPU | LLVM | 23,611 | 264 | 1 | [] |
[
"<s>",
"static",
"void",
"m68hc11_asm_out_constructor",
"(",
"rtx",
"symbol",
",",
"int",
"priority",
")",
"{",
"default_ctor_section_asm_out_constructor",
"(",
"symbol",
",",
"priority",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.globl\\t__do_global_ctors\\n\"",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_ASM_CONSTRUCTOR",
"."
] | [
"m68hc11",
"\"\\t.globl\\t__do_global_ctors\\n\""
] | m68hc111 | m68hc11_asm_out_constructor | m68hc11 | MPU | GCC | 23,612 | 26 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"shouldExpandAtomicStoreInIR",
"(",
"StoreInst",
"*",
"SI",
")",
"const",
"{",
"return",
"needsCmpXchgNb",
"(",
"SI",
"->",
"getValueOperand",
"(",
")",
"->",
"getType",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"given",
"(",
"atomic",
")",
"store",
"should",
"be",
"expanded",
"by",
"the",
"IR-level",
"AtomicExpand",
"pass",
"into",
"."
] | [
"X86",
"X86"
] | X86ISelLowering (2)3 | shouldExpandAtomicStoreInIR | X86 | CPU | LLVM | 23,613 | 26 | 1 | [] |
[
"<s>",
"static",
"void",
"add_sched_insns_for_speculation",
"(",
"void",
")",
"{",
"rtx_insn",
"*",
"insn",
";",
"if",
"(",
"!",
"ENABLE_WA_SPECULATIVE_LOADS",
"&&",
"!",
"ENABLE_WA_SPECULATIVE_SYNCS",
"&&",
"!",
"ENABLE_WA_INDIRECT_CALLS",
")",
"return",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"rtx",
"pat",
";",
"if",
"(",
"NOTE_P",
"(",
"insn",
")",
"||",
"BARRIER_P",
"(",
"insn",
")",
"||",
"LABEL_P",
"(",
"insn",
")",
")",
"continue",
";",
"if",
"(",
"JUMP_TABLE_DATA_P",
"(",
"insn",
")",
")",
"continue",
";",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"USE",
"||",
"GET_CODE",
"(",
"pat",
")",
"==",
"CLOBBER",
"||",
"GET_CODE",
"(",
"pat",
")",
"==",
"ASM_INPUT",
"||",
"asm_noperands",
"(",
"pat",
")",
">=",
"0",
")",
"continue",
";",
"if",
"(",
"JUMP_P",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"any_condjump_p",
"(",
"insn",
")",
"&&",
"!",
"cbranch_predicted_taken_p",
"(",
"insn",
")",
")",
"{",
"rtx_insn",
"*",
"n",
"=",
"next_real_insn",
"(",
"insn",
")",
";",
"emit_insn_before",
"(",
"gen_stall",
"(",
"GEN_INT",
"(",
"3",
")",
")",
",",
"n",
")",
";",
"}",
"}",
"}",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"JUMP_P",
"(",
"insn",
")",
"&&",
"any_condjump_p",
"(",
"insn",
")",
"&&",
"(",
"cbranch_predicted_taken_p",
"(",
"insn",
")",
")",
")",
"{",
"rtx",
"target",
"=",
"JUMP_LABEL",
"(",
"insn",
")",
";",
"rtx_insn",
"*",
"next",
"=",
"next_real_insn",
"(",
"target",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"next",
")",
")",
"==",
"UNSPEC_VOLATILE",
"&&",
"get_attr_type",
"(",
"next",
")",
"==",
"TYPE_STALL",
")",
"continue",
";",
"emit_insn_before",
"(",
"gen_stall",
"(",
"GEN_INT",
"(",
"1",
")",
")",
",",
"next",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Called",
"just",
"before",
"the",
"final",
"scheduling",
"pass",
".",
"If",
"we",
"need",
"to",
"insert",
"NOPs",
"later",
"on",
"to",
"work",
"around",
"speculative",
"loads",
",",
"insert",
"special",
"placeholder",
"insns",
"that",
"cause",
"loads",
"to",
"be",
"delayed",
"for",
"as",
"many",
"cycles",
"as",
"necessary",
"(",
"and",
"possible",
")",
".",
"This",
"reduces",
"the",
"number",
"of",
"NOPs",
"we",
"need",
"to",
"add",
".",
"The",
"dummy",
"insns",
"we",
"generate",
"are",
"later",
"removed",
"by",
"bfin_gen_bundles",
"."
] | [
"bfin",
"0",
"3",
"1"
] | bfin4 | add_sched_insns_for_speculation | bfin | DSP | GCC | 23,614 | 251 | 1 | [] |
[
"<s>",
"Function",
"*",
"BlackfinIntrinsicInfo",
"::",
"getDeclaration",
"(",
"Module",
"*",
"M",
",",
"unsigned",
"IntrID",
",",
"const",
"Type",
"*",
"*",
"Tys",
",",
"unsigned",
"numTy",
")",
"const",
"{",
"assert",
"(",
"!",
"isOverloaded",
"(",
"IntrID",
")",
"&&",
"\"Blackfin intrinsics are not overloaded\"",
")",
";",
"AttrListPtr",
"AList",
"=",
"getAttributes",
"(",
"(",
"bfinIntrinsic",
"::",
"ID",
")",
"IntrID",
")",
";",
"return",
"cast",
"<",
"Function",
">",
"(",
"M",
"->",
"getOrInsertFunction",
"(",
"getName",
"(",
"IntrID",
")",
",",
"getType",
"(",
"M",
"->",
"getContext",
"(",
")",
",",
"IntrID",
")",
",",
"AList",
")",
")",
";",
"}",
"</s>"
] | [
"Create",
"or",
"insert",
"an",
"LLVM",
"Function",
"declaration",
"for",
"an",
"intrinsic",
",",
"and",
"return",
"it",
"."
] | [
"Blackfin",
"\"Blackfin intrinsics are not overloaded\"",
"bfinIntrinsic::ID"
] | BlackfinIntrinsicInfo | getDeclaration | Blackfin | DSP | LLVM | 23,615 | 79 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonTTIImpl",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"TTI",
"::",
"TargetCostKind",
"CostKind",
",",
"TTI",
"::",
"OperandValueKind",
"Opd1Info",
",",
"TTI",
"::",
"OperandValueKind",
"Opd2Info",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd1PropInfo",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd2PropInfo",
",",
"ArrayRef",
"<",
"const",
"Value",
"*",
">",
"Args",
",",
"const",
"Instruction",
"*",
"CxtI",
")",
"{",
"if",
"(",
"CostKind",
"!=",
"TTI",
"::",
"TCK_RecipThroughput",
")",
"return",
"BaseT",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"CostKind",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
",",
"Args",
",",
"CxtI",
")",
";",
"if",
"(",
"Ty",
"->",
"isVectorTy",
"(",
")",
")",
"{",
"std",
"::",
"pair",
"<",
"int",
",",
"MVT",
">",
"LT",
"=",
"TLI",
".",
"getTypeLegalizationCost",
"(",
"DL",
",",
"Ty",
")",
";",
"if",
"(",
"LT",
".",
"second",
".",
"isFloatingPoint",
"(",
")",
")",
"return",
"LT",
".",
"first",
"+",
"FloatFactor",
"*",
"getTypeNumElements",
"(",
"Ty",
")",
";",
"}",
"return",
"BaseT",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"CostKind",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
",",
"Args",
",",
"CxtI",
")",
";",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo | getArithmeticInstrCost | Hexagon | DSP | LLVM | 23,616 | 159 | 1 | [] |
[
"<s>",
"void",
"aarch64_expand_sve_vcond",
"(",
"machine_mode",
"data_mode",
",",
"machine_mode",
"cmp_mode",
",",
"rtx",
"*",
"ops",
")",
"{",
"machine_mode",
"pred_mode",
"=",
"aarch64_get_mask_mode",
"(",
"GET_MODE_NUNITS",
"(",
"cmp_mode",
")",
",",
"GET_MODE_SIZE",
"(",
"cmp_mode",
")",
")",
".",
"require",
"(",
")",
";",
"rtx",
"pred",
"=",
"gen_reg_rtx",
"(",
"pred_mode",
")",
";",
"if",
"(",
"FLOAT_MODE_P",
"(",
"cmp_mode",
")",
")",
"{",
"if",
"(",
"aarch64_expand_sve_vec_cmp_float",
"(",
"pred",
",",
"GET_CODE",
"(",
"ops",
"[",
"3",
"]",
")",
",",
"ops",
"[",
"4",
"]",
",",
"ops",
"[",
"5",
"]",
",",
"true",
")",
")",
"std",
"::",
"swap",
"(",
"ops",
"[",
"1",
"]",
",",
"ops",
"[",
"2",
"]",
")",
";",
"}",
"else",
"aarch64_expand_sve_vec_cmp_int",
"(",
"pred",
",",
"GET_CODE",
"(",
"ops",
"[",
"3",
"]",
")",
",",
"ops",
"[",
"4",
"]",
",",
"ops",
"[",
"5",
"]",
")",
";",
"rtvec",
"vec",
"=",
"gen_rtvec",
"(",
"3",
",",
"pred",
",",
"ops",
"[",
"1",
"]",
",",
"ops",
"[",
"2",
"]",
")",
";",
"emit_set_insn",
"(",
"ops",
"[",
"0",
"]",
",",
"gen_rtx_UNSPEC",
"(",
"data_mode",
",",
"vec",
",",
"UNSPEC_SEL",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"SVE",
"vcond",
"pattern",
"with",
"operands",
"OPS",
".",
"DATA_MODE",
"is",
"the",
"mode",
"of",
"the",
"data",
"being",
"selected",
"and",
"CMP_MODE",
"is",
"the",
"mode",
"of",
"the",
"values",
"being",
"compared",
"."
] | [
"aarch64",
"3",
"4",
"5",
"1",
"2",
"3",
"4",
"5",
"3",
"1",
"2",
"0"
] | aarch645 | aarch64_expand_sve_vcond | aarch64 | CPU | GCC | 23,617 | 155 | 1 | [] |
[
"<s>",
"rtx_code",
"m68k_output_compare_qi",
"(",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"rtx_code",
"code",
")",
"{",
"rtx_code",
"tmp",
"=",
"m68k_find_flags_value",
"(",
"op0",
",",
"op1",
",",
"code",
")",
";",
"if",
"(",
"tmp",
"!=",
"UNKNOWN",
")",
"return",
"tmp",
";",
"remember_compare_flags",
"(",
"op0",
",",
"op1",
")",
";",
"rtx",
"ops",
"[",
"2",
"]",
";",
"ops",
"[",
"0",
"]",
"=",
"op0",
";",
"ops",
"[",
"1",
"]",
"=",
"op1",
";",
"if",
"(",
"op1",
"==",
"const0_rtx",
")",
"output_asm_insn",
"(",
"\"tst%.b %d0\"",
",",
"ops",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"op0",
")",
"==",
"MEM",
"&&",
"GET_CODE",
"(",
"op1",
")",
"==",
"MEM",
")",
"output_asm_insn",
"(",
"\"cmpm%.b %1,%0\"",
",",
"ops",
")",
";",
"else",
"if",
"(",
"REG_P",
"(",
"op1",
")",
"||",
"(",
"!",
"REG_P",
"(",
"op0",
")",
"&&",
"GET_CODE",
"(",
"op0",
")",
"!=",
"MEM",
")",
")",
"{",
"output_asm_insn",
"(",
"\"cmp%.b %d0,%d1\"",
",",
"ops",
")",
";",
"std",
"::",
"swap",
"(",
"flags_compare_op0",
",",
"flags_compare_op1",
")",
";",
"return",
"swap_condition",
"(",
"code",
")",
";",
"}",
"else",
"output_asm_insn",
"(",
"\"cmp%.b %d1,%d0\"",
",",
"ops",
")",
";",
"return",
"code",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"comparison",
"between",
"OP0",
"and",
"OP1",
".",
"CODE",
"is",
"the",
"code",
"of",
"the",
"comparison",
".",
"It",
"is",
"returned",
",",
"potentially",
"modified",
"if",
"necessary",
"."
] | [
"m68k",
"2",
"0",
"1",
"\"tst%.b %d0\"",
"\"cmpm%.b %1,%0\"",
"\"cmp%.b %d0,%d1\"",
"\"cmp%.b %d1,%d0\""
] | m68k | m68k_output_compare_qi | m68k | MPU | GCC | 23,618 | 157 | 1 | [] |
[
"<s>",
"static",
"bool",
"fr30_must_pass_in_stack",
"(",
"enum",
"machine_mode",
"mode",
",",
"tree",
"type",
")",
"{",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"return",
"true",
";",
"if",
"(",
"type",
"==",
"NULL",
")",
"return",
"false",
";",
"return",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"should",
"pass",
"an",
"argument",
"on",
"the",
"stack",
"rather",
"than",
"in",
"registers",
"."
] | [
"fr30"
] | fr303 | fr30_must_pass_in_stack | fr30 | DSP | GCC | 23,619 | 37 | 1 | [] |
[
"<s>",
"void",
"s390_expand_vec_compare",
"(",
"rtx",
"target",
",",
"enum",
"rtx_code",
"cond",
",",
"rtx",
"cmp_op1",
",",
"rtx",
"cmp_op2",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"target",
")",
";",
"bool",
"neg_p",
"=",
"false",
",",
"swap_p",
"=",
"false",
";",
"rtx",
"tmp",
";",
"if",
"(",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"cmp_op1",
")",
")",
"==",
"MODE_VECTOR_FLOAT",
")",
"{",
"switch",
"(",
"cond",
")",
"{",
"case",
"NE",
":",
"cond",
"=",
"EQ",
";",
"neg_p",
"=",
"true",
";",
"break",
";",
"case",
"UNGT",
":",
"cond",
"=",
"GE",
";",
"neg_p",
"=",
"true",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"case",
"UNGE",
":",
"cond",
"=",
"GT",
";",
"neg_p",
"=",
"true",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"case",
"LE",
":",
"cond",
"=",
"GE",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"case",
"UNLE",
":",
"cond",
"=",
"GT",
";",
"neg_p",
"=",
"true",
";",
"break",
";",
"case",
"LT",
":",
"cond",
"=",
"GT",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"case",
"UNLT",
":",
"cond",
"=",
"GE",
";",
"neg_p",
"=",
"true",
";",
"break",
";",
"case",
"UNEQ",
":",
"emit_insn",
"(",
"gen_vec_cmpuneq",
"(",
"target",
",",
"cmp_op1",
",",
"cmp_op2",
")",
")",
";",
"return",
";",
"case",
"LTGT",
":",
"emit_insn",
"(",
"gen_vec_cmpltgt",
"(",
"target",
",",
"cmp_op1",
",",
"cmp_op2",
")",
")",
";",
"return",
";",
"case",
"ORDERED",
":",
"emit_insn",
"(",
"gen_vec_ordered",
"(",
"target",
",",
"cmp_op1",
",",
"cmp_op2",
")",
")",
";",
"return",
";",
"case",
"UNORDERED",
":",
"emit_insn",
"(",
"gen_vec_unordered",
"(",
"target",
",",
"cmp_op1",
",",
"cmp_op2",
")",
")",
";",
"return",
";",
"default",
":",
"break",
";",
"}",
"}",
"else",
"{",
"switch",
"(",
"cond",
")",
"{",
"case",
"NE",
":",
"cond",
"=",
"EQ",
";",
"neg_p",
"=",
"true",
";",
"break",
";",
"case",
"GE",
":",
"cond",
"=",
"GT",
";",
"neg_p",
"=",
"true",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"case",
"GEU",
":",
"cond",
"=",
"GTU",
";",
"neg_p",
"=",
"true",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"case",
"LE",
":",
"cond",
"=",
"GT",
";",
"neg_p",
"=",
"true",
";",
"break",
";",
"case",
"LEU",
":",
"cond",
"=",
"GTU",
";",
"neg_p",
"=",
"true",
";",
"break",
";",
"case",
"LT",
":",
"cond",
"=",
"GT",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"case",
"LTU",
":",
"cond",
"=",
"GTU",
";",
"swap_p",
"=",
"true",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"if",
"(",
"swap_p",
")",
"{",
"tmp",
"=",
"cmp_op1",
";",
"cmp_op1",
"=",
"cmp_op2",
";",
"cmp_op2",
"=",
"tmp",
";",
"}",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"gen_rtx_fmt_ee",
"(",
"cond",
",",
"mode",
",",
"cmp_op1",
",",
"cmp_op2",
")",
")",
")",
";",
"if",
"(",
"neg_p",
")",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"gen_rtx_NOT",
"(",
"mode",
",",
"target",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Generate",
"a",
"vector",
"comparison",
"COND",
"of",
"CMP_OP1",
"and",
"CMP_OP2",
"and",
"store",
"the",
"result",
"in",
"TARGET",
"."
] | [
"s390"
] | s3907 | s390_expand_vec_compare | s390 | MPU | GCC | 23,620 | 397 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"get_label_padding",
"(",
"rtx",
"label",
")",
"{",
"HOST_WIDE_INT",
"align",
",",
"min_insn_size",
";",
"align",
"=",
"1",
"<<",
"label_to_alignment",
"(",
"label",
")",
".",
"levels",
"[",
"0",
"]",
".",
"log",
";",
"min_insn_size",
"=",
"TARGET_THUMB",
"?",
"2",
":",
"4",
";",
"return",
"align",
">",
"min_insn_size",
"?",
"align",
"-",
"min_insn_size",
":",
"0",
";",
"}",
"</s>"
] | [
"Return",
"the",
"maximum",
"amount",
"of",
"padding",
"that",
"will",
"be",
"inserted",
"before",
"label",
"LABEL",
"."
] | [
"arm",
"1",
"0",
"2",
"4",
"0"
] | arm | get_label_padding | arm | CPU | GCC | 23,621 | 49 | 1 | [] |
[
"<s>",
"static",
"inline",
"HOST_WIDE_INT",
"htm_spr_regno",
"(",
"enum",
"rs6000_builtins",
"code",
")",
"{",
"if",
"(",
"code",
"==",
"HTM_BUILTIN_GET_TFHAR",
"||",
"code",
"==",
"HTM_BUILTIN_SET_TFHAR",
")",
"return",
"TFHAR_REGNO",
";",
"else",
"if",
"(",
"code",
"==",
"HTM_BUILTIN_GET_TFIAR",
"||",
"code",
"==",
"HTM_BUILTIN_SET_TFIAR",
")",
"return",
"TFIAR_REGNO",
";",
"gcc_assert",
"(",
"code",
"==",
"HTM_BUILTIN_GET_TEXASR",
"||",
"code",
"==",
"HTM_BUILTIN_SET_TEXASR",
"||",
"code",
"==",
"HTM_BUILTIN_GET_TEXASRU",
"||",
"code",
"==",
"HTM_BUILTIN_SET_TEXASRU",
")",
";",
"return",
"TEXASR_REGNO",
";",
"}",
"</s>"
] | [
"Return",
"the",
"appropriate",
"SPR",
"regno",
"associated",
"with",
"the",
"given",
"builtin",
"."
] | [
"rs6000"
] | rs60004 | htm_spr_regno | rs6000 | CPU | GCC | 23,622 | 60 | 1 | [] |
[
"<s>",
"void",
"VEFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"assert",
"(",
"&",
"MF",
".",
"front",
"(",
")",
"==",
"&",
"MBB",
"&&",
"\"Shrink-wrapping not yet supported\"",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"VEInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"VERegisterInfo",
"&",
"RegInfo",
"=",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"dl",
";",
"bool",
"NeedsStackRealignment",
"=",
"RegInfo",
".",
"needsStackRealignment",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"NeedsStackRealignment",
"&&",
"MFI",
".",
"getMaxAlign",
"(",
")",
">",
"getStackAlign",
"(",
")",
")",
"report_fatal_error",
"(",
"\"Function \\\"\"",
"+",
"Twine",
"(",
"MF",
".",
"getName",
"(",
")",
")",
"+",
"\"\\\" required \"",
"\"stack re-alignment, but LLVM couldn't handle it \"",
"\"(probably because it has a dynamic alloca).\"",
")",
";",
"uint64_t",
"NumBytes",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"NumBytes",
"=",
"STI",
".",
"getAdjustedFrameSize",
"(",
"NumBytes",
")",
";",
"NumBytes",
"=",
"alignTo",
"(",
"NumBytes",
",",
"MFI",
".",
"getMaxAlign",
"(",
")",
")",
";",
"MFI",
".",
"setStackSize",
"(",
"NumBytes",
")",
";",
"emitPrologueInsns",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"NumBytes",
",",
"true",
")",
";",
"MaybeAlign",
"RuntimeAlign",
"=",
"NeedsStackRealignment",
"?",
"MaybeAlign",
"(",
"MFI",
".",
"getMaxAlign",
"(",
")",
")",
":",
"None",
";",
"emitSPAdjustment",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"-",
"(",
"int64_t",
")",
"NumBytes",
",",
"RuntimeAlign",
")",
";",
"if",
"(",
"hasBP",
"(",
"MF",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"VE",
"::",
"ORri",
")",
",",
"VE",
"::",
"SX17",
")",
".",
"addReg",
"(",
"VE",
"::",
"SX11",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"emitSPExtend",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
")",
";",
"Register",
"RegFP",
"=",
"RegInfo",
".",
"getDwarfRegNum",
"(",
"VE",
"::",
"SX9",
",",
"true",
")",
";",
"unsigned",
"CFIIndex",
"=",
"MF",
".",
"addFrameInst",
"(",
"MCCFIInstruction",
"::",
"createDefCfaRegister",
"(",
"nullptr",
",",
"RegFP",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"CFI_INSTRUCTION",
")",
")",
".",
"addCFIIndex",
"(",
"CFIIndex",
")",
";",
"CFIIndex",
"=",
"MF",
".",
"addFrameInst",
"(",
"MCCFIInstruction",
"::",
"createWindowSave",
"(",
"nullptr",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"CFI_INSTRUCTION",
")",
")",
".",
"addCFIIndex",
"(",
"CFIIndex",
")",
";",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"VE",
"VE",
"\"Shrink-wrapping not yet supported\"",
"VE",
"VE",
"\"Function \\\"\"",
"\"\\\" required \"",
"\"stack re-alignment, but LLVM couldn't handle it \"",
"\"(probably because it has a dynamic alloca).\"",
"VE::ORri",
"VE::SX17",
"VE::SX11",
"0",
"VE::SX9"
] | VEFrameLowering | emitPrologue | VE | CPU | LLVM | 23,623 | 349 | 1 | [] |
[
"<s>",
"static",
"bool",
"mem_locations_overlap",
"(",
"rtx",
"mem1",
",",
"rtx",
"mem2",
")",
"{",
"rtx",
"reg1",
",",
"reg2",
";",
"HOST_WIDE_INT",
"off1",
",",
"size1",
",",
"off2",
",",
"size2",
";",
"if",
"(",
"get_memref_parts",
"(",
"mem1",
",",
"&",
"reg1",
",",
"&",
"off1",
",",
"&",
"size1",
")",
"&&",
"get_memref_parts",
"(",
"mem2",
",",
"&",
"reg2",
",",
"&",
"off2",
",",
"&",
"size2",
")",
")",
"return",
"(",
"(",
"REGNO",
"(",
"reg1",
")",
"==",
"REGNO",
"(",
"reg2",
")",
")",
"&&",
"(",
"(",
"(",
"off1",
"<=",
"off2",
")",
"&&",
"(",
"off1",
"+",
"size1",
">",
"off2",
")",
")",
"||",
"(",
"(",
"off2",
"<=",
"off1",
")",
"&&",
"(",
"off2",
"+",
"size2",
">",
"off1",
")",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"function",
"returns",
"true",
"if",
"it",
"can",
"be",
"determined",
"that",
"the",
"two",
"MEM",
"locations",
"overlap",
"by",
"at",
"least",
"1",
"byte",
"based",
"on",
"base",
"reg/offset/size",
"."
] | [
"powerpcspe"
] | powerpcspe | mem_locations_overlap | powerpcspe | CPU | GCC | 23,624 | 108 | 1 | [] |
[
"<s>",
"const",
"Comet2Subtarget",
"*",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
")",
"const",
"override",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"Comet2",
"Comet2"
] | Comet2TargetMachine | getSubtargetImpl | Comet2 | CPU | LLVM | 23,625 | 17 | 1 | [] |
[
"<s>",
"SUnit",
"*",
"PPCPostRASchedStrategy",
"::",
"pickNode",
"(",
"bool",
"&",
"IsTopNode",
")",
"{",
"return",
"PostGenericScheduler",
"::",
"pickNode",
"(",
"IsTopNode",
")",
";",
"}",
"</s>"
] | [
"Pick",
"the",
"next",
"node",
"to",
"schedule",
",",
"or",
"return",
"NULL",
"."
] | [
"PowerPC",
"PPC"
] | PPCMachineScheduler | pickNode | PowerPC | CPU | LLVM | 23,626 | 20 | 1 | [] |
[
"<s>",
"void",
"X86FrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"bool",
"reserveCallFrame",
"=",
"hasReservedCallFrame",
"(",
"MF",
")",
";",
"unsigned",
"Opcode",
"=",
"I",
"->",
"getOpcode",
"(",
")",
";",
"bool",
"isDestroy",
"=",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"uint64_t",
"Amount",
"=",
"!",
"reserveCallFrame",
"?",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
":",
"0",
";",
"uint64_t",
"InternalAmt",
"=",
"(",
"isDestroy",
"||",
"Amount",
")",
"?",
"I",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
":",
"0",
";",
"I",
"=",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"if",
"(",
"!",
"reserveCallFrame",
")",
"{",
"unsigned",
"StackAlign",
"=",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"RoundUpToAlignment",
"(",
"Amount",
",",
"StackAlign",
")",
";",
"bool",
"HasDwarfEHHandlers",
"=",
"!",
"MF",
".",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
"->",
"usesWindowsCFI",
"(",
")",
"&&",
"!",
"MF",
".",
"getMMI",
"(",
")",
".",
"getLandingPads",
"(",
")",
".",
"empty",
"(",
")",
";",
"if",
"(",
"HasDwarfEHHandlers",
"&&",
"!",
"isDestroy",
"&&",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
"->",
"getHasPushSequences",
"(",
")",
")",
"BuildCFI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"MCCFIInstruction",
"::",
"createGnuArgsSize",
"(",
"nullptr",
",",
"Amount",
")",
")",
";",
"if",
"(",
"Amount",
"==",
"0",
")",
"return",
";",
"Amount",
"-=",
"InternalAmt",
";",
"if",
"(",
"Amount",
")",
"{",
"int",
"Offset",
"=",
"isDestroy",
"?",
"Amount",
":",
"-",
"Amount",
";",
"if",
"(",
"!",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"optForMinSize",
"(",
")",
"&&",
"adjustStackWithPops",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"Offset",
")",
")",
")",
"BuildStackAdjustment",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"Offset",
",",
"false",
")",
";",
"}",
"return",
";",
"}",
"if",
"(",
"isDestroy",
"&&",
"InternalAmt",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"B",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"B",
"&&",
"!",
"std",
"::",
"prev",
"(",
"I",
")",
"->",
"isCall",
"(",
")",
")",
"--",
"I",
";",
"BuildStackAdjustment",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"-",
"InternalAmt",
",",
"false",
")",
";",
"}",
"}",
"</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",
")",
"."
] | [
"X86",
"X86",
"0",
"0",
"1",
"0",
"X86",
"0"
] | X86FrameLowering | eliminateCallFramePseudoInstr | X86 | CPU | LLVM | 23,627 | 325 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineBlockFrequencyInfo",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"MachineBlockFrequencyInfo",
">",
"(",
")",
";",
"AU",
".",
"addPreservedID",
"(",
"MachineDominatorsID",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"WebAssembly"
] | WebAssemblyRegColoring (2) | getAnalysisUsage | WebAssembly | Virtual ISA | LLVM | 23,628 | 58 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"Comet2"
] | Comet2TargetMachine | getObjFileLowering | Comet2 | CPU | LLVM | 23,629 | 16 | 1 | [] |
[
"<s>",
"NVPTXTargetLowering",
"::",
"ConstraintType",
"NVPTXTargetLowering",
"::",
"getConstraintType",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'r'",
":",
"case",
"'h'",
":",
"case",
"'c'",
":",
"case",
"'l'",
":",
"case",
"'f'",
":",
"case",
"'d'",
":",
"case",
"'0'",
":",
"case",
"'N'",
":",
"return",
"C_RegisterClass",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getConstraintType",
"(",
"Constraint",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constraint",
"letter",
",",
"return",
"the",
"type",
"of",
"constraint",
"for",
"this",
"target",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX",
"1",
"0"
] | NVPTXISelLowering15 | getConstraintType | NVPTX | GPU | LLVM | 23,630 | 77 | 1 | [] |
[
"<s>",
"LLVM_DUMP_METHOD",
"void",
"GCNRegPressure",
"::",
"print",
"(",
"raw_ostream",
"&",
"OS",
",",
"const",
"SISubtarget",
"*",
"ST",
")",
"const",
"{",
"OS",
"<<",
"\"VGPRs: \"",
"<<",
"getVGRPNum",
"(",
")",
";",
"if",
"(",
"ST",
")",
"OS",
"<<",
"\"(O\"",
"<<",
"ST",
"->",
"getOccupancyWithNumVGPRs",
"(",
"getVGRPNum",
"(",
")",
")",
"<<",
"')'",
";",
"OS",
"<<",
"\", SGPRs: \"",
"<<",
"getSGRPNum",
"(",
")",
";",
"if",
"(",
"ST",
")",
"OS",
"<<",
"\"(O\"",
"<<",
"ST",
"->",
"getOccupancyWithNumSGPRs",
"(",
"getSGRPNum",
"(",
")",
")",
"<<",
"')'",
";",
"OS",
"<<",
"\", LVGPR WT: \"",
"<<",
"getVGPRTuplesWeight",
"(",
")",
"<<",
"\", LSGPR WT: \"",
"<<",
"getSGPRTuplesWeight",
"(",
")",
";",
"if",
"(",
"ST",
")",
"OS",
"<<",
"\" -> Occ: \"",
"<<",
"getOccupancy",
"(",
"*",
"ST",
")",
";",
"OS",
"<<",
"'\\n'",
";",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"AMDGPU",
"SI",
"\"VGPRs: \"",
"\"(O\"",
"\", SGPRs: \"",
"\"(O\"",
"\", LVGPR WT: \"",
"\", LSGPR WT: \"",
"\" -> Occ: \""
] | GCNRegPressure22 | print | AMDGPU | GPU | LLVM | 23,631 | 104 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m32c_all_frame_related",
"(",
"rtx",
"par",
")",
"{",
"int",
"len",
"=",
"XVECLEN",
"(",
"par",
",",
"0",
")",
";",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"len",
";",
"i",
"++",
")",
"F",
"(",
"XVECEXP",
"(",
"par",
",",
"0",
",",
"i",
")",
")",
";",
"return",
"par",
";",
"}",
"</s>"
] | [
"Mark",
"all",
"the",
"subexpressions",
"of",
"the",
"PARALLEL",
"rtx",
"PAR",
"as",
"frame-related",
".",
"Return",
"PAR",
".",
"dwarf2out.cc",
":",
"dwarf2out_frame_debug_expr",
"ignores",
"sub-expressions",
"of",
"a",
"PARALLEL",
"rtx",
"other",
"than",
"the",
"first",
"if",
"they",
"do",
"not",
"have",
"the",
"FRAME_RELATED",
"flag",
"set",
"on",
"them",
".",
"So",
"this",
"function",
"is",
"handy",
"for",
"marking",
"up",
"'enter",
"'",
"instructions",
"."
] | [
"m32c",
"0",
"0",
"0"
] | m32c | m32c_all_frame_related | m32c | MPU | GCC | 23,632 | 50 | 1 | [] |
[
"<s>",
"bool",
"GCNPassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"AMDGPUPassConfig",
"::",
"addPreISel",
"(",
")",
";",
"if",
"(",
"EnableAtomicOptimizations",
")",
"{",
"addPass",
"(",
"createAMDGPUAtomicOptimizerPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"&",
"AMDGPUUnifyDivergentExitNodesID",
")",
";",
"if",
"(",
"!",
"LateCFGStructurize",
")",
"{",
"if",
"(",
"EnableStructurizerWorkarounds",
")",
"{",
"addPass",
"(",
"createFixIrreduciblePass",
"(",
")",
")",
";",
"addPass",
"(",
"createUnifyLoopExitsPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createStructurizeCFGPass",
"(",
"false",
")",
")",
";",
"}",
"addPass",
"(",
"createSinkingPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUAnnotateUniformValues",
"(",
")",
")",
";",
"if",
"(",
"!",
"LateCFGStructurize",
")",
"{",
"addPass",
"(",
"createSIAnnotateControlFlowPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createLCSSAPass",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"SI"
] | AMDGPUTargetMachine106 | addPreISel | AMDGPU | GPU | LLVM | 23,633 | 106 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_emit_save_regs",
"(",
"void",
")",
"{",
"unsigned",
"int",
"regno",
";",
"rtx_insn",
"*",
"insn",
";",
"for",
"(",
"regno",
"=",
"FIRST_PSEUDO_REGISTER",
"-",
"1",
";",
"regno",
"--",
">",
"0",
";",
")",
"if",
"(",
"GENERAL_REGNO_P",
"(",
"regno",
")",
"&&",
"ix86_save_reg",
"(",
"regno",
",",
"true",
")",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"gen_push",
"(",
"gen_rtx_REG",
"(",
"word_mode",
",",
"regno",
")",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"save",
"registers",
"in",
"the",
"prologue",
"."
] | [
"i386",
"1",
"0",
"1"
] | i3865 | ix86_emit_save_regs | i386 | CPU | GCC | 23,634 | 68 | 1 | [] |
[
"<s>",
"bool",
"PPCPassConfig",
"::",
"addGlobalInstructionSelect",
"(",
")",
"{",
"addPass",
"(",
"new",
"InstructionSelect",
"(",
"getOptLevel",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"install",
"a",
"(",
"global",
")",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"possibly",
"generic",
"instructions",
"to",
"fully",
"target-specific",
"instructions",
",",
"thereby",
"constraining",
"all",
"generic",
"virtual",
"registers",
"to",
"register",
"classes",
"."
] | [
"PowerPC",
"PPC"
] | PPCTargetMachine40 | addGlobalInstructionSelect | PowerPC | CPU | LLVM | 23,635 | 22 | 1 | [] |
[
"<s>",
"bool",
"Z80oldRegisterInfo",
"::",
"needsFrameBaseReg",
"(",
"MachineInstr",
"*",
"MI",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"return",
"!",
"isFrameOffsetLegal",
"(",
"MI",
",",
"getFrameRegister",
"(",
"MF",
")",
",",
"Offset",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"'s",
"frame",
"index",
"reference",
"would",
"be",
"better",
"served",
"by",
"a",
"base",
"register",
"other",
"than",
"FP",
"or",
"SP",
"."
] | [
"Z80old",
"Z80old"
] | Z80oldRegisterInfo | needsFrameBaseReg | Z80old | MPU | LLVM | 23,636 | 45 | 1 | [] |
[
"<s>",
"static",
"int",
"forward_branch_p",
"(",
"rtx",
"insn",
")",
"{",
"rtx",
"label",
"=",
"JUMP_LABEL",
"(",
"insn",
")",
";",
"while",
"(",
"insn",
")",
"{",
"if",
"(",
"insn",
"==",
"label",
")",
"break",
";",
"else",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
";",
"}",
"return",
"(",
"insn",
"==",
"label",
")",
";",
"}",
"</s>"
] | [
"Return",
"1",
"if",
"INSN",
"branches",
"forward",
".",
"Should",
"be",
"using",
"insn_addresses",
"to",
"avoid",
"walking",
"through",
"all",
"the",
"insns",
"..."
] | [
"pa"
] | pa3 | forward_branch_p | pa | CPU | GCC | 23,637 | 46 | 1 | [] |
[
"<s>",
"void",
"AArch64AsmBackend",
"::",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"MCInst",
"&",
"Res",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"AArch64AsmBackend::relaxInstruction() unimplemented\"",
")",
";",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"AArch64",
"AArch64",
"\"AArch64AsmBackend::relaxInstruction() unimplemented\""
] | AArch64AsmBackend (2) | relaxInstruction | AArch64 | CPU | LLVM | 23,638 | 22 | 1 | [] |
[
"<s>",
"bool",
"ARMTTIImpl",
"::",
"isLegalMaskedGather",
"(",
"Type",
"*",
"Ty",
",",
"Align",
"Alignment",
")",
"{",
"if",
"(",
"!",
"EnableMaskedGatherScatters",
"||",
"!",
"ST",
"->",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"isa",
"<",
"VectorType",
">",
"(",
"Ty",
")",
")",
"return",
"false",
";",
"unsigned",
"EltWidth",
"=",
"Ty",
"->",
"getScalarSizeInBits",
"(",
")",
";",
"return",
"(",
"(",
"EltWidth",
"==",
"32",
"&&",
"Alignment",
">=",
"4",
")",
"||",
"(",
"EltWidth",
"==",
"16",
"&&",
"Alignment",
">=",
"2",
")",
"||",
"EltWidth",
"==",
"8",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"supports",
"masked",
"gather",
"."
] | [
"ARM",
"ARM",
"32",
"4",
"16",
"2",
"8"
] | ARMTargetTransformInfo14 | isLegalMaskedGather | ARM | CPU | LLVM | 23,639 | 78 | 1 | [] |
[
"<s>",
"bool",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"override",
"{",
"UsedList",
"=",
"AMDGPU",
"::",
"getUsedList",
"(",
"M",
")",
";",
"bool",
"Changed",
"=",
"processUsedLDS",
"(",
"M",
")",
";",
"for",
"(",
"Function",
"&",
"F",
":",
"M",
".",
"functions",
"(",
")",
")",
"{",
"if",
"(",
"F",
".",
"isDeclaration",
"(",
")",
")",
"continue",
";",
"if",
"(",
"!",
"AMDGPU",
"::",
"isKernel",
"(",
"F",
".",
"getCallingConv",
"(",
")",
")",
")",
"continue",
";",
"Changed",
"|=",
"processUsedLDS",
"(",
"M",
",",
"&",
"F",
")",
";",
"}",
"UsedList",
".",
"clear",
"(",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"AMDGPU",
"AMDGPU::getUsedList",
"AMDGPU::isKernel"
] | AMDGPULowerModuleLDSPass1 | runOnModule | AMDGPU | GPU | LLVM | 23,640 | 86 | 1 | [] |
[
"<s>",
"bool",
"evaluateBranch",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"uint64_t",
"Addr",
",",
"uint64_t",
"Size",
",",
"uint64_t",
"&",
"Target",
")",
"const",
"override",
"{",
"unsigned",
"NumOps",
"=",
"Inst",
".",
"getNumOperands",
"(",
")",
";",
"if",
"(",
"isBranch",
"(",
"Inst",
")",
"||",
"Inst",
".",
"getOpcode",
"(",
")",
"==",
"LoongArch",
"::",
"BL",
")",
"{",
"Target",
"=",
"Addr",
"+",
"Inst",
".",
"getOperand",
"(",
"NumOps",
"-",
"1",
")",
".",
"getImm",
"(",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Given",
"a",
"branch",
"instruction",
"try",
"to",
"get",
"the",
"address",
"the",
"branch",
"targets",
"."
] | [
"LoongArch",
"LoongArch::BL",
"1"
] | LoongArchMCTargetDesc | evaluateBranch | LoongArch | CPU | LLVM | 23,641 | 73 | 1 | [] |
[
"<s>",
"bool",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"char",
"ConstraintCode",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"override",
"{",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"PPCSubTarget",
"->",
"getRegisterInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"TRC",
"=",
"TRI",
"->",
"getPointerRegClass",
"(",
"*",
"MF",
",",
"1",
")",
";",
"SDValue",
"RC",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"TRC",
"->",
"getID",
"(",
")",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"NewOp",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"TargetOpcode",
"::",
"COPY_TO_REGCLASS",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
",",
"RC",
")",
",",
"0",
")",
";",
"OutOps",
".",
"push_back",
"(",
"NewOp",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"PowerPC",
"PPC",
"1",
"MVT::i32",
"0"
] | PPCISelDAGToDAG32 | SelectInlineAsmMemoryOperand | PowerPC | CPU | LLVM | 23,642 | 109 | 1 | [] |
[
"<s>",
"const",
"MCFixupKindInfo",
"&",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"Videocore",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"\"fixup_Videocore_16\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_32\"",
",",
"0",
",",
"32",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_REL32\"",
",",
"0",
",",
"32",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_24\"",
",",
"0",
",",
"24",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_HI16\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_LO16\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_GPREL16\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_LITERAL\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_GOT_Global\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_GOT_Local\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_PC24\"",
",",
"0",
",",
"24",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_Videocore_CALL16\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_GPREL32\"",
",",
"0",
",",
"32",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_SHIFT5\"",
",",
"6",
",",
"5",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_SHIFT6\"",
",",
"6",
",",
"5",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_64\"",
",",
"0",
",",
"64",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_TLSGD\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_GOTTPREL\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_TPREL_HI\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_TPREL_LO\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_TLSLDM\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_DTPREL_HI\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_DTPREL_LO\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_Videocore_Branch_PCRel\"",
",",
"0",
",",
"16",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
"}",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";",
"assert",
"(",
"unsigned",
"(",
"Kind",
"-",
"FirstTargetFixupKind",
")",
"<",
"getNumFixupKinds",
"(",
")",
"&&",
"\"Invalid kind!\"",
")",
";",
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";",
"}",
"</s>"
] | [
"Get",
"information",
"on",
"a",
"fixup",
"kind",
"."
] | [
"Videocore",
"Videocore::NumTargetFixupKinds",
"\"fixup_Videocore_16\"",
"0",
"16",
"0",
"\"fixup_Videocore_32\"",
"0",
"32",
"0",
"\"fixup_Videocore_REL32\"",
"0",
"32",
"0",
"\"fixup_Videocore_24\"",
"0",
"24",
"0",
"\"fixup_Videocore_HI16\"",
"0",
"16",
"0",
"\"fixup_Videocore_LO16\"",
"0",
"16",
"0",
"\"fixup_Videocore_GPREL16\"",
"0",
"16",
"0",
"\"fixup_Videocore_LITERAL\"",
"0",
"16",
"0",
"\"fixup_Videocore_GOT_Global\"",
"0",
"16",
"0",
"\"fixup_Videocore_GOT_Local\"",
"0",
"16",
"0",
"\"fixup_Videocore_PC24\"",
"0",
"24",
"\"fixup_Videocore_CALL16\"",
"0",
"16",
"0",
"\"fixup_Videocore_GPREL32\"",
"0",
"32",
"0",
"\"fixup_Videocore_SHIFT5\"",
"6",
"5",
"0",
"\"fixup_Videocore_SHIFT6\"",
"6",
"5",
"0",
"\"fixup_Videocore_64\"",
"0",
"64",
"0",
"\"fixup_Videocore_TLSGD\"",
"0",
"16",
"0",
"\"fixup_Videocore_GOTTPREL\"",
"0",
"16",
"0",
"\"fixup_Videocore_TPREL_HI\"",
"0",
"16",
"0",
"\"fixup_Videocore_TPREL_LO\"",
"0",
"16",
"0",
"\"fixup_Videocore_TLSLDM\"",
"0",
"16",
"0",
"\"fixup_Videocore_DTPREL_HI\"",
"0",
"16",
"0",
"\"fixup_Videocore_DTPREL_LO\"",
"0",
"16",
"0",
"\"fixup_Videocore_Branch_PCRel\"",
"0",
"16",
"\"Invalid kind!\""
] | VideocoreAsmBackend | getFixupKindInfo | Videocore | DSP | LLVM | 23,643 | 305 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isTypeDesirableForOp",
"(",
"unsigned",
"Opc",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"isTypeLegal",
"(",
"VT",
")",
")",
"return",
"false",
";",
"if",
"(",
"Opc",
"==",
"ISD",
"::",
"SHL",
"&&",
"VT",
".",
"isVector",
"(",
")",
"&&",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i8",
")",
"return",
"false",
";",
"if",
"(",
"(",
"Opc",
"==",
"ISD",
"::",
"MUL",
"||",
"Opc",
"==",
"ISD",
"::",
"SHL",
")",
"&&",
"VT",
"==",
"MVT",
"::",
"i8",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i16",
")",
"{",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"case",
"ISD",
"::",
"ANY_EXTEND",
":",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SRL",
":",
"case",
"ISD",
"::",
"SUB",
":",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"AND",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"XOR",
":",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"has",
"native",
"support",
"for",
"the",
"specified",
"value",
"type",
"and",
"it",
"is",
"'desirable",
"'",
"to",
"use",
"the",
"type",
"for",
"the",
"given",
"node",
"type",
"."
] | [
"X86",
"X86",
"ISD::SHL",
"MVT::i8",
"ISD::MUL",
"ISD::SHL",
"MVT::i8",
"MVT::i16",
"ISD::LOAD",
"ISD::SIGN_EXTEND",
"ISD::ZERO_EXTEND",
"ISD::ANY_EXTEND",
"ISD::SHL",
"ISD::SRA",
"ISD::SRL",
"ISD::SUB",
"ISD::ADD",
"ISD::MUL",
"ISD::AND",
"ISD::OR",
"ISD::XOR"
] | X86ISelLowering (2)5 | isTypeDesirableForOp | X86 | CPU | LLVM | 23,644 | 168 | 1 | [] |
[
"<s>",
"static",
"bool",
"arc_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
"ATTRIBUTE_UNUSED",
")",
"{",
"tree",
"attrs",
"=",
"NULL_TREE",
";",
"if",
"(",
"ARC_INTERRUPT_P",
"(",
"arc_compute_function_type",
"(",
"cfun",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"decl",
")",
"{",
"attrs",
"=",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
";",
"if",
"(",
"lookup_attribute",
"(",
"\"jli_always\"",
",",
"attrs",
")",
")",
"return",
"false",
";",
"if",
"(",
"lookup_attribute",
"(",
"\"jli_fixed\"",
",",
"attrs",
")",
")",
"return",
"false",
";",
"if",
"(",
"lookup_attribute",
"(",
"\"secure_call\"",
",",
"attrs",
")",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"ok",
"to",
"make",
"a",
"tail-call",
"to",
"DECL",
"."
] | [
"arc",
"\"jli_always\"",
"\"jli_fixed\"",
"\"secure_call\""
] | arc | arc_function_ok_for_sibcall | arc | MPU | GCC | 23,645 | 86 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"lshrsi3_out",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"operands",
"[",
"]",
",",
"int",
"*",
"len",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"operands",
"[",
"2",
"]",
")",
"==",
"CONST_INT",
")",
"{",
"int",
"k",
";",
"int",
"*",
"t",
"=",
"len",
";",
"if",
"(",
"!",
"len",
")",
"len",
"=",
"&",
"k",
";",
"switch",
"(",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"{",
"default",
":",
"if",
"(",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
"<",
"32",
")",
"break",
";",
"if",
"(",
"AVR_HAVE_MOVW",
")",
"return",
"*",
"len",
"=",
"3",
",",
"(",
"\"clr %D0\"",
"CR_TAB",
"\"clr %C0\"",
"CR_TAB",
"\"movw %A0,%C0\"",
")",
";",
"*",
"len",
"=",
"4",
";",
"return",
"(",
"\"clr %D0\"",
"CR_TAB",
"\"clr %C0\"",
"CR_TAB",
"\"clr %B0\"",
"CR_TAB",
"\"clr %A0\"",
")",
";",
"case",
"8",
":",
"{",
"int",
"reg0",
"=",
"true_regnum",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"int",
"reg1",
"=",
"true_regnum",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"*",
"len",
"=",
"4",
";",
"if",
"(",
"reg0",
"<=",
"reg1",
")",
"return",
"(",
"\"mov %A0,%B1\"",
"CR_TAB",
"\"mov %B0,%C1\"",
"CR_TAB",
"\"mov %C0,%D1\"",
"CR_TAB",
"\"clr %D0\"",
")",
";",
"else",
"return",
"(",
"\"clr %D0\"",
"CR_TAB",
"\"mov %C0,%D1\"",
"CR_TAB",
"\"mov %B0,%C1\"",
"CR_TAB",
"\"mov %A0,%B1\"",
")",
";",
"}",
"case",
"16",
":",
"{",
"int",
"reg0",
"=",
"true_regnum",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"int",
"reg1",
"=",
"true_regnum",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"if",
"(",
"reg0",
"==",
"reg1",
"+",
"2",
")",
"return",
"*",
"len",
"=",
"2",
",",
"(",
"\"clr %C0\"",
"CR_TAB",
"\"clr %D0\"",
")",
";",
"if",
"(",
"AVR_HAVE_MOVW",
")",
"return",
"*",
"len",
"=",
"3",
",",
"(",
"\"movw %A0,%C1\"",
"CR_TAB",
"\"clr %C0\"",
"CR_TAB",
"\"clr %D0\"",
")",
";",
"else",
"return",
"*",
"len",
"=",
"4",
",",
"(",
"\"mov %B0,%D1\"",
"CR_TAB",
"\"mov %A0,%C1\"",
"CR_TAB",
"\"clr %C0\"",
"CR_TAB",
"\"clr %D0\"",
")",
";",
"}",
"case",
"24",
":",
"return",
"*",
"len",
"=",
"4",
",",
"(",
"\"mov %A0,%D1\"",
"CR_TAB",
"\"clr %B0\"",
"CR_TAB",
"\"clr %C0\"",
"CR_TAB",
"\"clr %D0\"",
")",
";",
"case",
"31",
":",
"*",
"len",
"=",
"6",
";",
"return",
"(",
"\"clr %A0\"",
"CR_TAB",
"\"sbrc %D0,7\"",
"CR_TAB",
"\"inc %A0\"",
"CR_TAB",
"\"clr %B0\"",
"CR_TAB",
"\"clr %C0\"",
"CR_TAB",
"\"clr %D0\"",
")",
";",
"}",
"len",
"=",
"t",
";",
"}",
"out_shift_with_cnt",
"(",
"\"lsr %D0\"",
"CR_TAB",
"\"ror %C0\"",
"CR_TAB",
"\"ror %B0\"",
"CR_TAB",
"\"ror %A0\"",
",",
"insn",
",",
"operands",
",",
"len",
",",
"4",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"32bit",
"logic",
"shift",
"right",
"(",
"(",
"unsigned",
"int",
")",
"x",
">",
">",
"i",
")"
] | [
"avr",
"2",
"2",
"2",
"32",
"3",
"\"clr %D0\"",
"\"clr %C0\"",
"\"movw %A0,%C0\"",
"4",
"\"clr %D0\"",
"\"clr %C0\"",
"\"clr %B0\"",
"\"clr %A0\"",
"8",
"0",
"1",
"4",
"\"mov %A0,%B1\"",
"\"mov %B0,%C1\"",
"\"mov %C0,%D1\"",
"\"clr %D0\"",
"\"clr %D0\"",
"\"mov %C0,%D1\"",
"\"mov %B0,%C1\"",
"\"mov %A0,%B1\"",
"16",
"0",
"1",
"2",
"2",
"\"clr %C0\"",
"\"clr %D0\"",
"3",
"\"movw %A0,%C1\"",
"\"clr %C0\"",
"\"clr %D0\"",
"4",
"\"mov %B0,%D1\"",
"\"mov %A0,%C1\"",
"\"clr %C0\"",
"\"clr %D0\"",
"24",
"4",
"\"mov %A0,%D1\"",
"\"clr %B0\"",
"\"clr %C0\"",
"\"clr %D0\"",
"31",
"6",
"\"clr %A0\"",
"\"sbrc %D0,7\"",
"\"inc %A0\"",
"\"clr %B0\"",
"\"clr %C0\"",
"\"clr %D0\"",
"\"lsr %D0\"",
"\"ror %C0\"",
"\"ror %B0\"",
"\"ror %A0\"",
"4",
"\"\""
] | avr4 | lshrsi3_out | avr | MPU | GCC | 23,646 | 326 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m32c_subreg",
"(",
"enum",
"machine_mode",
"outer",
",",
"rtx",
"x",
",",
"enum",
"machine_mode",
"inner",
",",
"int",
"byte",
")",
"{",
"int",
"r",
",",
"nr",
"=",
"-",
"1",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SUBREG",
"&&",
"SUBREG_BYTE",
"(",
"x",
")",
"==",
"0",
"&&",
"GET_CODE",
"(",
"SUBREG_REG",
"(",
"x",
")",
")",
"==",
"MEM",
"&&",
"(",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"x",
")",
")",
"==",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"x",
")",
")",
")",
")",
")",
"{",
"rtx",
"oldx",
"=",
"x",
";",
"x",
"=",
"gen_rtx_MEM",
"(",
"GET_MODE",
"(",
"x",
")",
",",
"XEXP",
"(",
"SUBREG_REG",
"(",
"x",
")",
",",
"0",
")",
")",
";",
"MEM_COPY_ATTRIBUTES",
"(",
"x",
",",
"SUBREG_REG",
"(",
"oldx",
")",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"MEM",
"&&",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"PRE_DEC",
"||",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"POST_INC",
")",
")",
"return",
"gen_rtx_MEM",
"(",
"outer",
",",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SUBREG",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"MEM",
"&&",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"PRE_DEC",
"||",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"POST_INC",
")",
")",
"return",
"gen_rtx_MEM",
"(",
"outer",
",",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"!=",
"REG",
")",
"return",
"simplify_gen_subreg",
"(",
"outer",
",",
"x",
",",
"inner",
",",
"byte",
")",
";",
"r",
"=",
"REGNO",
"(",
"x",
")",
";",
"if",
"(",
"r",
">=",
"FIRST_PSEUDO_REGISTER",
"||",
"r",
"==",
"AP_REGNO",
")",
"return",
"simplify_gen_subreg",
"(",
"outer",
",",
"x",
",",
"inner",
",",
"byte",
")",
";",
"if",
"(",
"IS_MEM_REGNO",
"(",
"r",
")",
")",
"return",
"simplify_gen_subreg",
"(",
"outer",
",",
"x",
",",
"inner",
",",
"byte",
")",
";",
"if",
"(",
"byte",
"==",
"0",
")",
"nr",
"=",
"r",
";",
"else",
"if",
"(",
"outer",
"==",
"HImode",
")",
"{",
"if",
"(",
"r",
"==",
"R0_REGNO",
"&&",
"byte",
"==",
"2",
")",
"nr",
"=",
"R2_REGNO",
";",
"else",
"if",
"(",
"r",
"==",
"R0_REGNO",
"&&",
"byte",
"==",
"4",
")",
"nr",
"=",
"R1_REGNO",
";",
"else",
"if",
"(",
"r",
"==",
"R0_REGNO",
"&&",
"byte",
"==",
"6",
")",
"nr",
"=",
"R3_REGNO",
";",
"else",
"if",
"(",
"r",
"==",
"R1_REGNO",
"&&",
"byte",
"==",
"2",
")",
"nr",
"=",
"R3_REGNO",
";",
"else",
"if",
"(",
"r",
"==",
"A0_REGNO",
"&&",
"byte",
"==",
"2",
")",
"nr",
"=",
"A1_REGNO",
";",
"}",
"else",
"if",
"(",
"outer",
"==",
"SImode",
")",
"{",
"if",
"(",
"r",
"==",
"R0_REGNO",
"&&",
"byte",
"==",
"0",
")",
"nr",
"=",
"R0_REGNO",
";",
"else",
"if",
"(",
"r",
"==",
"R0_REGNO",
"&&",
"byte",
"==",
"4",
")",
"nr",
"=",
"R1_REGNO",
";",
"}",
"if",
"(",
"nr",
"==",
"-",
"1",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"m32c_subreg %s %s %d\\n\"",
",",
"mode_name",
"[",
"outer",
"]",
",",
"mode_name",
"[",
"inner",
"]",
",",
"byte",
")",
";",
"debug_rtx",
"(",
"x",
")",
";",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"gen_rtx_REG",
"(",
"outer",
",",
"nr",
")",
";",
"}",
"</s>"
] | [
"Subregs",
"are",
"non-orthogonal",
"for",
"us",
",",
"because",
"our",
"registers",
"are",
"all",
"different",
"sizes",
"."
] | [
"m32c",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
"4",
"6",
"2",
"2",
"0",
"4",
"1",
"\"m32c_subreg %s %s %d\\n\""
] | m32c2 | m32c_subreg | m32c | MPU | GCC | 23,647 | 480 | 1 | [] |
[
"<s>",
"void",
"releaseBottomNode",
"(",
"SUnit",
"*",
"SU",
")",
"override",
"{",
"}",
"</s>"
] | [
"Currently",
"only",
"scheduling",
"top-down",
",",
"so",
"this",
"method",
"is",
"empty",
"."
] | [
"AMDGPU"
] | GCNIterativeScheduler (2) | releaseBottomNode | AMDGPU | GPU | LLVM | 23,648 | 10 | 1 | [] |
[
"<s>",
"static",
"void",
"register_builtin_tuple_types",
"(",
"vector_type_index",
"type",
")",
"{",
"const",
"vector_type_info",
"*",
"info",
"=",
"&",
"vector_types",
"[",
"type",
"]",
";",
"if",
"(",
"scalar_types",
"[",
"type",
"]",
"==",
"boolean_type_node",
"||",
"(",
"info",
"->",
"requires_float",
"&&",
"!",
"TARGET_HAVE_MVE_FLOAT",
")",
")",
"return",
";",
"const",
"char",
"*",
"vector_type_name",
"=",
"info",
"->",
"acle_name",
";",
"char",
"buffer",
"[",
"sizeof",
"(",
"\"float32x4x2_t\"",
")",
"]",
";",
"for",
"(",
"unsigned",
"int",
"num_vectors",
"=",
"2",
";",
"num_vectors",
"<=",
"4",
";",
"num_vectors",
"+=",
"2",
")",
"{",
"snprintf",
"(",
"buffer",
",",
"sizeof",
"(",
"buffer",
")",
",",
"\"%.*sx%d_t\"",
",",
"(",
"int",
")",
"strlen",
"(",
"vector_type_name",
")",
"-",
"2",
",",
"vector_type_name",
",",
"num_vectors",
")",
";",
"tree",
"vectype",
"=",
"acle_vector_types",
"[",
"0",
"]",
"[",
"type",
"]",
";",
"tree",
"arrtype",
"=",
"build_array_type_nelts",
"(",
"vectype",
",",
"num_vectors",
")",
";",
"gcc_assert",
"(",
"TYPE_MODE_RAW",
"(",
"arrtype",
")",
"==",
"TYPE_MODE",
"(",
"arrtype",
")",
")",
";",
"tree",
"field",
"=",
"build_decl",
"(",
"input_location",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"val\"",
")",
",",
"arrtype",
")",
";",
"tree",
"t",
"=",
"lang_hooks",
".",
"types",
".",
"simulate_record_decl",
"(",
"input_location",
",",
"buffer",
",",
"make_array_slice",
"(",
"&",
"field",
",",
"1",
")",
")",
";",
"gcc_assert",
"(",
"TYPE_MODE_RAW",
"(",
"t",
")",
"==",
"TYPE_MODE",
"(",
"t",
")",
")",
";",
"acle_vector_types",
"[",
"num_vectors",
">>",
"1",
"]",
"[",
"type",
"]",
"=",
"TREE_TYPE",
"(",
"t",
")",
";",
"}",
"}",
"</s>"
] | [
"Register",
"tuple",
"type",
"TYPE",
"with",
"NUM_VECTORS",
"arity",
"under",
"its",
"arm_mve_types.h",
"name",
"."
] | [
"arm",
"\"float32x4x2_t\"",
"2",
"4",
"2",
"\"%.*sx%d_t\"",
"2",
"0",
"\"val\"",
"1",
"1"
] | arm-mve-builtins | register_builtin_tuple_types | arm | CPU | GCC | 23,649 | 203 | 1 | [] |
[
"<s>",
"static",
"pad_direction",
"rs6000_function_arg_padding",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
")",
"{",
"if",
"(",
"!",
"AGGREGATE_PADDING_FIXED",
")",
"{",
"if",
"(",
"BYTES_BIG_ENDIAN",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"0",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"{",
"if",
"(",
"type",
"&&",
"TREE_CODE",
"(",
"TYPE_SIZE",
"(",
"type",
")",
")",
"==",
"INTEGER_CST",
")",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"}",
"else",
"size",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"if",
"(",
"size",
"==",
"1",
"||",
"size",
"==",
"2",
"||",
"size",
"==",
"4",
")",
"return",
"PAD_DOWNWARD",
";",
"}",
"return",
"PAD_UPWARD",
";",
"}",
"if",
"(",
"AGGREGATES_PAD_UPWARD_ALWAYS",
")",
"{",
"if",
"(",
"type",
"!=",
"0",
"&&",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"return",
"PAD_UPWARD",
";",
"}",
"return",
"default_function_arg_padding",
"(",
"mode",
",",
"type",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG_PADDING",
".",
"For",
"the",
"AIX",
"ABI",
"structs",
"are",
"always",
"stored",
"left",
"shifted",
"in",
"their",
"argument",
"slot",
"."
] | [
"powerpcspe",
"0",
"1",
"2",
"4",
"0"
] | powerpcspe | rs6000_function_arg_padding | powerpcspe | CPU | GCC | 23,650 | 115 | 1 | [] |
[
"<s>",
"bool",
"quad_load_store_p",
"(",
"rtx",
"op0",
",",
"rtx",
"op1",
")",
"{",
"bool",
"ret",
";",
"if",
"(",
"!",
"TARGET_QUAD_MEMORY",
")",
"ret",
"=",
"false",
";",
"else",
"if",
"(",
"REG_P",
"(",
"op0",
")",
"&&",
"MEM_P",
"(",
"op1",
")",
")",
"ret",
"=",
"(",
"quad_int_reg_operand",
"(",
"op0",
",",
"GET_MODE",
"(",
"op0",
")",
")",
"&&",
"quad_memory_operand",
"(",
"op1",
",",
"GET_MODE",
"(",
"op1",
")",
")",
"&&",
"!",
"reg_overlap_mentioned_p",
"(",
"op0",
",",
"op1",
")",
")",
";",
"else",
"if",
"(",
"MEM_P",
"(",
"op0",
")",
"&&",
"REG_P",
"(",
"op1",
")",
")",
"ret",
"=",
"(",
"quad_memory_operand",
"(",
"op0",
",",
"GET_MODE",
"(",
"op0",
")",
")",
"&&",
"quad_int_reg_operand",
"(",
"op1",
",",
"GET_MODE",
"(",
"op1",
")",
")",
")",
";",
"else",
"ret",
"=",
"false",
";",
"if",
"(",
"TARGET_DEBUG_ADDR",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"\\n========== quad_load_store, return %s\\n\"",
",",
"ret",
"?",
"\"true\"",
":",
"\"false\"",
")",
";",
"debug_rtx",
"(",
"gen_rtx_SET",
"(",
"op0",
",",
"op1",
")",
")",
";",
"}",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"is",
"a",
"load",
"or",
"store",
"quad",
"operation",
".",
"This",
"function",
"does",
"not",
"handle",
"the",
"atomic",
"quad",
"memory",
"instructions",
"."
] | [
"powerpcspe",
"\"\\n========== quad_load_store, return %s\\n\"",
"\"true\"",
"\"false\""
] | powerpcspe | quad_load_store_p | powerpcspe | CPU | GCC | 23,651 | 142 | 1 | [] |
[
"<s>",
"unsigned",
"getExceptionPointerRegister",
"(",
"const",
"Constant",
"*",
"PersonalityFn",
")",
"const",
"override",
"{",
"return",
"XCore",
"::",
"R0",
";",
"}",
"</s>"
] | [
"If",
"a",
"physical",
"register",
",",
"this",
"returns",
"the",
"register",
"that",
"receives",
"the",
"exception",
"address",
"on",
"entry",
"to",
"an",
"EH",
"pad",
"."
] | [
"XCore",
"XCore::R0"
] | XCoreISelLowering (2)1 | getExceptionPointerRegister | XCore | MPU | LLVM | 23,652 | 17 | 1 | [] |
[
"<s>",
"bool",
"MVEVPTOptimisations",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"Fn",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"!",
"STI",
".",
"isThumb2",
"(",
")",
"||",
"!",
"STI",
".",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"false",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"Thumb2InstrInfo",
"*",
">",
"(",
"STI",
".",
"getInstrInfo",
"(",
")",
")",
";",
"MRI",
"=",
"&",
"Fn",
".",
"getRegInfo",
"(",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** ARM MVE VPT Optimisations **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"Fn",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"Fn",
")",
"{",
"Modified",
"|=",
"ReplaceVCMPsByVPNOTs",
"(",
"MBB",
")",
";",
"Modified",
"|=",
"ReduceOldVCCRValueUses",
"(",
"MBB",
")",
";",
"}",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"**************************************\\n\"",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"\"********** ARM MVE VPT Optimisations **********\\n\"",
"\"********** Function: \"",
"\"**************************************\\n\""
] | MVEVPTOptimisationsPass1 | runOnMachineFunction | ARM | CPU | LLVM | 23,653 | 134 | 1 | [] |
[
"<s>",
"DecodeStatus",
"PPCDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"MI",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"CS",
")",
"const",
"{",
"Size",
"=",
"4",
";",
"if",
"(",
"Bytes",
".",
"size",
"(",
")",
"<",
"4",
")",
"{",
"Size",
"=",
"0",
";",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"uint32_t",
"Inst",
"=",
"IsLittleEndian",
"?",
"support",
"::",
"endian",
"::",
"read32le",
"(",
"Bytes",
".",
"data",
"(",
")",
")",
":",
"support",
"::",
"endian",
"::",
"read32be",
"(",
"Bytes",
".",
"data",
"(",
")",
")",
";",
"if",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"PPC",
"::",
"FeatureQPX",
"]",
")",
"{",
"DecodeStatus",
"result",
"=",
"decodeInstruction",
"(",
"DecoderTableQPX32",
",",
"MI",
",",
"Inst",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"result",
";",
"}",
"else",
"if",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"PPC",
"::",
"FeatureSPE",
"]",
")",
"{",
"DecodeStatus",
"result",
"=",
"decodeInstruction",
"(",
"DecoderTableSPE32",
",",
"MI",
",",
"Inst",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"result",
";",
"}",
"return",
"decodeInstruction",
"(",
"DecoderTable32",
",",
"MI",
",",
"Inst",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"PowerPC",
"PPC",
"4",
"4",
"0",
"support::endian",
"support::endian",
"PPC::FeatureQPX",
"PPC::FeatureSPE"
] | PPCDisassembler26 | getInstruction | PowerPC | CPU | LLVM | 23,654 | 190 | 1 | [] |
[
"<s>",
"bool",
"SILowerControlFlowPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"bool",
"HaveKill",
"=",
"false",
";",
"bool",
"NeedWQM",
"=",
"false",
";",
"unsigned",
"Depth",
"=",
"0",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"BI",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"BE",
"=",
"MF",
".",
"end",
"(",
")",
";",
"BI",
"!=",
"BE",
";",
"++",
"BI",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"BI",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
",",
"Next",
"=",
"llvm",
"::",
"next",
"(",
"I",
")",
";",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"=",
"Next",
")",
"{",
"Next",
"=",
"llvm",
"::",
"next",
"(",
"I",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"I",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_IF",
":",
"++",
"Depth",
";",
"If",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_ELSE",
":",
"Else",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_BREAK",
":",
"Break",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_IF_BREAK",
":",
"IfBreak",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_ELSE_BREAK",
":",
"ElseBreak",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_LOOP",
":",
"++",
"Depth",
";",
"Loop",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_END_CF",
":",
"if",
"(",
"--",
"Depth",
"==",
"0",
"&&",
"HaveKill",
")",
"{",
"SkipIfDead",
"(",
"MI",
")",
";",
"HaveKill",
"=",
"false",
";",
"}",
"EndCf",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_KILL",
":",
"if",
"(",
"Depth",
"==",
"0",
")",
"SkipIfDead",
"(",
"MI",
")",
";",
"else",
"HaveKill",
"=",
"true",
";",
"Kill",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"S_BRANCH",
":",
"Branch",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_SRC",
":",
"IndirectSrc",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V2",
":",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V4",
":",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V8",
":",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V16",
":",
"IndirectDst",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"V_INTERP_P1_F32",
":",
"case",
"AMDGPU",
"::",
"V_INTERP_P2_F32",
":",
"case",
"AMDGPU",
"::",
"V_INTERP_MOV_F32",
":",
"NeedWQM",
"=",
"true",
";",
"break",
";",
"}",
"}",
"}",
"if",
"(",
"NeedWQM",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBB",
".",
"getFirstNonPHI",
"(",
")",
",",
"DebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_WQM_B64",
")",
",",
"AMDGPU",
"::",
"EXEC",
")",
".",
"addReg",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"R600",
"SI",
"0",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"0",
"SI",
"0",
"SI",
"SI",
"SI",
"SI",
"SI"
] | SILowerControlFlow34 | runOnMachineFunction | R600 | GPU | LLVM | 23,655 | 393 | 1 | [] |
[
"<s>",
"void",
"expand_epilogue",
"(",
"void",
")",
"{",
"int",
"size",
";",
"register",
"int",
"regno",
";",
"int",
"return_size",
";",
"rtx",
"scratch",
";",
"gcc_assert",
"(",
"reload_completed",
"==",
"1",
")",
";",
"size",
"=",
"get_frame_size",
"(",
")",
";",
"if",
"(",
"current_function_return_rtx",
"==",
"0",
")",
"return_size",
"=",
"0",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"current_function_return_rtx",
")",
"==",
"MEM",
")",
"return_size",
"=",
"HARD_REG_SIZE",
";",
"else",
"return_size",
"=",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"current_function_return_rtx",
")",
")",
";",
"if",
"(",
"return_size",
">",
"HARD_REG_SIZE",
"&&",
"return_size",
"<=",
"2",
"*",
"HARD_REG_SIZE",
")",
"scratch",
"=",
"iy_reg",
";",
"else",
"scratch",
"=",
"ix_reg",
";",
"for",
"(",
"regno",
"=",
"SOFT_REG_LAST",
";",
"regno",
">=",
"SOFT_REG_FIRST",
";",
"regno",
"--",
")",
"{",
"if",
"(",
"regs_ever_live",
"[",
"regno",
"]",
"&&",
"!",
"call_used_regs",
"[",
"regno",
"]",
")",
"{",
"emit_move_after_reload",
"(",
"gen_rtx_REG",
"(",
"HImode",
",",
"regno",
")",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"}",
"}",
"if",
"(",
"TARGET_M6812",
"&&",
"(",
"size",
">",
"4",
"||",
"size",
"==",
"3",
")",
")",
"{",
"emit_insn",
"(",
"gen_addhi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"size",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"(",
"!",
"optimize_size",
"&&",
"size",
">",
"8",
")",
"||",
"(",
"optimize_size",
"&&",
"size",
">",
"10",
")",
")",
"{",
"rtx",
"insn",
";",
"insn",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"2",
",",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"stack_pointer_rtx",
",",
"gen_rtx_PLUS",
"(",
"HImode",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"size",
")",
")",
")",
",",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"scratch",
")",
")",
")",
";",
"emit_insn",
"(",
"insn",
")",
";",
"}",
"else",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"2",
";",
"i",
"<=",
"size",
";",
"i",
"+=",
"2",
")",
"emit_move_after_reload",
"(",
"scratch",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"if",
"(",
"size",
"&",
"1",
")",
"emit_insn",
"(",
"gen_addhi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"const1_rtx",
")",
")",
";",
"}",
"if",
"(",
"current_function_interrupt",
")",
"{",
"emit_move_after_reload",
"(",
"gen_rtx_REG",
"(",
"HImode",
",",
"SOFT_SAVED_XY_REGNUM",
")",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"emit_move_after_reload",
"(",
"gen_rtx_REG",
"(",
"HImode",
",",
"SOFT_Z_REGNUM",
")",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"emit_move_after_reload",
"(",
"m68hc11_soft_tmp_reg",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"emit_move_after_reload",
"(",
"hard_frame_pointer_rtx",
",",
"stack_pop_word",
",",
"scratch",
")",
";",
"else",
"if",
"(",
"current_function_trap",
"&&",
"return_size",
"!=",
"0",
")",
"{",
"rtx",
"addr_reg",
"=",
"stack_pointer_rtx",
";",
"if",
"(",
"!",
"TARGET_M6812",
")",
"{",
"emit_move_after_reload",
"(",
"scratch",
",",
"stack_pointer_rtx",
",",
"0",
")",
";",
"addr_reg",
"=",
"scratch",
";",
"}",
"emit_move_after_reload",
"(",
"gen_rtx_MEM",
"(",
"HImode",
",",
"gen_rtx_PLUS",
"(",
"HImode",
",",
"addr_reg",
",",
"const1_rtx",
")",
")",
",",
"d_reg",
",",
"0",
")",
";",
"if",
"(",
"return_size",
">",
"HARD_REG_SIZE",
")",
"emit_move_after_reload",
"(",
"gen_rtx_MEM",
"(",
"HImode",
",",
"gen_rtx_PLUS",
"(",
"HImode",
",",
"addr_reg",
",",
"GEN_INT",
"(",
"3",
")",
")",
")",
",",
"ix_reg",
",",
"0",
")",
";",
"}",
"emit_jump_insn",
"(",
"gen_return",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"epilogue",
"into",
"RTL",
"."
] | [
"m68hc11",
"1",
"0",
"0",
"2",
"4",
"3",
"8",
"10",
"2",
"2",
"2",
"1",
"0",
"0",
"0",
"3",
"0"
] | m68hc111 | expand_epilogue | m68hc11 | MPU | GCC | 23,656 | 429 | 1 | [] |
[
"<s>",
"bool",
"function_checker",
"::",
"require_immediate",
"(",
"unsigned",
"int",
"argno",
",",
"HOST_WIDE_INT",
"min",
",",
"HOST_WIDE_INT",
"max",
")",
"const",
"{",
"gcc_assert",
"(",
"argno",
"<",
"m_nargs",
")",
";",
"tree",
"arg",
"=",
"m_args",
"[",
"argno",
"]",
";",
"if",
"(",
"!",
"tree_fits_uhwi_p",
"(",
"arg",
")",
")",
"{",
"report_non_ice",
"(",
"argno",
")",
";",
"return",
"false",
";",
"}",
"return",
"require_immediate_range",
"(",
"argno",
",",
"min",
",",
"max",
")",
";",
"}",
"</s>"
] | [
"Check",
"that",
"argument",
"ARGNO",
"is",
"an",
"integer",
"constant",
"expression",
"and",
"store",
"its",
"value",
"in",
"VALUE_OUT",
"if",
"so",
".",
"The",
"caller",
"should",
"first",
"check",
"that",
"argument",
"ARGNO",
"exists",
"."
] | [
"riscv"
] | riscv-vector-builtins | require_immediate | riscv | CPU | GCC | 23,657 | 61 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd",
"(",
"SDValue",
"X",
",",
"ConstantSDNode",
"*",
"XC",
",",
"ConstantSDNode",
"*",
"CC",
",",
"SDValue",
"Y",
",",
"unsigned",
"OldShiftOpcode",
",",
"unsigned",
"NewShiftOpcode",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"XC",
"&&",
"OldShiftOpcode",
"==",
"ISD",
"::",
"SRL",
"&&",
"XC",
"->",
"isOne",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"NewShiftOpcode",
"==",
"ISD",
"::",
"SRL",
"&&",
"CC",
"->",
"isOne",
"(",
")",
")",
"return",
"true",
";",
"return",
"!",
"XC",
";",
"}",
"</s>"
] | [
"Given",
"the",
"pattern",
"(",
"X",
"&",
"(",
"C",
"l",
">",
">",
"/",
"<",
"<",
"Y",
")",
")",
"==/",
"!",
"=",
"0",
"return",
"true",
"if",
"it",
"should",
"be",
"transformed",
"into",
":",
"(",
"(",
"X",
"<",
"<",
"/l",
">",
">",
"Y",
")",
"&",
"C",
")",
"==/",
"!",
"=",
"0",
"WARNING",
":",
"if",
"'",
"X",
"'",
"is",
"a",
"constant",
",",
"the",
"fold",
"may",
"deadlock",
"!",
"FIXME",
":",
"we",
"could",
"avoid",
"passing",
"XC",
",",
"but",
"we",
"ca",
"n't",
"use",
"isConstOrConstSplat",
"(",
")",
"here",
"because",
"it",
"can",
"end",
"up",
"being",
"not",
"linked",
"in",
"."
] | [
"RISCV",
"RISCV",
"ISD::SRL",
"ISD::SRL"
] | RISCVISelLowering33 | shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd | RISCV | CPU | LLVM | 23,658 | 72 | 1 | [] |
[
"<s>",
"bool",
"PPCSubtarget",
"::",
"enableMachinePipeliner",
"(",
")",
"const",
"{",
"return",
"(",
"CPUDirective",
"==",
"PPC",
"::",
"DIR_PWR9",
")",
"&&",
"EnableMachinePipeliner",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"subtarget",
"should",
"run",
"MachinePipeliner",
"."
] | [
"PowerPC",
"PPC",
"PPC::DIR_PWR9"
] | PPCSubtarget10 | enableMachinePipeliner | PowerPC | CPU | LLVM | 23,659 | 20 | 1 | [] |
[
"<s>",
"bool",
"ARMFrameLowering",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"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",
";",
"unsigned",
"FltOpc",
"=",
"ARM",
"::",
"VSTMDDB_UPD",
";",
"emitPushInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"PushOpc",
",",
"PushOneOpc",
",",
"false",
",",
"&",
"isARMArea1Register",
",",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"emitPushInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"PushOpc",
",",
"PushOneOpc",
",",
"false",
",",
"&",
"isARMArea2Register",
",",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"emitPushInst",
"(",
"MBB",
",",
"MI",
",",
"CSI",
",",
"FltOpc",
",",
"0",
",",
"true",
",",
"&",
"isARMArea3Register",
",",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"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",
"ARM::VSTMDDB_UPD",
"ARM",
"ARM",
"0",
"ARM"
] | ARMFrameLowering25 | spillCalleeSavedRegisters | ARM | CPU | LLVM | 23,660 | 177 | 1 | [] |
[
"<s>",
"static",
"int",
"frv_string_begins_with",
"(",
"tree",
"name",
",",
"const",
"char",
"*",
"prefix",
")",
"{",
"int",
"prefix_len",
"=",
"strlen",
"(",
"prefix",
")",
";",
"return",
"(",
"TREE_STRING_LENGTH",
"(",
"name",
")",
">",
"prefix_len",
"&&",
"strncmp",
"(",
"TREE_STRING_POINTER",
"(",
"name",
")",
",",
"prefix",
",",
"prefix_len",
")",
"==",
"0",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"NAME",
"(",
"a",
"STRING_CST",
"node",
")",
"begins",
"with",
"PREFIX",
"."
] | [
"frv",
"0"
] | frv2 | frv_string_begins_with | frv | VLIW | GCC | 23,661 | 46 | 1 | [] |
[
"<s>",
"SDValue",
"MipsTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"SDLoc",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"MipsCC",
"MipsCCInfo",
"(",
"CallConv",
",",
"Subtarget",
".",
"isABI_O32",
"(",
")",
",",
"Subtarget",
".",
"isFP64bit",
"(",
")",
",",
"CCInfo",
")",
";",
"MipsCCInfo",
".",
"analyzeReturn",
"(",
"Outs",
",",
"Subtarget",
".",
"abiUsesSoftFloat",
"(",
")",
",",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getReturnType",
"(",
")",
")",
";",
"SDValue",
"Flag",
";",
"SmallVector",
"<",
"SDValue",
",",
"4",
">",
"RetOps",
"(",
"1",
",",
"Chain",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"SDValue",
"Val",
"=",
"OutVals",
"[",
"i",
"]",
";",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
"!=",
"RVLocs",
"[",
"i",
"]",
".",
"getLocVT",
"(",
")",
")",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocVT",
"(",
")",
",",
"Val",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"hasStructRetAttr",
"(",
")",
")",
"{",
"MipsFunctionInfo",
"*",
"MipsFI",
"=",
"MF",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"Reg",
"=",
"MipsFI",
"->",
"getSRetReturnReg",
"(",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"llvm_unreachable",
"(",
"\"sret virtual register not created in the entry block\"",
")",
";",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"Reg",
",",
"getPointerTy",
"(",
")",
")",
";",
"unsigned",
"V0",
"=",
"Subtarget",
".",
"isABI_N64",
"(",
")",
"?",
"Mips",
"::",
"V0_64",
":",
"Mips",
"::",
"V0",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"V0",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"V0",
",",
"getPointerTy",
"(",
")",
")",
")",
";",
"}",
"RetOps",
"[",
"0",
"]",
"=",
"Chain",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"RetOps",
".",
"push_back",
"(",
"Flag",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"MipsISD",
"::",
"Ret",
",",
"DL",
",",
"MVT",
"::",
"Other",
",",
"RetOps",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"Mips",
"Mips",
"ISD::OutputArg",
"16",
"Mips",
"Mips",
"Mips",
"4",
"1",
"0",
"\"Can only return in registers!\"",
"ISD::BITCAST",
"1",
"Mips",
"Mips",
"Mips",
"Mips",
"\"sret virtual register not created in the entry block\"",
"Mips::V0_64",
"Mips::V0",
"1",
"0",
"MipsISD::Ret",
"MVT::Other"
] | MipsISelLowering120 | LowerReturn | Mips | CPU | LLVM | 23,662 | 451 | 1 | [] |
[
"<s>",
"const",
"MCFixupKindInfo",
"&",
"SystemZMCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"SystemZ",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"\"FK_390_PC12DBL\"",
",",
"4",
",",
"12",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"FK_390_PC16DBL\"",
",",
"0",
",",
"16",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"FK_390_PC24DBL\"",
",",
"0",
",",
"24",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"FK_390_PC32DBL\"",
",",
"0",
",",
"32",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"FK_390_TLS_CALL\"",
",",
"0",
",",
"0",
",",
"0",
"}",
"}",
";",
"if",
"(",
"Kind",
">=",
"FirstLiteralRelocationKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"FK_NONE",
")",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";",
"assert",
"(",
"unsigned",
"(",
"Kind",
"-",
"FirstTargetFixupKind",
")",
"<",
"getNumFixupKinds",
"(",
")",
"&&",
"\"Invalid kind!\"",
")",
";",
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";",
"}",
"</s>"
] | [
"Get",
"information",
"on",
"a",
"fixup",
"kind",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ::NumTargetFixupKinds",
"\"FK_390_PC12DBL\"",
"4",
"12",
"\"FK_390_PC16DBL\"",
"0",
"16",
"\"FK_390_PC24DBL\"",
"0",
"24",
"\"FK_390_PC32DBL\"",
"0",
"32",
"\"FK_390_TLS_CALL\"",
"0",
"0",
"0",
"\"Invalid kind!\""
] | SystemZMCAsmBackend22 | getFixupKindInfo | SystemZ | CPU | LLVM | 23,663 | 135 | 1 | [] |
[
"<s>",
"static",
"void",
"alpha_conditional_register_usage",
"(",
"void",
")",
"{",
"int",
"i",
";",
"if",
"(",
"!",
"TARGET_FPREGS",
")",
"for",
"(",
"i",
"=",
"32",
";",
"i",
"<",
"63",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
";",
"}",
"</s>"
] | [
"On",
"the",
"Alpha",
",",
"we",
"use",
"this",
"to",
"disable",
"the",
"floating-point",
"registers",
"when",
"they",
"do",
"n't",
"exist",
"."
] | [
"alpha",
"32",
"63",
"1"
] | alpha | alpha_conditional_register_usage | alpha | MPU | GCC | 23,664 | 41 | 1 | [] |
[
"<s>",
"void",
"alpha_split_tmode_pair",
"(",
"rtx",
"operands",
"[",
"4",
"]",
",",
"machine_mode",
"mode",
",",
"bool",
"fixup_overlap",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"operands",
"[",
"1",
"]",
")",
")",
"{",
"case",
"REG",
":",
"operands",
"[",
"3",
"]",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"REGNO",
"(",
"operands",
"[",
"1",
"]",
")",
"+",
"1",
")",
";",
"operands",
"[",
"2",
"]",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"REGNO",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"break",
";",
"case",
"MEM",
":",
"operands",
"[",
"3",
"]",
"=",
"adjust_address",
"(",
"operands",
"[",
"1",
"]",
",",
"DImode",
",",
"8",
")",
";",
"operands",
"[",
"2",
"]",
"=",
"adjust_address",
"(",
"operands",
"[",
"1",
"]",
",",
"DImode",
",",
"0",
")",
";",
"break",
";",
"case",
"CONST_INT",
":",
"case",
"CONST_DOUBLE",
":",
"gcc_assert",
"(",
"operands",
"[",
"1",
"]",
"==",
"CONST0_RTX",
"(",
"mode",
")",
")",
";",
"operands",
"[",
"2",
"]",
"=",
"operands",
"[",
"3",
"]",
"=",
"const0_rtx",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"switch",
"(",
"GET_CODE",
"(",
"operands",
"[",
"0",
"]",
")",
")",
"{",
"case",
"REG",
":",
"operands",
"[",
"1",
"]",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"REGNO",
"(",
"operands",
"[",
"0",
"]",
")",
"+",
"1",
")",
";",
"operands",
"[",
"0",
"]",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"REGNO",
"(",
"operands",
"[",
"0",
"]",
")",
")",
";",
"break",
";",
"case",
"MEM",
":",
"operands",
"[",
"1",
"]",
"=",
"adjust_address",
"(",
"operands",
"[",
"0",
"]",
",",
"DImode",
",",
"8",
")",
";",
"operands",
"[",
"0",
"]",
"=",
"adjust_address",
"(",
"operands",
"[",
"0",
"]",
",",
"DImode",
",",
"0",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"fixup_overlap",
"&&",
"reg_overlap_mentioned_p",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"3",
"]",
")",
")",
"{",
"std",
"::",
"swap",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"1",
"]",
")",
";",
"std",
"::",
"swap",
"(",
"operands",
"[",
"2",
"]",
",",
"operands",
"[",
"3",
"]",
")",
";",
"}",
"}",
"</s>"
] | [
"Split",
"a",
"TImode",
"or",
"TFmode",
"move",
"from",
"OP",
"[",
"1",
"]",
"to",
"OP",
"[",
"0",
"]",
"into",
"a",
"pair",
"of",
"DImode",
"moves",
"from",
"OP",
"[",
"2,3",
"]",
"to",
"OP",
"[",
"0,1",
"]",
".",
"If",
"FIXUP_OVERLAP",
"is",
"true",
",",
"guarantee",
"that",
"the",
"sequence",
"set",
"(",
"OP",
"[",
"0",
"]",
"OP",
"[",
"2",
"]",
")",
"set",
"(",
"OP",
"[",
"1",
"]",
"OP",
"[",
"3",
"]",
")",
"is",
"valid",
".",
"Naturally",
",",
"output",
"operand",
"ordering",
"is",
"little-endian",
".",
"This",
"is",
"used",
"by",
"*",
"movtf_internal",
"and",
"*",
"movti_internal",
"."
] | [
"alpha",
"4",
"1",
"3",
"1",
"1",
"2",
"1",
"3",
"1",
"8",
"2",
"1",
"0",
"1",
"2",
"3",
"0",
"1",
"0",
"1",
"0",
"0",
"1",
"0",
"8",
"0",
"0",
"0",
"0",
"3",
"0",
"1",
"2",
"3"
] | alpha4 | alpha_split_tmode_pair | alpha | MPU | GCC | 23,665 | 299 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isTailCall",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
"->",
"isBranch",
"(",
")",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"&",
"Op",
":",
"MI",
"->",
"operands",
"(",
")",
")",
"if",
"(",
"Op",
".",
"isGlobal",
"(",
")",
"||",
"Op",
".",
"isSymbol",
"(",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Determines",
"whether",
"Inst",
"is",
"a",
"tail",
"call",
"instruction",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonInstrInfo (2) | isTailCall | Hexagon | DSP | LLVM | 23,666 | 57 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
",",
"Align",
"Alignment",
",",
"MachineMemOperand",
"::",
"Flags",
"Flags",
",",
"bool",
"*",
"Fast",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"false",
";",
"EVT",
"ElemVT",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"if",
"(",
"Alignment",
">=",
"ElemVT",
".",
"getStoreSize",
"(",
")",
")",
"{",
"if",
"(",
"Fast",
")",
"*",
"Fast",
"=",
"true",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"RISCV",
"RISCV"
] | RISCVISelLowering1 | allowsMisalignedMemoryAccesses | RISCV | CPU | LLVM | 23,667 | 74 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"begin",
"(",
")",
"const",
"{",
"return",
"getStart",
"(",
")",
";",
"}",
"</s>"
] | [
"Recipe",
"iterator",
"methods",
"."
] | [
"AArch64"
] | AArch64A57FPLoadBalancing11 | begin | AArch64 | CPU | LLVM | 23,668 | 14 | 1 | [] |
[
"<s>",
"bool",
"isStackIdSafeForLocalArea",
"(",
"unsigned",
"StackId",
")",
"const",
"override",
"{",
"return",
"StackId",
"!=",
"TargetStackID",
"::",
"SVEVector",
";",
"}",
"</s>"
] | [
"This",
"method",
"returns",
"whether",
"or",
"not",
"it",
"is",
"safe",
"for",
"an",
"object",
"with",
"the",
"given",
"stack",
"id",
"to",
"be",
"bundled",
"into",
"the",
"local",
"area",
"."
] | [
"AArch64"
] | AArch64FrameLowering16 | isStackIdSafeForLocalArea | AArch64 | CPU | LLVM | 23,669 | 17 | 1 | [] |
[
"<s>",
"bool",
"OR1KAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"SmallVectorImpl",
"<",
"MCParsedAsmOperand",
"*",
">",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
")",
"{",
"MCInst",
"Inst",
";",
"SMLoc",
"ErrorLoc",
";",
"unsigned",
"Kind",
";",
"unsigned",
"ErrorInfo",
";",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"std",
"::",
"string",
">",
",",
"4",
">",
"MapAndConstraints",
";",
"switch",
"(",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Kind",
",",
"Inst",
",",
"MapAndConstraints",
",",
"ErrorInfo",
",",
"false",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"Instruction use requires option to be enabled\"",
")",
";",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"Unrecognized instruction mnemonic\"",
")",
";",
"case",
"Match_InvalidOperand",
":",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0U",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"Too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"OR1KOperand",
"*",
")",
"Operands",
"[",
"ErrorInfo",
"]",
")",
"->",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"IDLoc",
",",
"\"Invalid operand for instruction\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Unknown match type detected!\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"OR1K",
"OR1K",
"4",
"\"Instruction use requires option to be enabled\"",
"\"Unrecognized instruction mnemonic\"",
"0U",
"\"Too few operands for instruction\"",
"OR1K",
"\"Invalid operand for instruction\"",
"\"Unknown match type detected!\""
] | OR1KAsmParser | MatchAndEmitInstruction | OR1K | CPU | LLVM | 23,670 | 185 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterInfo",
"*",
"XtensaSubtarget",
"::",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"Xtensa",
"Xtensa"
] | XtensaSubtarget1 | getRegisterInfo | Xtensa | MPU | LLVM | 23,671 | 19 | 1 | [] |
[
"<s>",
"bool",
"WaitcntBrackets",
"::",
"merge",
"(",
"const",
"WaitcntBrackets",
"&",
"Other",
")",
"{",
"bool",
"StrictDom",
"=",
"false",
";",
"VgprUB",
"=",
"std",
"::",
"max",
"(",
"VgprUB",
",",
"Other",
".",
"VgprUB",
")",
";",
"SgprUB",
"=",
"std",
"::",
"max",
"(",
"SgprUB",
",",
"Other",
".",
"SgprUB",
")",
";",
"for",
"(",
"auto",
"T",
":",
"inst_counter_types",
"(",
")",
")",
"{",
"const",
"bool",
"OldOutOfOrder",
"=",
"counterOutOfOrder",
"(",
"T",
")",
";",
"const",
"unsigned",
"OldEvents",
"=",
"PendingEvents",
"&",
"WaitEventMaskForInst",
"[",
"T",
"]",
";",
"const",
"unsigned",
"OtherEvents",
"=",
"Other",
".",
"PendingEvents",
"&",
"WaitEventMaskForInst",
"[",
"T",
"]",
";",
"if",
"(",
"OtherEvents",
"&",
"~",
"OldEvents",
")",
"StrictDom",
"=",
"true",
";",
"PendingEvents",
"|=",
"OtherEvents",
";",
"const",
"unsigned",
"MyPending",
"=",
"ScoreUBs",
"[",
"T",
"]",
"-",
"ScoreLBs",
"[",
"T",
"]",
";",
"const",
"unsigned",
"OtherPending",
"=",
"Other",
".",
"ScoreUBs",
"[",
"T",
"]",
"-",
"Other",
".",
"ScoreLBs",
"[",
"T",
"]",
";",
"const",
"unsigned",
"NewUB",
"=",
"ScoreLBs",
"[",
"T",
"]",
"+",
"std",
"::",
"max",
"(",
"MyPending",
",",
"OtherPending",
")",
";",
"if",
"(",
"NewUB",
"<",
"ScoreLBs",
"[",
"T",
"]",
")",
"report_fatal_error",
"(",
"\"waitcnt score overflow\"",
")",
";",
"MergeInfo",
"M",
";",
"M",
".",
"OldLB",
"=",
"ScoreLBs",
"[",
"T",
"]",
";",
"M",
".",
"OtherLB",
"=",
"Other",
".",
"ScoreLBs",
"[",
"T",
"]",
";",
"M",
".",
"MyShift",
"=",
"NewUB",
"-",
"ScoreUBs",
"[",
"T",
"]",
";",
"M",
".",
"OtherShift",
"=",
"NewUB",
"-",
"Other",
".",
"ScoreUBs",
"[",
"T",
"]",
";",
"ScoreUBs",
"[",
"T",
"]",
"=",
"NewUB",
";",
"StrictDom",
"|=",
"mergeScore",
"(",
"M",
",",
"LastFlat",
"[",
"T",
"]",
",",
"Other",
".",
"LastFlat",
"[",
"T",
"]",
")",
";",
"bool",
"RegStrictDom",
"=",
"false",
";",
"for",
"(",
"int",
"J",
"=",
"0",
";",
"J",
"<=",
"VgprUB",
";",
"J",
"++",
")",
"{",
"RegStrictDom",
"|=",
"mergeScore",
"(",
"M",
",",
"VgprScores",
"[",
"T",
"]",
"[",
"J",
"]",
",",
"Other",
".",
"VgprScores",
"[",
"T",
"]",
"[",
"J",
"]",
")",
";",
"}",
"if",
"(",
"T",
"==",
"VM_CNT",
")",
"{",
"for",
"(",
"int",
"J",
"=",
"0",
";",
"J",
"<=",
"VgprUB",
";",
"J",
"++",
")",
"{",
"unsigned",
"char",
"NewVmemTypes",
"=",
"VgprVmemTypes",
"[",
"J",
"]",
"|",
"Other",
".",
"VgprVmemTypes",
"[",
"J",
"]",
";",
"RegStrictDom",
"|=",
"NewVmemTypes",
"!=",
"VgprVmemTypes",
"[",
"J",
"]",
";",
"VgprVmemTypes",
"[",
"J",
"]",
"=",
"NewVmemTypes",
";",
"}",
"}",
"if",
"(",
"T",
"==",
"LGKM_CNT",
")",
"{",
"for",
"(",
"int",
"J",
"=",
"0",
";",
"J",
"<=",
"SgprUB",
";",
"J",
"++",
")",
"{",
"RegStrictDom",
"|=",
"mergeScore",
"(",
"M",
",",
"SgprScores",
"[",
"J",
"]",
",",
"Other",
".",
"SgprScores",
"[",
"J",
"]",
")",
";",
"}",
"}",
"if",
"(",
"RegStrictDom",
"&&",
"!",
"OldOutOfOrder",
")",
"StrictDom",
"=",
"true",
";",
"}",
"return",
"StrictDom",
";",
"}",
"</s>"
] | [
"Merge",
"target",
"triples",
"."
] | [
"AMDGPU",
"\"waitcnt score overflow\"",
"0",
"0",
"0"
] | SIInsertWaitcnts1 | merge | AMDGPU | GPU | LLVM | 23,672 | 398 | 1 | [] |
[
"<s>",
"static",
"void",
"hwloop_fail",
"(",
"hwloop_info",
"loop",
")",
"{",
"rtx",
"insn",
",",
"test",
",",
"testreg",
";",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"\"splitting doloop insn %d\\n\"",
",",
"INSN_UID",
"(",
"loop",
"->",
"loop_end",
")",
")",
";",
"insn",
"=",
"gen_addsi3",
"(",
"loop",
"->",
"iter_reg",
",",
"loop",
"->",
"iter_reg",
",",
"constm1_rtx",
")",
";",
"if",
"(",
"loop",
"->",
"head",
"==",
"NULL",
"||",
"loop",
"->",
"iter_reg_used_outside",
"||",
"loop",
"->",
"iter_reg_used",
"||",
"TEST_HARD_REG_BIT",
"(",
"loop",
"->",
"regs_set_in_loop",
",",
"REGNO",
"(",
"loop",
"->",
"iter_reg",
")",
")",
"||",
"loop",
"->",
"incoming_dest",
"!=",
"loop",
"->",
"head",
"||",
"EDGE_COUNT",
"(",
"loop",
"->",
"head",
"->",
"preds",
")",
"!=",
"2",
")",
"emit_insn_before",
"(",
"insn",
",",
"loop",
"->",
"loop_end",
")",
";",
"else",
"{",
"rtx_insn",
"*",
"t",
"=",
"loop",
"->",
"start_label",
";",
"while",
"(",
"!",
"NOTE_P",
"(",
"t",
")",
"||",
"NOTE_KIND",
"(",
"t",
")",
"!=",
"NOTE_INSN_BASIC_BLOCK",
")",
"t",
"=",
"NEXT_INSN",
"(",
"t",
")",
";",
"emit_insn_after",
"(",
"insn",
",",
"t",
")",
";",
"}",
"testreg",
"=",
"SET_DEST",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"loop",
"->",
"loop_end",
")",
",",
"0",
",",
"2",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"testreg",
")",
"==",
"SCRATCH",
")",
"testreg",
"=",
"loop",
"->",
"iter_reg",
";",
"else",
"emit_insn_before",
"(",
"gen_movsi",
"(",
"testreg",
",",
"loop",
"->",
"iter_reg",
")",
",",
"loop",
"->",
"loop_end",
")",
";",
"test",
"=",
"gen_rtx_NE",
"(",
"VOIDmode",
",",
"testreg",
",",
"const0_rtx",
")",
";",
"insn",
"=",
"emit_jump_insn_before",
"(",
"gen_cbranchsi4",
"(",
"test",
",",
"testreg",
",",
"const0_rtx",
",",
"loop",
"->",
"start_label",
")",
",",
"loop",
"->",
"loop_end",
")",
";",
"JUMP_LABEL",
"(",
"insn",
")",
"=",
"loop",
"->",
"start_label",
";",
"LABEL_NUSES",
"(",
"loop",
"->",
"start_label",
")",
"++",
";",
"delete_insn",
"(",
"loop",
"->",
"loop_end",
")",
";",
"}",
"</s>"
] | [
"A",
"callback",
"for",
"the",
"hw-doloop",
"pass",
".",
"Called",
"when",
"a",
"loop",
"we",
"have",
"discovered",
"turns",
"out",
"not",
"to",
"be",
"optimizable",
";",
"we",
"have",
"to",
"split",
"the",
"doloop_end",
"pattern",
"into",
"a",
"subtract",
"and",
"a",
"test",
"."
] | [
"c6x",
"\"splitting doloop insn %d\\n\"",
"2",
"0",
"2"
] | c6x | hwloop_fail | c6x | VLIW | GCC | 23,673 | 255 | 1 | [] |
[
"<s>",
"unsigned",
"getNumFixupKinds",
"(",
")",
"const",
"override",
"{",
"return",
"Z80",
"::",
"NumTargetFixupKinds",
";",
"}",
"</s>"
] | [
"Get",
"the",
"number",
"of",
"target",
"specific",
"fixup",
"kinds",
"."
] | [
"Z80",
"Z80::NumTargetFixupKinds"
] | Z80AsmBackend1 | getNumFixupKinds | Z80 | MPU | LLVM | 23,674 | 13 | 1 | [] |
[
"<s>",
"void",
"initialize",
"(",
"MCContext",
"&",
"Context",
")",
"{",
"Ctx",
"=",
"&",
"Context",
";",
"usesSgprAt",
"(",
"SgprIndexUnusedMin",
"=",
"-",
"1",
")",
";",
"usesVgprAt",
"(",
"VgprIndexUnusedMin",
"=",
"-",
"1",
")",
";",
"}",
"</s>"
] | [
"Initialize",
"the",
"strategy",
"after",
"building",
"the",
"DAG",
"for",
"a",
"new",
"region",
"."
] | [
"AMDGPU",
"1",
"1"
] | AMDGPUAsmParser1 | initialize | AMDGPU | GPU | LLVM | 23,675 | 30 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"RISCVTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"StringRef",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"RISCV",
"::",
"GPRRegClass",
")",
";",
"default",
":",
"break",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"RISCV",
"RISCV",
"1",
"0",
"0U",
"RISCV::GPRRegClass"
] | RISCVISelLowering | getRegForInlineAsmConstraint | RISCV | CPU | LLVM | 23,676 | 81 | 1 | [] |
[
"<s>",
"bool",
"GBZ80InstrInfo",
"::",
"isBranchOffsetInRange",
"(",
"unsigned",
"BranchOp",
",",
"int64_t",
"BrOffset",
")",
"const",
"{",
"switch",
"(",
"BranchOp",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"unexpected opcode!\"",
")",
";",
"case",
"GB",
"::",
"CALL_cc_nn",
":",
"case",
"GB",
"::",
"CALL_nn",
":",
"case",
"GB",
"::",
"JP_cc_nn",
":",
"case",
"GB",
"::",
"JP_nn",
":",
"return",
"true",
";",
"case",
"GB",
"::",
"JR_cc_e",
":",
"case",
"GB",
"::",
"JR_e",
":",
"return",
"BrOffset",
">=",
"-",
"127",
"&&",
"BrOffset",
"<=",
"129",
";",
"}",
"}",
"</s>"
] | [
"Determine",
"if",
"the",
"branch",
"target",
"is",
"in",
"range",
"."
] | [
"GBZ80",
"GB",
"\"unexpected opcode!\"",
"GB::CALL_cc_nn",
"GB::CALL_nn",
"GB::JP_cc_nn",
"GB::JP_nn",
"GB::JR_cc_e",
"GB::JR_e",
"127",
"129"
] | GBZ80InstrInfo | isBranchOffsetInRange | GBZ80 | MPU | LLVM | 23,677 | 70 | 1 | [] |
[
"<s>",
"static",
"tree",
"arm_cxx_guard_type",
"(",
"void",
")",
"{",
"return",
"TARGET_AAPCS_BASED",
"?",
"integer_type_node",
":",
"long_long_integer_type_node",
";",
"}",
"</s>"
] | [
"The",
"generic",
"C++",
"ABI",
"says",
"64-bit",
"(",
"long",
"long",
")",
".",
"The",
"EABI",
"says",
"32-bit",
"."
] | [
"arm"
] | arm | arm_cxx_guard_type | arm | CPU | GCC | 23,678 | 15 | 1 | [] |
[
"<s>",
"unsigned",
"SystemZRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"assert",
"(",
"0",
"&&",
"\"What is the frame register\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"SystemZ",
"SystemZ",
"0",
"\"What is the frame register\"",
"0"
] | SystemZRegisterInfo13 | getFrameRegister | SystemZ | CPU | LLVM | 23,679 | 23 | 1 | [] |
[
"<s>",
"void",
"SIWholeQuadMode",
"::",
"processBlock",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"unsigned",
"LiveMaskReg",
",",
"bool",
"isEntry",
")",
"{",
"auto",
"BII",
"=",
"Blocks",
".",
"find",
"(",
"&",
"MBB",
")",
";",
"if",
"(",
"BII",
"==",
"Blocks",
".",
"end",
"(",
")",
")",
"return",
";",
"const",
"BlockInfo",
"&",
"BI",
"=",
"BII",
"->",
"second",
";",
"if",
"(",
"!",
"(",
"BI",
".",
"InNeeds",
"&",
"StateWQM",
")",
")",
"return",
";",
"if",
"(",
"!",
"isEntry",
"&&",
"!",
"(",
"BI",
".",
"Needs",
"&",
"StateExact",
")",
"&&",
"BI",
".",
"OutNeeds",
"!=",
"StateExact",
")",
"return",
";",
"unsigned",
"SavedWQMReg",
"=",
"0",
";",
"bool",
"WQMFromExec",
"=",
"isEntry",
";",
"char",
"State",
"=",
"isEntry",
"?",
"StateExact",
":",
"StateWQM",
";",
"auto",
"II",
"=",
"MBB",
".",
"getFirstNonPHI",
"(",
")",
",",
"IE",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"II",
"!=",
"IE",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"++",
"II",
";",
"if",
"(",
"TII",
"->",
"isScalarUnit",
"(",
"MI",
")",
"&&",
"!",
"MI",
".",
"isTerminator",
"(",
")",
")",
"continue",
";",
"if",
"(",
"TargetInstrInfo",
"::",
"isGenericOpcode",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
")",
"{",
"if",
"(",
"MI",
".",
"getNumExplicitOperands",
"(",
")",
">=",
"1",
")",
"{",
"const",
"MachineOperand",
"&",
"Op",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"Op",
".",
"isReg",
"(",
")",
")",
"{",
"if",
"(",
"TRI",
"->",
"isSGPRReg",
"(",
"*",
"MRI",
",",
"Op",
".",
"getReg",
"(",
")",
")",
")",
"{",
"continue",
";",
"}",
"}",
"}",
"}",
"char",
"Needs",
"=",
"0",
";",
"char",
"OutNeeds",
"=",
"0",
";",
"auto",
"InstrInfoIt",
"=",
"Instructions",
".",
"find",
"(",
"&",
"MI",
")",
";",
"if",
"(",
"InstrInfoIt",
"!=",
"Instructions",
".",
"end",
"(",
")",
")",
"{",
"Needs",
"=",
"InstrInfoIt",
"->",
"second",
".",
"Needs",
";",
"OutNeeds",
"=",
"InstrInfoIt",
"->",
"second",
".",
"OutNeeds",
";",
"if",
"(",
"OutNeeds",
"==",
"StateExact",
"&&",
"MI",
".",
"isTerminator",
"(",
")",
")",
"{",
"assert",
"(",
"Needs",
"==",
"0",
")",
";",
"Needs",
"=",
"StateExact",
";",
"}",
"}",
"if",
"(",
"Needs",
"&&",
"State",
"!=",
"Needs",
")",
"{",
"if",
"(",
"Needs",
"==",
"StateExact",
")",
"{",
"assert",
"(",
"!",
"SavedWQMReg",
")",
";",
"if",
"(",
"!",
"WQMFromExec",
"&&",
"(",
"OutNeeds",
"&",
"StateWQM",
")",
")",
"SavedWQMReg",
"=",
"MRI",
"->",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_64RegClass",
")",
";",
"toExact",
"(",
"MBB",
",",
"&",
"MI",
",",
"SavedWQMReg",
",",
"LiveMaskReg",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"WQMFromExec",
"==",
"(",
"SavedWQMReg",
"==",
"0",
")",
")",
";",
"toWQM",
"(",
"MBB",
",",
"&",
"MI",
",",
"SavedWQMReg",
")",
";",
"SavedWQMReg",
"=",
"0",
";",
"}",
"State",
"=",
"Needs",
";",
"}",
"}",
"if",
"(",
"(",
"BI",
".",
"OutNeeds",
"&",
"StateWQM",
")",
"&&",
"State",
"!=",
"StateWQM",
")",
"{",
"assert",
"(",
"WQMFromExec",
"==",
"(",
"SavedWQMReg",
"==",
"0",
")",
")",
";",
"toWQM",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
",",
"SavedWQMReg",
")",
";",
"}",
"else",
"if",
"(",
"BI",
".",
"OutNeeds",
"==",
"StateExact",
"&&",
"State",
"!=",
"StateExact",
")",
"{",
"toExact",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
",",
"0",
",",
"LiveMaskReg",
")",
";",
"}",
"}",
"</s>"
] | [
"processBlock",
"-",
"If",
"there",
"are",
"any",
"predecessors",
"whose",
"control",
"can",
"be",
"threaded",
"through",
"to",
"a",
"successor",
",",
"transform",
"them",
"now",
"."
] | [
"AMDGPU",
"SI",
"0",
"1",
"0",
"0",
"0",
"0",
"AMDGPU::SReg_64RegClass",
"0",
"0",
"0",
"0"
] | SIWholeQuadMode22 | processBlock | AMDGPU | GPU | LLVM | 23,680 | 460 | 1 | [] |
[
"<s>",
"SDValue",
"WebAssemblyTargetLowering",
"::",
"LowerFormalArguments",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"SDLoc",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"if",
"(",
"!",
"CallingConvSupported",
"(",
"CallConv",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly doesn't support non-C calling conventions\"",
")",
";",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"addLiveIn",
"(",
"WebAssembly",
"::",
"ARGUMENTS",
")",
";",
"for",
"(",
"const",
"ISD",
"::",
"InputArg",
"&",
"In",
":",
"Ins",
")",
"{",
"if",
"(",
"In",
".",
"Flags",
".",
"isInAlloca",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented inalloca arguments\"",
")",
";",
"if",
"(",
"In",
".",
"Flags",
".",
"isNest",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented nest arguments\"",
")",
";",
"if",
"(",
"In",
".",
"Flags",
".",
"isInConsecutiveRegs",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented cons regs arguments\"",
")",
";",
"if",
"(",
"In",
".",
"Flags",
".",
"isInConsecutiveRegsLast",
"(",
")",
")",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"WebAssembly hasn't implemented cons regs last arguments\"",
")",
";",
"InVals",
".",
"push_back",
"(",
"In",
".",
"Used",
"?",
"DAG",
".",
"getNode",
"(",
"WebAssemblyISD",
"::",
"ARGUMENT",
",",
"DL",
",",
"In",
".",
"VT",
",",
"DAG",
".",
"getTargetConstant",
"(",
"InVals",
".",
"size",
"(",
")",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
":",
"DAG",
".",
"getUNDEF",
"(",
"In",
".",
"VT",
")",
")",
";",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
"->",
"addParam",
"(",
"In",
".",
"VT",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"the",
"Ins",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"WebAssembly",
"WebAssembly",
"ISD::InputArg",
"\"WebAssembly doesn't support non-C calling conventions\"",
"WebAssembly::ARGUMENTS",
"ISD::InputArg",
"\"WebAssembly hasn't implemented inalloca arguments\"",
"\"WebAssembly hasn't implemented nest arguments\"",
"\"WebAssembly hasn't implemented cons regs arguments\"",
"\"WebAssembly hasn't implemented cons regs last arguments\"",
"WebAssemblyISD::ARGUMENT",
"MVT::i32",
"WebAssembly"
] | WebAssemblyISelLowering44 | LowerFormalArguments | WebAssembly | Virtual ISA | LLVM | 23,681 | 240 | 1 | [] |
[
"<s>",
"bool",
"AArch64PassConfig",
"::",
"addPostRegAlloc",
"(",
")",
"{",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableDeadRegisterElimination",
")",
"addPass",
"(",
"createAArch64DeadRegisterDefinitions",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"register",
"allocation",
"pass",
"pipeline",
"but",
"before",
"prolog-epilog",
"insertion",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine3 | addPostRegAlloc | AArch64 | CPU | LLVM | 23,682 | 32 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips_interrupt_extra_call_saved_reg_p",
"(",
"unsigned",
"int",
"regno",
")",
"{",
"if",
"(",
"(",
"ISA_HAS_HILO",
"||",
"TARGET_DSP",
")",
"&&",
"MD_REG_P",
"(",
"regno",
")",
")",
"return",
"true",
";",
"if",
"(",
"TARGET_DSP",
"&&",
"DSP_ACC_REG_P",
"(",
"regno",
")",
")",
"return",
"true",
";",
"if",
"(",
"GP_REG_P",
"(",
"regno",
")",
"&&",
"cfun",
"->",
"machine",
"->",
"use_shadow_register_set",
"==",
"SHADOW_SET_NO",
")",
"{",
"if",
"(",
"regno",
"==",
"GP_REG_FIRST",
")",
"return",
"false",
";",
"if",
"(",
"KERNEL_REG_P",
"(",
"regno",
")",
")",
"return",
"false",
";",
"if",
"(",
"regno",
"==",
"STACK_POINTER_REGNUM",
")",
"return",
"false",
";",
"return",
"call_used_regs",
"[",
"regno",
"]",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"REGNO",
"is",
"a",
"register",
"that",
"is",
"ordinarily",
"call-clobbered",
"but",
"must",
"nevertheless",
"be",
"preserved",
"by",
"an",
"interrupt",
"handler",
"."
] | [
"mips"
] | mips | mips_interrupt_extra_call_saved_reg_p | mips | CPU | GCC | 23,683 | 92 | 1 | [] |
[
"<s>",
"bool",
"AArch64PassConfig",
"::",
"addGlobalInstructionSelect",
"(",
")",
"{",
"addPass",
"(",
"new",
"InstructionSelect",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createAArch64PostSelectOptimize",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"install",
"a",
"(",
"global",
")",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"possibly",
"generic",
"instructions",
"to",
"fully",
"target-specific",
"instructions",
",",
"thereby",
"constraining",
"all",
"generic",
"virtual",
"registers",
"to",
"register",
"classes",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine33 | addGlobalInstructionSelect | AArch64 | CPU | LLVM | 23,684 | 36 | 1 | [] |
[
"<s>",
"bool",
"function_checker",
"::",
"require_immediate",
"(",
"unsigned",
"int",
"argno",
",",
"HOST_WIDE_INT",
"&",
"value_out",
")",
"{",
"gcc_assert",
"(",
"argno",
"<",
"m_nargs",
")",
";",
"tree",
"arg",
"=",
"m_args",
"[",
"argno",
"]",
";",
"if",
"(",
"!",
"tree_fits_uhwi_p",
"(",
"arg",
")",
")",
"{",
"report_non_ice",
"(",
"location",
",",
"fndecl",
",",
"argno",
")",
";",
"return",
"false",
";",
"}",
"value_out",
"=",
"tree_to_uhwi",
"(",
"arg",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Check",
"that",
"argument",
"ARGNO",
"is",
"an",
"integer",
"constant",
"expression",
"and",
"store",
"its",
"value",
"in",
"VALUE_OUT",
"if",
"so",
".",
"The",
"caller",
"should",
"first",
"check",
"that",
"argument",
"ARGNO",
"exists",
"."
] | [
"aarch64"
] | aarch64-sve-builtins | require_immediate | aarch64 | CPU | GCC | 23,685 | 62 | 1 | [] |
[
"<s>",
"void",
"ix86_expand_copysign",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"enum",
"machine_mode",
"mode",
",",
"vmode",
";",
"rtx",
"dest",
",",
"op0",
",",
"op1",
",",
"mask",
",",
"nmask",
";",
"dest",
"=",
"operands",
"[",
"0",
"]",
";",
"op0",
"=",
"operands",
"[",
"1",
"]",
";",
"op1",
"=",
"operands",
"[",
"2",
"]",
";",
"mode",
"=",
"GET_MODE",
"(",
"dest",
")",
";",
"vmode",
"=",
"mode",
"==",
"SFmode",
"?",
"V4SFmode",
":",
"V2DFmode",
";",
"if",
"(",
"GET_CODE",
"(",
"op0",
")",
"==",
"CONST_DOUBLE",
")",
"{",
"rtvec",
"v",
";",
"if",
"(",
"real_isneg",
"(",
"CONST_DOUBLE_REAL_VALUE",
"(",
"op0",
")",
")",
")",
"op0",
"=",
"simplify_unary_operation",
"(",
"ABS",
",",
"mode",
",",
"op0",
",",
"mode",
")",
";",
"if",
"(",
"op0",
"==",
"CONST0_RTX",
"(",
"mode",
")",
")",
"op0",
"=",
"CONST0_RTX",
"(",
"vmode",
")",
";",
"else",
"{",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"v",
"=",
"gen_rtvec",
"(",
"4",
",",
"op0",
",",
"CONST0_RTX",
"(",
"SFmode",
")",
",",
"CONST0_RTX",
"(",
"SFmode",
")",
",",
"CONST0_RTX",
"(",
"SFmode",
")",
")",
";",
"else",
"v",
"=",
"gen_rtvec",
"(",
"2",
",",
"op0",
",",
"CONST0_RTX",
"(",
"DFmode",
")",
")",
";",
"op0",
"=",
"force_reg",
"(",
"vmode",
",",
"gen_rtx_CONST_VECTOR",
"(",
"vmode",
",",
"v",
")",
")",
";",
"}",
"mask",
"=",
"ix86_build_signbit_mask",
"(",
"mode",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"emit_insn",
"(",
"gen_copysignsf3_const",
"(",
"dest",
",",
"op0",
",",
"op1",
",",
"mask",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_copysigndf3_const",
"(",
"dest",
",",
"op0",
",",
"op1",
",",
"mask",
")",
")",
";",
"}",
"else",
"{",
"nmask",
"=",
"ix86_build_signbit_mask",
"(",
"mode",
",",
"0",
",",
"1",
")",
";",
"mask",
"=",
"ix86_build_signbit_mask",
"(",
"mode",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"emit_insn",
"(",
"gen_copysignsf3_var",
"(",
"dest",
",",
"NULL",
",",
"op0",
",",
"op1",
",",
"nmask",
",",
"mask",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_copysigndf3_var",
"(",
"dest",
",",
"NULL",
",",
"op0",
",",
"op1",
",",
"nmask",
",",
"mask",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Expand",
"a",
"copysign",
"operation",
".",
"Special",
"case",
"operand",
"0",
"being",
"a",
"constant",
"."
] | [
"i386",
"0",
"1",
"2",
"4",
"2",
"0",
"0",
"0",
"1",
"0",
"0"
] | i3863 | ix86_expand_copysign | i386 | CPU | GCC | 23,686 | 294 | 1 | [] |
[
"<s>",
"void",
"X86PassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"addPass",
"(",
"createAtomicExpandPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86LowerAMXIntrinsicsPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86LowerAMXTypePass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createX86PreAMXConfigPass",
"(",
")",
")",
";",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"createInterleavedAccessPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86PartialReductionPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createIndirectBrExpandPass",
"(",
")",
")",
";",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
"->",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSWindows",
"(",
")",
")",
"{",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86_64",
")",
"{",
"addPass",
"(",
"createCFGuardDispatchPass",
"(",
")",
")",
";",
"}",
"else",
"{",
"addPass",
"(",
"createCFGuardCheckPass",
"(",
")",
")",
";",
"}",
"}",
"if",
"(",
"TM",
"->",
"Options",
".",
"JMCInstrument",
")",
"addPass",
"(",
"createJMCInstrumenterPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine61 | addIRPasses | X86 | CPU | LLVM | 23,687 | 156 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_sve_pred_valid_immediate",
"(",
"rtx",
"x",
",",
"simd_immediate_info",
"*",
"info",
")",
"{",
"if",
"(",
"aarch64_sve_ptrue_svpattern_p",
"(",
"x",
",",
"info",
")",
")",
"return",
"true",
";",
"if",
"(",
"x",
"==",
"CONST0_RTX",
"(",
"GET_MODE",
"(",
"x",
")",
")",
")",
"{",
"if",
"(",
"info",
")",
"*",
"info",
"=",
"simd_immediate_info",
"(",
"DImode",
",",
"0",
")",
";",
"return",
"true",
";",
"}",
"rtx_vector_builder",
"builder",
";",
"if",
"(",
"!",
"aarch64_get_sve_pred_bits",
"(",
"builder",
",",
"x",
")",
")",
"return",
"false",
";",
"unsigned",
"int",
"elt_size",
"=",
"aarch64_widest_sve_pred_elt_size",
"(",
"builder",
")",
";",
"if",
"(",
"int",
"vl",
"=",
"aarch64_partial_ptrue_length",
"(",
"builder",
",",
"elt_size",
")",
")",
"{",
"machine_mode",
"mode",
"=",
"aarch64_sve_pred_mode",
"(",
"elt_size",
")",
".",
"require",
"(",
")",
";",
"aarch64_svpattern",
"pattern",
"=",
"aarch64_svpattern_for_vl",
"(",
"mode",
",",
"vl",
")",
";",
"if",
"(",
"pattern",
"!=",
"AARCH64_NUM_SVPATTERNS",
")",
"{",
"if",
"(",
"info",
")",
"{",
"scalar_int_mode",
"int_mode",
"=",
"aarch64_sve_element_int_mode",
"(",
"mode",
")",
";",
"*",
"info",
"=",
"simd_immediate_info",
"(",
"int_mode",
",",
"pattern",
")",
";",
"}",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"X",
"is",
"a",
"valid",
"SVE",
"predicate",
".",
"If",
"INFO",
"is",
"nonnull",
",",
"use",
"it",
"to",
"describe",
"valid",
"immediates",
"."
] | [
"aarch64",
"0"
] | aarch64 | aarch64_sve_pred_valid_immediate | aarch64 | CPU | GCC | 23,688 | 155 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"hasUnwantedEffectsWhenEXECEmpty",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"MI",
".",
"mayStore",
"(",
")",
"&&",
"isSMRD",
"(",
"MI",
")",
")",
"return",
"true",
";",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"S_SENDMSG",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"S_SENDMSGHALT",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"EXP",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"EXP_DONE",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"DS_ORDERED_COUNT",
")",
"return",
"true",
";",
"if",
"(",
"MI",
".",
"isInlineAsm",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"V_READFIRSTLANE_B32",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"V_READLANE_B32",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Whether",
"we",
"must",
"prevent",
"this",
"instruction",
"from",
"executing",
"with",
"EXEC",
"=",
"0",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::S_SENDMSG",
"AMDGPU::S_SENDMSGHALT",
"AMDGPU::EXP",
"AMDGPU::EXP_DONE",
"AMDGPU::DS_ORDERED_COUNT",
"AMDGPU::V_READFIRSTLANE_B32",
"AMDGPU::V_READLANE_B32"
] | SIInstrInfo1 | hasUnwantedEffectsWhenEXECEmpty | AMDGPU | GPU | LLVM | 23,689 | 104 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"ENDPGM",
",",
"DL",
",",
"MVT",
"::",
"Other",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"AMDGPU",
"AMDGPU",
"ISD::OutputArg",
"AMDGPUISD::ENDPGM",
"MVT::Other"
] | AMDGPUISelLowering102 | LowerReturn | AMDGPU | GPU | LLVM | 23,690 | 64 | 1 | [] |
[
"<s>",
"void",
"MCS51InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"Register",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MCS51MachineFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"MCS51MachineFunctionInfo",
">",
"(",
")",
";",
"AFI",
"->",
"setHasSpills",
"(",
"true",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"}",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FrameIndex",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
",",
"MFI",
".",
"getObjectAlign",
"(",
"FrameIndex",
")",
")",
";",
"unsigned",
"Opcode",
"=",
"0",
";",
"if",
"(",
"TRI",
"->",
"isTypeLegalForClass",
"(",
"*",
"RC",
",",
"MVT",
"::",
"i8",
")",
")",
"{",
"Opcode",
"=",
"MCS51",
"::",
"STDPtrQRr",
";",
"}",
"else",
"if",
"(",
"TRI",
"->",
"isTypeLegalForClass",
"(",
"*",
"RC",
",",
"MVT",
"::",
"i16",
")",
")",
"{",
"Opcode",
"=",
"MCS51",
"::",
"STDWPtrQRr",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Cannot store this register into a stack slot!\"",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"MCS51",
"MCS51",
"MCS51",
"MCS51",
"0",
"MVT::i8",
"MCS51::STDPtrQRr",
"MVT::i16",
"MCS51::STDWPtrQRr",
"\"Cannot store this register into a stack slot!\"",
"0"
] | MCS51InstrInfo | storeRegToStackSlot | MCS51 | MPU | LLVM | 23,691 | 234 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_sim_wait_units",
"(",
"struct",
"mips_sim",
"*",
"state",
",",
"rtx",
"insn",
")",
"{",
"state_t",
"tmp_state",
";",
"tmp_state",
"=",
"alloca",
"(",
"state_size",
"(",
")",
")",
";",
"while",
"(",
"state",
"->",
"insns_left",
"==",
"0",
"||",
"(",
"memcpy",
"(",
"tmp_state",
",",
"state",
"->",
"dfa_state",
",",
"state_size",
"(",
")",
")",
",",
"state_transition",
"(",
"tmp_state",
",",
"insn",
")",
">=",
"0",
")",
")",
"mips_sim_next_cycle",
"(",
"state",
")",
";",
"}",
"</s>"
] | [
"Advance",
"simulation",
"state",
"STATE",
"until",
"the",
"units",
"required",
"by",
"instruction",
"INSN",
"are",
"available",
"."
] | [
"mips",
"0",
"0"
] | mips3 | mips_sim_wait_units | mips | CPU | GCC | 23,692 | 63 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"rs6000_disable_incompatible_switches",
"(",
"void",
")",
"{",
"HOST_WIDE_INT",
"ignore_masks",
"=",
"rs6000_isa_flags_explicit",
";",
"size_t",
"i",
",",
"j",
";",
"static",
"const",
"struct",
"{",
"const",
"HOST_WIDE_INT",
"no_flag",
";",
"const",
"HOST_WIDE_INT",
"dep_flags",
";",
"const",
"char",
"*",
"const",
"name",
";",
"}",
"flags",
"[",
"]",
"=",
"{",
"{",
"OPTION_MASK_POWER10",
",",
"OTHER_POWER10_MASKS",
",",
"\"power10\"",
"}",
",",
"{",
"OPTION_MASK_P9_VECTOR",
",",
"OTHER_P9_VECTOR_MASKS",
",",
"\"power9-vector\"",
"}",
",",
"{",
"OPTION_MASK_P8_VECTOR",
",",
"OTHER_P8_VECTOR_MASKS",
",",
"\"power8-vector\"",
"}",
",",
"{",
"OPTION_MASK_VSX",
",",
"OTHER_VSX_VECTOR_MASKS",
",",
"\"vsx\"",
"}",
",",
"{",
"OPTION_MASK_ALTIVEC",
",",
"OTHER_ALTIVEC_MASKS",
",",
"\"altivec\"",
"}",
",",
"}",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"flags",
")",
";",
"i",
"++",
")",
"{",
"HOST_WIDE_INT",
"no_flag",
"=",
"flags",
"[",
"i",
"]",
".",
"no_flag",
";",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"no_flag",
")",
"==",
"0",
"&&",
"(",
"rs6000_isa_flags_explicit",
"&",
"no_flag",
")",
"!=",
"0",
")",
"{",
"HOST_WIDE_INT",
"dep_flags",
"=",
"flags",
"[",
"i",
"]",
".",
"dep_flags",
";",
"HOST_WIDE_INT",
"set_flags",
"=",
"(",
"rs6000_isa_flags_explicit",
"&",
"rs6000_isa_flags",
"&",
"dep_flags",
")",
";",
"if",
"(",
"set_flags",
")",
"{",
"for",
"(",
"j",
"=",
"0",
";",
"j",
"<",
"ARRAY_SIZE",
"(",
"rs6000_opt_masks",
")",
";",
"j",
"++",
")",
"if",
"(",
"(",
"set_flags",
"&",
"rs6000_opt_masks",
"[",
"j",
"]",
".",
"mask",
")",
"!=",
"0",
")",
"{",
"set_flags",
"&=",
"~",
"rs6000_opt_masks",
"[",
"j",
"]",
".",
"mask",
";",
"error",
"(",
"\"%<-mno-%s%> turns off %<-m%s%>\"",
",",
"flags",
"[",
"i",
"]",
".",
"name",
",",
"rs6000_opt_masks",
"[",
"j",
"]",
".",
"name",
")",
";",
"}",
"gcc_assert",
"(",
"!",
"set_flags",
")",
";",
"}",
"rs6000_isa_flags",
"&=",
"~",
"dep_flags",
";",
"ignore_masks",
"|=",
"no_flag",
"|",
"dep_flags",
";",
"}",
"}",
"return",
"ignore_masks",
";",
"}",
"</s>"
] | [
"If",
"the",
"user",
"used",
"-mno-vsx",
",",
"we",
"need",
"turn",
"off",
"all",
"of",
"the",
"implicit",
"ISA",
"2.06",
",",
"2.07",
",",
"and",
"3.0",
"options",
"that",
"relate",
"to",
"the",
"vector",
"unit",
"(",
"-mdirect-move",
",",
"-mupper-regs-df",
",",
"etc.",
")",
".",
"If",
"the",
"user",
"used",
"-mno-power8-vector",
",",
"we",
"need",
"to",
"turn",
"off",
"all",
"of",
"the",
"implicit",
"ISA",
"2.07",
"and",
"3.0",
"options",
"that",
"relate",
"to",
"the",
"vector",
"unit",
".",
"If",
"the",
"user",
"used",
"-mno-power9-vector",
",",
"we",
"need",
"to",
"turn",
"off",
"all",
"of",
"the",
"implicit",
"ISA",
"3.0",
"options",
"that",
"relate",
"to",
"the",
"vector",
"unit",
".",
"This",
"function",
"does",
"not",
"handle",
"explicit",
"options",
"such",
"as",
"the",
"user",
"specifying",
"-mdirect-move",
".",
"These",
"are",
"handled",
"in",
"rs6000_option_override_internal",
",",
"and",
"the",
"appropriate",
"error",
"is",
"given",
"if",
"needed",
".",
"We",
"return",
"a",
"mask",
"of",
"all",
"of",
"the",
"implicit",
"options",
"that",
"should",
"not",
"be",
"enabled",
"by",
"default",
"."
] | [
"rs6000",
"\"power10\"",
"\"power9-vector\"",
"\"power8-vector\"",
"\"vsx\"",
"\"altivec\"",
"0",
"0",
"0",
"0",
"0",
"\"%<-mno-%s%> turns off %<-m%s%>\""
] | rs60001 | rs6000_disable_incompatible_switches | rs6000 | CPU | GCC | 23,693 | 241 | 1 | [] |
[
"<s>",
"bool",
"TL45TargetLowering",
"::",
"shouldReduceLoadWidth",
"(",
"SDNode",
"*",
"Load",
",",
"ISD",
"::",
"LoadExtType",
"ExtTy",
",",
"EVT",
"NewVT",
")",
"const",
"{",
"return",
"TargetLoweringBase",
"::",
"shouldReduceLoadWidth",
"(",
"Load",
",",
"ExtTy",
",",
"NewVT",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"believe",
"it",
"is",
"correct",
"and",
"profitable",
"to",
"reduce",
"the",
"load",
"node",
"to",
"a",
"smaller",
"type",
"."
] | [
"TL45",
"TL45",
"ISD::LoadExtType"
] | TL45ISelLowering | shouldReduceLoadWidth | TL45 | MPU | LLVM | 23,694 | 32 | 1 | [] |
[
"<s>",
"static",
"void",
"ia64_option_override",
"(",
"void",
")",
"{",
"unsigned",
"int",
"i",
";",
"cl_deferred_option",
"*",
"opt",
";",
"vec",
"<",
"cl_deferred_option",
">",
"*",
"v",
"=",
"(",
"vec",
"<",
"cl_deferred_option",
">",
"*",
")",
"ia64_deferred_options",
";",
"if",
"(",
"v",
")",
"FOR_EACH_VEC_ELT",
"(",
"*",
"v",
",",
"i",
",",
"opt",
")",
"{",
"switch",
"(",
"opt",
"->",
"opt_index",
")",
"{",
"case",
"OPT_mfixed_range_",
":",
"fix_range",
"(",
"opt",
"->",
"arg",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"if",
"(",
"TARGET_AUTO_PIC",
")",
"target_flags",
"|=",
"MASK_CONST_GP",
";",
"if",
"(",
"optimize",
">=",
"3",
")",
"flag_ira_loop_pressure",
"=",
"1",
";",
"ia64_section_threshold",
"=",
"(",
"OPTION_SET_P",
"(",
"g_switch_value",
")",
"?",
"g_switch_value",
":",
"IA64_DEFAULT_GVALUE",
")",
";",
"init_machine_status",
"=",
"ia64_init_machine_status",
";",
"if",
"(",
"flag_align_functions",
"&&",
"!",
"str_align_functions",
")",
"str_align_functions",
"=",
"\"64\"",
";",
"if",
"(",
"flag_align_loops",
"&&",
"!",
"str_align_loops",
")",
"str_align_loops",
"=",
"\"32\"",
";",
"if",
"(",
"TARGET_ABI_OPEN_VMS",
")",
"flag_no_common",
"=",
"1",
";",
"ia64_override_options_after_change",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_OPTION_OVERRIDE",
"."
] | [
"ia64",
"3",
"1",
"\"64\"",
"\"32\"",
"1"
] | ia64 | ia64_option_override | ia64 | CPU | GCC | 23,695 | 142 | 1 | [] |
[
"<s>",
"int",
"ConvergingVLIWScheduler",
"::",
"SchedulingCost",
"(",
"ReadyQueue",
"&",
"Q",
",",
"SUnit",
"*",
"SU",
",",
"SchedCandidate",
"&",
"Candidate",
",",
"RegPressureDelta",
"&",
"Delta",
",",
"bool",
"verbose",
")",
"{",
"int",
"ResCount",
"=",
"1",
";",
"if",
"(",
"!",
"SU",
"||",
"SU",
"->",
"isScheduled",
")",
"return",
"ResCount",
";",
"if",
"(",
"SU",
"->",
"isScheduleHigh",
")",
"ResCount",
"+=",
"PriorityOne",
";",
"if",
"(",
"Q",
".",
"getID",
"(",
")",
"==",
"TopQID",
")",
"{",
"ResCount",
"+=",
"(",
"SU",
"->",
"getHeight",
"(",
")",
"*",
"ScaleTwo",
")",
";",
"if",
"(",
"Top",
".",
"ResourceModel",
"->",
"isResourceAvailable",
"(",
"SU",
")",
")",
"ResCount",
"<<=",
"FactorOne",
";",
"}",
"else",
"{",
"ResCount",
"+=",
"(",
"SU",
"->",
"getDepth",
"(",
")",
"*",
"ScaleTwo",
")",
";",
"if",
"(",
"Bot",
".",
"ResourceModel",
"->",
"isResourceAvailable",
"(",
"SU",
")",
")",
"ResCount",
"<<=",
"FactorOne",
";",
"}",
"unsigned",
"NumNodesBlocking",
"=",
"0",
";",
"if",
"(",
"Q",
".",
"getID",
"(",
")",
"==",
"TopQID",
")",
"{",
"for",
"(",
"SUnit",
"::",
"const_succ_iterator",
"I",
"=",
"SU",
"->",
"Succs",
".",
"begin",
"(",
")",
",",
"E",
"=",
"SU",
"->",
"Succs",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"if",
"(",
"getSingleUnscheduledPred",
"(",
"I",
"->",
"getSUnit",
"(",
")",
")",
"==",
"SU",
")",
"++",
"NumNodesBlocking",
";",
"}",
"else",
"{",
"for",
"(",
"SUnit",
"::",
"const_pred_iterator",
"I",
"=",
"SU",
"->",
"Preds",
".",
"begin",
"(",
")",
",",
"E",
"=",
"SU",
"->",
"Preds",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"if",
"(",
"getSingleUnscheduledSucc",
"(",
"I",
"->",
"getSUnit",
"(",
")",
")",
"==",
"SU",
")",
"++",
"NumNodesBlocking",
";",
"}",
"ResCount",
"+=",
"(",
"NumNodesBlocking",
"*",
"ScaleTwo",
")",
";",
"ResCount",
"-=",
"(",
"Delta",
".",
"Excess",
".",
"UnitIncrease",
"*",
"PriorityThree",
")",
";",
"ResCount",
"-=",
"(",
"Delta",
".",
"CriticalMax",
".",
"UnitIncrease",
"*",
"PriorityThree",
")",
";",
"DEBUG",
"(",
"if",
"(",
"verbose",
")",
"dbgs",
"(",
")",
"<<",
"\" Total(\"",
"<<",
"ResCount",
"<<",
"\")\"",
")",
";",
"return",
"ResCount",
";",
"}",
"</s>"
] | [
"Single",
"point",
"to",
"compute",
"overall",
"scheduling",
"cost",
"."
] | [
"Hexagon",
"1",
"0",
"\" Total(\"",
"\")\""
] | HexagonMachineScheduler10 | SchedulingCost | Hexagon | DSP | LLVM | 23,696 | 290 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_sim_finish_insn",
"(",
"struct",
"mips_sim",
"*",
"state",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"if",
"(",
"JUMP_P",
"(",
"insn",
")",
")",
"mips_sim_issue_nop",
"(",
"state",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"SEQ_BEGIN",
"(",
"insn",
")",
")",
")",
"{",
"case",
"CODE_LABEL",
":",
"case",
"CALL_INSN",
":",
"mips_sim_reset",
"(",
"state",
")",
";",
"break",
";",
"case",
"JUMP_INSN",
":",
"if",
"(",
"INSN_ANNULLED_BRANCH_P",
"(",
"SEQ_BEGIN",
"(",
"insn",
")",
")",
")",
"mips_sim_reset",
"(",
"state",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"</s>"
] | [
"Update",
"simulation",
"state",
"STATE",
"so",
"that",
"it",
"'s",
"ready",
"to",
"accept",
"the",
"instruction",
"after",
"INSN",
".",
"INSN",
"should",
"be",
"part",
"of",
"the",
"main",
"rtl",
"chain",
",",
"not",
"a",
"member",
"of",
"a",
"SEQUENCE",
"."
] | [
"mips"
] | mips | mips_sim_finish_insn | mips | CPU | GCC | 23,697 | 76 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_gimple_fold_builtin",
"(",
"gimple_stmt_iterator",
"*",
"gsi",
")",
"{",
"gcall",
"*",
"stmt",
"=",
"as_a",
"<",
"gcall",
"*",
">",
"(",
"gsi_stmt",
"(",
"*",
"gsi",
")",
")",
";",
"tree",
"fndecl",
"=",
"gimple_call_fndecl",
"(",
"stmt",
")",
";",
"unsigned",
"int",
"code",
"=",
"DECL_MD_FUNCTION_CODE",
"(",
"fndecl",
")",
";",
"unsigned",
"int",
"subcode",
"=",
"code",
">>",
"AARCH64_BUILTIN_SHIFT",
";",
"gimple",
"*",
"new_stmt",
"=",
"NULL",
";",
"switch",
"(",
"code",
"&",
"AARCH64_BUILTIN_CLASS",
")",
"{",
"case",
"AARCH64_BUILTIN_GENERAL",
":",
"new_stmt",
"=",
"aarch64_general_gimple_fold_builtin",
"(",
"subcode",
",",
"stmt",
")",
";",
"break",
";",
"case",
"AARCH64_BUILTIN_SVE",
":",
"new_stmt",
"=",
"aarch64_sve",
"::",
"gimple_fold_builtin",
"(",
"subcode",
",",
"gsi",
",",
"stmt",
")",
";",
"break",
";",
"}",
"if",
"(",
"!",
"new_stmt",
")",
"return",
"false",
";",
"gsi_replace",
"(",
"gsi",
",",
"new_stmt",
",",
"true",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_GIMPLE_FOLD_BUILTIN",
"."
] | [
"aarch64",
"aarch64_sve::gimple_fold_builtin"
] | aarch64 | aarch64_gimple_fold_builtin | aarch64 | CPU | GCC | 23,698 | 118 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"Register",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FrameIndex",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"FrameInfo",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
",",
"FrameInfo",
".",
"getObjectAlign",
"(",
"FrameIndex",
")",
")",
";",
"unsigned",
"SpillSize",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
";",
"if",
"(",
"RI",
".",
"isSGPRClass",
"(",
"RC",
")",
")",
"{",
"MFI",
"->",
"setHasSpilledSGPRs",
"(",
")",
";",
"assert",
"(",
"SrcReg",
"!=",
"AMDGPU",
"::",
"M0",
"&&",
"\"m0 should not be spilled\"",
")",
";",
"assert",
"(",
"SrcReg",
"!=",
"AMDGPU",
"::",
"EXEC_LO",
"&&",
"SrcReg",
"!=",
"AMDGPU",
"::",
"EXEC_HI",
"&&",
"SrcReg",
"!=",
"AMDGPU",
"::",
"EXEC",
"&&",
"\"exec should not be spilled\"",
")",
";",
"const",
"MCInstrDesc",
"&",
"OpDesc",
"=",
"get",
"(",
"getSGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
")",
";",
"if",
"(",
"SrcReg",
".",
"isVirtual",
"(",
")",
"&&",
"SpillSize",
"==",
"4",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"SrcReg",
",",
"&",
"AMDGPU",
"::",
"SReg_32_XM0_XEXECRegClass",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"OpDesc",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getStackPtrOffsetReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
";",
"if",
"(",
"RI",
".",
"spillSGPRToVGPR",
"(",
")",
")",
"FrameInfo",
".",
"setStackID",
"(",
"FrameIndex",
",",
"TargetStackID",
"::",
"SGPRSpill",
")",
";",
"return",
";",
"}",
"unsigned",
"Opcode",
"=",
"RI",
".",
"hasAGPRs",
"(",
"RC",
")",
"?",
"getAGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
":",
"getVGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
";",
"MFI",
"->",
"setHasSpilledVGPRs",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU::M0",
"\"m0 should not be spilled\"",
"AMDGPU::EXEC_LO",
"AMDGPU::EXEC_HI",
"AMDGPU::EXEC",
"\"exec should not be spilled\"",
"4",
"AMDGPU::SReg_32_XM0_XEXECRegClass",
"0"
] | SIInstrInfo111 | storeRegToStackSlot | AMDGPU | GPU | LLVM | 23,699 | 395 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.