ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"static",
"void",
"nvptx_record_offload_symbol",
"(",
"tree",
"decl",
")",
"{",
"switch",
"(",
"TREE_CODE",
"(",
"decl",
")",
")",
"{",
"case",
"VAR_DECL",
":",
"fprintf",
"(",
"asm_out_file",
",",
"\"//:VAR_MAP \\\"%s\\\"\\n\"",
",",
"IDENTIFIER_POINTER",
"(",
"DECL_ASSEMBLER_NAME",
"(",
"decl",
")",
")",
")",
";",
"break",
";",
"case",
"FUNCTION_DECL",
":",
"{",
"tree",
"attr",
"=",
"get_oacc_fn_attrib",
"(",
"decl",
")",
";",
"tree",
"dims",
"=",
"TREE_VALUE",
"(",
"attr",
")",
";",
"unsigned",
"ix",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"//:FUNC_MAP \\\"%s\\\"\"",
",",
"IDENTIFIER_POINTER",
"(",
"DECL_ASSEMBLER_NAME",
"(",
"decl",
")",
")",
")",
";",
"for",
"(",
"ix",
"=",
"0",
";",
"ix",
"!=",
"GOMP_DIM_MAX",
";",
"ix",
"++",
",",
"dims",
"=",
"TREE_CHAIN",
"(",
"dims",
")",
")",
"{",
"int",
"size",
"=",
"TREE_INT_CST_LOW",
"(",
"TREE_VALUE",
"(",
"dims",
")",
")",
";",
"gcc_assert",
"(",
"!",
"TREE_PURPOSE",
"(",
"dims",
")",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\", %#x\"",
",",
"size",
")",
";",
"}",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\n\"",
")",
";",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Record",
"a",
"symbol",
"for",
"mkoffload",
"to",
"enter",
"into",
"the",
"mapping",
"table",
"."
] | [
"nvptx",
"\"//:VAR_MAP \\\"%s\\\"\\n\"",
"\"//:FUNC_MAP \\\"%s\\\"\"",
"0",
"\", %#x\"",
"\"\\n\""
] | nvptx3 | nvptx_record_offload_symbol | nvptx | GPU | GCC | 19,600 | 143 | 1 | [] |
[
"<s>",
"static",
"rtx",
"rs6000_expand_zeroop_builtin",
"(",
"enum",
"insn_code",
"icode",
",",
"rtx",
"target",
")",
"{",
"rtx",
"pat",
";",
"machine_mode",
"tmode",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"mode",
";",
"if",
"(",
"icode",
"==",
"CODE_FOR_nothing",
")",
"return",
"0",
";",
"if",
"(",
"icode",
"==",
"CODE_FOR_rs6000_mffsl",
"&&",
"rs6000_isa_flags",
"&",
"OPTION_MASK_SOFT_FLOAT",
")",
"{",
"error",
"(",
"\"%<__builtin_mffsl%> not supported with %<-msoft-float%>\"",
")",
";",
"return",
"const0_rtx",
";",
"}",
"if",
"(",
"target",
"==",
"0",
"||",
"GET_MODE",
"(",
"target",
")",
"!=",
"tmode",
"||",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"predicate",
")",
"(",
"target",
",",
"tmode",
")",
")",
"target",
"=",
"gen_reg_rtx",
"(",
"tmode",
")",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
")",
";",
"if",
"(",
"!",
"pat",
")",
"return",
"0",
";",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Expand",
"an",
"expression",
"EXP",
"that",
"calls",
"a",
"builtin",
"without",
"arguments",
"."
] | [
"rs6000",
"0",
"0",
"\"%<__builtin_mffsl%> not supported with %<-msoft-float%>\"",
"0",
"0",
"0"
] | rs6000-call | rs6000_expand_zeroop_builtin | rs6000 | CPU | GCC | 19,601 | 127 | 1 | [] |
[
"<s>",
"unsigned",
"SparcMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"Ctx",
".",
"getRegisterInfo",
"(",
")",
"->",
"getEncodingValue",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"if",
"(",
"const",
"SparcMCExpr",
"*",
"SExpr",
"=",
"dyn_cast",
"<",
"SparcMCExpr",
">",
"(",
"Expr",
")",
")",
"{",
"MCFixupKind",
"Kind",
"=",
"(",
"MCFixupKind",
")",
"SExpr",
"->",
"getFixupKind",
"(",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"Create",
"(",
"0",
",",
"Expr",
",",
"Kind",
")",
")",
";",
"return",
"0",
";",
"}",
"int64_t",
"Res",
";",
"if",
"(",
"Expr",
"->",
"EvaluateAsAbsolute",
"(",
"Res",
")",
")",
"return",
"Res",
";",
"assert",
"(",
"0",
"&&",
"\"Unhandled expression!\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"0",
"0",
"0",
"\"Unhandled expression!\"",
"0"
] | SparcMCCodeEmitter14 | getMachineOpValue | Sparc | CPU | LLVM | 19,602 | 162 | 1 | [] |
[
"<s>",
"void",
"X86WinAllocaExpander",
"::",
"lower",
"(",
"MachineInstr",
"*",
"MI",
",",
"Lowering",
"L",
")",
"{",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MI",
"->",
"getParent",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"*",
"MI",
";",
"int64_t",
"Amount",
"=",
"getWinAllocaAmount",
"(",
"MI",
",",
"MRI",
")",
";",
"if",
"(",
"Amount",
"==",
"0",
")",
"{",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
";",
"}",
"bool",
"Is64Bit",
"=",
"STI",
"->",
"is64Bit",
"(",
")",
";",
"assert",
"(",
"SlotSize",
"==",
"4",
"||",
"SlotSize",
"==",
"8",
")",
";",
"unsigned",
"RegA",
"=",
"(",
"SlotSize",
"==",
"8",
")",
"?",
"X86",
"::",
"RAX",
":",
"X86",
"::",
"EAX",
";",
"switch",
"(",
"L",
")",
"{",
"case",
"TouchAndSub",
":",
"assert",
"(",
"Amount",
">=",
"SlotSize",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Is64Bit",
"?",
"X86",
"::",
"PUSH64r",
":",
"X86",
"::",
"PUSH32r",
")",
")",
".",
"addReg",
"(",
"RegA",
",",
"RegState",
"::",
"Undef",
")",
";",
"Amount",
"-=",
"SlotSize",
";",
"if",
"(",
"!",
"Amount",
")",
"break",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"Sub",
":",
"assert",
"(",
"Amount",
">",
"0",
")",
";",
"if",
"(",
"Amount",
"==",
"SlotSize",
")",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Is64Bit",
"?",
"X86",
"::",
"PUSH64r",
":",
"X86",
"::",
"PUSH32r",
")",
")",
".",
"addReg",
"(",
"RegA",
",",
"RegState",
"::",
"Undef",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"getSubOpcode",
"(",
"Is64Bit",
",",
"Amount",
")",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"break",
";",
"case",
"Probe",
":",
"if",
"(",
"!",
"NoStackArgProbe",
")",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"RegA",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
";",
"STI",
"->",
"getFrameLowering",
"(",
")",
"->",
"emitStackProbe",
"(",
"*",
"MBB",
"->",
"getParent",
"(",
")",
",",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"false",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Is64Bit",
"?",
"X86",
"::",
"SUB64rr",
":",
"X86",
"::",
"SUB32rr",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
";",
"}",
"break",
";",
"}",
"unsigned",
"AmountReg",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"for",
"(",
";",
";",
")",
"{",
"if",
"(",
"!",
"MRI",
"->",
"use_empty",
"(",
"AmountReg",
")",
")",
"break",
";",
"MachineInstr",
"*",
"AmountDef",
"=",
"MRI",
"->",
"getUniqueVRegDef",
"(",
"AmountReg",
")",
";",
"if",
"(",
"!",
"AmountDef",
")",
"break",
";",
"if",
"(",
"AmountDef",
"->",
"isCopy",
"(",
")",
"&&",
"AmountDef",
"->",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
")",
"AmountReg",
"=",
"AmountDef",
"->",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
";",
"AmountDef",
"->",
"eraseFromParent",
"(",
")",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"The",
"instruction",
"is",
"lowered",
"."
] | [
"X86",
"X86",
"0",
"4",
"8",
"8",
"X86::RAX",
"X86::EAX",
"X86::PUSH64r",
"X86::PUSH32r",
"0",
"X86::PUSH64r",
"X86::PUSH32r",
"0",
"X86::SUB64rr",
"X86::SUB32rr",
"0",
"0",
"1",
"1"
] | X86WinAllocaExpander4 | lower | X86 | CPU | LLVM | 19,603 | 476 | 1 | [] |
[
"<s>",
"const",
"uint16_t",
"*",
"KudeyarRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
"->",
"getFunction",
"(",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"*",
"MF",
")",
")",
"return",
"(",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"Kudeyar_INTR",
"?",
"CSR_FP_INTR_SaveList",
":",
"CSR_FP_SaveList",
")",
";",
"else",
"return",
"(",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"Kudeyar_INTR",
"?",
"CSR_NoFP_INTR_SaveList",
":",
"CSR_NoFP_SaveList",
")",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Kudeyar",
"Kudeyar",
"Kudeyar",
"Kudeyar"
] | KudeyarRegisterInfo | getCalleeSavedRegs | Kudeyar | CPU | LLVM | 19,604 | 86 | 1 | [] |
[
"<s>",
"void",
"mmix_asm_output_internal_label",
"(",
"FILE",
"*",
"stream",
",",
"const",
"char",
"*",
"name",
")",
"{",
"assemble_name_raw",
"(",
"stream",
",",
"name",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"\\tIS @\\n\"",
")",
";",
"}",
"</s>"
] | [
"ASM_OUTPUT_INTERNAL_LABEL",
"."
] | [
"mmix",
"\"\\tIS @\\n\""
] | mmix | mmix_asm_output_internal_label | mmix | CPU | GCC | 19,605 | 28 | 1 | [] |
[
"<s>",
"MachineInstrBuilder",
"SIInstrInfo",
"::",
"buildIndirectRead",
"(",
"MachineBasicBlock",
"*",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"ValueReg",
",",
"unsigned",
"Address",
",",
"unsigned",
"OffsetReg",
")",
"const",
"{",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MBB",
"->",
"findDebugLoc",
"(",
"I",
")",
";",
"unsigned",
"IndirectBaseReg",
"=",
"AMDGPU",
"::",
"VReg_32RegClass",
".",
"getRegister",
"(",
"getIndirectIndexBegin",
"(",
"*",
"MBB",
"->",
"getParent",
"(",
")",
")",
")",
";",
"return",
"BuildMI",
"(",
"*",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"SI_INDIRECT_SRC",
")",
")",
".",
"addOperand",
"(",
"I",
"->",
"getOperand",
"(",
"0",
")",
")",
".",
"addOperand",
"(",
"I",
"->",
"getOperand",
"(",
"1",
")",
")",
".",
"addReg",
"(",
"IndirectBaseReg",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"</s>"
] | [
"Build",
"instruction",
"(",
"s",
")",
"for",
"an",
"indirect",
"register",
"read",
"."
] | [
"R600",
"SI",
"SI",
"0",
"1",
"0"
] | SIInstrInfo116 | buildIndirectRead | R600 | GPU | LLVM | 19,606 | 111 | 1 | [] |
[
"<s>",
"BitVector",
"SIRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"EXEC_LO",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"EXEC_HI",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"INDIRECT_BASE_ADDR",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"FLAT_SCR",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"FLAT_SCR_LO",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"FLAT_SCR_HI",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"VGPR255",
")",
";",
"Reserved",
".",
"set",
"(",
"AMDGPU",
"::",
"VGPR254",
")",
";",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
")",
".",
"hasSGPRInitBug",
"(",
")",
")",
"{",
"unsigned",
"NumSGPRs",
"=",
"AMDGPU",
"::",
"SGPR_32RegClass",
".",
"getNumRegs",
"(",
")",
";",
"unsigned",
"Limit",
"=",
"AMDGPUSubtarget",
"::",
"FIXED_SGPR_COUNT_FOR_INIT_BUG",
"-",
"4",
";",
"for",
"(",
"unsigned",
"i",
"=",
"Limit",
";",
"i",
"<",
"NumSGPRs",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"AMDGPU",
"::",
"SGPR_32RegClass",
".",
"getRegister",
"(",
"i",
")",
";",
"MCRegAliasIterator",
"R",
"=",
"MCRegAliasIterator",
"(",
"Reg",
",",
"this",
",",
"true",
")",
";",
"for",
"(",
";",
"R",
".",
"isValid",
"(",
")",
";",
"++",
"R",
")",
"Reserved",
".",
"set",
"(",
"*",
"R",
")",
";",
"}",
"}",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"R600",
"SI",
"4"
] | SIRegisterInfo33 | getReservedRegs | R600 | GPU | LLVM | 19,607 | 202 | 1 | [] |
[
"<s>",
"unsigned",
"SPScope",
"::",
"getDepth",
"(",
")",
"const",
"{",
"return",
"(",
"Priv",
"->",
"Parent",
"==",
"NULL",
")",
"?",
"0",
":",
"Priv",
"->",
"Parent",
"->",
"getDepth",
"(",
")",
"+",
"1",
";",
"}",
"</s>"
] | [
"The",
"depth",
",",
"in",
"the",
"dependence",
"graph",
",",
"for",
"a",
"node",
"."
] | [
"Patmos",
"0",
"1"
] | SPScope | getDepth | Patmos | VLIW | LLVM | 19,608 | 30 | 1 | [] |
[
"<s>",
"bool",
"X86InstructionSelector",
"::",
"select",
"(",
"MachineInstr",
"&",
"I",
")",
"const",
"{",
"assert",
"(",
"I",
".",
"getParent",
"(",
")",
"&&",
"\"Instruction should be in a basic block!\"",
")",
";",
"assert",
"(",
"I",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"&&",
"\"Instruction should be in a function!\"",
")",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"I",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"unsigned",
"Opcode",
"=",
"I",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"!",
"isPreISelGenericOpcode",
"(",
"Opcode",
")",
")",
"{",
"if",
"(",
"Opcode",
"==",
"TargetOpcode",
"::",
"LOAD_STACK_GUARD",
")",
"return",
"false",
";",
"if",
"(",
"I",
".",
"isCopy",
"(",
")",
")",
"return",
"selectCopy",
"(",
"I",
",",
"MRI",
")",
";",
"return",
"true",
";",
"}",
"assert",
"(",
"I",
".",
"getNumOperands",
"(",
")",
"==",
"I",
".",
"getNumExplicitOperands",
"(",
")",
"&&",
"\"Generic instruction has unexpected implicit operands\\n\"",
")",
";",
"if",
"(",
"selectImpl",
"(",
"I",
")",
")",
"return",
"true",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\" C++ instruction selection: \"",
";",
"I",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
")",
";",
"switch",
"(",
"I",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"TargetOpcode",
"::",
"G_STORE",
":",
"case",
"TargetOpcode",
"::",
"G_LOAD",
":",
"return",
"selectLoadStoreOp",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_GEP",
":",
"case",
"TargetOpcode",
"::",
"G_FRAME_INDEX",
":",
"return",
"selectFrameIndexOrGep",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_GLOBAL_VALUE",
":",
"return",
"selectGlobalValue",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_CONSTANT",
":",
"return",
"selectConstant",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_FCONSTANT",
":",
"return",
"materializeFP",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_TRUNC",
":",
"return",
"selectTrunc",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_ZEXT",
":",
"return",
"selectZext",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_ANYEXT",
":",
"return",
"selectAnyext",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_ICMP",
":",
"return",
"selectCmp",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_UADDE",
":",
"return",
"selectUadde",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_UNMERGE_VALUES",
":",
"return",
"selectUnmergeValues",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_MERGE_VALUES",
":",
"return",
"selectMergeValues",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_EXTRACT",
":",
"return",
"selectExtract",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_INSERT",
":",
"return",
"selectInsert",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_BRCOND",
":",
"return",
"selectCondBranch",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
";",
"case",
"TargetOpcode",
"::",
"G_IMPLICIT_DEF",
":",
"case",
"TargetOpcode",
"::",
"G_PHI",
":",
"return",
"selectImplicitDefOrPHI",
"(",
"I",
",",
"MRI",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Select",
"the",
"(",
"possibly",
"generic",
")",
"instruction",
"I",
"to",
"only",
"use",
"target-specific",
"opcodes",
"."
] | [
"X86",
"X86",
"\"Instruction should be in a basic block!\"",
"\"Instruction should be in a function!\"",
"\"Generic instruction has unexpected implicit operands\\n\"",
"\" C++ instruction selection: \""
] | X86InstructionSelector12 | select | X86 | CPU | LLVM | 19,609 | 435 | 1 | [] |
[
"<s>",
"virtual",
"unsigned",
"getReg",
"(",
")",
"const",
"LLVM_OVERRIDE",
"{",
"return",
"Reg",
".",
"Num",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"Videocore"
] | VideocoreAsmParser | getReg | Videocore | DSP | LLVM | 19,610 | 14 | 1 | [] |
[
"<s>",
"bool",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCRelaxableFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"CAHP"
] | CAHPAsmBackend | fixupNeedsRelaxation | CAHP | CPU | LLVM | 19,611 | 28 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"X86TargetLowering",
"::",
"getScratchRegisters",
"(",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"static",
"const",
"MCPhysReg",
"ScratchRegs",
"[",
"]",
"=",
"{",
"X86",
"::",
"R11",
",",
"0",
"}",
";",
"return",
"ScratchRegs",
";",
"}",
"</s>"
] | [
"Returns",
"a",
"0",
"terminated",
"array",
"of",
"registers",
"that",
"can",
"be",
"safely",
"used",
"as",
"scratch",
"registers",
"."
] | [
"X86",
"X86",
"X86::R11",
"0"
] | X86ISelLowering (2) | getScratchRegisters | X86 | CPU | LLVM | 19,612 | 32 | 1 | [] |
[
"<s>",
"bool",
"SHUXIFrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"SHUXI",
"::",
"POP",
")",
",",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] | [
"SHUXI",
"SHUXI",
"0",
"SHUXI::POP"
] | SHUXIFrameLowering | restoreCalleeSavedRegisters | SHUXI | CPU | LLVM | 19,613 | 142 | 1 | [] |
[
"<s>",
"MCContext",
"&",
"getContext",
"(",
")",
"{",
"return",
"Ctx",
";",
"}",
"</s>"
] | [
"Return",
"the",
"LLVMContext",
"used",
"by",
"the",
"analysis",
"."
] | [
"Patmos"
] | PatmosMCInstLower | getContext | Patmos | VLIW | LLVM | 19,614 | 10 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_assemble_integer",
"(",
"rtx",
"x",
",",
"unsigned",
"int",
"size",
",",
"int",
"aligned_p",
")",
"{",
"if",
"(",
"RELOCATABLE_NEEDS_FIXUP",
"&&",
"size",
"==",
"4",
"&&",
"aligned_p",
")",
"{",
"static",
"int",
"recurse",
"=",
"0",
";",
"if",
"(",
"TARGET_RELOCATABLE",
"&&",
"in_section",
"!=",
"toc_section",
"&&",
"!",
"recurse",
"&&",
"!",
"CONST_SCALAR_INT_P",
"(",
"x",
")",
"&&",
"CONSTANT_P",
"(",
"x",
")",
")",
"{",
"char",
"buf",
"[",
"256",
"]",
";",
"recurse",
"=",
"1",
";",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"buf",
",",
"\"LCP\"",
",",
"fixuplabelno",
")",
";",
"fixuplabelno",
"++",
";",
"ASM_OUTPUT_LABEL",
"(",
"asm_out_file",
",",
"buf",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.long\\t(\"",
")",
";",
"output_addr_const",
"(",
"asm_out_file",
",",
"x",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\")@fixup\\n\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"",
")",
";",
"ASM_OUTPUT_ALIGN",
"(",
"asm_out_file",
",",
"2",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.long\\t\"",
")",
";",
"assemble_name",
"(",
"asm_out_file",
",",
"buf",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\n\\t.previous\\n\"",
")",
";",
"recurse",
"=",
"0",
";",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"&&",
"XSTR",
"(",
"x",
",",
"0",
")",
"[",
"0",
"]",
"==",
"'.'",
"&&",
"DEFAULT_ABI",
"==",
"ABI_AIX",
")",
"{",
"const",
"char",
"*",
"name",
"=",
"XSTR",
"(",
"x",
",",
"0",
")",
";",
"while",
"(",
"*",
"name",
"==",
"'.'",
")",
"name",
"++",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.long\\t%s\\n\"",
",",
"name",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"default_assemble_integer",
"(",
"x",
",",
"size",
",",
"aligned_p",
")",
";",
"}",
"</s>"
] | [
"Target",
"hook",
"for",
"assembling",
"integer",
"objects",
".",
"The",
"powerpc",
"version",
"has",
"to",
"handle",
"fixup",
"entries",
"for",
"relocatable",
"code",
"if",
"RELOCATABLE_NEEDS_FIXUP",
"is",
"defined",
".",
"It",
"also",
"needs",
"to",
"handle",
"DI-mode",
"objects",
"on",
"64-bit",
"targets",
"."
] | [
"rs6000",
"4",
"0",
"256",
"1",
"\"LCP\"",
"\"\\t.long\\t(\"",
"\")@fixup\\n\"",
"\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"",
"2",
"\"\\t.long\\t\"",
"\"\\n\\t.previous\\n\"",
"0",
"0",
"0",
"0",
"\"\\t.long\\t%s\\n\""
] | rs60004 | rs6000_assemble_integer | rs6000 | CPU | GCC | 19,615 | 222 | 1 | [] |
[
"<s>",
"static",
"void",
"tilepro_file_end",
"(",
"void",
")",
"{",
"if",
"(",
"NEED_INDICATE_EXEC_STACK",
")",
"file_end_indicate_exec_stack",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_FILE_END",
"."
] | [
"tilepro"
] | tilepro | tilepro_file_end | tilepro | VLIW | GCC | 19,616 | 16 | 1 | [] |
[
"<s>",
"bool",
"HexagonGenInsert",
"::",
"removeDeadCode",
"(",
"MachineDomTreeNode",
"*",
"N",
")",
"{",
"bool",
"Changed",
"=",
"false",
";",
"typedef",
"GraphTraits",
"<",
"MachineDomTreeNode",
"*",
">",
"GTN",
";",
"for",
"(",
"auto",
"I",
"=",
"GTN",
"::",
"child_begin",
"(",
"N",
")",
",",
"E",
"=",
"GTN",
"::",
"child_end",
"(",
"N",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"Changed",
"|=",
"removeDeadCode",
"(",
"*",
"I",
")",
";",
"MachineBasicBlock",
"*",
"B",
"=",
"N",
"->",
"getBlock",
"(",
")",
";",
"std",
"::",
"vector",
"<",
"MachineInstr",
"*",
">",
"Instrs",
";",
"for",
"(",
"auto",
"I",
"=",
"B",
"->",
"rbegin",
"(",
")",
",",
"E",
"=",
"B",
"->",
"rend",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"Instrs",
".",
"push_back",
"(",
"&",
"*",
"I",
")",
";",
"for",
"(",
"auto",
"I",
"=",
"Instrs",
".",
"begin",
"(",
")",
",",
"E",
"=",
"Instrs",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"*",
"I",
";",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opc",
"==",
"TargetOpcode",
"::",
"LIFETIME_START",
"||",
"Opc",
"==",
"TargetOpcode",
"::",
"LIFETIME_END",
")",
"continue",
";",
"bool",
"Store",
"=",
"false",
";",
"if",
"(",
"MI",
"->",
"isInlineAsm",
"(",
")",
"||",
"!",
"MI",
"->",
"isSafeToMove",
"(",
"nullptr",
",",
"Store",
")",
")",
"continue",
";",
"bool",
"AllDead",
"=",
"true",
";",
"SmallVector",
"<",
"unsigned",
",",
"2",
">",
"Regs",
";",
"for",
"(",
"ConstMIOperands",
"Op",
"(",
"*",
"MI",
")",
";",
"Op",
".",
"isValid",
"(",
")",
";",
"++",
"Op",
")",
"{",
"if",
"(",
"!",
"Op",
"->",
"isReg",
"(",
")",
"||",
"!",
"Op",
"->",
"isDef",
"(",
")",
")",
"continue",
";",
"unsigned",
"R",
"=",
"Op",
"->",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"R",
")",
"||",
"!",
"MRI",
"->",
"use_nodbg_empty",
"(",
"R",
")",
")",
"{",
"AllDead",
"=",
"false",
";",
"break",
";",
"}",
"Regs",
".",
"push_back",
"(",
"R",
")",
";",
"}",
"if",
"(",
"!",
"AllDead",
")",
"continue",
";",
"B",
"->",
"erase",
"(",
"MI",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
",",
"N",
"=",
"Regs",
".",
"size",
"(",
")",
";",
"I",
"!=",
"N",
";",
"++",
"I",
")",
"MRI",
"->",
"markUsesInDebugValueAsUndef",
"(",
"Regs",
"[",
"I",
"]",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"Remove",
"all",
"dead",
"instructions",
"between",
"the",
"I",
"and",
"E",
"."
] | [
"Hexagon",
"Hexagon",
"2",
"0"
] | HexagonGenInsert | removeDeadCode | Hexagon | DSP | LLVM | 19,617 | 345 | 1 | [] |
[
"<s>",
"FastISel",
"*",
"ARM",
"::",
"createFastISel",
"(",
"FunctionLoweringInfo",
"&",
"funcInfo",
",",
"const",
"TargetLibraryInfo",
"*",
"libInfo",
")",
"{",
"if",
"(",
"funcInfo",
".",
"MF",
"->",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
".",
"useFastISel",
"(",
")",
")",
"return",
"new",
"ARMFastISel",
"(",
"funcInfo",
",",
"libInfo",
")",
";",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"This",
"method",
"returns",
"a",
"target",
"specific",
"FastISel",
"object",
",",
"or",
"null",
"if",
"the",
"target",
"does",
"not",
"support",
"``",
"fast",
"''",
"ISel",
"."
] | [
"ARM",
"ARM::createFastISel",
"ARM",
"ARM"
] | ARMFastISel (2)2 | createFastISel | ARM | CPU | LLVM | 19,618 | 46 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"TII",
"=",
"static_cast",
"<",
"const",
"R600InstrInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"&",
"TII",
"->",
"getRegisterInfo",
"(",
")",
";",
"DEBUG",
"(",
"MF",
".",
"dump",
"(",
")",
";",
")",
";",
"OrderedBlks",
".",
"clear",
"(",
")",
";",
"FuncRep",
"=",
"&",
"MF",
";",
"MLI",
"=",
"&",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"LoopInfo:\\n\"",
";",
"PrintLoopinfo",
"(",
"*",
"MLI",
")",
";",
")",
";",
"MDT",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"DEBUG",
"(",
"MDT",
"->",
"print",
"(",
"dbgs",
"(",
")",
",",
"(",
"const",
"llvm",
"::",
"Module",
"*",
")",
"nullptr",
")",
";",
")",
";",
"PDT",
"=",
"&",
"getAnalysis",
"<",
"MachinePostDominatorTree",
">",
"(",
")",
";",
"DEBUG",
"(",
"PDT",
"->",
"print",
"(",
"dbgs",
"(",
")",
")",
";",
")",
";",
"prepare",
"(",
")",
";",
"run",
"(",
")",
";",
"DEBUG",
"(",
"MF",
".",
"dump",
"(",
")",
";",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"R600",
"\"LoopInfo:\\n\""
] | AMDILCFGStructurizer45 | runOnMachineFunction | R600 | GPU | LLVM | 19,619 | 162 | 1 | [] |
[
"<s>",
"void",
"AArch64AsmPrinter",
"::",
"emitEndOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"EmitHwasanMemaccessSymbols",
"(",
"M",
")",
";",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
".",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"{",
"OutStreamer",
"->",
"emitAssemblerFlag",
"(",
"MCAF_SubsectionsViaSymbols",
")",
";",
"}",
"emitStackMaps",
"(",
"SM",
")",
";",
"FM",
".",
"serializeToFaultMapSection",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"end",
"of",
"their",
"file",
"."
] | [
"AArch64",
"AArch64"
] | AArch64AsmPrinter25 | emitEndOfAsmFile | AArch64 | CPU | LLVM | 19,620 | 55 | 1 | [] |
[
"<s>",
"bool",
"X86FastISel",
"::",
"tryToFoldLoadIntoMI",
"(",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"const",
"LoadInst",
"*",
"LI",
")",
"{",
"const",
"Value",
"*",
"Ptr",
"=",
"LI",
"->",
"getPointerOperand",
"(",
")",
";",
"X86AddressMode",
"AM",
";",
"if",
"(",
"!",
"X86SelectAddress",
"(",
"Ptr",
",",
"AM",
")",
")",
"return",
"false",
";",
"const",
"X86InstrInfo",
"&",
"XII",
"=",
"(",
"const",
"X86InstrInfo",
"&",
")",
"TII",
";",
"unsigned",
"Size",
"=",
"DL",
".",
"getTypeAllocSize",
"(",
"LI",
"->",
"getType",
"(",
")",
")",
";",
"unsigned",
"Alignment",
"=",
"LI",
"->",
"getAlignment",
"(",
")",
";",
"if",
"(",
"Alignment",
"==",
"0",
")",
"Alignment",
"=",
"DL",
".",
"getABITypeAlignment",
"(",
"LI",
"->",
"getType",
"(",
")",
")",
";",
"SmallVector",
"<",
"MachineOperand",
",",
"8",
">",
"AddrOps",
";",
"AM",
".",
"getFullAddress",
"(",
"AddrOps",
")",
";",
"MachineInstr",
"*",
"Result",
"=",
"XII",
".",
"foldMemoryOperandImpl",
"(",
"*",
"FuncInfo",
".",
"MF",
",",
"MI",
",",
"OpNo",
",",
"AddrOps",
",",
"Size",
",",
"Alignment",
",",
"true",
")",
";",
"if",
"(",
"!",
"Result",
")",
"return",
"false",
";",
"Result",
"->",
"addMemOperand",
"(",
"*",
"FuncInfo",
".",
"MF",
",",
"createMachineMemOperandFor",
"(",
"LI",
")",
")",
";",
"FuncInfo",
".",
"MBB",
"->",
"insert",
"(",
"FuncInfo",
".",
"InsertPt",
",",
"Result",
")",
";",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"The",
"specified",
"machine",
"instr",
"operand",
"is",
"a",
"vreg",
",",
"and",
"that",
"vreg",
"is",
"being",
"provided",
"by",
"the",
"specified",
"load",
"instruction",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"8"
] | X86FastISel128 | tryToFoldLoadIntoMI | X86 | CPU | LLVM | 19,621 | 186 | 1 | [] |
[
"<s>",
"bool",
"X86DAGToDAGISel",
"::",
"IsProfitableToFold",
"(",
"SDValue",
"N",
",",
"SDNode",
"*",
"U",
",",
"SDNode",
"*",
"Root",
")",
"const",
"{",
"if",
"(",
"OptLevel",
"==",
"CodeGenOpt",
"::",
"None",
")",
"return",
"false",
";",
"if",
"(",
"!",
"N",
".",
"hasOneUse",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"N",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"LOAD",
")",
"return",
"true",
";",
"if",
"(",
"U",
"==",
"Root",
")",
"{",
"switch",
"(",
"U",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"X86ISD",
"::",
"ADD",
":",
"case",
"X86ISD",
"::",
"SUB",
":",
"case",
"X86ISD",
"::",
"AND",
":",
"case",
"X86ISD",
"::",
"XOR",
":",
"case",
"X86ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"ADDCARRY",
":",
"case",
"ISD",
"::",
"AND",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"XOR",
":",
"{",
"SDValue",
"Op1",
"=",
"U",
"->",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"ConstantSDNode",
"*",
"Imm",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op1",
")",
")",
"{",
"if",
"(",
"Imm",
"->",
"getAPIntValue",
"(",
")",
".",
"isSignedIntN",
"(",
"8",
")",
")",
"return",
"false",
";",
"if",
"(",
"U",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"AND",
"&&",
"Imm",
"->",
"getAPIntValue",
"(",
")",
".",
"getBitWidth",
"(",
")",
"==",
"64",
"&&",
"Imm",
"->",
"getAPIntValue",
"(",
")",
".",
"isIntN",
"(",
"32",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"Op1",
".",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"Wrapper",
")",
"{",
"SDValue",
"Val",
"=",
"Op1",
".",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"Val",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"TargetGlobalTLSAddress",
")",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"IsProfitableToFold",
"-",
"Returns",
"true",
"if",
"it",
"'s",
"profitable",
"to",
"fold",
"the",
"specific",
"operand",
"node",
"N",
"of",
"U",
"during",
"instruction",
"selection",
"that",
"starts",
"at",
"Root",
"."
] | [
"X86",
"X86",
"ISD::LOAD",
"X86ISD::ADD",
"X86ISD::SUB",
"X86ISD::AND",
"X86ISD::XOR",
"X86ISD::OR",
"ISD::ADD",
"ISD::ADDCARRY",
"ISD::AND",
"ISD::OR",
"ISD::XOR",
"1",
"8",
"ISD::AND",
"64",
"32",
"X86ISD::Wrapper",
"0",
"ISD::TargetGlobalTLSAddress"
] | X86ISelDAGToDAG112 | IsProfitableToFold | X86 | CPU | LLVM | 19,622 | 253 | 1 | [] |
[
"<s>",
"SDValue",
"PIC16TargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"ADDC",
":",
"case",
"ISD",
"::",
"ADDE",
":",
"return",
"LowerADD",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SUB",
":",
"case",
"ISD",
"::",
"SUBC",
":",
"case",
"ISD",
"::",
"SUBE",
":",
"return",
"LowerSUB",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"ExpandLoad",
"(",
"Op",
".",
"getNode",
"(",
")",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"ExpandStore",
"(",
"Op",
".",
"getNode",
"(",
")",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"LowerMUL",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SRL",
":",
"return",
"LowerShift",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"AND",
":",
"case",
"ISD",
"::",
"XOR",
":",
"return",
"LowerBinOp",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BR_CC",
":",
"return",
"LowerBR_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"PIC16",
"PIC16",
"ISD::ADD",
"ISD::ADDC",
"ISD::ADDE",
"ISD::SUB",
"ISD::SUBC",
"ISD::SUBE",
"ISD::LOAD",
"ISD::STORE",
"ISD::MUL",
"ISD::SHL",
"ISD::SRA",
"ISD::SRL",
"ISD::OR",
"ISD::AND",
"ISD::XOR",
"ISD::BR_CC",
"ISD::SELECT_CC"
] | PIC16ISelLowering | LowerOperation | PIC16 | MPU | LLVM | 19,623 | 194 | 1 | [] |
[
"<s>",
"Optional",
"<",
"Instruction",
"*",
">",
"AArch64TTIImpl",
"::",
"instCombineIntrinsic",
"(",
"InstCombiner",
"&",
"IC",
",",
"IntrinsicInst",
"&",
"II",
")",
"const",
"{",
"Intrinsic",
"::",
"ID",
"IID",
"=",
"II",
".",
"getIntrinsicID",
"(",
")",
";",
"switch",
"(",
"IID",
")",
"{",
"default",
":",
"break",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_convert_from_svbool",
":",
"return",
"instCombineConvertFromSVBool",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_dup",
":",
"return",
"instCombineSVEDup",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_dup_x",
":",
"return",
"instCombineSVEDupX",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_cmpne",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_cmpne_wide",
":",
"return",
"instCombineSVECmpNE",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_rdffr",
":",
"return",
"instCombineRDFFR",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_lasta",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_lastb",
":",
"return",
"instCombineSVELast",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_cntd",
":",
"return",
"instCombineSVECntElts",
"(",
"IC",
",",
"II",
",",
"2",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_cntw",
":",
"return",
"instCombineSVECntElts",
"(",
"IC",
",",
"II",
",",
"4",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_cnth",
":",
"return",
"instCombineSVECntElts",
"(",
"IC",
",",
"II",
",",
"8",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_cntb",
":",
"return",
"instCombineSVECntElts",
"(",
"IC",
",",
"II",
",",
"16",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_ptest_any",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_ptest_first",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_ptest_last",
":",
"return",
"instCombineSVEPTest",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_mul",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_fmul",
":",
"return",
"instCombineSVEVectorMul",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_fadd",
":",
"return",
"instCombineSVEVectorFAdd",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_fsub",
":",
"return",
"instCombineSVEVectorBinOp",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_tbl",
":",
"return",
"instCombineSVETBL",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_uunpkhi",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_uunpklo",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_sunpkhi",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_sunpklo",
":",
"return",
"instCombineSVEUnpack",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_tuple_get",
":",
"return",
"instCombineSVETupleGet",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_zip1",
":",
"case",
"Intrinsic",
"::",
"aarch64_sve_zip2",
":",
"return",
"instCombineSVEZip",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_ld1_gather_index",
":",
"return",
"instCombineLD1GatherIndex",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_st1_scatter_index",
":",
"return",
"instCombineST1ScatterIndex",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_ld1",
":",
"return",
"instCombineSVELD1",
"(",
"IC",
",",
"II",
",",
"DL",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_st1",
":",
"return",
"instCombineSVEST1",
"(",
"IC",
",",
"II",
",",
"DL",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_sdiv",
":",
"return",
"instCombineSVESDIV",
"(",
"IC",
",",
"II",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_sel",
":",
"return",
"instCombineSVESel",
"(",
"IC",
",",
"II",
")",
";",
"}",
"return",
"None",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"implement",
"their",
"own",
"combinations",
"for",
"target-specific",
"intrinsics",
"."
] | [
"AArch64",
"AArch64",
"Intrinsic::ID",
"Intrinsic::aarch64_sve_convert_from_svbool",
"Intrinsic::aarch64_sve_dup",
"Intrinsic::aarch64_sve_dup_x",
"Intrinsic::aarch64_sve_cmpne",
"Intrinsic::aarch64_sve_cmpne_wide",
"Intrinsic::aarch64_sve_rdffr",
"Intrinsic::aarch64_sve_lasta",
"Intrinsic::aarch64_sve_lastb",
"Intrinsic::aarch64_sve_cntd",
"2",
"Intrinsic::aarch64_sve_cntw",
"4",
"Intrinsic::aarch64_sve_cnth",
"8",
"Intrinsic::aarch64_sve_cntb",
"16",
"Intrinsic::aarch64_sve_ptest_any",
"Intrinsic::aarch64_sve_ptest_first",
"Intrinsic::aarch64_sve_ptest_last",
"Intrinsic::aarch64_sve_mul",
"Intrinsic::aarch64_sve_fmul",
"Intrinsic::aarch64_sve_fadd",
"Intrinsic::aarch64_sve_fsub",
"Intrinsic::aarch64_sve_tbl",
"Intrinsic::aarch64_sve_uunpkhi",
"Intrinsic::aarch64_sve_uunpklo",
"Intrinsic::aarch64_sve_sunpkhi",
"Intrinsic::aarch64_sve_sunpklo",
"Intrinsic::aarch64_sve_tuple_get",
"Intrinsic::aarch64_sve_zip1",
"Intrinsic::aarch64_sve_zip2",
"Intrinsic::aarch64_sve_ld1_gather_index",
"Intrinsic::aarch64_sve_st1_scatter_index",
"Intrinsic::aarch64_sve_ld1",
"Intrinsic::aarch64_sve_st1",
"Intrinsic::aarch64_sve_sdiv",
"Intrinsic::aarch64_sve_sel"
] | AArch64TargetTransformInfo24 | instCombineIntrinsic | AArch64 | CPU | LLVM | 19,624 | 413 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_get_cprestore_base_and_offset",
"(",
"rtx",
"*",
"base",
",",
"HOST_WIDE_INT",
"*",
"offset",
",",
"bool",
"load_p",
")",
"{",
"const",
"struct",
"mips_frame_info",
"*",
"frame",
";",
"frame",
"=",
"&",
"cfun",
"->",
"machine",
"->",
"frame",
";",
"if",
"(",
"frame_pointer_needed",
"&&",
"!",
"(",
"TARGET_CPRESTORE_DIRECTIVE",
"&&",
"!",
"load_p",
")",
")",
"{",
"*",
"base",
"=",
"hard_frame_pointer_rtx",
";",
"*",
"offset",
"=",
"frame",
"->",
"args_size",
"-",
"frame",
"->",
"hard_frame_pointer_offset",
";",
"}",
"else",
"{",
"*",
"base",
"=",
"stack_pointer_rtx",
";",
"*",
"offset",
"=",
"frame",
"->",
"args_size",
";",
"}",
"}",
"</s>"
] | [
"Fill",
"*",
"BASE",
"and",
"*",
"OFFSET",
"such",
"that",
"*",
"BASE",
"+",
"*",
"OFFSET",
"refers",
"to",
"the",
"cprestore",
"slot",
".",
"LOAD_P",
"is",
"true",
"if",
"the",
"caller",
"wants",
"to",
"load",
"from",
"the",
"cprestore",
"slot",
";",
"it",
"is",
"false",
"if",
"the",
"caller",
"wants",
"to",
"store",
"to",
"the",
"slot",
"."
] | [
"mips"
] | mips | mips_get_cprestore_base_and_offset | mips | CPU | GCC | 19,625 | 77 | 1 | [] |
[
"<s>",
"bool",
"Mips16RegisterInfo",
"::",
"saveScavengerRegister",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"UseMI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"Register",
"Reg",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"TII",
".",
"copyPhysReg",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"Mips",
"::",
"T0",
",",
"Reg",
",",
"true",
")",
";",
"TII",
".",
"copyPhysReg",
"(",
"MBB",
",",
"UseMI",
",",
"DL",
",",
"Reg",
",",
"Mips",
"::",
"T0",
",",
"true",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Spill",
"the",
"register",
"so",
"it",
"can",
"be",
"used",
"by",
"the",
"register",
"scavenger",
"."
] | [
"Mips",
"Mips",
"Mips::T0",
"Mips::T0"
] | Mips16RegisterInfo13 | saveScavengerRegister | Mips | CPU | LLVM | 19,626 | 95 | 1 | [] |
[
"<s>",
"bool",
"PPCFrameLowering",
"::",
"enableShrinkWrapping",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"(",
"MF",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
".",
"isSVR4ABI",
"(",
")",
"&&",
"MF",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
".",
"isPPC64",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"will",
"correctly",
"handle",
"shrink",
"wrapping",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"PPC"
] | PPCFrameLowering (2) | enableShrinkWrapping | PowerPC | CPU | LLVM | 19,627 | 42 | 1 | [] |
[
"<s>",
"unsigned",
"int",
"arc_compute_function_type",
"(",
"struct",
"function",
"*",
"fun",
")",
"{",
"tree",
"attr",
",",
"decl",
"=",
"fun",
"->",
"decl",
";",
"unsigned",
"int",
"fn_type",
"=",
"fun",
"->",
"machine",
"->",
"fn_type",
";",
"if",
"(",
"fn_type",
"!=",
"ARC_FUNCTION_UNKNOWN",
")",
"return",
"fn_type",
";",
"if",
"(",
"lookup_attribute",
"(",
"\"naked\"",
",",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
")",
"!=",
"NULL_TREE",
")",
"fn_type",
"|=",
"ARC_FUNCTION_NAKED",
";",
"else",
"fn_type",
"|=",
"ARC_FUNCTION_NORMAL",
";",
"attr",
"=",
"lookup_attribute",
"(",
"\"interrupt\"",
",",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
")",
";",
"if",
"(",
"attr",
"!=",
"NULL_TREE",
")",
"{",
"tree",
"value",
",",
"args",
"=",
"TREE_VALUE",
"(",
"attr",
")",
";",
"gcc_assert",
"(",
"list_length",
"(",
"args",
")",
"==",
"1",
")",
";",
"value",
"=",
"TREE_VALUE",
"(",
"args",
")",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"value",
")",
"==",
"STRING_CST",
")",
";",
"if",
"(",
"!",
"strcmp",
"(",
"TREE_STRING_POINTER",
"(",
"value",
")",
",",
"\"ilink1\"",
")",
"||",
"!",
"strcmp",
"(",
"TREE_STRING_POINTER",
"(",
"value",
")",
",",
"\"ilink\"",
")",
")",
"fn_type",
"|=",
"ARC_FUNCTION_ILINK1",
";",
"else",
"if",
"(",
"!",
"strcmp",
"(",
"TREE_STRING_POINTER",
"(",
"value",
")",
",",
"\"ilink2\"",
")",
")",
"fn_type",
"|=",
"ARC_FUNCTION_ILINK2",
";",
"else",
"if",
"(",
"!",
"strcmp",
"(",
"TREE_STRING_POINTER",
"(",
"value",
")",
",",
"\"firq\"",
")",
")",
"fn_type",
"|=",
"ARC_FUNCTION_FIRQ",
";",
"else",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"fun",
"->",
"machine",
"->",
"fn_type",
"=",
"fn_type",
";",
"}",
"</s>"
] | [
"Type",
"of",
"function",
"DECL",
".",
"The",
"result",
"is",
"cached",
".",
"To",
"reset",
"the",
"cache",
"at",
"the",
"end",
"of",
"a",
"function",
",",
"call",
"with",
"DECL",
"=",
"NULL_TREE",
"."
] | [
"arc",
"\"naked\"",
"\"interrupt\"",
"1",
"\"ilink1\"",
"\"ilink\"",
"\"ilink2\"",
"\"firq\""
] | arc7 | arc_compute_function_type | arc | MPU | GCC | 19,628 | 197 | 1 | [] |
[
"<s>",
"void",
"Mips16InstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"MCRegister",
"DestReg",
",",
"MCRegister",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"0",
";",
"if",
"(",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"DestReg",
")",
"&&",
"Mips",
"::",
"GPR32RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MoveR3216",
";",
"else",
"if",
"(",
"Mips",
"::",
"GPR32RegClass",
".",
"contains",
"(",
"DestReg",
")",
"&&",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"Move32R16",
";",
"else",
"if",
"(",
"(",
"SrcReg",
"==",
"Mips",
"::",
"HI0",
")",
"&&",
"(",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
")",
"Opc",
"=",
"Mips",
"::",
"Mfhi16",
",",
"SrcReg",
"=",
"0",
";",
"else",
"if",
"(",
"(",
"SrcReg",
"==",
"Mips",
"::",
"LO0",
")",
"&&",
"(",
"Mips",
"::",
"CPU16RegsRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
")",
"Opc",
"=",
"Mips",
"::",
"Mflo16",
",",
"SrcReg",
"=",
"0",
";",
"assert",
"(",
"Opc",
"&&",
"\"Cannot copy registers\"",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
";",
"if",
"(",
"DestReg",
")",
"MIB",
".",
"addReg",
"(",
"DestReg",
",",
"RegState",
"::",
"Define",
")",
";",
"if",
"(",
"SrcReg",
")",
"MIB",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"Mips",
"Mips",
"0",
"Mips::CPU16RegsRegClass",
"Mips::GPR32RegClass",
"Mips::MoveR3216",
"Mips::GPR32RegClass",
"Mips::CPU16RegsRegClass",
"Mips::Move32R16",
"Mips::HI0",
"Mips::CPU16RegsRegClass",
"Mips::Mfhi16",
"0",
"Mips::LO0",
"Mips::CPU16RegsRegClass",
"Mips::Mflo16",
"0",
"\"Cannot copy registers\""
] | Mips16InstrInfo10 | copyPhysReg | Mips | CPU | LLVM | 19,629 | 208 | 1 | [] |
[
"<s>",
"static",
"void",
"gcn_goacc_reduction_fini",
"(",
"gcall",
"*",
"call",
")",
"{",
"gimple_stmt_iterator",
"gsi",
"=",
"gsi_for_stmt",
"(",
"call",
")",
";",
"tree",
"lhs",
"=",
"gimple_call_lhs",
"(",
"call",
")",
";",
"tree",
"ref_to_res",
"=",
"gimple_call_arg",
"(",
"call",
",",
"1",
")",
";",
"tree",
"var",
"=",
"gimple_call_arg",
"(",
"call",
",",
"2",
")",
";",
"int",
"level",
"=",
"TREE_INT_CST_LOW",
"(",
"gimple_call_arg",
"(",
"call",
",",
"3",
")",
")",
";",
"enum",
"tree_code",
"op",
"=",
"(",
"enum",
"tree_code",
")",
"TREE_INT_CST_LOW",
"(",
"gimple_call_arg",
"(",
"call",
",",
"4",
")",
")",
";",
"gimple_seq",
"seq",
"=",
"NULL",
";",
"tree",
"r",
"=",
"NULL_TREE",
";",
";",
"push_gimplify_context",
"(",
"true",
")",
";",
"tree",
"accum",
"=",
"NULL_TREE",
";",
"if",
"(",
"level",
"==",
"GOMP_DIM_WORKER",
")",
"{",
"tree",
"var_type",
"=",
"TREE_TYPE",
"(",
"var",
")",
";",
"tree",
"offset",
"=",
"gimple_call_arg",
"(",
"call",
",",
"5",
")",
";",
"tree",
"decl",
"=",
"gcn_goacc_get_worker_red_decl",
"(",
"var_type",
",",
"TREE_INT_CST_LOW",
"(",
"offset",
")",
")",
";",
"accum",
"=",
"build_fold_addr_expr",
"(",
"decl",
")",
";",
"}",
"else",
"if",
"(",
"integer_zerop",
"(",
"ref_to_res",
")",
")",
"r",
"=",
"var",
";",
"else",
"accum",
"=",
"ref_to_res",
";",
"if",
"(",
"accum",
")",
"{",
"gsi_insert_seq_before",
"(",
"&",
"gsi",
",",
"seq",
",",
"GSI_SAME_STMT",
")",
";",
"seq",
"=",
"NULL",
";",
"r",
"=",
"gcn_reduction_update",
"(",
"gimple_location",
"(",
"call",
")",
",",
"&",
"gsi",
",",
"accum",
",",
"var",
",",
"op",
")",
";",
"}",
"if",
"(",
"lhs",
")",
"gimplify_assign",
"(",
"lhs",
",",
"r",
",",
"&",
"seq",
")",
";",
"pop_gimplify_context",
"(",
"NULL",
")",
";",
"gsi_replace_with_seq",
"(",
"&",
"gsi",
",",
"seq",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Expand",
"IFN_GOACC_REDUCTION_FINI",
"."
] | [
"gcn",
"1",
"2",
"3",
"4",
"5"
] | gcn-tree | gcn_goacc_reduction_fini | gcn | GPU | GCC | 19,630 | 229 | 1 | [] |
[
"<s>",
"static",
"bool",
"classof",
"(",
"const",
"MCExpr",
"*",
"E",
")",
"{",
"return",
"E",
"->",
"getKind",
"(",
")",
"==",
"MCExpr",
"::",
"Target",
";",
"}",
"</s>"
] | [
"Methods",
"for",
"support",
"type",
"inquiry",
"through",
"isa",
",",
"cast",
",",
"and",
"dyn_cast",
":"
] | [
"AVR"
] | AVRMCExpr | classof | AVR | MPU | LLVM | 19,631 | 22 | 1 | [] |
[
"<s>",
"RegisterBankInfo",
"::",
"InstructionMapping",
"X86RegisterBankInfo",
"::",
"getInstrMapping",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"auto",
"Opc",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"!",
"isPreISelGenericOpcode",
"(",
"Opc",
")",
")",
"{",
"InstructionMapping",
"Mapping",
"=",
"getInstrMappingImpl",
"(",
"MI",
")",
";",
"if",
"(",
"Mapping",
".",
"isValid",
"(",
")",
")",
"return",
"Mapping",
";",
"}",
"switch",
"(",
"Opc",
")",
"{",
"case",
"TargetOpcode",
"::",
"G_ADD",
":",
"case",
"TargetOpcode",
"::",
"G_SUB",
":",
"return",
"getOperandsMapping",
"(",
"MI",
",",
"false",
")",
";",
"break",
";",
"default",
":",
"return",
"InstructionMapping",
"{",
"}",
";",
"}",
"return",
"InstructionMapping",
"{",
"}",
";",
"}",
"</s>"
] | [
"Get",
"the",
"mapping",
"of",
"the",
"different",
"operands",
"of",
"MI",
"on",
"the",
"register",
"bank",
"."
] | [
"X86",
"X86"
] | X86RegisterBankInfo9 | getInstrMapping | X86 | CPU | LLVM | 19,632 | 91 | 1 | [] |
[
"<s>",
"static",
"rtx",
"mips16_stub_function",
"(",
"const",
"char",
"*",
"name",
")",
"{",
"rtx",
"x",
";",
"x",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"ggc_strdup",
"(",
"name",
")",
")",
";",
"SYMBOL_REF_FLAGS",
"(",
"x",
")",
"|=",
"(",
"SYMBOL_FLAG_EXTERNAL",
"|",
"SYMBOL_FLAG_FUNCTION",
")",
";",
"return",
"x",
";",
"}",
"</s>"
] | [
"Return",
"a",
"SYMBOL_REF",
"for",
"a",
"MIPS16",
"function",
"called",
"NAME",
"."
] | [
"mips"
] | mips | mips16_stub_function | mips | CPU | GCC | 19,633 | 40 | 1 | [] |
[
"<s>",
"void",
"bpf_expand_epilogue",
"(",
"void",
")",
"{",
"if",
"(",
"TARGET_XBPF",
")",
"{",
"rtx",
"insn",
";",
"int",
"regno",
";",
"int",
"fp_offset",
"=",
"-",
"cfun",
"->",
"machine",
"->",
"local_vars_size",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"{",
"if",
"(",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"!",
"call_used_or_fixed_reg_p",
"(",
"regno",
")",
")",
"||",
"(",
"cfun",
"->",
"calls_alloca",
"&&",
"regno",
"==",
"STACK_POINTER_REGNUM",
")",
")",
"{",
"rtx",
"mem",
";",
"if",
"(",
"!",
"IN_RANGE",
"(",
"fp_offset",
",",
"-",
"1",
"-",
"0x7fff",
",",
"0x7fff",
")",
")",
"break",
";",
"else",
"{",
"mem",
"=",
"gen_frame_mem",
"(",
"DImode",
",",
"plus_constant",
"(",
"DImode",
",",
"hard_frame_pointer_rtx",
",",
"fp_offset",
"-",
"8",
")",
")",
";",
"insn",
"=",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"DImode",
",",
"regno",
")",
",",
"mem",
")",
";",
"fp_offset",
"-=",
"8",
";",
"}",
"}",
"}",
"}",
"emit_jump_insn",
"(",
"gen_exit",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"to",
"the",
"instructions",
"in",
"a",
"function",
"epilogue",
".",
"This",
"function",
"is",
"called",
"when",
"expanding",
"the",
"'epilogue",
"'",
"pattern",
"in",
"bpf.md",
"."
] | [
"bpf",
"0",
"1",
"0x7fff",
"0x7fff",
"8",
"8"
] | bpf | bpf_expand_epilogue | bpf | Virtual ISA | GCC | 19,634 | 137 | 1 | [] |
[
"<s>",
"Align",
"NVPTXTargetLowering",
"::",
"getFunctionParamOptimizedAlign",
"(",
"const",
"Function",
"*",
"F",
",",
"Type",
"*",
"ArgTy",
",",
"const",
"DataLayout",
"&",
"DL",
")",
"const",
"{",
"const",
"uint64_t",
"ABITypeAlign",
"=",
"DL",
".",
"getABITypeAlign",
"(",
"ArgTy",
")",
".",
"value",
"(",
")",
";",
"if",
"(",
"!",
"F",
"->",
"hasLocalLinkage",
"(",
")",
")",
"return",
"Align",
"(",
"ABITypeAlign",
")",
";",
"assert",
"(",
"!",
"isKernelFunction",
"(",
"*",
"F",
")",
"&&",
"\"Expect kernels to have non-local linkage\"",
")",
";",
"return",
"Align",
"(",
"std",
"::",
"max",
"(",
"uint64_t",
"(",
"16",
")",
",",
"ABITypeAlign",
")",
")",
";",
"}",
"</s>"
] | [
"getFunctionParamOptimizedAlign",
"-",
"since",
"function",
"arguments",
"are",
"passed",
"via",
".param",
"space",
",",
"we",
"may",
"want",
"to",
"increase",
"their",
"alignment",
"in",
"a",
"way",
"that",
"ensures",
"that",
"we",
"can",
"effectively",
"vectorize",
"their",
"loads",
"&",
"stores",
"."
] | [
"NVPTX",
"NVPTX",
"\"Expect kernels to have non-local linkage\"",
"16"
] | NVPTXISelLowering39 | getFunctionParamOptimizedAlign | NVPTX | GPU | LLVM | 19,635 | 80 | 1 | [] |
[
"<s>",
"bool",
"XCoreRegisterInfo",
"::",
"requiresRegisterScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"return",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"(",
"and",
"can",
"make",
"use",
"of",
")",
"the",
"register",
"scavenger",
"."
] | [
"XCore",
"XCore"
] | XCoreRegisterInfo12 | requiresRegisterScavenging | XCore | MPU | LLVM | 19,636 | 36 | 1 | [] |
[
"<s>",
"void",
"print_reg",
"(",
"rtx",
"x",
",",
"int",
"code",
",",
"FILE",
"*",
"file",
")",
"{",
"const",
"char",
"*",
"reg",
";",
"int",
"msize",
";",
"unsigned",
"int",
"regno",
";",
"bool",
"duplicated",
";",
"if",
"(",
"ASSEMBLER_DIALECT",
"==",
"ASM_ATT",
")",
"putc",
"(",
"'%'",
",",
"file",
")",
";",
"if",
"(",
"x",
"==",
"pc_rtx",
")",
"{",
"gcc_assert",
"(",
"TARGET_64BIT",
")",
";",
"fputs",
"(",
"\"rip\"",
",",
"file",
")",
";",
"return",
";",
"}",
"if",
"(",
"code",
"==",
"'y'",
"&&",
"STACK_TOP_P",
"(",
"x",
")",
")",
"{",
"fputs",
"(",
"\"st(0)\"",
",",
"file",
")",
";",
"return",
";",
"}",
"if",
"(",
"code",
"==",
"'w'",
")",
"msize",
"=",
"2",
";",
"else",
"if",
"(",
"code",
"==",
"'b'",
")",
"msize",
"=",
"1",
";",
"else",
"if",
"(",
"code",
"==",
"'k'",
")",
"msize",
"=",
"4",
";",
"else",
"if",
"(",
"code",
"==",
"'q'",
")",
"msize",
"=",
"8",
";",
"else",
"if",
"(",
"code",
"==",
"'h'",
")",
"msize",
"=",
"0",
";",
"else",
"if",
"(",
"code",
"==",
"'x'",
")",
"msize",
"=",
"16",
";",
"else",
"if",
"(",
"code",
"==",
"'t'",
")",
"msize",
"=",
"32",
";",
"else",
"if",
"(",
"code",
"==",
"'g'",
")",
"msize",
"=",
"64",
";",
"else",
"msize",
"=",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"x",
")",
")",
";",
"regno",
"=",
"true_regnum",
"(",
"x",
")",
";",
"gcc_assert",
"(",
"regno",
"!=",
"ARG_POINTER_REGNUM",
"&&",
"regno",
"!=",
"FRAME_POINTER_REGNUM",
"&&",
"regno",
"!=",
"FLAGS_REG",
"&&",
"regno",
"!=",
"FPSR_REG",
"&&",
"regno",
"!=",
"FPCR_REG",
")",
";",
"duplicated",
"=",
"code",
"==",
"'d'",
"&&",
"TARGET_AVX",
";",
"switch",
"(",
"msize",
")",
"{",
"case",
"8",
":",
"case",
"4",
":",
"if",
"(",
"LEGACY_INT_REGNO_P",
"(",
"regno",
")",
")",
"putc",
"(",
"msize",
"==",
"8",
"&&",
"TARGET_64BIT",
"?",
"'r'",
":",
"'e'",
",",
"file",
")",
";",
"case",
"16",
":",
"case",
"12",
":",
"case",
"2",
":",
"normal",
":",
"reg",
"=",
"hi_reg_name",
"[",
"regno",
"]",
";",
"break",
";",
"case",
"1",
":",
"if",
"(",
"regno",
">=",
"ARRAY_SIZE",
"(",
"qi_reg_name",
")",
")",
"goto",
"normal",
";",
"reg",
"=",
"qi_reg_name",
"[",
"regno",
"]",
";",
"break",
";",
"case",
"0",
":",
"if",
"(",
"regno",
">=",
"ARRAY_SIZE",
"(",
"qi_high_reg_name",
")",
")",
"goto",
"normal",
";",
"reg",
"=",
"qi_high_reg_name",
"[",
"regno",
"]",
";",
"break",
";",
"case",
"32",
":",
"case",
"64",
":",
"if",
"(",
"SSE_REGNO_P",
"(",
"regno",
")",
")",
"{",
"gcc_assert",
"(",
"!",
"duplicated",
")",
";",
"putc",
"(",
"msize",
"==",
"32",
"?",
"'y'",
":",
"'z'",
",",
"file",
")",
";",
"reg",
"=",
"hi_reg_name",
"[",
"regno",
"]",
"+",
"1",
";",
"break",
";",
"}",
"goto",
"normal",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"fputs",
"(",
"reg",
",",
"file",
")",
";",
"if",
"(",
"REX_INT_REGNO_P",
"(",
"regno",
")",
")",
"{",
"gcc_assert",
"(",
"TARGET_64BIT",
")",
";",
"switch",
"(",
"msize",
")",
"{",
"case",
"0",
":",
"error",
"(",
"\"extended registers have no high halves\"",
")",
";",
"break",
";",
"case",
"1",
":",
"putc",
"(",
"'b'",
",",
"file",
")",
";",
"break",
";",
"case",
"2",
":",
"putc",
"(",
"'w'",
",",
"file",
")",
";",
"break",
";",
"case",
"4",
":",
"putc",
"(",
"'d'",
",",
"file",
")",
";",
"break",
";",
"case",
"8",
":",
"break",
";",
"default",
":",
"error",
"(",
"\"unsupported operand size for extended register\"",
")",
";",
"break",
";",
"}",
"return",
";",
"}",
"if",
"(",
"duplicated",
")",
"{",
"if",
"(",
"ASSEMBLER_DIALECT",
"==",
"ASM_ATT",
")",
"fprintf",
"(",
"file",
",",
"\", %%%s\"",
",",
"reg",
")",
";",
"else",
"fprintf",
"(",
"file",
",",
"\", %s\"",
",",
"reg",
")",
";",
"}",
"}",
"</s>"
] | [
"Print",
"a",
"register",
"."
] | [
"i386",
"\"rip\"",
"\"st(0)\"",
"2",
"1",
"4",
"8",
"0",
"16",
"32",
"64",
"8",
"4",
"8",
"16",
"12",
"2",
"1",
"0",
"32",
"64",
"32",
"1",
"0",
"\"extended registers have no high halves\"",
"1",
"2",
"4",
"8",
"\"unsupported operand size for extended register\"",
"\", %%%s\"",
"\", %s\""
] | i3865 | print_reg | i386 | CPU | GCC | 19,637 | 499 | 1 | [] |
[
"<s>",
"void",
"X86AsmInstrumentation",
"::",
"EmitInstruction",
"(",
"MCStreamer",
"&",
"Out",
",",
"const",
"MCInst",
"&",
"Inst",
")",
"{",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"*",
"STI",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"X86",
"X86"
] | X86AsmInstrumentation13 | EmitInstruction | X86 | CPU | LLVM | 19,638 | 26 | 1 | [] |
[
"<s>",
"void",
"PTXFPRoundingModePass",
"::",
"processInstruction",
"(",
"MachineInstr",
"&",
"MI",
")",
"{",
"if",
"(",
"Instrs",
".",
"count",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
")",
"{",
"const",
"RndModeDesc",
"&",
"Desc",
"=",
"Instrs",
"[",
"MI",
".",
"getOpcode",
"(",
")",
"]",
";",
"MachineOperand",
"&",
"Op",
"=",
"MI",
".",
"getOperand",
"(",
"Desc",
".",
"first",
")",
";",
"if",
"(",
"Op",
".",
"getImm",
"(",
")",
"==",
"PTXRoundingMode",
"::",
"RndDefault",
")",
"{",
"Op",
".",
"setImm",
"(",
"Desc",
".",
"second",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Process",
"a",
"single",
"instruction",
"and",
"collect",
"debug",
"info",
"anchors",
"."
] | [
"PTX",
"PTX",
"PTXRoundingMode::RndDefault"
] | PTXFPRoundingModePass | processInstruction | PTX | GPU | LLVM | 19,639 | 76 | 1 | [] |
[
"<s>",
"static",
"rtx",
"mips_legitimize_tls_address",
"(",
"rtx",
"loc",
")",
"{",
"rtx",
"dest",
",",
"insn",
",",
"v0",
",",
"v1",
",",
"tmp1",
",",
"tmp2",
",",
"eqv",
";",
"enum",
"tls_model",
"model",
";",
"v0",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_RETURN",
")",
";",
"v1",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_RETURN",
"+",
"1",
")",
";",
"model",
"=",
"SYMBOL_REF_TLS_MODEL",
"(",
"loc",
")",
";",
"switch",
"(",
"model",
")",
"{",
"case",
"TLS_MODEL_GLOBAL_DYNAMIC",
":",
"insn",
"=",
"mips_call_tls_get_addr",
"(",
"loc",
",",
"SYMBOL_TLSGD",
",",
"v0",
")",
";",
"dest",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_libcall_block",
"(",
"insn",
",",
"dest",
",",
"v0",
",",
"loc",
")",
";",
"break",
";",
"case",
"TLS_MODEL_LOCAL_DYNAMIC",
":",
"insn",
"=",
"mips_call_tls_get_addr",
"(",
"loc",
",",
"SYMBOL_TLSLDM",
",",
"v0",
")",
";",
"tmp1",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"eqv",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"const0_rtx",
")",
",",
"UNSPEC_TLS_LDM",
")",
";",
"emit_libcall_block",
"(",
"insn",
",",
"tmp1",
",",
"v0",
",",
"eqv",
")",
";",
"tmp2",
"=",
"mips_unspec_offset_high",
"(",
"NULL",
",",
"tmp1",
",",
"loc",
",",
"SYMBOL_DTPREL",
")",
";",
"dest",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"tmp2",
",",
"mips_unspec_address",
"(",
"loc",
",",
"SYMBOL_DTPREL",
")",
")",
";",
"break",
";",
"case",
"TLS_MODEL_INITIAL_EXEC",
":",
"tmp1",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"tmp2",
"=",
"mips_unspec_address",
"(",
"loc",
",",
"SYMBOL_GOTTPREL",
")",
";",
"if",
"(",
"Pmode",
"==",
"DImode",
")",
"{",
"emit_insn",
"(",
"gen_tls_get_tp_di",
"(",
"v1",
")",
")",
";",
"emit_insn",
"(",
"gen_load_gotdi",
"(",
"tmp1",
",",
"pic_offset_table_rtx",
",",
"tmp2",
")",
")",
";",
"}",
"else",
"{",
"emit_insn",
"(",
"gen_tls_get_tp_si",
"(",
"v1",
")",
")",
";",
"emit_insn",
"(",
"gen_load_gotsi",
"(",
"tmp1",
",",
"pic_offset_table_rtx",
",",
"tmp2",
")",
")",
";",
"}",
"dest",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_add3_insn",
"(",
"dest",
",",
"tmp1",
",",
"v1",
")",
")",
";",
"break",
";",
"case",
"TLS_MODEL_LOCAL_EXEC",
":",
"if",
"(",
"Pmode",
"==",
"DImode",
")",
"emit_insn",
"(",
"gen_tls_get_tp_di",
"(",
"v1",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_tls_get_tp_si",
"(",
"v1",
")",
")",
";",
"tmp1",
"=",
"mips_unspec_offset_high",
"(",
"NULL",
",",
"v1",
",",
"loc",
",",
"SYMBOL_TPREL",
")",
";",
"dest",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"tmp1",
",",
"mips_unspec_address",
"(",
"loc",
",",
"SYMBOL_TPREL",
")",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"dest",
";",
"}",
"</s>"
] | [
"Generate",
"the",
"code",
"to",
"access",
"LOC",
",",
"a",
"thread",
"local",
"SYMBOL_REF",
".",
"The",
"return",
"value",
"will",
"be",
"a",
"valid",
"address",
"and",
"move_operand",
"(",
"either",
"a",
"REG",
"or",
"a",
"LO_SUM",
")",
"."
] | [
"mips",
"1",
"1"
] | mips3 | mips_legitimize_tls_address | mips | CPU | GCC | 19,640 | 331 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAlwaysInline",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"std",
"::",
"vector",
"<",
"Function",
"*",
">",
"FuncsToClone",
";",
"for",
"(",
"Module",
"::",
"iterator",
"I",
"=",
"M",
".",
"begin",
"(",
")",
",",
"E",
"=",
"M",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"Function",
"&",
"F",
"=",
"*",
"I",
";",
"if",
"(",
"!",
"F",
".",
"hasLocalLinkage",
"(",
")",
"&&",
"!",
"F",
".",
"isDeclaration",
"(",
")",
"&&",
"!",
"F",
".",
"use_empty",
"(",
")",
")",
"FuncsToClone",
".",
"push_back",
"(",
"&",
"F",
")",
";",
"}",
"for",
"(",
"Function",
"*",
"F",
":",
"FuncsToClone",
")",
"{",
"ValueToValueMapTy",
"VMap",
";",
"Function",
"*",
"NewFunc",
"=",
"CloneFunction",
"(",
"F",
",",
"VMap",
",",
"false",
")",
";",
"NewFunc",
"->",
"setLinkage",
"(",
"GlobalValue",
"::",
"InternalLinkage",
")",
";",
"F",
"->",
"getParent",
"(",
")",
"->",
"getFunctionList",
"(",
")",
".",
"push_back",
"(",
"NewFunc",
")",
";",
"F",
"->",
"replaceAllUsesWith",
"(",
"NewFunc",
")",
";",
"}",
"for",
"(",
"Module",
"::",
"iterator",
"I",
"=",
"M",
".",
"begin",
"(",
")",
",",
"E",
"=",
"M",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"Function",
"&",
"F",
"=",
"*",
"I",
";",
"if",
"(",
"F",
".",
"hasLocalLinkage",
"(",
")",
")",
"{",
"F",
".",
"addFnAttr",
"(",
"Attribute",
"::",
"AlwaysInline",
")",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"R600"
] | AMDGPUAlwaysInlinePass16 | runOnModule | R600 | GPU | LLVM | 19,641 | 204 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_setup_incoming_varargs",
"(",
"cumulative_args_t",
"cum_v",
",",
"machine_mode",
"mode",
",",
"tree",
"type",
",",
"int",
"*",
"pretend_size",
",",
"int",
"second_time",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"CUMULATIVE_ARGS",
"local_cum",
";",
"cumulative_args_t",
"local_cum_v",
"=",
"pack_cumulative_args",
"(",
"&",
"local_cum",
")",
";",
"int",
"regs_to_push",
";",
"int",
"pret_size",
";",
"local_cum",
"=",
"*",
"cum",
";",
"nios2_function_arg_advance",
"(",
"local_cum_v",
",",
"mode",
",",
"type",
",",
"1",
")",
";",
"regs_to_push",
"=",
"NUM_ARG_REGS",
"-",
"local_cum",
".",
"regs_used",
";",
"if",
"(",
"!",
"second_time",
"&&",
"regs_to_push",
">",
"0",
")",
"{",
"rtx",
"ptr",
"=",
"virtual_incoming_args_rtx",
";",
"rtx",
"mem",
"=",
"gen_rtx_MEM",
"(",
"BLKmode",
",",
"ptr",
")",
";",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"move_block_from_reg",
"(",
"local_cum",
".",
"regs_used",
"+",
"FIRST_ARG_REGNO",
",",
"mem",
",",
"regs_to_push",
")",
";",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"}",
"pret_size",
"=",
"regs_to_push",
"*",
"UNITS_PER_WORD",
";",
"if",
"(",
"pret_size",
")",
"*",
"pretend_size",
"=",
"pret_size",
";",
"}",
"</s>"
] | [
"TODO",
":",
"It",
"may",
"be",
"possible",
"to",
"eliminate",
"the",
"copyback",
"and",
"implement",
"own",
"va_arg",
"type",
"."
] | [
"nios2",
"1",
"0"
] | nios22 | nios2_setup_incoming_varargs | nios2 | MPU | GCC | 19,642 | 141 | 1 | [] |
[
"<s>",
"bool",
"MipsTargetLowering",
"::",
"CanLowerReturn",
"(",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"MachineFunction",
"&",
"MF",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"LLVMContext",
"&",
"Context",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"MF",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"Context",
")",
";",
"return",
"CCInfo",
".",
"CheckReturn",
"(",
"Outs",
",",
"RetCC_MipsO32",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"should",
"be",
"implemented",
"to",
"check",
"whether",
"the",
"return",
"values",
"described",
"by",
"the",
"Outs",
"array",
"can",
"fit",
"into",
"the",
"return",
"registers",
"."
] | [
"Mips",
"Mips",
"ISD::OutputArg",
"16",
"Mips"
] | MipsISelLowering11 | CanLowerReturn | Mips | CPU | LLVM | 19,643 | 70 | 1 | [] |
[
"<s>",
"unsigned",
"MipsMCCodeEmitter",
"::",
"getBranchTarget26OpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
">>",
"2",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"\"getBranchTarget26OpValue expects only expressions or immediates\"",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"Expr",
",",
"MCFixupKind",
"(",
"Mips",
"::",
"fixup_MIPS_PC26_S2",
")",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTarget26OpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"2",
"\"getBranchTarget26OpValue expects only expressions or immediates\"",
"0",
"Mips::fixup_MIPS_PC26_S2",
"0"
] | MipsMCCodeEmitter55 | getBranchTarget26OpValue | Mips | CPU | LLVM | 19,644 | 103 | 1 | [] |
[
"<s>",
"static",
"int",
"is_dispatch_slot_restricted",
"(",
"rtx",
"insn",
")",
"{",
"enum",
"attr_type",
"type",
";",
"if",
"(",
"!",
"rs6000_sched_groups",
")",
"return",
"0",
";",
"if",
"(",
"!",
"insn",
"||",
"insn",
"==",
"NULL_RTX",
"||",
"GET_CODE",
"(",
"insn",
")",
"==",
"NOTE",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"USE",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"CLOBBER",
")",
"return",
"0",
";",
"type",
"=",
"get_attr_type",
"(",
"insn",
")",
";",
"switch",
"(",
"type",
")",
"{",
"case",
"TYPE_MFCR",
":",
"case",
"TYPE_MFCRF",
":",
"case",
"TYPE_MTCR",
":",
"case",
"TYPE_DELAYED_CR",
":",
"case",
"TYPE_CR_LOGICAL",
":",
"case",
"TYPE_MTJMPR",
":",
"case",
"TYPE_MFJMPR",
":",
"return",
"1",
";",
"case",
"TYPE_IDIV",
":",
"case",
"TYPE_LDIV",
":",
"return",
"2",
";",
"case",
"TYPE_LOAD_L",
":",
"case",
"TYPE_STORE_C",
":",
"case",
"TYPE_ISYNC",
":",
"case",
"TYPE_SYNC",
":",
"return",
"4",
";",
"default",
":",
"if",
"(",
"rs6000_cpu",
"==",
"PROCESSOR_POWER5",
"&&",
"is_cracked_insn",
"(",
"insn",
")",
")",
"return",
"2",
";",
"return",
"0",
";",
"}",
"}",
"</s>"
] | [
"The",
"function",
"returns",
"a",
"nonzero",
"value",
"if",
"INSN",
"can",
"be",
"scheduled",
"only",
"as",
"the",
"first",
"insn",
"in",
"a",
"dispatch",
"group",
"(",
"``",
"dispatch-slot",
"restricted",
"''",
")",
".",
"In",
"this",
"case",
",",
"the",
"returned",
"value",
"indicates",
"how",
"many",
"dispatch",
"slots",
"the",
"insn",
"occupies",
"(",
"at",
"the",
"beginning",
"of",
"the",
"group",
")",
".",
"Return",
"0",
"otherwise",
"."
] | [
"rs6000",
"0",
"0",
"1",
"2",
"4",
"2",
"0"
] | rs60003 | is_dispatch_slot_restricted | rs6000 | CPU | GCC | 19,645 | 140 | 1 | [] |
[
"<s>",
"void",
"sparc_split_reg_reg",
"(",
"rtx",
"dest",
",",
"rtx",
"src",
",",
"machine_mode",
"mode",
")",
"{",
"rtx",
"dest1",
"=",
"gen_highpart",
"(",
"mode",
",",
"dest",
")",
";",
"rtx",
"dest2",
"=",
"gen_lowpart",
"(",
"mode",
",",
"dest",
")",
";",
"rtx",
"src1",
"=",
"gen_highpart",
"(",
"mode",
",",
"src",
")",
";",
"rtx",
"src2",
"=",
"gen_lowpart",
"(",
"mode",
",",
"src",
")",
";",
"if",
"(",
"reg_overlap_mentioned_p",
"(",
"dest1",
",",
"src2",
")",
")",
"{",
"emit_move_insn_1",
"(",
"dest2",
",",
"src2",
")",
";",
"emit_move_insn_1",
"(",
"dest1",
",",
"src1",
")",
";",
"}",
"else",
"{",
"emit_move_insn_1",
"(",
"dest1",
",",
"src1",
")",
";",
"emit_move_insn_1",
"(",
"dest2",
",",
"src2",
")",
";",
"}",
"}",
"</s>"
] | [
"Split",
"a",
"REG",
"<",
"--",
">",
"REG",
"move",
"into",
"a",
"pair",
"of",
"moves",
"in",
"MODE",
"."
] | [
"sparc"
] | sparc | sparc_split_reg_reg | sparc | CPU | GCC | 19,646 | 96 | 1 | [] |
[
"<s>",
"bool",
"MSP430AsmParser",
"::",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
"Info",
",",
"StringRef",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"{",
"if",
"(",
"Name",
".",
"endswith_insensitive",
"(",
"\".w\"",
")",
")",
"Name",
"=",
"Name",
".",
"drop_back",
"(",
"2",
")",
";",
"if",
"(",
"!",
"parseJccInstruction",
"(",
"Info",
",",
"Name",
",",
"NameLoc",
",",
"Operands",
")",
")",
"return",
"false",
";",
"if",
"(",
"Name",
".",
"startswith_insensitive",
"(",
"\"rpt\"",
")",
")",
"return",
"parseRptDirective",
"(",
"Info",
",",
"Name",
",",
"NameLoc",
",",
"Operands",
")",
";",
"Operands",
".",
"push_back",
"(",
"MSP430Operand",
"::",
"CreateToken",
"(",
"Name",
",",
"NameLoc",
")",
")",
";",
"if",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"return",
"false",
";",
"if",
"(",
"ParseOperand",
"(",
"Operands",
")",
")",
"return",
"true",
";",
"if",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"{",
"getLexer",
"(",
")",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"ParseOperand",
"(",
"Operands",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"getParser",
"(",
")",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"unexpected token\"",
")",
";",
"}",
"getParser",
"(",
")",
".",
"Lex",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"MSP430",
"MSP430",
"\".w\"",
"2",
"\"rpt\"",
"MSP430Operand::CreateToken",
"\"unexpected token\""
] | MSP430AsmParser14 | ParseInstruction | MSP430 | MPU | LLVM | 19,647 | 203 | 1 | [] |
[
"<s>",
"static",
"bool",
"hasIndex",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MCRegisterInfo",
"&",
"RI",
")",
"{",
"for",
"(",
"const",
"MachineOperand",
"&",
"Op",
":",
"MI",
".",
"explicit_operands",
"(",
")",
")",
"if",
"(",
"isIndex",
"(",
"Op",
",",
"RI",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"given",
"machine",
"instr",
"is",
"mapped",
"to",
"an",
"index",
",",
"otherwise",
"returns",
"false",
"."
] | [
"Z80old"
] | Z80oldInstrInfo | hasIndex | Z80old | MPU | LLVM | 19,648 | 46 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isZExtFree",
"(",
"const",
"Type",
"*",
"Ty1",
",",
"const",
"Type",
"*",
"Ty2",
")",
"const",
"{",
"return",
"Ty1",
"==",
"Type",
"::",
"getInt32Ty",
"(",
"Ty1",
"->",
"getContext",
"(",
")",
")",
"&&",
"Ty2",
"==",
"Type",
"::",
"getInt64Ty",
"(",
"Ty1",
"->",
"getContext",
"(",
")",
")",
"&&",
"Subtarget",
"->",
"is64Bit",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"zero-extending",
"the",
"specific",
"node",
"Val",
"to",
"type",
"VT2",
"is",
"free",
"(",
"either",
"because",
"it",
"'s",
"implicitly",
"zero-extended",
"such",
"as",
"ARM",
"ldrb",
"/",
"ldrh",
"or",
"because",
"it",
"'s",
"folded",
"such",
"as",
"X86",
"zero-extending",
"loads",
")",
"."
] | [
"X86",
"X86"
] | X86ISelLowering94 | isZExtFree | X86 | CPU | LLVM | 19,649 | 51 | 1 | [] |
[
"<s>",
"MCSymbol",
"*",
"ARMMCInstLower",
"::",
"GetExternalSymbolSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"switch",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
")",
"{",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"Unknown target flag on GV operand\"",
")",
";",
"case",
"0",
":",
"break",
";",
"}",
"return",
"Printer",
".",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"MCSymbol",
"for",
"the",
"specified",
"ExternalSymbol",
"."
] | [
"ARM",
"ARM",
"0",
"\"Unknown target flag on GV operand\"",
"0"
] | ARMMCInstLower2 | GetExternalSymbolSymbol | ARM | CPU | LLVM | 19,650 | 50 | 1 | [] |
[
"<s>",
"const",
"AMDGPUTargetLowering",
"*",
"getTLI",
"(",
")",
"const",
"{",
"return",
"TLI",
";",
"}",
"</s>"
] | [
"Getter",
"for",
"generic",
"TargetLowering",
"class",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUTargetTransformInfo (2) | getTLI | AMDGPU | GPU | LLVM | 19,651 | 12 | 1 | [] |
[
"<s>",
"bool",
"HexagonCallFrameInformation",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"auto",
"&",
"HFI",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"bool",
"NeedCFI",
"=",
"MF",
".",
"needsFrameMoves",
"(",
")",
";",
"if",
"(",
"!",
"NeedCFI",
")",
"return",
"false",
";",
"HFI",
".",
"insertCFIInstructions",
"(",
"MF",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonFrameLowering10 | runOnMachineFunction | Hexagon | DSP | LLVM | 19,652 | 56 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"ARM64"
] | ARM64CleanupLocalDynamicTLSPass1 | getAnalysisUsage | ARM64 | CPU | LLVM | 19,653 | 33 | 1 | [] |
[
"<s>",
"static",
"bool",
"avr_assemble_integer",
"(",
"rtx",
"x",
",",
"unsigned",
"int",
"size",
",",
"int",
"aligned_p",
")",
"{",
"if",
"(",
"size",
"==",
"POINTER_SIZE",
"/",
"BITS_PER_UNIT",
"&&",
"aligned_p",
"&&",
"(",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"&&",
"SYMBOL_REF_FUNCTION_P",
"(",
"x",
")",
")",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"LABEL_REF",
")",
")",
"{",
"fputs",
"(",
"\"\\t.word\\tpm(\"",
",",
"asm_out_file",
")",
";",
"output_addr_const",
"(",
"asm_out_file",
",",
"x",
")",
";",
"fputs",
"(",
"\")\\n\"",
",",
"asm_out_file",
")",
";",
"return",
"true",
";",
"}",
"return",
"default_assemble_integer",
"(",
"x",
",",
"size",
",",
"aligned_p",
")",
";",
"}",
"</s>"
] | [
"Target",
"hook",
"for",
"assembling",
"integer",
"objects",
".",
"The",
"AVR",
"version",
"needs",
"special",
"handling",
"for",
"references",
"to",
"certain",
"labels",
"."
] | [
"avr",
"\"\\t.word\\tpm(\"",
"\")\\n\""
] | avr3 | avr_assemble_integer | avr | MPU | GCC | 19,654 | 85 | 1 | [] |
[
"<s>",
"void",
"BPFFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"BPF",
"BPF"
] | BPFFrameLowering | emitPrologue | BPF | Virtual ISA | LLVM | 19,655 | 16 | 1 | [] |
[
"<s>",
"bool",
"convertSetCCLogicToBitwiseLogic",
"(",
"EVT",
"VT",
")",
"const",
"override",
"{",
"return",
"VT",
".",
"isScalarInteger",
"(",
")",
";",
"}",
"</s>"
] | [
"Use",
"bitwise",
"logic",
"to",
"make",
"pairs",
"of",
"compares",
"more",
"efficient",
"."
] | [
"PowerPC"
] | PPCISelLowering (2)2 | convertSetCCLogicToBitwiseLogic | PowerPC | CPU | LLVM | 19,656 | 17 | 1 | [] |
[
"<s>",
"bool",
"PPCSubtarget",
"::",
"enableMachinePipeliner",
"(",
")",
"const",
"{",
"return",
"getSchedModel",
"(",
")",
".",
"hasInstrSchedModel",
"(",
")",
"&&",
"EnableMachinePipeliner",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"subtarget",
"should",
"run",
"MachinePipeliner",
"."
] | [
"PowerPC",
"PPC"
] | PPCSubtarget13 | enableMachinePipeliner | PowerPC | CPU | LLVM | 19,657 | 20 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"RISCVRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"auto",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"\"interrupt\"",
")",
")",
"{",
"if",
"(",
"Subtarget",
".",
"hasStdExtD",
"(",
")",
")",
"return",
"CSR_XLEN_F64_Interrupt_RegMask",
";",
"if",
"(",
"Subtarget",
".",
"hasStdExtF",
"(",
")",
")",
"return",
"CSR_XLEN_F32_Interrupt_RegMask",
";",
"return",
"CSR_Interrupt_RegMask",
";",
"}",
"return",
"CSR_ILP32_LP64_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"\"interrupt\""
] | RISCVRegisterInfo31 | getCallPreservedMask | RISCV | CPU | LLVM | 19,658 | 75 | 1 | [] |
[
"<s>",
"static",
"tree",
"ix86_build_builtin_va_list",
"(",
"void",
")",
"{",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"tree",
"sysv_va_list",
",",
"ms_va_list",
";",
"sysv_va_list",
"=",
"ix86_build_builtin_va_list_64",
"(",
")",
";",
"sysv_va_list_type_node",
"=",
"build_variant_type_copy",
"(",
"sysv_va_list",
")",
";",
"ms_va_list",
"=",
"build_pointer_type",
"(",
"char_type_node",
")",
";",
"ms_va_list_type_node",
"=",
"build_variant_type_copy",
"(",
"ms_va_list",
")",
";",
"return",
"(",
"ix86_abi",
"==",
"MS_ABI",
")",
"?",
"ms_va_list",
":",
"sysv_va_list",
";",
"}",
"else",
"{",
"return",
"build_pointer_type",
"(",
"char_type_node",
")",
";",
"}",
"}",
"</s>"
] | [
"Create",
"the",
"va_list",
"data",
"type",
"."
] | [
"i386"
] | i3865 | ix86_build_builtin_va_list | i386 | CPU | GCC | 19,659 | 66 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"ix86_secondary_memory_needed_mode",
"(",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"<",
"32",
"&&",
"INTEGRAL_MODE_P",
"(",
"mode",
")",
")",
"return",
"mode_for_size",
"(",
"32",
",",
"GET_MODE_CLASS",
"(",
"mode",
")",
",",
"0",
")",
".",
"require",
"(",
")",
";",
"return",
"mode",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_SECONDARY_MEMORY_NEEDED_MODE",
".",
"get_secondary_mem",
"widens",
"integral",
"modes",
"to",
"BITS_PER_WORD",
".",
"There",
"is",
"no",
"need",
"to",
"emit",
"full",
"64",
"bit",
"move",
"on",
"64",
"bit",
"targets",
"for",
"integral",
"modes",
"that",
"can",
"be",
"moved",
"using",
"32",
"bit",
"move",
"."
] | [
"i386",
"32",
"32",
"0"
] | i386 | ix86_secondary_memory_needed_mode | i386 | CPU | GCC | 19,660 | 43 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"Z80"
] | Z80TargetMachine1 | getObjFileLowering | Z80 | MPU | LLVM | 19,661 | 16 | 1 | [] |
[
"<s>",
"static",
"avr_map_op_t",
"avr_map_decompose",
"(",
"unsigned",
"int",
"f",
",",
"const",
"avr_map_op_t",
"*",
"g",
",",
"bool",
"val_const_p",
")",
"{",
"bool",
"val_used_p",
"=",
"0",
"!=",
"avr_map_metric",
"(",
"f",
",",
"MAP_MASK_PREIMAGE_F",
")",
";",
"avr_map_op_t",
"f_ginv",
"=",
"*",
"g",
";",
"unsigned",
"int",
"ginv",
"=",
"g",
"->",
"ginv",
";",
"f_ginv",
".",
"cost",
"=",
"-",
"1",
";",
"for",
"(",
"int",
"i",
"=",
"7",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"int",
"x",
"=",
"avr_map",
"(",
"f",
",",
"i",
")",
";",
"if",
"(",
"x",
"<=",
"7",
")",
"{",
"x",
"=",
"avr_map",
"(",
"ginv",
",",
"x",
")",
";",
"if",
"(",
"x",
">",
"7",
")",
"return",
"f_ginv",
";",
"}",
"f_ginv",
".",
"map",
"=",
"(",
"f_ginv",
".",
"map",
"<<",
"4",
")",
"+",
"x",
";",
"}",
"if",
"(",
"0",
"==",
"avr_map_metric",
"(",
"f_ginv",
".",
"map",
",",
"MAP_NONFIXED_0_7",
")",
")",
"{",
"f_ginv",
".",
"cost",
"=",
"2",
"+",
"(",
"val_used_p",
"&&",
"!",
"val_const_p",
")",
";",
"}",
"else",
"{",
"rtx",
"xop",
"[",
"4",
"]",
";",
"xop",
"[",
"0",
"]",
"=",
"all_regs_rtx",
"[",
"24",
"]",
";",
"xop",
"[",
"1",
"]",
"=",
"gen_int_mode",
"(",
"f_ginv",
".",
"map",
",",
"SImode",
")",
";",
"xop",
"[",
"2",
"]",
"=",
"all_regs_rtx",
"[",
"25",
"]",
";",
"xop",
"[",
"3",
"]",
"=",
"val_used_p",
"?",
"xop",
"[",
"0",
"]",
":",
"const0_rtx",
";",
"avr_out_insert_bits",
"(",
"xop",
",",
"&",
"f_ginv",
".",
"cost",
")",
";",
"f_ginv",
".",
"cost",
"+=",
"val_const_p",
"&&",
"val_used_p",
"?",
"1",
":",
"0",
";",
"}",
"f_ginv",
".",
"cost",
"+=",
"g",
"->",
"cost",
";",
"if",
"(",
"avr_log",
".",
"builtin",
")",
"avr_edump",
"(",
"\" %s%d=%d\"",
",",
"g",
"->",
"str",
",",
"g",
"->",
"arg",
",",
"f_ginv",
".",
"cost",
")",
";",
"return",
"f_ginv",
";",
"}",
"</s>"
] | [
"Try",
"to",
"decompose",
"F",
"as",
"F",
"=",
"(",
"F",
"o",
"G^-1",
")",
"o",
"G",
"as",
"described",
"above",
".",
"The",
"result",
"is",
"a",
"struct",
"representing",
"F",
"o",
"G^-1",
"and",
"G.",
"If",
"result.cost",
"<",
"0",
"then",
"such",
"a",
"decomposition",
"does",
"not",
"exist",
"."
] | [
"avr",
"0",
"1",
"7",
"0",
"7",
"7",
"4",
"0",
"2",
"4",
"0",
"24",
"1",
"2",
"25",
"3",
"0",
"1",
"0",
"\" %s%d=%d\""
] | avr6 | avr_map_decompose | avr | MPU | GCC | 19,662 | 258 | 1 | [] |
[
"<s>",
"void",
"PPCTargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"SDValue",
"Op",
",",
"std",
"::",
"string",
"&",
"Constraint",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"Result",
"(",
"0",
",",
"0",
")",
";",
"if",
"(",
"Constraint",
".",
"length",
"(",
")",
">",
"1",
")",
"return",
";",
"char",
"Letter",
"=",
"Constraint",
"[",
"0",
"]",
";",
"switch",
"(",
"Letter",
")",
"{",
"default",
":",
"break",
";",
"case",
"'I'",
":",
"case",
"'J'",
":",
"case",
"'K'",
":",
"case",
"'L'",
":",
"case",
"'M'",
":",
"case",
"'N'",
":",
"case",
"'O'",
":",
"case",
"'P'",
":",
"{",
"ConstantSDNode",
"*",
"CST",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
";",
"if",
"(",
"!",
"CST",
")",
"return",
";",
"unsigned",
"Value",
"=",
"CST",
"->",
"getZExtValue",
"(",
")",
";",
"switch",
"(",
"Letter",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown constraint letter!\"",
")",
";",
"case",
"'I'",
":",
"if",
"(",
"(",
"short",
")",
"Value",
"==",
"(",
"int",
")",
"Value",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'J'",
":",
"case",
"'L'",
":",
"if",
"(",
"(",
"short",
")",
"Value",
"==",
"0",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'K'",
":",
"if",
"(",
"(",
"Value",
">>",
"16",
")",
"==",
"0",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'M'",
":",
"if",
"(",
"Value",
">",
"31",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'N'",
":",
"if",
"(",
"(",
"int",
")",
"Value",
">",
"0",
"&&",
"isPowerOf2_32",
"(",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'O'",
":",
"if",
"(",
"Value",
"==",
"0",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'P'",
":",
"if",
"(",
"(",
"short",
")",
"-",
"Value",
"==",
"(",
"int",
")",
"-",
"Value",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"}",
"break",
";",
"}",
"}",
"if",
"(",
"Result",
".",
"getNode",
"(",
")",
")",
"{",
"Ops",
".",
"push_back",
"(",
"Result",
")",
";",
"return",
";",
"}",
"TargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"Op",
",",
"Constraint",
",",
"Ops",
",",
"DAG",
")",
";",
"}",
"</s>"
] | [
"Lower",
"the",
"specified",
"operand",
"into",
"the",
"Ops",
"vector",
"."
] | [
"PowerPC",
"PPC",
"0",
"0",
"1",
"0",
"\"Unknown constraint letter!\"",
"0",
"16",
"0",
"31",
"0",
"0"
] | PPCISelLowering (2) | LowerAsmOperandForConstraint | PowerPC | CPU | LLVM | 19,663 | 383 | 1 | [] |
[
"<s>",
"void",
"ARMHazardRecognizer",
"::",
"Reset",
"(",
")",
"{",
"LastMI",
"=",
"0",
";",
"FpMLxStalls",
"=",
"0",
";",
"ITBlockSize",
"=",
"0",
";",
"ScoreboardHazardRecognizer",
"::",
"Reset",
"(",
")",
";",
"}",
"</s>"
] | [
"Reset",
"the",
"unwind",
"opcode",
"assembler",
"."
] | [
"ARM",
"ARM",
"0",
"0",
"0"
] | ARMHazardRecognizer20 | Reset | ARM | CPU | LLVM | 19,664 | 26 | 1 | [] |
[
"<s>",
"bool",
"isVirtualSection",
"(",
"const",
"MCSection",
"&",
"Section",
")",
"const",
"{",
"const",
"MCSectionMachO",
"&",
"SMO",
"=",
"static_cast",
"<",
"const",
"MCSectionMachO",
"&",
">",
"(",
"Section",
")",
";",
"return",
"(",
"SMO",
".",
"getType",
"(",
")",
"==",
"MCSectionMachO",
"::",
"S_ZEROFILL",
"||",
"SMO",
".",
"getType",
"(",
")",
"==",
"MCSectionMachO",
"::",
"S_GB_ZEROFILL",
")",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"this",
"section",
"is",
"``",
"virtual",
"''",
",",
"that",
"is",
"has",
"no",
"actual",
"object",
"file",
"contents",
"."
] | [
"X86"
] | X86AsmBackend9 | isVirtualSection | X86 | CPU | LLVM | 19,665 | 49 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"ConstraintWeight",
"PPCTargetLowering",
"::",
"getSingleConstraintMatchWeight",
"(",
"AsmOperandInfo",
"&",
"info",
",",
"const",
"char",
"*",
"constraint",
")",
"const",
"{",
"ConstraintWeight",
"weight",
"=",
"CW_Invalid",
";",
"Value",
"*",
"CallOperandVal",
"=",
"info",
".",
"CallOperandVal",
";",
"if",
"(",
"CallOperandVal",
"==",
"NULL",
")",
"return",
"CW_Default",
";",
"Type",
"*",
"type",
"=",
"CallOperandVal",
"->",
"getType",
"(",
")",
";",
"switch",
"(",
"*",
"constraint",
")",
"{",
"default",
":",
"weight",
"=",
"TargetLowering",
"::",
"getSingleConstraintMatchWeight",
"(",
"info",
",",
"constraint",
")",
";",
"break",
";",
"case",
"'b'",
":",
"if",
"(",
"type",
"->",
"isIntegerTy",
"(",
")",
")",
"weight",
"=",
"CW_Register",
";",
"break",
";",
"case",
"'f'",
":",
"if",
"(",
"type",
"->",
"isFloatTy",
"(",
")",
")",
"weight",
"=",
"CW_Register",
";",
"break",
";",
"case",
"'d'",
":",
"if",
"(",
"type",
"->",
"isDoubleTy",
"(",
")",
")",
"weight",
"=",
"CW_Register",
";",
"break",
";",
"case",
"'v'",
":",
"if",
"(",
"type",
"->",
"isVectorTy",
"(",
")",
")",
"weight",
"=",
"CW_Register",
";",
"break",
";",
"case",
"'y'",
":",
"weight",
"=",
"CW_Register",
";",
"break",
";",
"}",
"return",
"weight",
";",
"}",
"</s>"
] | [
"Examine",
"constraint",
"string",
"and",
"operand",
"type",
"and",
"determine",
"a",
"weight",
"value",
"."
] | [
"PowerPC",
"PPC"
] | PPCISelLowering113 | getSingleConstraintMatchWeight | PowerPC | CPU | LLVM | 19,666 | 153 | 1 | [] |
[
"<s>",
"void",
"Thumb1InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"assert",
"(",
"(",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"SrcReg",
")",
"&&",
"isARMLowRegister",
"(",
"SrcReg",
")",
")",
")",
"&&",
"\"Unknown regclass!\"",
")",
";",
"if",
"(",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"SrcReg",
")",
"&&",
"isARMLowRegister",
"(",
"SrcReg",
")",
")",
")",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"(",
"PseudoSourceValue",
"::",
"getFixedStack",
"(",
"FI",
")",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tSTRspi",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::tGPRRegisterClass",
"ARM",
"\"Unknown regclass!\"",
"ARM::tGPRRegisterClass",
"ARM",
"ARM::tSTRspi",
"0"
] | Thumb1InstrInfo41 | storeRegToStackSlot | ARM | CPU | LLVM | 19,667 | 211 | 1 | [] |
[
"<s>",
"bool",
"ARMCallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"&",
"F",
",",
"ArrayRef",
"<",
"unsigned",
">",
"VRegs",
")",
"const",
"{",
"auto",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"ARMTargetLowering",
">",
"(",
")",
";",
"auto",
"Subtarget",
"=",
"TLI",
".",
"getSubtarget",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"F",
".",
"arg_empty",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"F",
".",
"isVarArg",
"(",
")",
")",
"return",
"false",
";",
"auto",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"auto",
"&",
"MBB",
"=",
"MIRBuilder",
".",
"getMBB",
"(",
")",
";",
"auto",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"{",
"if",
"(",
"!",
"isSupportedType",
"(",
"DL",
",",
"TLI",
",",
"Arg",
".",
"getType",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"Arg",
".",
"hasByValOrInAllocaAttr",
"(",
")",
")",
"return",
"false",
";",
"}",
"CCAssignFn",
"*",
"AssignFn",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"F",
".",
"getCallingConv",
"(",
")",
",",
"F",
".",
"isVarArg",
"(",
")",
")",
";",
"FormalArgHandler",
"ArgHandler",
"(",
"MIRBuilder",
",",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getRegInfo",
"(",
")",
",",
"AssignFn",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"8",
">",
"ArgInfos",
";",
"SmallVector",
"<",
"unsigned",
",",
"4",
">",
"SplitRegs",
";",
"unsigned",
"Idx",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"{",
"ArgInfo",
"AInfo",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"Arg",
".",
"getType",
"(",
")",
")",
";",
"setArgFlags",
"(",
"AInfo",
",",
"Idx",
"+",
"AttributeList",
"::",
"FirstArgIndex",
",",
"DL",
",",
"F",
")",
";",
"SplitRegs",
".",
"clear",
"(",
")",
";",
"splitToValueTypes",
"(",
"AInfo",
",",
"ArgInfos",
",",
"MF",
",",
"[",
"&",
"]",
"(",
"unsigned",
"Reg",
",",
"uint64_t",
"Offset",
")",
"{",
"SplitRegs",
".",
"push_back",
"(",
"Reg",
")",
";",
"}",
")",
";",
"if",
"(",
"!",
"SplitRegs",
".",
"empty",
"(",
")",
")",
"MIRBuilder",
".",
"buildMerge",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"SplitRegs",
")",
";",
"Idx",
"++",
";",
"}",
"if",
"(",
"!",
"MBB",
".",
"empty",
"(",
")",
")",
"MIRBuilder",
".",
"setInstr",
"(",
"*",
"MBB",
".",
"begin",
"(",
")",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"ArgInfos",
",",
"ArgHandler",
")",
")",
"return",
"false",
";",
"MIRBuilder",
".",
"setMBB",
"(",
"MBB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"ARM",
"ARM",
"ARM",
"8",
"4",
"0"
] | ARMCallLowering17 | lowerFormalArguments | ARM | CPU | LLVM | 19,668 | 359 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"MSP430 DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"MSP430",
"\"MSP430 DAG->DAG Pattern Instruction Selection\""
] | MSP430ISelDAGToDAG12 | getPassName | MSP430 | MPU | LLVM | 19,669 | 13 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"SystemZInstrInfo",
"*",
"TII",
")",
"{",
"unsigned",
"Size",
"=",
"TII",
"->",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"assert",
"(",
"(",
"Size",
"||",
"MI",
".",
"isDebugOrPseudoInstr",
"(",
")",
"||",
"MI",
".",
"isPosition",
"(",
")",
"||",
"MI",
".",
"isKill",
"(",
")",
"||",
"MI",
".",
"isImplicitDef",
"(",
")",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SystemZ",
"::",
"MemBarrier",
"||",
"MI",
".",
"isInlineAsm",
"(",
")",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SystemZ",
"::",
"STACKMAP",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"SystemZ",
"::",
"PATCHPOINT",
")",
"&&",
"\"Missing size value for instruction.\"",
")",
";",
"return",
"Size",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ::MemBarrier",
"SystemZ::STACKMAP",
"SystemZ::PATCHPOINT",
"\"Missing size value for instruction.\""
] | SystemZLongBranch | getInstSizeInBytes | SystemZ | CPU | LLVM | 19,670 | 98 | 1 | [] |
[
"<s>",
"void",
"SparcFrameInfo",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"prior",
"(",
"MBB",
".",
"end",
"(",
")",
")",
";",
"const",
"SparcInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"SparcInstrInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"assert",
"(",
"MBBI",
"->",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"RETL",
"&&",
"\"Can only put epilog before 'retl' instruction!\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SP",
"::",
"RESTORErr",
")",
",",
"SP",
"::",
"G0",
")",
".",
"addReg",
"(",
"SP",
"::",
"G0",
")",
".",
"addReg",
"(",
"SP",
"::",
"G0",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"SP::RETL",
"\"Can only put epilog before 'retl' instruction!\"",
"SP::RESTORErr",
"SP::G0",
"SP::G0",
"SP::G0"
] | SparcFrameInfo | emitEpilogue | Sparc | CPU | LLVM | 19,671 | 114 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"rs6000_insn_for_and_mask",
"(",
"machine_mode",
"mode",
",",
"rtx",
"*",
"operands",
",",
"bool",
"dot",
")",
"{",
"int",
"nb",
",",
"ne",
";",
"if",
"(",
"!",
"rs6000_is_valid_mask",
"(",
"operands",
"[",
"2",
"]",
",",
"&",
"nb",
",",
"&",
"ne",
",",
"mode",
")",
")",
"gcc_unreachable",
"(",
")",
";",
"if",
"(",
"mode",
"==",
"DImode",
"&&",
"ne",
"==",
"0",
")",
"{",
"operands",
"[",
"3",
"]",
"=",
"GEN_INT",
"(",
"63",
"-",
"nb",
")",
";",
"if",
"(",
"dot",
")",
"return",
"\"rldicl. %0,%1,0,%3\"",
";",
"return",
"\"rldicl %0,%1,0,%3\"",
";",
"}",
"if",
"(",
"mode",
"==",
"DImode",
"&&",
"nb",
"==",
"63",
")",
"{",
"operands",
"[",
"3",
"]",
"=",
"GEN_INT",
"(",
"63",
"-",
"ne",
")",
";",
"if",
"(",
"dot",
")",
"return",
"\"rldicr. %0,%1,0,%3\"",
";",
"return",
"\"rldicr %0,%1,0,%3\"",
";",
"}",
"if",
"(",
"nb",
"<",
"32",
"&&",
"ne",
"<",
"32",
")",
"{",
"operands",
"[",
"3",
"]",
"=",
"GEN_INT",
"(",
"31",
"-",
"nb",
")",
";",
"operands",
"[",
"4",
"]",
"=",
"GEN_INT",
"(",
"31",
"-",
"ne",
")",
";",
"if",
"(",
"dot",
")",
"return",
"\"rlwinm. %0,%1,0,%3,%4\"",
";",
"return",
"\"rlwinm %0,%1,0,%3,%4\"",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"instruction",
"template",
"for",
"an",
"AND",
"with",
"mask",
"in",
"mode",
"MODE",
",",
"with",
"operands",
"OPERANDS",
".",
"If",
"DOT",
"is",
"true",
",",
"make",
"it",
"a",
"record-form",
"instruction",
"."
] | [
"powerpcspe",
"2",
"0",
"3",
"63",
"\"rldicl. %0,%1,0,%3\"",
"\"rldicl %0,%1,0,%3\"",
"63",
"3",
"63",
"\"rldicr. %0,%1,0,%3\"",
"\"rldicr %0,%1,0,%3\"",
"32",
"32",
"3",
"31",
"4",
"31",
"\"rlwinm. %0,%1,0,%3,%4\"",
"\"rlwinm %0,%1,0,%3,%4\""
] | powerpcspe | rs6000_insn_for_and_mask | powerpcspe | CPU | GCC | 19,672 | 163 | 1 | [] |
[
"<s>",
"void",
"m32r_init",
"(",
")",
"{",
"init_reg_tables",
"(",
")",
";",
"memset",
"(",
"m32r_punct_chars",
",",
"0",
",",
"sizeof",
"(",
"m32r_punct_chars",
")",
")",
";",
"m32r_punct_chars",
"[",
"'#'",
"]",
"=",
"1",
";",
"m32r_punct_chars",
"[",
"'@'",
"]",
"=",
"1",
";",
"if",
"(",
"!",
"g_switch_set",
")",
"g_switch_value",
"=",
"SDATA_DEFAULT_SIZE",
";",
"if",
"(",
"strcmp",
"(",
"m32r_model_string",
",",
"\"small\"",
")",
"==",
"0",
")",
"m32r_model",
"=",
"M32R_MODEL_SMALL",
";",
"else",
"if",
"(",
"strcmp",
"(",
"m32r_model_string",
",",
"\"medium\"",
")",
"==",
"0",
")",
"m32r_model",
"=",
"M32R_MODEL_MEDIUM",
";",
"else",
"if",
"(",
"strcmp",
"(",
"m32r_model_string",
",",
"\"large\"",
")",
"==",
"0",
")",
"m32r_model",
"=",
"M32R_MODEL_LARGE",
";",
"else",
"error",
"(",
"\"bad value (%s) for -mmodel switch\"",
",",
"m32r_model_string",
")",
";",
"if",
"(",
"strcmp",
"(",
"m32r_sdata_string",
",",
"\"none\"",
")",
"==",
"0",
")",
"m32r_sdata",
"=",
"M32R_SDATA_NONE",
";",
"else",
"if",
"(",
"strcmp",
"(",
"m32r_sdata_string",
",",
"\"sdata\"",
")",
"==",
"0",
")",
"m32r_sdata",
"=",
"M32R_SDATA_SDATA",
";",
"else",
"if",
"(",
"strcmp",
"(",
"m32r_sdata_string",
",",
"\"use\"",
")",
"==",
"0",
")",
"m32r_sdata",
"=",
"M32R_SDATA_USE",
";",
"else",
"error",
"(",
"\"bad value (%s) for -msdata switch\"",
",",
"m32r_sdata_string",
")",
";",
"}",
"</s>"
] | [
"Called",
"by",
"OVERRIDE_OPTIONS",
"to",
"initialize",
"various",
"things",
"."
] | [
"m32r",
"0",
"1",
"1",
"\"small\"",
"0",
"\"medium\"",
"0",
"\"large\"",
"0",
"\"bad value (%s) for -mmodel switch\"",
"\"none\"",
"0",
"\"sdata\"",
"0",
"\"use\"",
"0",
"\"bad value (%s) for -msdata switch\""
] | m32r2 | m32r_init | m32r | MPU | GCC | 19,673 | 155 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"{",
"assert",
"(",
"Kind",
"==",
"Register",
"&&",
"\"Invalid access!\"",
")",
";",
"return",
"Reg",
".",
"RegNum",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"Patmos",
"\"Invalid access!\""
] | PatmosAsmParser | getReg | Patmos | VLIW | LLVM | 19,674 | 21 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"aarch64_output_probe_stack_range",
"(",
"rtx",
"reg1",
",",
"rtx",
"reg2",
")",
"{",
"static",
"int",
"labelno",
"=",
"0",
";",
"char",
"loop_lab",
"[",
"32",
"]",
";",
"rtx",
"xops",
"[",
"2",
"]",
";",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"loop_lab",
",",
"\"LPSRL\"",
",",
"labelno",
"++",
")",
";",
"ASM_OUTPUT_INTERNAL_LABEL",
"(",
"asm_out_file",
",",
"loop_lab",
")",
";",
"HOST_WIDE_INT",
"stack_clash_probe_interval",
"=",
"1",
"<<",
"PARAM_VALUE",
"(",
"PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE",
")",
";",
"xops",
"[",
"0",
"]",
"=",
"reg1",
";",
"HOST_WIDE_INT",
"interval",
";",
"if",
"(",
"flag_stack_clash_protection",
")",
"interval",
"=",
"stack_clash_probe_interval",
";",
"else",
"interval",
"=",
"PROBE_INTERVAL",
";",
"gcc_assert",
"(",
"aarch64_uimm12_shift",
"(",
"interval",
")",
")",
";",
"xops",
"[",
"1",
"]",
"=",
"GEN_INT",
"(",
"interval",
")",
";",
"output_asm_insn",
"(",
"\"sub\\t%0, %0, %1\"",
",",
"xops",
")",
";",
"if",
"(",
"flag_stack_clash_protection",
")",
"xops",
"[",
"1",
"]",
"=",
"GEN_INT",
"(",
"STACK_CLASH_CALLER_GUARD",
")",
";",
"else",
"xops",
"[",
"1",
"]",
"=",
"CONST0_RTX",
"(",
"GET_MODE",
"(",
"xops",
"[",
"1",
"]",
")",
")",
";",
"output_asm_insn",
"(",
"\"str\\txzr, [%0, %1]\"",
",",
"xops",
")",
";",
"xops",
"[",
"1",
"]",
"=",
"reg2",
";",
"output_asm_insn",
"(",
"\"cmp\\t%0, %1\"",
",",
"xops",
")",
";",
"fputs",
"(",
"\"\\tb.ne\\t\"",
",",
"asm_out_file",
")",
";",
"assemble_name_raw",
"(",
"asm_out_file",
",",
"loop_lab",
")",
";",
"fputc",
"(",
"'\\n'",
",",
"asm_out_file",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"Probe",
"a",
"range",
"of",
"stack",
"addresses",
"from",
"REG1",
"to",
"REG2",
"inclusive",
".",
"These",
"are",
"absolute",
"addresses",
"."
] | [
"aarch64",
"0",
"32",
"2",
"\"LPSRL\"",
"1",
"0",
"1",
"\"sub\\t%0, %0, %1\"",
"1",
"1",
"1",
"\"str\\txzr, [%0, %1]\"",
"1",
"\"cmp\\t%0, %1\"",
"\"\\tb.ne\\t\"",
"\"\""
] | aarch646 | aarch64_output_probe_stack_range | aarch64 | CPU | GCC | 19,675 | 182 | 1 | [] |
[
"<s>",
"void",
"FixupLEAPass",
"::",
"processInstruction",
"(",
"MachineBasicBlock",
"::",
"iterator",
"&",
"I",
",",
"MachineFunction",
"::",
"iterator",
"MFI",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"I",
";",
"int",
"opcode",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"int",
"AddrOffset",
"=",
"X86II",
"::",
"getMemoryOperandNo",
"(",
"Desc",
".",
"TSFlags",
",",
"opcode",
")",
";",
"if",
"(",
"AddrOffset",
">=",
"0",
")",
"{",
"AddrOffset",
"+=",
"X86II",
"::",
"getOperandBias",
"(",
"Desc",
")",
";",
"MachineOperand",
"&",
"p",
"=",
"MI",
"->",
"getOperand",
"(",
"AddrOffset",
"+",
"X86",
"::",
"AddrBaseReg",
")",
";",
"if",
"(",
"p",
".",
"isReg",
"(",
")",
"&&",
"p",
".",
"getReg",
"(",
")",
"!=",
"X86",
"::",
"ESP",
")",
"{",
"seekLEAFixup",
"(",
"p",
",",
"I",
",",
"MFI",
")",
";",
"}",
"MachineOperand",
"&",
"q",
"=",
"MI",
"->",
"getOperand",
"(",
"AddrOffset",
"+",
"X86",
"::",
"AddrIndexReg",
")",
";",
"if",
"(",
"q",
".",
"isReg",
"(",
")",
"&&",
"q",
".",
"getReg",
"(",
")",
"!=",
"X86",
"::",
"ESP",
")",
"{",
"seekLEAFixup",
"(",
"q",
",",
"I",
",",
"MFI",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Process",
"a",
"single",
"instruction",
"and",
"collect",
"debug",
"info",
"anchors",
"."
] | [
"X86",
"X86II::getMemoryOperandNo",
"0",
"X86II::getOperandBias",
"X86::AddrBaseReg",
"X86::ESP",
"X86::AddrIndexReg",
"X86::ESP"
] | X86FixupLEAs12 | processInstruction | X86 | CPU | LLVM | 19,676 | 163 | 1 | [] |
[
"<s>",
"int64_t",
"getFrameAdjustment",
"(",
"const",
"MachineInstr",
"&",
"I",
")",
"const",
"{",
"assert",
"(",
"isFrameInstr",
"(",
"I",
")",
")",
";",
"if",
"(",
"isFrameSetup",
"(",
"I",
")",
")",
"return",
"I",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"return",
"I",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"stack",
"pointer",
"adjustment",
"that",
"happens",
"inside",
"the",
"frame",
"setup",
"..",
"destroy",
"sequence",
"(",
"e.g",
"."
] | [
"X86",
"2",
"1"
] | X86InstrInfo (2)2 | getFrameAdjustment | X86 | CPU | LLVM | 19,677 | 50 | 1 | [] |
[
"<s>",
"int",
"get_dest_uid",
"(",
"rtx",
"label",
",",
"int",
"max_uid",
")",
"{",
"rtx",
"dest",
"=",
"next_real_insn",
"(",
"label",
")",
";",
"int",
"dest_uid",
";",
"if",
"(",
"!",
"dest",
")",
"return",
"0",
";",
"dest_uid",
"=",
"INSN_UID",
"(",
"dest",
")",
";",
"while",
"(",
"dest_uid",
">=",
"max_uid",
")",
"{",
"dest",
"=",
"NEXT_INSN",
"(",
"dest",
")",
";",
"dest_uid",
"=",
"INSN_UID",
"(",
"dest",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"dest",
")",
"==",
"JUMP_INSN",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"dest",
")",
")",
"==",
"RETURN",
")",
"return",
"0",
";",
"return",
"dest_uid",
";",
"}",
"</s>"
] | [
"Return",
"the",
"UID",
"of",
"the",
"insn",
"that",
"follows",
"the",
"specified",
"label",
"."
] | [
"sh",
"0",
"0"
] | sh3 | get_dest_uid | sh | CPU | GCC | 19,678 | 84 | 1 | [] |
[
"<s>",
"const",
"CallLowering",
"*",
"getCallLowering",
"(",
")",
"const",
"override",
"{",
"return",
"CallLoweringInfo",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Methods",
"used",
"by",
"Global",
"ISel",
"."
] | [
"X86"
] | X86Subtarget24 | getCallLowering | X86 | CPU | LLVM | 19,679 | 17 | 1 | [] |
[
"<s>",
"bool",
"LanaiAsmPrinter",
"::",
"isBlockOnlyReachableByFallthrough",
"(",
"const",
"MachineBasicBlock",
"*",
"MBB",
")",
"const",
"{",
"const",
"MachineBasicBlock",
"*",
"Pred",
"=",
"*",
"MBB",
"->",
"pred_begin",
"(",
")",
";",
"if",
"(",
"const",
"BasicBlock",
"*",
"B",
"=",
"Pred",
"->",
"getBasicBlock",
"(",
")",
")",
"if",
"(",
"isa",
"<",
"SwitchInst",
">",
"(",
"B",
"->",
"getTerminator",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"AsmPrinter",
"::",
"isBlockOnlyReachableByFallthrough",
"(",
"MBB",
")",
")",
"return",
"false",
";",
"MachineBasicBlock",
"::",
"const_iterator",
"I",
"=",
"Pred",
"->",
"end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"Pred",
"->",
"begin",
"(",
")",
"&&",
"!",
"(",
"--",
"I",
")",
"->",
"isTerminator",
"(",
")",
")",
"{",
"}",
"return",
"!",
"I",
"->",
"isBarrier",
"(",
")",
";",
"}",
"</s>"
] | [
"isBlockOnlyReachableByFallthough",
"-",
"Return",
"true",
"if",
"the",
"basic",
"block",
"has",
"exactly",
"one",
"predecessor",
"and",
"the",
"control",
"transfer",
"mechanism",
"between",
"the",
"predecessor",
"and",
"this",
"block",
"is",
"a",
"fall-through",
"."
] | [
"Lanai",
"Lanai"
] | LanaiAsmPrinter | isBlockOnlyReachableByFallthrough | Lanai | CPU | LLVM | 19,680 | 109 | 1 | [] |
[
"<s>",
"TargetLoweringBase",
"::",
"AtomicRMWExpansionKind",
"ARMTargetLowering",
"::",
"shouldExpandAtomicRMWInIR",
"(",
"AtomicRMWInst",
"*",
"AI",
")",
"const",
"{",
"unsigned",
"Size",
"=",
"AI",
"->",
"getType",
"(",
")",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"return",
"(",
"Size",
"<=",
"(",
"Subtarget",
"->",
"isMClass",
"(",
")",
"?",
"32U",
":",
"64U",
")",
")",
"?",
"AtomicRMWExpansionKind",
"::",
"LLSC",
":",
"AtomicRMWExpansionKind",
"::",
"None",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"IR-level",
"AtomicExpand",
"pass",
"should",
"expand",
"the",
"given",
"AtomicRMW",
",",
"if",
"at",
"all",
"."
] | [
"ARM",
"ARM",
"32U",
"64U"
] | ARMISelLowering132 | shouldExpandAtomicRMWInIR | ARM | CPU | LLVM | 19,681 | 52 | 1 | [] |
[
"<s>",
"std",
"::",
"unique_ptr",
"<",
"MCObjectWriter",
">",
"WebAssemblyAsmBackend",
"::",
"createObjectWriter",
"(",
"raw_pwrite_stream",
"&",
"OS",
")",
"const",
"{",
"return",
"createWebAssemblyWasmObjectWriter",
"(",
"OS",
",",
"Is64Bit",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly"
] | WebAssemblyAsmBackend26 | createObjectWriter | WebAssembly | Virtual ISA | LLVM | 19,682 | 25 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"const",
"X86TargetMachine",
"*",
"TM",
"=",
"static_cast",
"<",
"const",
"X86TargetMachine",
"*",
">",
"(",
"&",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"const",
"X86Subtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"if",
"(",
"STI",
".",
"is64Bit",
"(",
")",
"&&",
"(",
"TM",
"->",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Small",
"||",
"TM",
"->",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Kernel",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"TM",
"->",
"isPositionIndependent",
"(",
")",
")",
"return",
"false",
";",
"X86MachineFunctionInfo",
"*",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"GlobalBaseReg",
"=",
"X86FI",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"if",
"(",
"GlobalBaseReg",
"==",
"0",
")",
"return",
"false",
";",
"MachineBasicBlock",
"&",
"FirstMBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"FirstMBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"FirstMBB",
".",
"findDebugLoc",
"(",
"MBBI",
")",
";",
"MachineRegisterInfo",
"&",
"RegInfo",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"X86InstrInfo",
"*",
"TII",
"=",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"unsigned",
"PC",
";",
"if",
"(",
"STI",
".",
"isPICStyleGOT",
"(",
")",
")",
"PC",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"&",
"X86",
"::",
"GR32RegClass",
")",
";",
"else",
"PC",
"=",
"GlobalBaseReg",
";",
"if",
"(",
"STI",
".",
"is64Bit",
"(",
")",
")",
"{",
"if",
"(",
"TM",
"->",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Medium",
")",
"{",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"LEA64r",
")",
",",
"PC",
")",
".",
"addReg",
"(",
"X86",
"::",
"RIP",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"0",
")",
".",
"addExternalSymbol",
"(",
"\"_GLOBAL_OFFSET_TABLE_\"",
")",
".",
"addReg",
"(",
"0",
")",
";",
"}",
"else",
"if",
"(",
"TM",
"->",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Large",
")",
"{",
"unsigned",
"Scratch",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"&",
"X86",
"::",
"GR64RegClass",
")",
";",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"MOVGOT64r",
")",
",",
"PC",
")",
".",
"addReg",
"(",
"Scratch",
",",
"RegState",
"::",
"Undef",
"|",
"RegState",
"::",
"Define",
")",
".",
"addExternalSymbol",
"(",
"\"_GLOBAL_OFFSET_TABLE_\"",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"unexpected code model\"",
")",
";",
"}",
"}",
"else",
"{",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"MOVPC32r",
")",
",",
"PC",
")",
".",
"addImm",
"(",
"0",
")",
";",
"if",
"(",
"STI",
".",
"isPICStyleGOT",
"(",
")",
")",
"{",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"ADD32ri",
")",
",",
"GlobalBaseReg",
")",
".",
"addReg",
"(",
"PC",
")",
".",
"addExternalSymbol",
"(",
"\"_GLOBAL_OFFSET_TABLE_\"",
",",
"X86II",
"::",
"MO_GOT_ABSOLUTE_ADDRESS",
")",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"X86",
"X86::GR32RegClass",
"X86::LEA64r",
"X86::RIP",
"0",
"0",
"\"_GLOBAL_OFFSET_TABLE_\"",
"0",
"X86::GR64RegClass",
"X86::MOVGOT64r",
"\"_GLOBAL_OFFSET_TABLE_\"",
"\"unexpected code model\"",
"X86::MOVPC32r",
"0",
"X86::ADD32ri",
"\"_GLOBAL_OFFSET_TABLE_\"",
"X86II::MO_GOT_ABSOLUTE_ADDRESS"
] | X86InstrInfo | runOnMachineFunction | X86 | CPU | LLVM | 19,683 | 420 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"SITargetLowering",
"::",
"shouldExpandAtomicStoreInIR",
"(",
"StoreInst",
"*",
"SI",
")",
"const",
"{",
"return",
"SI",
"->",
"getPointerAddressSpace",
"(",
")",
"==",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
"?",
"AtomicExpansionKind",
"::",
"NotAtomic",
":",
"AtomicExpansionKind",
"::",
"None",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"given",
"(",
"atomic",
")",
"store",
"should",
"be",
"expanded",
"by",
"the",
"IR-level",
"AtomicExpand",
"pass",
"into",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU"
] | SIISelLowering62 | shouldExpandAtomicStoreInIR | AMDGPU | GPU | LLVM | 19,684 | 33 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"!",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNo",
",",
"ExtraCode",
",",
"O",
")",
")",
"return",
"false",
";",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"1",
"]",
"!=",
"0",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"break",
";",
"default",
":",
"return",
"true",
";",
"}",
"}",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"AMDGPUInstPrinter",
"::",
"printRegOperand",
"(",
"MO",
".",
"getReg",
"(",
")",
",",
"O",
",",
"*",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"int64_t",
"Val",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"AMDGPU",
"::",
"isInlinableIntLiteral",
"(",
"Val",
")",
")",
"{",
"O",
"<<",
"Val",
";",
"}",
"else",
"if",
"(",
"isUInt",
"<",
"16",
">",
"(",
"Val",
")",
")",
"{",
"O",
"<<",
"format",
"(",
"\"0x%\"",
"PRIx64",
",",
"static_cast",
"<",
"uint16_t",
">",
"(",
"Val",
")",
")",
";",
"}",
"else",
"if",
"(",
"isUInt",
"<",
"32",
">",
"(",
"Val",
")",
")",
"{",
"O",
"<<",
"format",
"(",
"\"0x%\"",
"PRIx64",
",",
"static_cast",
"<",
"uint32_t",
">",
"(",
"Val",
")",
")",
";",
"}",
"else",
"{",
"O",
"<<",
"format",
"(",
"\"0x%\"",
"PRIx64",
",",
"static_cast",
"<",
"uint64_t",
">",
"(",
"Val",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"AMDGPU",
"AMDGPU",
"0",
"1",
"0",
"0",
"AMDGPU",
"AMDGPU::isInlinableIntLiteral",
"16",
"\"0x%\"",
"32",
"\"0x%\"",
"\"0x%\""
] | AMDGPUAsmPrinter34 | PrintAsmOperand | AMDGPU | GPU | LLVM | 19,685 | 252 | 1 | [] |
[
"<s>",
"bool",
"rx_match_ccmode",
"(",
"rtx",
"insn",
",",
"machine_mode",
"cc_mode",
")",
"{",
"rtx",
"op1",
",",
"flags",
";",
"machine_mode",
"flags_mode",
";",
"gcc_checking_assert",
"(",
"XVECLEN",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
")",
"==",
"2",
")",
";",
"op1",
"=",
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
",",
"1",
")",
";",
"gcc_checking_assert",
"(",
"GET_CODE",
"(",
"SET_SRC",
"(",
"op1",
")",
")",
"==",
"COMPARE",
")",
";",
"flags",
"=",
"SET_DEST",
"(",
"op1",
")",
";",
"flags_mode",
"=",
"GET_MODE",
"(",
"flags",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"SET_SRC",
"(",
"op1",
")",
")",
"!=",
"flags_mode",
")",
"return",
"false",
";",
"if",
"(",
"GET_MODE_CLASS",
"(",
"flags_mode",
")",
"!=",
"MODE_CC",
")",
"return",
"false",
";",
"if",
"(",
"flags_from_mode",
"(",
"flags_mode",
")",
"&",
"~",
"flags_from_mode",
"(",
"cc_mode",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"A",
"helper",
"function",
"for",
"matching",
"parallels",
"that",
"set",
"the",
"flags",
"."
] | [
"rx",
"0",
"2",
"0",
"1"
] | rx2 | rx_match_ccmode | rx | CPU | GCC | 19,686 | 121 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"auto",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"if",
"(",
"!",
"needsSP",
"(",
"MF",
",",
"*",
"MFI",
")",
"||",
"!",
"needsSPWriteback",
"(",
"MF",
",",
"*",
"MFI",
")",
")",
"return",
";",
"auto",
"*",
"WFI",
"=",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
";",
"const",
"auto",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"InsertPt",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"InsertPt",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"DL",
"=",
"InsertPt",
"->",
"getDebugLoc",
"(",
")",
";",
"}",
"if",
"(",
"StackSize",
")",
"{",
"unsigned",
"OffsetReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"WebAssembly",
"::",
"I32RegClass",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"CONST_I32",
")",
",",
"OffsetReg",
")",
".",
"addImm",
"(",
"StackSize",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"ADD_I32",
")",
",",
"WebAssembly",
"::",
"SP32",
")",
".",
"addReg",
"(",
"hasFP",
"(",
"MF",
")",
"?",
"WebAssembly",
"::",
"FP32",
":",
"WebAssembly",
"::",
"SP32",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
";",
"WFI",
"->",
"stackifyVReg",
"(",
"OffsetReg",
")",
";",
"}",
"writeSPToMemory",
"(",
"(",
"!",
"StackSize",
"&&",
"hasFP",
"(",
"MF",
")",
")",
"?",
"WebAssembly",
"::",
"FP32",
":",
"WebAssembly",
"::",
"SP32",
",",
"MF",
",",
"MBB",
",",
"InsertPt",
",",
"DL",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly::I32RegClass",
"WebAssembly::CONST_I32",
"WebAssembly::ADD_I32",
"WebAssembly::SP32",
"WebAssembly::FP32",
"WebAssembly::SP32",
"WebAssembly::FP32",
"WebAssembly::SP32"
] | WebAssemblyFrameLowering4 | emitEpilogue | WebAssembly | Virtual ISA | LLVM | 19,687 | 253 | 1 | [] |
[
"<s>",
"void",
"RISCVTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"InitializeELF",
"(",
"TM",
".",
"Options",
".",
"UseInitArray",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
] | [
"RISCV",
"RISCV"
] | RISCVISelLowering (2)2 | Initialize | RISCV | CPU | LLVM | 19,688 | 34 | 1 | [] |
[
"<s>",
"void",
"EmitInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"bool",
")",
"override",
"{",
"EmitA64MappingSymbol",
"(",
")",
";",
"MCELFStreamer",
"::",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"AArch64"
] | AArch64ELFStreamer | EmitInstruction | AArch64 | CPU | LLVM | 19,689 | 31 | 1 | [] |
[
"<s>",
"void",
"RegisterAggr",
"::",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"OS",
"<<",
"'{'",
";",
"for",
"(",
"int",
"U",
"=",
"Units",
".",
"find_first",
"(",
")",
";",
"U",
">=",
"0",
";",
"U",
"=",
"Units",
".",
"find_next",
"(",
"U",
")",
")",
"OS",
"<<",
"' '",
"<<",
"PrintRegUnit",
"(",
"U",
",",
"&",
"PRI",
".",
"getTRI",
"(",
")",
")",
";",
"OS",
"<<",
"\" }\"",
";",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"Hexagon",
"0",
"\" }\""
] | RDFRegisters1 | print | Hexagon | DSP | LLVM | 19,690 | 60 | 1 | [] |
[
"<s>",
"int",
"arc_output_commutative_cond_exec",
"(",
"rtx",
"*",
"operands",
",",
"bool",
"output_p",
")",
"{",
"enum",
"rtx_code",
"commutative_op",
"=",
"GET_CODE",
"(",
"operands",
"[",
"3",
"]",
")",
";",
"const",
"char",
"*",
"pat",
"=",
"NULL",
";",
"gcc_assert",
"(",
"!",
"CONSTANT_P",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"switch",
"(",
"commutative_op",
")",
"{",
"case",
"AND",
":",
"if",
"(",
"satisfies_constraint_C1p",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"pat",
"=",
"\"bmsk%? %0,%1,%Z2\"",
";",
"else",
"if",
"(",
"satisfies_constraint_Ccp",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"pat",
"=",
"\"bclr%? %0,%1,%M2\"",
";",
"else",
"if",
"(",
"satisfies_constraint_CnL",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"pat",
"=",
"\"bic%? %0,%1,%n2-1\"",
";",
"break",
";",
"case",
"IOR",
":",
"if",
"(",
"satisfies_constraint_C0p",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"pat",
"=",
"\"bset%? %0,%1,%z2\"",
";",
"break",
";",
"case",
"XOR",
":",
"if",
"(",
"satisfies_constraint_C0p",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"pat",
"=",
"\"bxor%? %0,%1,%z2\"",
";",
"break",
";",
"case",
"PLUS",
":",
"return",
"arc_output_addsi",
"(",
"operands",
",",
"true",
",",
"output_p",
")",
";",
"default",
":",
"break",
";",
"}",
"if",
"(",
"output_p",
")",
"output_asm_insn",
"(",
"pat",
"?",
"pat",
":",
"\"%O3.%d5 %0,%1,%2\"",
",",
"operands",
")",
";",
"if",
"(",
"pat",
"||",
"REG_P",
"(",
"operands",
"[",
"2",
"]",
")",
"||",
"satisfies_constraint_L",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"return",
"4",
";",
"return",
"8",
";",
"}",
"</s>"
] | [
"Emit",
"code",
"for",
"an",
"commutative_cond_exec",
"instruction",
"with",
"OPERANDS",
".",
"Return",
"the",
"length",
"of",
"the",
"instruction",
".",
"If",
"OUTPUT_P",
"is",
"false",
",",
"do",
"n't",
"actually",
"output",
"the",
"instruction",
",",
"just",
"return",
"its",
"length",
"."
] | [
"arc",
"3",
"1",
"2",
"\"bmsk%? %0,%1,%Z2\"",
"2",
"\"bclr%? %0,%1,%M2\"",
"2",
"\"bic%? %0,%1,%n2-1\"",
"2",
"\"bset%? %0,%1,%z2\"",
"2",
"\"bxor%? %0,%1,%z2\"",
"\"%O3.%d5 %0,%1,%2\"",
"2",
"2",
"4",
"8"
] | arc4 | arc_output_commutative_cond_exec | arc | MPU | GCC | 19,691 | 194 | 1 | [] |
[
"<s>",
"unsigned",
"M88kInstrInfo",
"::",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isInlineAsm",
"(",
")",
")",
"{",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"char",
"*",
"AsmStr",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSymbolName",
"(",
")",
";",
"return",
"getInlineAsmLength",
"(",
"AsmStr",
",",
"*",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
")",
";",
"}",
"return",
"MI",
".",
"getDesc",
"(",
")",
".",
"getSize",
"(",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"M88k",
"M88k",
"0"
] | M88kInstrInfo | getInstSizeInBytes | M88k | MPU | LLVM | 19,692 | 82 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_simode_bld",
"(",
"int",
"bild",
",",
"rtx",
"operands",
"[",
"]",
")",
"{",
"int",
"clear_first",
"=",
"(",
"REG_P",
"(",
"operands",
"[",
"0",
"]",
")",
"&&",
"REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
"&&",
"REGNO",
"(",
"operands",
"[",
"0",
"]",
")",
"!=",
"REGNO",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"if",
"(",
"clear_first",
")",
"output_asm_insn",
"(",
"\"sub.l\\t%S0,%S0\"",
",",
"operands",
")",
";",
"if",
"(",
"bild",
")",
"output_asm_insn",
"(",
"\"bild\\t%Z2,%Y1\"",
",",
"operands",
")",
";",
"else",
"output_asm_insn",
"(",
"\"bld\\t%Z2,%Y1\"",
",",
"operands",
")",
";",
"if",
"(",
"!",
"clear_first",
")",
"output_asm_insn",
"(",
"\"xor.l\\t%S0,%S0\"",
",",
"operands",
")",
";",
"output_asm_insn",
"(",
"\"rotxl.l\\t%S0\"",
",",
"operands",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"Output",
"a",
"single-bit",
"extraction",
"."
] | [
"h8300",
"0",
"1",
"0",
"1",
"\"sub.l\\t%S0,%S0\"",
"\"bild\\t%Z2,%Y1\"",
"\"bld\\t%Z2,%Y1\"",
"\"xor.l\\t%S0,%S0\"",
"\"rotxl.l\\t%S0\"",
"\"\""
] | h8300 | output_simode_bld | h8300 | MPU | GCC | 19,693 | 104 | 1 | [] |
[
"<s>",
"MCSymbol",
"*",
"AArch64AsmPrinter",
"::",
"GetCPISymbol",
"(",
"unsigned",
"CPID",
")",
"const",
"{",
"if",
"(",
"!",
"getDataLayout",
"(",
")",
".",
"getLinkerPrivateGlobalPrefix",
"(",
")",
".",
"empty",
"(",
")",
")",
"return",
"OutContext",
".",
"getOrCreateSymbol",
"(",
"Twine",
"(",
"getDataLayout",
"(",
")",
".",
"getLinkerPrivateGlobalPrefix",
"(",
")",
")",
"+",
"\"CPI\"",
"+",
"Twine",
"(",
"getFunctionNumber",
"(",
")",
")",
"+",
"\"_\"",
"+",
"Twine",
"(",
"CPID",
")",
")",
";",
"return",
"AsmPrinter",
"::",
"GetCPISymbol",
"(",
"CPID",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"symbol",
"for",
"the",
"specified",
"constant",
"pool",
"entry",
"."
] | [
"AArch64",
"AArch64",
"\"CPI\"",
"\"_\""
] | AArch64AsmPrinter | GetCPISymbol | AArch64 | CPU | LLVM | 19,694 | 68 | 1 | [] |
[
"<s>",
"bool",
"PPCAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"switch",
"(",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
")",
"{",
"case",
"Match_Success",
":",
"ProcessInstruction",
"(",
"Inst",
",",
"Operands",
")",
";",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction use requires an option to be enabled\"",
")",
";",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"unrecognized instruction mnemonic\"",
")",
";",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0ULL",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"PPCOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"}",
"llvm_unreachable",
"(",
"\"Implement any new match types added!\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"PowerPC",
"PPC",
"\"instruction use requires an option to be enabled\"",
"\"unrecognized instruction mnemonic\"",
"0ULL",
"\"too few operands for instruction\"",
"PPC",
"\"invalid operand for instruction\"",
"\"Implement any new match types added!\""
] | PPCAsmParser | MatchAndEmitInstruction | PowerPC | CPU | LLVM | 19,695 | 178 | 1 | [] |
[
"<s>",
"const",
"TGSIInstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"TGSI",
"TGSI"
] | TGSISubtarget | getInstrInfo | TGSI | Virtual ISA | LLVM | 19,696 | 14 | 1 | [] |
[
"<s>",
"bool",
"WebAssembly",
"::",
"mayThrow",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"WebAssembly",
"::",
"THROW_I32",
":",
"case",
"WebAssembly",
"::",
"THROW_I64",
":",
"case",
"WebAssembly",
"::",
"RETHROW",
":",
"return",
"true",
";",
"}",
"if",
"(",
"isCallIndirect",
"(",
"MI",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"MI",
".",
"isCall",
"(",
")",
")",
"return",
"false",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"getCalleeOpNo",
"(",
"MI",
")",
")",
";",
"assert",
"(",
"MO",
".",
"isGlobal",
"(",
")",
")",
";",
"const",
"auto",
"*",
"F",
"=",
"dyn_cast",
"<",
"Function",
">",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
";",
"if",
"(",
"!",
"F",
")",
"return",
"true",
";",
"if",
"(",
"F",
"->",
"doesNotThrow",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"F",
"->",
"getName",
"(",
")",
"==",
"CxaBeginCatchFn",
"||",
"F",
"->",
"getName",
"(",
")",
"==",
"PersonalityWrapperFn",
"||",
"F",
"->",
"getName",
"(",
")",
"==",
"ClangCallTerminateFn",
"||",
"F",
"->",
"getName",
"(",
")",
"==",
"StdTerminateFn",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"instruction",
"may",
"throw",
"an",
"exception",
"."
] | [
"WebAssembly",
"WebAssembly::mayThrow",
"WebAssembly::THROW_I32",
"WebAssembly::THROW_I64",
"WebAssembly::RETHROW"
] | WebAssemblyUtilities12 | mayThrow | WebAssembly | Virtual ISA | LLVM | 19,697 | 162 | 1 | [] |
[
"<s>",
"const",
"MCSection",
"*",
"X86ELFMCAsmInfo",
"::",
"getNonexecutableStackSection",
"(",
"MCContext",
"&",
"Ctx",
")",
"const",
"{",
"return",
"Ctx",
".",
"getELFSection",
"(",
"\".note.GNU-stack\"",
",",
"MCSectionELF",
"::",
"SHT_PROGBITS",
",",
"0",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"implement",
"this",
"method",
"to",
"specify",
"a",
"section",
"to",
"switch",
"to",
"if",
"the",
"translation",
"unit",
"does",
"n't",
"have",
"any",
"trampolines",
"that",
"require",
"an",
"executable",
"stack",
"."
] | [
"X86",
"X86",
"\".note.GNU-stack\"",
"0"
] | X86MCAsmInfo20 | getNonexecutableStackSection | X86 | CPU | LLVM | 19,698 | 34 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64TargetLowering",
"::",
"getSqrtEstimate",
"(",
"SDValue",
"Operand",
",",
"SelectionDAG",
"&",
"DAG",
",",
"int",
"Enabled",
",",
"int",
"&",
"ExtraSteps",
",",
"bool",
"&",
"UseOneConst",
",",
"bool",
"Reciprocal",
")",
"const",
"{",
"if",
"(",
"Enabled",
"==",
"ReciprocalEstimate",
"::",
"Enabled",
"||",
"(",
"Enabled",
"==",
"ReciprocalEstimate",
"::",
"Unspecified",
"&&",
"Subtarget",
"->",
"useRSqrt",
"(",
")",
")",
")",
"if",
"(",
"SDValue",
"Estimate",
"=",
"getEstimate",
"(",
"Subtarget",
",",
"AArch64ISD",
"::",
"FRSQRTE",
",",
"Operand",
",",
"DAG",
",",
"ExtraSteps",
")",
")",
"{",
"SDLoc",
"DL",
"(",
"Operand",
")",
";",
"EVT",
"VT",
"=",
"Operand",
".",
"getValueType",
"(",
")",
";",
"SDNodeFlags",
"Flags",
";",
"Flags",
".",
"setUnsafeAlgebra",
"(",
"true",
")",
";",
"for",
"(",
"int",
"i",
"=",
"ExtraSteps",
";",
"i",
">",
"0",
";",
"--",
"i",
")",
"{",
"SDValue",
"Step",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FMUL",
",",
"DL",
",",
"VT",
",",
"Estimate",
",",
"Estimate",
",",
"&",
"Flags",
")",
";",
"Step",
"=",
"DAG",
".",
"getNode",
"(",
"AArch64ISD",
"::",
"FRSQRTS",
",",
"DL",
",",
"VT",
",",
"Operand",
",",
"Step",
",",
"&",
"Flags",
")",
";",
"Estimate",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FMUL",
",",
"DL",
",",
"VT",
",",
"Estimate",
",",
"Step",
",",
"&",
"Flags",
")",
";",
"}",
"if",
"(",
"!",
"Reciprocal",
")",
"{",
"EVT",
"CCVT",
"=",
"getSetCCResultType",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"VT",
")",
";",
"SDValue",
"FPZero",
"=",
"DAG",
".",
"getConstantFP",
"(",
"0.0",
",",
"DL",
",",
"VT",
")",
";",
"SDValue",
"Eq",
"=",
"DAG",
".",
"getSetCC",
"(",
"DL",
",",
"CCVT",
",",
"Operand",
",",
"FPZero",
",",
"ISD",
"::",
"SETEQ",
")",
";",
"Estimate",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FMUL",
",",
"DL",
",",
"VT",
",",
"Operand",
",",
"Estimate",
",",
"&",
"Flags",
")",
";",
"Estimate",
"=",
"DAG",
".",
"getNode",
"(",
"VT",
".",
"isVector",
"(",
")",
"?",
"ISD",
"::",
"VSELECT",
":",
"ISD",
"::",
"SELECT",
",",
"DL",
",",
"VT",
",",
"Eq",
",",
"Operand",
",",
"Estimate",
")",
";",
"}",
"ExtraSteps",
"=",
"0",
";",
"return",
"Estimate",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Hooks",
"for",
"building",
"estimates",
"in",
"place",
"of",
"slower",
"divisions",
"and",
"square",
"roots",
"."
] | [
"AArch64",
"AArch64",
"AArch64ISD::FRSQRTE",
"0",
"ISD::FMUL",
"AArch64ISD::FRSQRTS",
"ISD::FMUL",
"0.0",
"ISD::SETEQ",
"ISD::FMUL",
"ISD::VSELECT",
"ISD::SELECT",
"0"
] | AArch64ISelLowering119 | getSqrtEstimate | AArch64 | CPU | LLVM | 19,699 | 308 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.