ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"bool",
"R600AsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"MF",
".",
"ensureLogAlignment",
"(",
"8",
")",
";",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"MCContext",
"&",
"Context",
"=",
"getObjFileLowering",
"(",
")",
".",
"getContext",
"(",
")",
";",
"MCSectionELF",
"*",
"ConfigSection",
"=",
"Context",
".",
"getELFSection",
"(",
"\".AMDGPU.config\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"0",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"ConfigSection",
")",
";",
"EmitProgramInfoR600",
"(",
"MF",
")",
";",
"EmitFunctionBody",
"(",
")",
";",
"if",
"(",
"isVerbose",
"(",
")",
")",
"{",
"MCSectionELF",
"*",
"CommentSection",
"=",
"Context",
".",
"getELFSection",
"(",
"\".AMDGPU.csdata\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"0",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"CommentSection",
")",
";",
"R600MachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"R600MachineFunctionInfo",
">",
"(",
")",
";",
"OutStreamer",
"->",
"emitRawComment",
"(",
"Twine",
"(",
"\"SQ_PGM_RESOURCES:STACK_SIZE = \"",
"+",
"Twine",
"(",
"MFI",
"->",
"CFStackSize",
")",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AMDGPU",
"R600",
"8",
"\".AMDGPU.config\"",
"0",
"R600",
"\".AMDGPU.csdata\"",
"0",
"R600",
"R600",
"\"SQ_PGM_RESOURCES:STACK_SIZE = \""
] | R600AsmPrinter2 | runOnMachineFunction | AMDGPU | GPU | LLVM | 19,200 | 133 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"AU",
".",
"addRequired",
"<",
"TargetData",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"MachineFunctionAnalysis",
">",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"NVPTX"
] | NVPTXAllocaHoisting8 | getAnalysisUsage | NVPTX | GPU | LLVM | 19,201 | 28 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonInstrInfo",
"::",
"getSize",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isDebugValue",
"(",
")",
"||",
"MI",
".",
"isPosition",
"(",
")",
")",
"return",
"0",
";",
"unsigned",
"Size",
"=",
"MI",
".",
"getDesc",
"(",
")",
".",
"getSize",
"(",
")",
";",
"if",
"(",
"!",
"Size",
")",
"Size",
"=",
"HEXAGON_INSTR_SIZE",
";",
"if",
"(",
"isConstExtended",
"(",
"MI",
")",
"||",
"isExtended",
"(",
"MI",
")",
")",
"Size",
"+=",
"HEXAGON_INSTR_SIZE",
";",
"if",
"(",
"BranchRelaxAsmLarge",
"&&",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Hexagon",
"::",
"INLINEASM",
")",
"{",
"const",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"MCAsmInfo",
"*",
"MAI",
"=",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
";",
"unsigned",
"NumDefs",
"=",
"0",
";",
"for",
"(",
";",
"MI",
".",
"getOperand",
"(",
"NumDefs",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"NumDefs",
")",
".",
"isDef",
"(",
")",
";",
"++",
"NumDefs",
")",
"assert",
"(",
"NumDefs",
"!=",
"MI",
".",
"getNumOperands",
"(",
")",
"-",
"2",
"&&",
"\"No asm string?\"",
")",
";",
"assert",
"(",
"MI",
".",
"getOperand",
"(",
"NumDefs",
")",
".",
"isSymbol",
"(",
")",
"&&",
"\"No asm string?\"",
")",
";",
"const",
"char",
"*",
"AsmStr",
"=",
"MI",
".",
"getOperand",
"(",
"NumDefs",
")",
".",
"getSymbolName",
"(",
")",
";",
"Size",
"=",
"getInlineAsmLength",
"(",
"AsmStr",
",",
"*",
"MAI",
")",
";",
"}",
"return",
"Size",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"bytes",
"in",
"the",
"encoding",
"of",
"this",
"instruction",
",",
"or",
"zero",
"if",
"the",
"encoding",
"size",
"can",
"not",
"be",
"known",
"from",
"the",
"opcode",
"."
] | [
"Hexagon",
"Hexagon",
"0",
"Hexagon::INLINEASM",
"0",
"2",
"\"No asm string?\"",
"\"No asm string?\""
] | HexagonInstrInfo10 | getSize | Hexagon | DSP | LLVM | 19,202 | 215 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"AArch64TargetStreamer",
"::",
"addConstantPoolEntry",
"(",
"const",
"MCExpr",
"*",
"Expr",
",",
"unsigned",
"Size",
",",
"SMLoc",
"Loc",
")",
"{",
"return",
"ConstantPools",
"->",
"addEntry",
"(",
"Streamer",
",",
"Expr",
",",
"Size",
",",
"Loc",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"new",
"entry",
"to",
"the",
"constant",
"pool",
"for",
"the",
"current",
"section",
"and",
"return",
"an",
"MCExpr",
"that",
"can",
"be",
"used",
"to",
"refer",
"to",
"the",
"constant",
"pool",
"location",
"."
] | [
"AArch64",
"AArch64"
] | AArch64TargetStreamer10 | addConstantPoolEntry | AArch64 | CPU | LLVM | 19,203 | 34 | 1 | [] |
[
"<s>",
"void",
"MipsInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Mips",
"::",
"RDHWR",
":",
"case",
"Mips",
"::",
"RDHWR64",
":",
"O",
"<<",
"\"\\t.set\\tpush\\n\"",
";",
"O",
"<<",
"\"\\t.set\\tmips32r2\\n\"",
";",
"break",
";",
"case",
"Mips",
"::",
"Save16",
":",
"O",
"<<",
"\"\\tsave\\t\"",
";",
"printSaveRestore",
"(",
"MI",
",",
"O",
")",
";",
"O",
"<<",
"\" # 16 bit inst\\n\"",
";",
"return",
";",
"case",
"Mips",
"::",
"SaveX16",
":",
"O",
"<<",
"\"\\tsave\\t\"",
";",
"printSaveRestore",
"(",
"MI",
",",
"O",
")",
";",
"O",
"<<",
"\"\\n\"",
";",
"return",
";",
"case",
"Mips",
"::",
"Restore16",
":",
"O",
"<<",
"\"\\trestore\\t\"",
";",
"printSaveRestore",
"(",
"MI",
",",
"O",
")",
";",
"O",
"<<",
"\" # 16 bit inst\\n\"",
";",
"return",
";",
"case",
"Mips",
"::",
"RestoreX16",
":",
"O",
"<<",
"\"\\trestore\\t\"",
";",
"printSaveRestore",
"(",
"MI",
",",
"O",
")",
";",
"O",
"<<",
"\"\\n\"",
";",
"return",
";",
"}",
"if",
"(",
"!",
"printAliasInstr",
"(",
"MI",
",",
"O",
")",
"&&",
"!",
"printAlias",
"(",
"*",
"MI",
",",
"O",
")",
")",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Mips",
"::",
"RDHWR",
":",
"case",
"Mips",
"::",
"RDHWR64",
":",
"O",
"<<",
"\"\\n\\t.set\\tpop\"",
";",
"}",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"Mips",
"Mips",
"Mips::RDHWR",
"Mips::RDHWR64",
"\"\\t.set\\tpush\\n\"",
"\"\\t.set\\tmips32r2\\n\"",
"Mips::Save16",
"\"\\tsave\\t\"",
"\" # 16 bit inst\\n\"",
"Mips::SaveX16",
"\"\\tsave\\t\"",
"\"\\n\"",
"Mips::Restore16",
"\"\\trestore\\t\"",
"\" # 16 bit inst\\n\"",
"Mips::RestoreX16",
"\"\\trestore\\t\"",
"\"\\n\"",
"Mips::RDHWR",
"Mips::RDHWR64",
"\"\\n\\t.set\\tpop\""
] | MipsInstPrinter12 | printInst | Mips | CPU | LLVM | 19,204 | 207 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"{",
"assert",
"(",
"isRegBase",
"(",
")",
"&&",
"\"Invalid base register access!\"",
")",
";",
"return",
"Base",
".",
"Reg",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"AArch64",
"\"Invalid base register access!\""
] | AArch64FastISel (2) | getReg | AArch64 | CPU | LLVM | 19,205 | 21 | 1 | [] |
[
"<s>",
"bool",
"SystemZMCAsmInfoGOFF",
"::",
"isAcceptableChar",
"(",
"char",
"C",
")",
"const",
"{",
"return",
"MCAsmInfo",
"::",
"isAcceptableChar",
"(",
"C",
")",
"||",
"C",
"==",
"'#'",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"C",
"is",
"an",
"acceptable",
"character",
"inside",
"a",
"symbol",
"name",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZMCAsmInfo6 | isAcceptableChar | SystemZ | CPU | LLVM | 19,206 | 23 | 1 | [] |
[
"<s>",
"bool",
"M88kMCAsmBackend",
"::",
"shouldForceRelocation",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
")",
"{",
"return",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"M88k",
"::",
"FK_88K_DISP16",
"||",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"M88k",
"::",
"FK_88K_DISP26",
";",
"}",
"</s>"
] | [
"Hook",
"to",
"check",
"if",
"a",
"relocation",
"is",
"needed",
"for",
"some",
"target",
"specific",
"reason",
"."
] | [
"M88k",
"M88k",
"M88k::FK_88K_DISP16",
"M88k::FK_88K_DISP26"
] | M88kMCAsmBackend | shouldForceRelocation | M88k | MPU | LLVM | 19,207 | 43 | 1 | [] |
[
"<s>",
"void",
"function_checker",
"::",
"report_non_ice",
"(",
"unsigned",
"int",
"argno",
")",
"const",
"{",
"error_at",
"(",
"location",
",",
"\"argument %d of %qE must be an integer constant\"",
"\" expression\"",
",",
"argno",
"+",
"1",
",",
"fndecl",
")",
";",
"}",
"</s>"
] | [
"Report",
"that",
"LOCATION",
"has",
"a",
"call",
"to",
"FNDECL",
"in",
"which",
"argument",
"ARGNO",
"was",
"not",
"an",
"integer",
"constant",
"expression",
".",
"ARGNO",
"counts",
"from",
"zero",
"."
] | [
"riscv",
"\"argument %d of %qE must be an integer constant\"",
"\" expression\"",
"1"
] | riscv-vector-builtins | report_non_ice | riscv | CPU | GCC | 19,208 | 26 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
"->",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"Patmos"
] | PatmosTargetMachine1 | getRegisterInfo | Patmos | VLIW | LLVM | 19,209 | 21 | 1 | [] |
[
"<s>",
"bool",
"DLXAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"1",
"]",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"case",
"'H'",
":",
"{",
"if",
"(",
"OpNo",
"==",
"0",
")",
"return",
"true",
";",
"const",
"MachineOperand",
"&",
"FlagsOP",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNo",
"-",
"1",
")",
";",
"if",
"(",
"!",
"FlagsOP",
".",
"isImm",
"(",
")",
")",
"return",
"true",
";",
"unsigned",
"Flags",
"=",
"FlagsOP",
".",
"getImm",
"(",
")",
";",
"unsigned",
"NumVals",
"=",
"InlineAsm",
"::",
"getNumOperandRegisters",
"(",
"Flags",
")",
";",
"if",
"(",
"NumVals",
"!=",
"2",
")",
"return",
"true",
";",
"unsigned",
"RegOp",
"=",
"OpNo",
"+",
"1",
";",
"if",
"(",
"RegOp",
">=",
"MI",
"->",
"getNumOperands",
"(",
")",
")",
"return",
"true",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"RegOp",
")",
";",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"true",
";",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"O",
"<<",
"DLXInstPrinter",
"::",
"getRegisterName",
"(",
"Reg",
")",
";",
"return",
"false",
";",
"}",
"default",
":",
"return",
"true",
";",
"}",
"}",
"printOperand",
"(",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"DLX",
"DLX",
"0",
"1",
"0",
"0",
"1",
"2",
"1",
"DLX"
] | DLXAsmPrinter | PrintAsmOperand | DLX | CPU | LLVM | 19,210 | 206 | 1 | [] |
[
"<s>",
"void",
"mt_expand_epilogue",
"(",
"enum",
"epilogue_type",
"eh_mode",
")",
"{",
"rtx",
"size_rtx",
",",
"insn",
";",
"unsigned",
"frame_size",
";",
"mt_compute_frame_size",
"(",
"get_frame_size",
"(",
")",
")",
";",
"if",
"(",
"TARGET_DEBUG_STACK",
")",
"mt_debug_stack",
"(",
"&",
"current_frame_info",
")",
";",
"frame_size",
"=",
"current_frame_info",
".",
"total_size",
";",
"if",
"(",
"CONST_OK_FOR_LETTER_P",
"(",
"frame_size",
",",
"'O'",
")",
")",
"size_rtx",
"=",
"GEN_INT",
"(",
"frame_size",
")",
";",
"else",
"{",
"gcc_assert",
"(",
"!",
"interrupt_handler",
")",
";",
"size_rtx",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"GPR_R9",
")",
";",
"insn",
"=",
"emit_move_insn",
"(",
"size_rtx",
",",
"GEN_INT",
"(",
"frame_size",
"&",
"0xffff0000",
")",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_iorsi3",
"(",
"size_rtx",
",",
"size_rtx",
",",
"GEN_INT",
"(",
"frame_size",
"&",
"0x0000ffff",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"size_rtx",
",",
"size_rtx",
",",
"stack_pointer_rtx",
")",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"insn",
"=",
"emit_move_insn",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
")",
";",
"mt_emit_save_fp",
"(",
"FROM_MEM_TO_PROCESSOR",
",",
"current_frame_info",
")",
";",
"mt_emit_save_regs",
"(",
"FROM_MEM_TO_PROCESSOR",
",",
"current_frame_info",
")",
";",
"if",
"(",
"frame_size",
")",
"{",
"if",
"(",
"CONST_OK_FOR_LETTER_P",
"(",
"frame_size",
",",
"'O'",
")",
")",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"size_rtx",
")",
")",
";",
"else",
"insn",
"=",
"emit_move_insn",
"(",
"stack_pointer_rtx",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"GPR_R9",
")",
")",
";",
"REG_NOTES",
"(",
"insn",
")",
"=",
"gen_rtx_EXPR_LIST",
"(",
"REG_FRAME_RELATED_EXPR",
",",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"stack_pointer_rtx",
",",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"frame_size",
")",
")",
")",
",",
"REG_NOTES",
"(",
"insn",
")",
")",
";",
"}",
"if",
"(",
"cfun",
"->",
"machine",
"&&",
"cfun",
"->",
"machine",
"->",
"eh_stack_adjust",
"!=",
"NULL_RTX",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"cfun",
"->",
"machine",
"->",
"eh_stack_adjust",
")",
")",
";",
"if",
"(",
"eh_mode",
"==",
"EH_EPILOGUE",
")",
"{",
"emit_jump_insn",
"(",
"gen_eh_return_internal",
"(",
")",
")",
";",
"emit_barrier",
"(",
")",
";",
"}",
"else",
"if",
"(",
"interrupt_handler",
")",
"emit_jump_insn",
"(",
"gen_return_interrupt_internal",
"(",
")",
")",
";",
"else",
"emit_jump_insn",
"(",
"gen_return_internal",
"(",
")",
")",
";",
"interrupt_handler",
"=",
"0",
";",
"current_frame_info",
"=",
"zero_frame_info",
";",
"if",
"(",
"cfun",
"->",
"machine",
")",
"cfun",
"->",
"machine",
"->",
"eh_stack_adjust",
"=",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Generate",
"epilogue",
".",
"EH_MODE",
"is",
"NORMAL_EPILOGUE",
"when",
"generating",
"a",
"function",
"epilogue",
",",
"or",
"EH_EPILOGUE",
"when",
"generating",
"an",
"EH",
"epilogue",
"."
] | [
"mt",
"0xffff0000",
"0x0000ffff",
"0"
] | mt | mt_expand_epilogue | mt | CPU | GCC | 19,211 | 315 | 1 | [] |
[
"<s>",
"static",
"void",
"arc_pre_atomic_barrier",
"(",
"enum",
"memmodel",
"model",
")",
"{",
"if",
"(",
"need_atomic_barrier_p",
"(",
"model",
",",
"true",
")",
")",
"emit_insn",
"(",
"gen_memory_barrier",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"(",
"pre",
")",
"memory",
"barrier",
"around",
"an",
"atomic",
"sequence",
"according",
"to",
"MODEL",
"."
] | [
"arc"
] | arc | arc_pre_atomic_barrier | arc | MPU | GCC | 19,212 | 26 | 1 | [] |
[
"<s>",
"unsigned",
"ARMTTIImpl",
"::",
"getIntImmCost",
"(",
"const",
"APInt",
"&",
"Imm",
",",
"Type",
"*",
"Ty",
")",
"{",
"assert",
"(",
"Ty",
"->",
"isIntegerTy",
"(",
")",
")",
";",
"unsigned",
"Bits",
"=",
"Ty",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"Bits",
"==",
"0",
"||",
"Bits",
">",
"32",
")",
"return",
"4",
";",
"int32_t",
"SImmVal",
"=",
"Imm",
".",
"getSExtValue",
"(",
")",
";",
"uint32_t",
"ZImmVal",
"=",
"Imm",
".",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"!",
"ST",
"->",
"isThumb",
"(",
")",
")",
"{",
"if",
"(",
"(",
"SImmVal",
">=",
"0",
"&&",
"SImmVal",
"<",
"65536",
")",
"||",
"(",
"ARM_AM",
"::",
"getSOImmVal",
"(",
"ZImmVal",
")",
"!=",
"-",
"1",
")",
"||",
"(",
"ARM_AM",
"::",
"getSOImmVal",
"(",
"~",
"ZImmVal",
")",
"!=",
"-",
"1",
")",
")",
"return",
"1",
";",
"return",
"ST",
"->",
"hasV6T2Ops",
"(",
")",
"?",
"2",
":",
"3",
";",
"}",
"if",
"(",
"ST",
"->",
"isThumb2",
"(",
")",
")",
"{",
"if",
"(",
"(",
"SImmVal",
">=",
"0",
"&&",
"SImmVal",
"<",
"65536",
")",
"||",
"(",
"ARM_AM",
"::",
"getT2SOImmVal",
"(",
"ZImmVal",
")",
"!=",
"-",
"1",
")",
"||",
"(",
"ARM_AM",
"::",
"getT2SOImmVal",
"(",
"~",
"ZImmVal",
")",
"!=",
"-",
"1",
")",
")",
"return",
"1",
";",
"return",
"ST",
"->",
"hasV6T2Ops",
"(",
")",
"?",
"2",
":",
"3",
";",
"}",
"if",
"(",
"SImmVal",
">=",
"0",
"&&",
"SImmVal",
"<",
"256",
")",
"return",
"1",
";",
"if",
"(",
"(",
"~",
"ZImmVal",
"<",
"256",
")",
"||",
"ARM_AM",
"::",
"isThumbImmShiftedVal",
"(",
"ZImmVal",
")",
")",
"return",
"2",
";",
"return",
"3",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"materializing",
"a",
"64-bit",
"value",
"."
] | [
"ARM",
"ARM",
"0",
"32",
"4",
"0",
"65536",
"ARM_AM::getSOImmVal",
"1",
"ARM_AM::getSOImmVal",
"1",
"1",
"2",
"3",
"0",
"65536",
"ARM_AM::getT2SOImmVal",
"1",
"ARM_AM::getT2SOImmVal",
"1",
"1",
"2",
"3",
"0",
"256",
"1",
"256",
"ARM_AM::isThumbImmShiftedVal",
"2",
"3"
] | ARMTargetTransformInfo23 | getIntImmCost | ARM | CPU | LLVM | 19,213 | 223 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyAsmPrinter",
"::",
"PrintAsmMemoryOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"OS",
")",
"{",
"if",
"(",
"AsmVariant",
"!=",
"0",
")",
"report_fatal_error",
"(",
"\"There are no defined alternate asm variants\"",
")",
";",
"if",
"(",
"!",
"ExtraCode",
")",
"{",
"OS",
"<<",
"\"0(\"",
"+",
"regToString",
"(",
"MI",
"->",
"getOperand",
"(",
"OpNo",
")",
")",
"+",
"')'",
";",
"return",
"false",
";",
"}",
"return",
"AsmPrinter",
"::",
"PrintAsmMemoryOperand",
"(",
"MI",
",",
"OpNo",
",",
"AsmVariant",
",",
"ExtraCode",
",",
"OS",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"operand",
"of",
"MI",
",",
"an",
"INLINEASM",
"instruction",
",",
"using",
"the",
"specified",
"assembler",
"variant",
"as",
"an",
"address",
"."
] | [
"WebAssembly",
"WebAssembly",
"0",
"\"There are no defined alternate asm variants\"",
"\"0(\""
] | WebAssemblyAsmPrinter (2) | PrintAsmMemoryOperand | WebAssembly | Virtual ISA | LLVM | 19,214 | 80 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"Z80RegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"id",
")",
"const",
"{",
"return",
"CC_Save_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"Z80",
"Z80"
] | Z80RegisterInfo (2) | getCallPreservedMask | Z80 | MPU | LLVM | 19,215 | 23 | 1 | [] |
[
"<s>",
"void",
"MMIXInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"MMIX",
"MMIX"
] | MMIXInstPrinter | printInst | MMIX | CPU | LLVM | 19,216 | 38 | 1 | [] |
[
"<s>",
"static",
"int",
"mips_fp_div_cost",
"(",
"machine_mode",
"mode",
")",
"{",
"return",
"mode",
"==",
"DFmode",
"?",
"mips_cost",
"->",
"fp_div_df",
":",
"mips_cost",
"->",
"fp_div_sf",
";",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"floating-point",
"divisions",
"of",
"mode",
"MODE",
"."
] | [
"mips"
] | mips | mips_fp_div_cost | mips | CPU | GCC | 19,217 | 22 | 1 | [] |
[
"<s>",
"static",
"void",
"csky_output_mi_thunk",
"(",
"FILE",
"*",
"file",
",",
"tree",
"thunk",
"ATTRIBUTE_UNUSED",
",",
"HOST_WIDE_INT",
"delta",
",",
"HOST_WIDE_INT",
"vcall_offset",
",",
"tree",
"function",
")",
"{",
"const",
"char",
"*",
"thiz",
"=",
"\"a0\"",
";",
"const",
"char",
"*",
"reg0",
"=",
"\"t0\"",
";",
"const",
"char",
"*",
"reg1",
"=",
"\"t1\"",
";",
"int",
"maxoff",
"=",
"4096",
";",
"final_start_function",
"(",
"emit_barrier",
"(",
")",
",",
"file",
",",
"1",
")",
";",
"rtx",
"fnaddr",
"=",
"XEXP",
"(",
"DECL_RTL",
"(",
"function",
")",
",",
"0",
")",
";",
"if",
"(",
"CSKY_TARGET_ARCH",
"(",
"CK801",
")",
")",
"{",
"reg0",
"=",
"\"l0\"",
";",
"reg1",
"=",
"\"l1\"",
";",
"maxoff",
"=",
"256",
";",
"if",
"(",
"vcall_offset",
">",
"maxoff",
"||",
"vcall_offset",
"<",
"-",
"maxoff",
")",
"fprintf",
"(",
"file",
",",
"\"\\tpush\\tl0, l1\\n\"",
")",
";",
"else",
"if",
"(",
"delta",
">",
"maxoff",
"||",
"delta",
"<",
"-",
"maxoff",
")",
"fprintf",
"(",
"file",
",",
"\"\\tpush\\tl0\\n\"",
")",
";",
"}",
"if",
"(",
"aggregate_value_p",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"function",
")",
")",
",",
"function",
")",
")",
"thiz",
"=",
"\"a1\"",
";",
"if",
"(",
"delta",
"!=",
"0",
")",
"{",
"if",
"(",
"delta",
">",
"maxoff",
"||",
"delta",
"<",
"-",
"maxoff",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\tlrw\\t%s, %ld\\n\"",
",",
"reg0",
",",
"(",
"long",
")",
"delta",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\taddu\\t%s, %s, %s\\n\"",
",",
"thiz",
",",
"thiz",
",",
"reg0",
")",
";",
"}",
"else",
"fprintf",
"(",
"file",
",",
"\"\\t%s\\t%s, %s, %ld\\n\"",
",",
"(",
"delta",
">",
"0",
"?",
"\"addi\"",
":",
"\"subi\"",
")",
",",
"thiz",
",",
"thiz",
",",
"(",
"long",
")",
"(",
"delta",
">",
"0",
"?",
"delta",
":",
"-",
"delta",
")",
")",
";",
"}",
"if",
"(",
"vcall_offset",
"!=",
"0",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\tld.w\\t%s, (%s, 0)\\n\"",
",",
"reg0",
",",
"thiz",
")",
";",
"if",
"(",
"vcall_offset",
">",
"maxoff",
"||",
"vcall_offset",
"<",
"-",
"maxoff",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\tlrw\\t%s, %ld\\n\"",
",",
"reg1",
",",
"(",
"long",
")",
"vcall_offset",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\taddu\\t%s, %s, %s\\n\"",
",",
"reg0",
",",
"reg0",
",",
"reg1",
")",
";",
"}",
"else",
"fprintf",
"(",
"file",
",",
"\"\\t%s\\t%s, %s, %ld\\n\"",
",",
"(",
"vcall_offset",
">",
"0",
"?",
"\"addi\"",
":",
"\"subi\"",
")",
",",
"reg0",
",",
"reg0",
",",
"(",
"long",
")",
"(",
"vcall_offset",
">",
"0",
"?",
"vcall_offset",
":",
"-",
"vcall_offset",
")",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\tld.w\\t%s, (%s, 0)\\n\"",
",",
"reg0",
",",
"reg0",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\taddu\\t%s, %s, %s\\n\"",
",",
"thiz",
",",
"thiz",
",",
"reg0",
")",
";",
"}",
"if",
"(",
"CSKY_TARGET_ARCH",
"(",
"CK801",
")",
")",
"{",
"if",
"(",
"vcall_offset",
">",
"maxoff",
"||",
"vcall_offset",
"<",
"-",
"maxoff",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\tld.w\\tl0, (sp, 0)\\n\"",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\tld.w\\tl1, (sp, 4)\\n\"",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\taddi\\t sp, sp, 8\\n\"",
")",
";",
"}",
"else",
"if",
"(",
"delta",
">",
"maxoff",
"||",
"delta",
"<",
"-",
"maxoff",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\tld.w\\tl0, (sp, 0)\\n\"",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\taddi\\tsp, sp, 4\\n\"",
")",
";",
"}",
"}",
"fprintf",
"(",
"file",
",",
"\"\\tjbr\\t\"",
")",
";",
"output_addr_const",
"(",
"file",
",",
"fnaddr",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\n\"",
")",
";",
"final_end_function",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_OUTPUT_MI_THUNK",
".",
"Output",
"code",
"to",
"add",
"DELTA",
"to",
"the",
"first",
"argument",
",",
"and",
"then",
"jump",
"to",
"FUNCTION",
".",
"Used",
"for",
"C++",
"multiple",
"inheritance",
"."
] | [
"csky",
"\"a0\"",
"\"t0\"",
"\"t1\"",
"4096",
"1",
"0",
"\"l0\"",
"\"l1\"",
"256",
"\"\\tpush\\tl0, l1\\n\"",
"\"\\tpush\\tl0\\n\"",
"\"a1\"",
"0",
"\"\\tlrw\\t%s, %ld\\n\"",
"\"\\taddu\\t%s, %s, %s\\n\"",
"\"\\t%s\\t%s, %s, %ld\\n\"",
"0",
"\"addi\"",
"\"subi\"",
"0",
"0",
"\"\\tld.w\\t%s, (%s, 0)\\n\"",
"\"\\tlrw\\t%s, %ld\\n\"",
"\"\\taddu\\t%s, %s, %s\\n\"",
"\"\\t%s\\t%s, %s, %ld\\n\"",
"0",
"\"addi\"",
"\"subi\"",
"0",
"\"\\tld.w\\t%s, (%s, 0)\\n\"",
"\"\\taddu\\t%s, %s, %s\\n\"",
"\"\\tld.w\\tl0, (sp, 0)\\n\"",
"\"\\tld.w\\tl1, (sp, 4)\\n\"",
"\"\\taddi\\t sp, sp, 8\\n\"",
"\"\\tld.w\\tl0, (sp, 0)\\n\"",
"\"\\taddi\\tsp, sp, 4\\n\"",
"\"\\tjbr\\t\"",
"\"\\n\""
] | csky2 | csky_output_mi_thunk | csky | CPU | GCC | 19,218 | 449 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_return_in_msb",
"(",
"const_tree",
"valtype",
")",
"{",
"return",
"(",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
"&&",
"BYTES_BIG_ENDIAN",
"&&",
"AGGREGATE_TYPE_P",
"(",
"valtype",
")",
"&&",
"(",
"rs6000_function_arg_padding",
"(",
"TYPE_MODE",
"(",
"valtype",
")",
",",
"valtype",
")",
"==",
"PAD_UPWARD",
")",
")",
";",
"}",
"</s>"
] | [
"Specify",
"whether",
"values",
"returned",
"in",
"registers",
"should",
"be",
"at",
"the",
"most",
"significant",
"end",
"of",
"a",
"register",
".",
"We",
"want",
"aggregates",
"returned",
"by",
"value",
"to",
"match",
"the",
"way",
"aggregates",
"are",
"passed",
"to",
"functions",
"."
] | [
"rs6000"
] | rs60007 | rs6000_return_in_msb | rs6000 | CPU | GCC | 19,219 | 37 | 1 | [] |
[
"<s>",
"static",
"tree",
"avr_handle_fndecl_attribute",
"(",
"tree",
"*",
"node",
",",
"tree",
"name",
",",
"tree",
"args",
"ATTRIBUTE_UNUSED",
",",
"int",
"flags",
"ATTRIBUTE_UNUSED",
",",
"bool",
"*",
"no_add_attrs",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"*",
"node",
")",
"!=",
"FUNCTION_DECL",
")",
"{",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%qs attribute only applies to functions\"",
",",
"IDENTIFIER_POINTER",
"(",
"name",
")",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"else",
"{",
"const",
"char",
"*",
"func_name",
"=",
"IDENTIFIER_POINTER",
"(",
"DECL_NAME",
"(",
"*",
"node",
")",
")",
";",
"const",
"char",
"*",
"attr",
"=",
"IDENTIFIER_POINTER",
"(",
"name",
")",
";",
"if",
"(",
"strncmp",
"(",
"attr",
",",
"\"interrupt\"",
",",
"strlen",
"(",
"\"interrupt\"",
")",
")",
"==",
"0",
")",
"{",
"if",
"(",
"strncmp",
"(",
"func_name",
",",
"\"__vector\"",
",",
"strlen",
"(",
"\"__vector\"",
")",
")",
"!=",
"0",
")",
"{",
"warning",
"(",
"0",
",",
"\"%qs appears to be a misspelled interrupt handler\"",
",",
"func_name",
")",
";",
"}",
"}",
"else",
"if",
"(",
"strncmp",
"(",
"attr",
",",
"\"signal\"",
",",
"strlen",
"(",
"\"signal\"",
")",
")",
"==",
"0",
")",
"{",
"if",
"(",
"strncmp",
"(",
"func_name",
",",
"\"__vector\"",
",",
"strlen",
"(",
"\"__vector\"",
")",
")",
"!=",
"0",
")",
"{",
"warning",
"(",
"0",
",",
"\"%qs appears to be a misspelled signal handler\"",
",",
"func_name",
")",
";",
"}",
"}",
"}",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Handle",
"an",
"attribute",
"requiring",
"a",
"FUNCTION_DECL",
";",
"arguments",
"as",
"in",
"struct",
"attribute_spec.handler",
"."
] | [
"avr",
"\"%qs attribute only applies to functions\"",
"\"interrupt\"",
"\"interrupt\"",
"0",
"\"__vector\"",
"\"__vector\"",
"0",
"0",
"\"%qs appears to be a misspelled interrupt handler\"",
"\"signal\"",
"\"signal\"",
"0",
"\"__vector\"",
"\"__vector\"",
"0",
"0",
"\"%qs appears to be a misspelled signal handler\""
] | avr3 | avr_handle_fndecl_attribute | avr | MPU | GCC | 19,220 | 175 | 1 | [] |
[
"<s>",
"std",
"::",
"unique_ptr",
"<",
"SICacheControl",
">",
"SICacheControl",
"::",
"create",
"(",
"const",
"GCNSubtarget",
"&",
"ST",
")",
"{",
"GCNSubtarget",
"::",
"Generation",
"Generation",
"=",
"ST",
".",
"getGeneration",
"(",
")",
";",
"if",
"(",
"Generation",
"<=",
"AMDGPUSubtarget",
"::",
"SOUTHERN_ISLANDS",
")",
"return",
"std",
"::",
"make_unique",
"<",
"SIGfx6CacheControl",
">",
"(",
"ST",
")",
";",
"if",
"(",
"Generation",
"<",
"AMDGPUSubtarget",
"::",
"GFX10",
")",
"return",
"std",
"::",
"make_unique",
"<",
"SIGfx7CacheControl",
">",
"(",
"ST",
")",
";",
"return",
"std",
"::",
"make_unique",
"<",
"SIGfx10CacheControl",
">",
"(",
"ST",
")",
";",
"}",
"</s>"
] | [
"This",
"creates",
"an",
"identified",
"struct",
"."
] | [
"AMDGPU",
"SI",
"SI",
"AMDGPU",
"SI",
"AMDGPU",
"SI",
"SI"
] | SIMemoryLegalizer10 | create | AMDGPU | GPU | LLVM | 19,221 | 77 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"analyzeSelect",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"unsigned",
"&",
"TrueOp",
",",
"unsigned",
"&",
"FalseOp",
",",
"bool",
"&",
"Optimizable",
")",
"const",
"{",
"assert",
"(",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"MOVCCr",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"t2MOVCCr",
")",
"&&",
"\"Unknown select instruction\"",
")",
";",
"TrueOp",
"=",
"1",
";",
"FalseOp",
"=",
"2",
";",
"Cond",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"3",
")",
")",
";",
"Cond",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"4",
")",
")",
";",
"Optimizable",
"=",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Analyze",
"the",
"given",
"select",
"instruction",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"."
] | [
"ARM",
"ARM",
"ARM::MOVCCr",
"ARM::t2MOVCCr",
"\"Unknown select instruction\"",
"1",
"2",
"3",
"4"
] | ARMBaseInstrInfo (2)2 | analyzeSelect | ARM | CPU | LLVM | 19,222 | 98 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"isAddImmediate",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineOperand",
"*",
"&",
"Destination",
",",
"const",
"MachineOperand",
"*",
"&",
"Source",
",",
"int64_t",
"&",
"Offset",
")",
"const",
"{",
"int",
"Sign",
"=",
"1",
";",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"ARM",
"::",
"SUBri",
")",
"Sign",
"=",
"-",
"1",
";",
"else",
"if",
"(",
"Opcode",
"!=",
"ARM",
"::",
"ADDri",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isReg",
"(",
")",
"||",
"!",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"||",
"!",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"Destination",
"=",
"&",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"Source",
"=",
"&",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"Offset",
"=",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"*",
"Sign",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"If",
"the",
"specific",
"machine",
"instruction",
"is",
"an",
"instruction",
"that",
"adds",
"an",
"immediate",
"value",
"and",
"a",
"register",
",",
"and",
"stores",
"the",
"result",
"in",
"the",
"given",
"register",
"Reg",
",",
"return",
"a",
"pair",
"of",
"the",
"source",
"register",
"and",
"the",
"offset",
"which",
"has",
"been",
"added",
"."
] | [
"ARM",
"ARM",
"1",
"ARM::SUBri",
"1",
"ARM::ADDri",
"0",
"1",
"2",
"0",
"1",
"2"
] | ARMBaseInstrInfo25 | isAddImmediate | ARM | CPU | LLVM | 19,223 | 147 | 1 | [] |
[
"<s>",
"bool",
"SparcPassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"PM",
"->",
"add",
"(",
"createSparcISelDag",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"Sparc"
] | SparcTargetMachine58 | addInstSelector | Sparc | CPU | LLVM | 19,224 | 23 | 1 | [] |
[
"<s>",
"void",
"AArch64PassConfig",
"::",
"addPreLegalizeMachineIR",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createAArch64O0PreLegalizerCombiner",
"(",
")",
")",
";",
"else",
"addPass",
"(",
"createAArch64PreLegalizerCombiner",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"legalization",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine1 | addPreLegalizeMachineIR | AArch64 | CPU | LLVM | 19,225 | 33 | 1 | [] |
[
"<s>",
"bool",
"requiresFrameIndexScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"post",
"PEI",
"scavenging",
"of",
"registers",
"for",
"materializing",
"frame",
"index",
"constants",
"."
] | [
"CAHP"
] | CAHPRegisterInfo | requiresFrameIndexScavenging | CAHP | CPU | LLVM | 19,226 | 15 | 1 | [] |
[
"<s>",
"static",
"void",
"bfin_gen_bundles",
"(",
"void",
")",
"{",
"basic_block",
"bb",
";",
"FOR_EACH_BB_FN",
"(",
"bb",
",",
"cfun",
")",
"{",
"rtx_insn",
"*",
"insn",
",",
"*",
"next",
";",
"rtx_insn",
"*",
"slot",
"[",
"3",
"]",
";",
"int",
"n_filled",
"=",
"0",
";",
"slot",
"[",
"0",
"]",
"=",
"slot",
"[",
"1",
"]",
"=",
"slot",
"[",
"2",
"]",
"=",
"NULL",
";",
"for",
"(",
"insn",
"=",
"BB_HEAD",
"(",
"bb",
")",
";",
";",
"insn",
"=",
"next",
")",
"{",
"int",
"at_end",
";",
"rtx_insn",
"*",
"delete_this",
"=",
"NULL",
";",
"if",
"(",
"NONDEBUG_INSN_P",
"(",
"insn",
")",
")",
"{",
"enum",
"attr_type",
"type",
"=",
"get_attr_type",
"(",
"insn",
")",
";",
"if",
"(",
"type",
"==",
"TYPE_STALL",
")",
"{",
"gcc_assert",
"(",
"n_filled",
"==",
"0",
")",
";",
"delete_this",
"=",
"insn",
";",
"}",
"else",
"{",
"if",
"(",
"type",
"==",
"TYPE_DSP32",
"||",
"type",
"==",
"TYPE_DSP32SHIFTIMM",
")",
"slot",
"[",
"0",
"]",
"=",
"insn",
";",
"else",
"if",
"(",
"slot",
"[",
"1",
"]",
"==",
"NULL_RTX",
")",
"slot",
"[",
"1",
"]",
"=",
"insn",
";",
"else",
"slot",
"[",
"2",
"]",
"=",
"insn",
";",
"n_filled",
"++",
";",
"}",
"}",
"next",
"=",
"NEXT_INSN",
"(",
"insn",
")",
";",
"while",
"(",
"next",
"&&",
"insn",
"!=",
"BB_END",
"(",
"bb",
")",
"&&",
"!",
"(",
"INSN_P",
"(",
"next",
")",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"next",
")",
")",
"!=",
"USE",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"next",
")",
")",
"!=",
"CLOBBER",
")",
")",
"{",
"insn",
"=",
"next",
";",
"next",
"=",
"NEXT_INSN",
"(",
"insn",
")",
";",
"}",
"at_end",
"=",
"insn",
"==",
"BB_END",
"(",
"bb",
")",
";",
"if",
"(",
"delete_this",
"==",
"NULL_RTX",
"&&",
"(",
"at_end",
"||",
"GET_MODE",
"(",
"next",
")",
"==",
"TImode",
")",
")",
"{",
"if",
"(",
"(",
"n_filled",
"<",
"2",
"||",
"!",
"gen_one_bundle",
"(",
"slot",
")",
")",
"&&",
"slot",
"[",
"0",
"]",
"!=",
"NULL_RTX",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"slot",
"[",
"0",
"]",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"SET",
"&&",
"GET_CODE",
"(",
"SET_SRC",
"(",
"pat",
")",
")",
"==",
"UNSPEC",
"&&",
"XINT",
"(",
"SET_SRC",
"(",
"pat",
")",
",",
"1",
")",
"==",
"UNSPEC_32BIT",
")",
"{",
"SET_SRC",
"(",
"pat",
")",
"=",
"XVECEXP",
"(",
"SET_SRC",
"(",
"pat",
")",
",",
"0",
",",
"0",
")",
";",
"INSN_CODE",
"(",
"slot",
"[",
"0",
"]",
")",
"=",
"-",
"1",
";",
"df_insn_rescan",
"(",
"slot",
"[",
"0",
"]",
")",
";",
"}",
"}",
"n_filled",
"=",
"0",
";",
"slot",
"[",
"0",
"]",
"=",
"slot",
"[",
"1",
"]",
"=",
"slot",
"[",
"2",
"]",
"=",
"NULL",
";",
"}",
"if",
"(",
"delete_this",
"!=",
"NULL_RTX",
")",
"delete_insn",
"(",
"delete_this",
")",
";",
"if",
"(",
"at_end",
")",
"break",
";",
"}",
"}",
"}",
"</s>"
] | [
"Go",
"through",
"all",
"insns",
",",
"and",
"use",
"the",
"information",
"generated",
"during",
"scheduling",
"to",
"generate",
"SEQUENCEs",
"to",
"represent",
"bundles",
"of",
"instructions",
"issued",
"simultaneously",
"."
] | [
"bfin",
"3",
"0",
"0",
"1",
"2",
"0",
"0",
"1",
"1",
"2",
"2",
"0",
"0",
"1",
"0",
"0",
"0",
"1",
"0",
"0",
"0",
"1",
"2"
] | bfin | bfin_gen_bundles | bfin | DSP | GCC | 19,227 | 393 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"Nios2TargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"Nios2PassConfig",
"(",
"*",
"this",
",",
"&",
"PM",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"Nios2",
"Nios2",
"Nios2"
] | Nios2TargetMachine1 | createPassConfig | Nios2 | MPU | LLVM | 19,228 | 23 | 1 | [] |
[
"<s>",
"virtual",
"const",
"TargetRegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"XNCM"
] | XNCMTargetMachine | getRegisterInfo | XNCM | CPU | LLVM | 19,229 | 18 | 1 | [] |
[
"<s>",
"const",
"MCFixupKindInfo",
"&",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"override",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"AArch64",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"\"fixup_aarch64_pcrel_adr_imm21\"",
",",
"0",
",",
"32",
",",
"PCRelFlagVal",
"}",
",",
"{",
"\"fixup_aarch64_pcrel_adrp_imm21\"",
",",
"0",
",",
"32",
",",
"PCRelFlagVal",
"}",
",",
"{",
"\"fixup_aarch64_add_imm12\"",
",",
"10",
",",
"12",
",",
"0",
"}",
",",
"{",
"\"fixup_aarch64_ldst_imm12_scale1\"",
",",
"10",
",",
"12",
",",
"0",
"}",
",",
"{",
"\"fixup_aarch64_ldst_imm12_scale2\"",
",",
"10",
",",
"12",
",",
"0",
"}",
",",
"{",
"\"fixup_aarch64_ldst_imm12_scale4\"",
",",
"10",
",",
"12",
",",
"0",
"}",
",",
"{",
"\"fixup_aarch64_ldst_imm12_scale8\"",
",",
"10",
",",
"12",
",",
"0",
"}",
",",
"{",
"\"fixup_aarch64_ldst_imm12_scale16\"",
",",
"10",
",",
"12",
",",
"0",
"}",
",",
"{",
"\"fixup_aarch64_ldr_pcrel_imm19\"",
",",
"5",
",",
"19",
",",
"PCRelFlagVal",
"}",
",",
"{",
"\"fixup_aarch64_movw\"",
",",
"5",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_aarch64_pcrel_branch14\"",
",",
"5",
",",
"14",
",",
"PCRelFlagVal",
"}",
",",
"{",
"\"fixup_aarch64_pcrel_branch19\"",
",",
"5",
",",
"19",
",",
"PCRelFlagVal",
"}",
",",
"{",
"\"fixup_aarch64_pcrel_branch26\"",
",",
"0",
",",
"26",
",",
"PCRelFlagVal",
"}",
",",
"{",
"\"fixup_aarch64_pcrel_call26\"",
",",
"0",
",",
"26",
",",
"PCRelFlagVal",
"}",
",",
"{",
"\"fixup_aarch64_tlsdesc_call\"",
",",
"0",
",",
"0",
",",
"0",
"}",
"}",
";",
"if",
"(",
"Kind",
">=",
"FirstLiteralRelocationKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"FK_NONE",
")",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";",
"assert",
"(",
"unsigned",
"(",
"Kind",
"-",
"FirstTargetFixupKind",
")",
"<",
"getNumFixupKinds",
"(",
")",
"&&",
"\"Invalid kind!\"",
")",
";",
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";",
"}",
"</s>"
] | [
"Get",
"information",
"on",
"a",
"fixup",
"kind",
"."
] | [
"AArch64",
"AArch64::NumTargetFixupKinds",
"\"fixup_aarch64_pcrel_adr_imm21\"",
"0",
"32",
"\"fixup_aarch64_pcrel_adrp_imm21\"",
"0",
"32",
"\"fixup_aarch64_add_imm12\"",
"10",
"12",
"0",
"\"fixup_aarch64_ldst_imm12_scale1\"",
"10",
"12",
"0",
"\"fixup_aarch64_ldst_imm12_scale2\"",
"10",
"12",
"0",
"\"fixup_aarch64_ldst_imm12_scale4\"",
"10",
"12",
"0",
"\"fixup_aarch64_ldst_imm12_scale8\"",
"10",
"12",
"0",
"\"fixup_aarch64_ldst_imm12_scale16\"",
"10",
"12",
"0",
"\"fixup_aarch64_ldr_pcrel_imm19\"",
"5",
"19",
"\"fixup_aarch64_movw\"",
"5",
"16",
"0",
"\"fixup_aarch64_pcrel_branch14\"",
"5",
"14",
"\"fixup_aarch64_pcrel_branch19\"",
"5",
"19",
"\"fixup_aarch64_pcrel_branch26\"",
"0",
"26",
"\"fixup_aarch64_pcrel_call26\"",
"0",
"26",
"\"fixup_aarch64_tlsdesc_call\"",
"0",
"0",
"0",
"\"Invalid kind!\""
] | AArch64AsmBackend17 | getFixupKindInfo | AArch64 | CPU | LLVM | 19,230 | 226 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"SystemZSelectionDAGInfo",
"::",
"EmitTargetCodeForMemchr",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Src",
",",
"SDValue",
"Char",
",",
"SDValue",
"Length",
",",
"MachinePointerInfo",
"SrcPtrInfo",
")",
"const",
"{",
"EVT",
"PtrVT",
"=",
"Src",
".",
"getValueType",
"(",
")",
";",
"SDVTList",
"VTs",
"=",
"DAG",
".",
"getVTList",
"(",
"PtrVT",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Other",
")",
";",
"Length",
"=",
"DAG",
".",
"getZExtOrTrunc",
"(",
"Length",
",",
"DL",
",",
"PtrVT",
")",
";",
"Char",
"=",
"DAG",
".",
"getZExtOrTrunc",
"(",
"Char",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
";",
"Char",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Char",
",",
"DAG",
".",
"getConstant",
"(",
"255",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"SDValue",
"Limit",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"Src",
",",
"Length",
")",
";",
"SDValue",
"End",
"=",
"DAG",
".",
"getNode",
"(",
"SystemZISD",
"::",
"SEARCH_STRING",
",",
"DL",
",",
"VTs",
",",
"Chain",
",",
"Limit",
",",
"Src",
",",
"Char",
")",
";",
"SDValue",
"CCReg",
"=",
"End",
".",
"getValue",
"(",
"1",
")",
";",
"Chain",
"=",
"End",
".",
"getValue",
"(",
"2",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"End",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"PtrVT",
")",
",",
"DAG",
".",
"getTargetConstant",
"(",
"SystemZ",
"::",
"CCMASK_SRST",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
",",
"DAG",
".",
"getTargetConstant",
"(",
"SystemZ",
"::",
"CCMASK_SRST_FOUND",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
",",
"CCReg",
"}",
";",
"End",
"=",
"DAG",
".",
"getNode",
"(",
"SystemZISD",
"::",
"SELECT_CCMASK",
",",
"DL",
",",
"PtrVT",
",",
"Ops",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"End",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memchr",
",",
"in",
"cases",
"where",
"that",
"is",
"faster",
"than",
"a",
"libcall",
"."
] | [
"SystemZ",
"SystemZ",
"MVT::i32",
"MVT::Other",
"MVT::i32",
"ISD::AND",
"MVT::i32",
"255",
"MVT::i32",
"ISD::ADD",
"SystemZISD::SEARCH_STRING",
"1",
"2",
"0",
"SystemZ::CCMASK_SRST",
"MVT::i32",
"SystemZ::CCMASK_SRST_FOUND",
"MVT::i32",
"SystemZISD::SELECT_CCMASK"
] | SystemZSelectionDAGInfo | EmitTargetCodeForMemchr | SystemZ | CPU | LLVM | 19,231 | 268 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"ReplaceNodeResults",
"(",
"SDNode",
"*",
"N",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Results",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"Res",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Don't know how to custom expand this!\"",
")",
";",
"case",
"ISD",
"::",
"READ_REGISTER",
":",
"ExpandREAD_REGISTER",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"BITCAST",
":",
"Res",
"=",
"ExpandBITCAST",
"(",
"N",
",",
"DAG",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SRL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"Res",
"=",
"Expand64BitShift",
"(",
"N",
",",
"DAG",
",",
"Subtarget",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SREM",
":",
"case",
"ISD",
"::",
"UREM",
":",
"Res",
"=",
"LowerREM",
"(",
"N",
",",
"DAG",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SDIVREM",
":",
"case",
"ISD",
"::",
"UDIVREM",
":",
"Res",
"=",
"LowerDivRem",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
")",
";",
"assert",
"(",
"Res",
".",
"getNumOperands",
"(",
")",
"==",
"2",
"&&",
"\"DivRem needs two values\"",
")",
";",
"Results",
".",
"push_back",
"(",
"Res",
".",
"getValue",
"(",
"0",
")",
")",
";",
"Results",
".",
"push_back",
"(",
"Res",
".",
"getValue",
"(",
"1",
")",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"READCYCLECOUNTER",
":",
"ReplaceREADCYCLECOUNTER",
"(",
"N",
",",
"Results",
",",
"DAG",
",",
"Subtarget",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"UDIV",
":",
"case",
"ISD",
"::",
"SDIV",
":",
"assert",
"(",
"Subtarget",
"->",
"isTargetWindows",
"(",
")",
"&&",
"\"can only expand DIV on Windows\"",
")",
";",
"return",
"ExpandDIV_Windows",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"DAG",
",",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
",",
"Results",
")",
";",
"case",
"ISD",
"::",
"ATOMIC_CMP_SWAP",
":",
"ReplaceCMP_SWAP_64Results",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"ReplaceLongIntrinsic",
"(",
"N",
",",
"Results",
",",
"DAG",
")",
";",
"}",
"if",
"(",
"Res",
".",
"getNode",
"(",
")",
")",
"Results",
".",
"push_back",
"(",
"Res",
")",
";",
"}",
"</s>"
] | [
"ReplaceNodeResults",
"-",
"Replace",
"the",
"results",
"of",
"node",
"with",
"an",
"illegal",
"result",
"type",
"with",
"new",
"values",
"built",
"out",
"of",
"custom",
"code",
"."
] | [
"ARM",
"ARM",
"\"Don't know how to custom expand this!\"",
"ISD::READ_REGISTER",
"ISD::BITCAST",
"ISD::SRL",
"ISD::SRA",
"ISD::SREM",
"ISD::UREM",
"ISD::SDIVREM",
"ISD::UDIVREM",
"0",
"2",
"\"DivRem needs two values\"",
"0",
"1",
"ISD::READCYCLECOUNTER",
"ISD::UDIV",
"ISD::SDIV",
"\"can only expand DIV on Windows\"",
"0",
"ISD::SDIV",
"ISD::ATOMIC_CMP_SWAP",
"ISD::INTRINSIC_WO_CHAIN"
] | ARMISelLowering108 | ReplaceNodeResults | ARM | CPU | LLVM | 19,232 | 292 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"getSubtargetImpl",
"(",
")",
"->",
"getInstrItineraryData",
"(",
")",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"X86"
] | X86TargetMachine | getInstrItineraryData | X86 | CPU | LLVM | 19,233 | 20 | 1 | [] |
[
"<s>",
"bool",
"Error",
"(",
"SMLoc",
"L",
",",
"const",
"Twine",
"&",
"Msg",
",",
"ArrayRef",
"<",
"SMRange",
">",
"Ranges",
"=",
"None",
",",
"bool",
"MatchingInlineAsm",
"=",
"false",
")",
"{",
"MCAsmParser",
"&",
"Parser",
"=",
"getParser",
"(",
")",
";",
"if",
"(",
"MatchingInlineAsm",
")",
"return",
"true",
";",
"return",
"Parser",
".",
"Error",
"(",
"L",
",",
"Msg",
",",
"Ranges",
")",
";",
"}",
"</s>"
] | [
"Return",
"an",
"error",
"at",
"the",
"location",
"L",
",",
"with",
"the",
"message",
"Msg",
"."
] | [
"X86"
] | X86AsmParser (2)3 | Error | X86 | CPU | LLVM | 19,234 | 53 | 1 | [] |
[
"<s>",
"static",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"splitVector",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"dl",
")",
"{",
"EVT",
"VT",
"=",
"Op",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"NumElems",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"unsigned",
"SizeInBits",
"=",
"VT",
".",
"getSizeInBits",
"(",
")",
";",
"assert",
"(",
"(",
"NumElems",
"%",
"2",
")",
"==",
"0",
"&&",
"(",
"SizeInBits",
"%",
"2",
")",
"==",
"0",
"&&",
"\"Can't split odd sized vector\"",
")",
";",
"SDValue",
"Lo",
"=",
"extractSubVector",
"(",
"Op",
",",
"0",
",",
"DAG",
",",
"dl",
",",
"SizeInBits",
"/",
"2",
")",
";",
"SDValue",
"Hi",
"=",
"extractSubVector",
"(",
"Op",
",",
"NumElems",
"/",
"2",
",",
"DAG",
",",
"dl",
",",
"SizeInBits",
"/",
"2",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"Lo",
",",
"Hi",
")",
";",
"}",
"</s>"
] | [
"Split",
"a",
"vector",
"value",
"into",
"two",
"parts",
"of",
"types",
"LoVT",
"and",
"HiVT",
"."
] | [
"X86",
"2",
"0",
"2",
"0",
"\"Can't split odd sized vector\"",
"0",
"2",
"2",
"2"
] | X86ISelLowering (2)5 | splitVector | X86 | CPU | LLVM | 19,235 | 121 | 1 | [] |
[
"<s>",
"static",
"void",
"reset",
"(",
")",
"{",
"Blocks",
".",
"clear",
"(",
")",
";",
"PredicatedInsts",
".",
"clear",
"(",
")",
";",
"CurrentPredicates",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"Reset",
"an",
"existing",
"scalar",
"value",
"for",
"Def",
"and",
"a",
"given",
"Instance",
"."
] | [
"ARM"
] | ARMLowOverheadLoops | reset | ARM | CPU | LLVM | 19,236 | 25 | 1 | [] |
[
"<s>",
"static",
"void",
"riscv_adjust_block_mem",
"(",
"rtx",
"mem",
",",
"unsigned",
"HOST_WIDE_INT",
"length",
",",
"rtx",
"*",
"loop_reg",
",",
"rtx",
"*",
"loop_mem",
")",
"{",
"*",
"loop_reg",
"=",
"copy_addr_to_reg",
"(",
"XEXP",
"(",
"mem",
",",
"0",
")",
")",
";",
"*",
"loop_mem",
"=",
"change_address",
"(",
"mem",
",",
"BLKmode",
",",
"*",
"loop_reg",
")",
";",
"set_mem_align",
"(",
"*",
"loop_mem",
",",
"MIN",
"(",
"MEM_ALIGN",
"(",
"mem",
")",
",",
"length",
"*",
"BITS_PER_UNIT",
")",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"for",
"doing",
"a",
"loop-based",
"block",
"operation",
"on",
"memory",
"reference",
"MEM",
".",
"Each",
"iteration",
"of",
"the",
"loop",
"will",
"operate",
"on",
"LENGTH",
"bytes",
"of",
"MEM",
".",
"Create",
"a",
"new",
"base",
"register",
"for",
"use",
"within",
"the",
"loop",
"and",
"point",
"it",
"to",
"the",
"start",
"of",
"MEM",
".",
"Create",
"a",
"new",
"memory",
"reference",
"that",
"uses",
"this",
"register",
".",
"Store",
"them",
"in",
"*",
"LOOP_REG",
"and",
"*",
"LOOP_MEM",
"respectively",
"."
] | [
"riscv",
"0"
] | riscv | riscv_adjust_block_mem | riscv | CPU | GCC | 19,237 | 65 | 1 | [] |
[
"<s>",
"void",
"HexagonRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOp",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
"&&",
"\"Unexpected\"",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineBasicBlock",
"&",
"MB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MB",
".",
"getParent",
"(",
")",
";",
"auto",
"&",
"HST",
"=",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
";",
"auto",
"&",
"HII",
"=",
"*",
"HST",
".",
"getInstrInfo",
"(",
")",
";",
"auto",
"&",
"HFI",
"=",
"*",
"HST",
".",
"getFrameLowering",
"(",
")",
";",
"unsigned",
"BP",
"=",
"0",
";",
"int",
"FI",
"=",
"MI",
".",
"getOperand",
"(",
"FIOp",
")",
".",
"getIndex",
"(",
")",
";",
"int",
"Offset",
"=",
"HFI",
".",
"getFrameIndexReference",
"(",
"MF",
",",
"FI",
",",
"BP",
")",
";",
"int",
"RealOffset",
"=",
"Offset",
"+",
"MI",
".",
"getOperand",
"(",
"FIOp",
"+",
"1",
")",
".",
"getImm",
"(",
")",
";",
"bool",
"IsKill",
"=",
"false",
";",
"unsigned",
"Opc",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"case",
"Hexagon",
"::",
"PS_fia",
":",
"MI",
".",
"setDesc",
"(",
"HII",
".",
"get",
"(",
"Hexagon",
"::",
"A2_addi",
")",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOp",
")",
".",
"ChangeToImmediate",
"(",
"RealOffset",
")",
";",
"MI",
".",
"RemoveOperand",
"(",
"FIOp",
"+",
"1",
")",
";",
"return",
";",
"case",
"Hexagon",
"::",
"PS_fi",
":",
"MI",
".",
"setDesc",
"(",
"HII",
".",
"get",
"(",
"Hexagon",
"::",
"A2_addi",
")",
")",
";",
"break",
";",
"}",
"if",
"(",
"!",
"HII",
".",
"isValidOffset",
"(",
"Opc",
",",
"RealOffset",
")",
")",
"{",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"unsigned",
"TmpR",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"Hexagon",
"::",
"IntRegsRegClass",
")",
";",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"BuildMI",
"(",
"MB",
",",
"II",
",",
"DL",
",",
"HII",
".",
"get",
"(",
"Hexagon",
"::",
"A2_addi",
")",
",",
"TmpR",
")",
".",
"addReg",
"(",
"BP",
")",
".",
"addImm",
"(",
"RealOffset",
")",
";",
"BP",
"=",
"TmpR",
";",
"RealOffset",
"=",
"0",
";",
"IsKill",
"=",
"true",
";",
"}",
"MI",
".",
"getOperand",
"(",
"FIOp",
")",
".",
"ChangeToRegister",
"(",
"BP",
",",
"false",
",",
"false",
",",
"IsKill",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOp",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"RealOffset",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"Hexagon",
"Hexagon",
"0",
"\"Unexpected\"",
"Hexagon",
"0",
"1",
"Hexagon::PS_fia",
"Hexagon::A2_addi",
"1",
"Hexagon::PS_fi",
"Hexagon::A2_addi",
"Hexagon::IntRegsRegClass",
"Hexagon::A2_addi",
"0",
"1"
] | HexagonRegisterInfo12 | eliminateFrameIndex | Hexagon | DSP | LLVM | 19,238 | 352 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"AArch64 Collect Linker Optimization Hint (LOH)\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AArch64",
"\"AArch64 Collect Linker Optimization Hint (LOH)\""
] | AArch64CollectLOH10 | getPassName | AArch64 | CPU | LLVM | 19,239 | 13 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"requiresUniformRegister",
"(",
"MachineFunction",
"&",
"MF",
",",
"const",
"Value",
"*",
"V",
")",
"const",
"{",
"if",
"(",
"const",
"IntrinsicInst",
"*",
"Intrinsic",
"=",
"dyn_cast",
"<",
"IntrinsicInst",
">",
"(",
"V",
")",
")",
"{",
"switch",
"(",
"Intrinsic",
"->",
"getIntrinsicID",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"Intrinsic",
"::",
"amdgcn_if_break",
":",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"const",
"ExtractValueInst",
"*",
"ExtValue",
"=",
"dyn_cast",
"<",
"ExtractValueInst",
">",
"(",
"V",
")",
")",
"{",
"if",
"(",
"const",
"IntrinsicInst",
"*",
"Intrinsic",
"=",
"dyn_cast",
"<",
"IntrinsicInst",
">",
"(",
"ExtValue",
"->",
"getOperand",
"(",
"0",
")",
")",
")",
"{",
"switch",
"(",
"Intrinsic",
"->",
"getIntrinsicID",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"Intrinsic",
"::",
"amdgcn_if",
":",
"case",
"Intrinsic",
"::",
"amdgcn_else",
":",
"{",
"ArrayRef",
"<",
"unsigned",
">",
"Indices",
"=",
"ExtValue",
"->",
"getIndices",
"(",
")",
";",
"if",
"(",
"Indices",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"Indices",
"[",
"0",
"]",
"==",
"1",
")",
"{",
"return",
"true",
";",
"}",
"}",
"}",
"}",
"}",
"if",
"(",
"const",
"CallInst",
"*",
"CI",
"=",
"dyn_cast",
"<",
"CallInst",
">",
"(",
"V",
")",
")",
"{",
"if",
"(",
"isa",
"<",
"InlineAsm",
">",
"(",
"CI",
"->",
"getCalledValue",
"(",
")",
")",
")",
"{",
"const",
"SIRegisterInfo",
"*",
"SIRI",
"=",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
";",
"ImmutableCallSite",
"CS",
"(",
"CI",
")",
";",
"TargetLowering",
"::",
"AsmOperandInfoVector",
"TargetConstraints",
"=",
"ParseConstraints",
"(",
"MF",
".",
"getDataLayout",
"(",
")",
",",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
",",
"CS",
")",
";",
"for",
"(",
"auto",
"&",
"TC",
":",
"TargetConstraints",
")",
"{",
"if",
"(",
"TC",
".",
"Type",
"==",
"InlineAsm",
"::",
"isOutput",
")",
"{",
"ComputeConstraintToUse",
"(",
"TC",
",",
"SDValue",
"(",
")",
")",
";",
"unsigned",
"AssignedReg",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
";",
"std",
"::",
"tie",
"(",
"AssignedReg",
",",
"RC",
")",
"=",
"getRegForInlineAsmConstraint",
"(",
"SIRI",
",",
"TC",
".",
"ConstraintCode",
",",
"TC",
".",
"ConstraintVT",
")",
";",
"if",
"(",
"RC",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"if",
"(",
"AssignedReg",
"!=",
"0",
"&&",
"SIRI",
"->",
"isSGPRReg",
"(",
"MRI",
",",
"AssignedReg",
")",
")",
"return",
"true",
";",
"else",
"if",
"(",
"SIRI",
"->",
"isSGPRClass",
"(",
"RC",
")",
")",
"return",
"true",
";",
"}",
"}",
"}",
"}",
"}",
"SmallPtrSet",
"<",
"const",
"Value",
"*",
",",
"16",
">",
"Visited",
";",
"return",
"hasCFUser",
"(",
"V",
",",
"Visited",
")",
";",
"}",
"</s>"
] | [
"Allows",
"target",
"to",
"decide",
"about",
"the",
"register",
"class",
"of",
"the",
"specific",
"value",
"that",
"is",
"live",
"outside",
"the",
"defining",
"block",
"."
] | [
"AMDGPU",
"SI",
"Intrinsic::amdgcn_if_break",
"0",
"Intrinsic::amdgcn_if",
"Intrinsic::amdgcn_else",
"1",
"0",
"1",
"SI",
"SI",
"SI",
"0",
"SI",
"SI",
"16"
] | SIISelLowering106 | requiresUniformRegister | AMDGPU | GPU | LLVM | 19,240 | 355 | 1 | [] |
[
"<s>",
"void",
"m32r_expand_prologue",
"(",
"void",
")",
"{",
"int",
"regno",
";",
"int",
"frame_size",
";",
"unsigned",
"int",
"gmask",
";",
"int",
"pic_reg_used",
"=",
"flag_pic",
"&&",
"(",
"crtl",
"->",
"uses_pic_offset_table",
"|",
"crtl",
"->",
"profile",
")",
";",
"if",
"(",
"!",
"current_frame_info",
".",
"initialized",
")",
"m32r_compute_frame_size",
"(",
"get_frame_size",
"(",
")",
")",
";",
"gmask",
"=",
"current_frame_info",
".",
"gmask",
";",
"gcc_assert",
"(",
"current_frame_info",
".",
"total_size",
"||",
"!",
"gmask",
")",
";",
"if",
"(",
"current_frame_info",
".",
"pretend_size",
"!=",
"0",
")",
"{",
"HOST_WIDE_INT",
"pretend_size",
"=",
"current_frame_info",
".",
"pretend_size",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"pretend_size",
")",
")",
")",
";",
"}",
"if",
"(",
"current_frame_info",
".",
"save_fp",
")",
"emit_insn",
"(",
"gen_movsi_push",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
")",
")",
";",
"gmask",
"&=",
"~",
"(",
"FRAME_POINTER_MASK",
"|",
"RETURN_ADDR_MASK",
")",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<=",
"M32R_MAX_INT_REGS",
";",
"++",
"regno",
")",
"{",
"if",
"(",
"(",
"gmask",
"&",
"(",
"1",
"<<",
"regno",
")",
")",
"!=",
"0",
")",
"emit_insn",
"(",
"gen_movsi_push",
"(",
"stack_pointer_rtx",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"regno",
")",
")",
")",
";",
"}",
"if",
"(",
"current_frame_info",
".",
"save_lr",
")",
"emit_insn",
"(",
"gen_movsi_push",
"(",
"stack_pointer_rtx",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"RETURN_ADDR_REGNUM",
")",
")",
")",
";",
"frame_size",
"=",
"(",
"current_frame_info",
".",
"total_size",
"-",
"(",
"current_frame_info",
".",
"pretend_size",
"+",
"current_frame_info",
".",
"reg_size",
")",
")",
";",
"if",
"(",
"frame_size",
"==",
"0",
")",
";",
"else",
"if",
"(",
"frame_size",
"<=",
"32768",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"frame_size",
")",
")",
")",
";",
"else",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"PROLOGUE_TMP_REGNUM",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"tmp",
",",
"GEN_INT",
"(",
"frame_size",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_subsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"tmp",
")",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"emit_insn",
"(",
"gen_movsi",
"(",
"frame_pointer_rtx",
",",
"stack_pointer_rtx",
")",
")",
";",
"if",
"(",
"crtl",
"->",
"profile",
")",
"emit_insn",
"(",
"gen_movsi_push",
"(",
"stack_pointer_rtx",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"RETURN_ADDR_REGNUM",
")",
")",
")",
";",
"if",
"(",
"pic_reg_used",
")",
"{",
"m32r_load_pic_register",
"(",
")",
";",
"m32r_reload_lr",
"(",
"stack_pointer_rtx",
",",
"(",
"crtl",
"->",
"profile",
"?",
"0",
":",
"frame_size",
")",
")",
";",
"}",
"if",
"(",
"crtl",
"->",
"profile",
"&&",
"!",
"pic_reg_used",
")",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"m32r",
"prologue",
"as",
"a",
"series",
"of",
"insns",
"."
] | [
"m32r",
"0",
"0",
"1",
"0",
"0",
"32768",
"0"
] | m32r4 | m32r_expand_prologue | m32r | MPU | GCC | 19,241 | 347 | 1 | [] |
[
"<s>",
"bool",
"fusion_p9_p",
"(",
"rtx",
"addis_reg",
",",
"rtx",
"addis_value",
",",
"rtx",
"dest",
",",
"rtx",
"src",
")",
"{",
"rtx",
"addr",
",",
"mem",
",",
"offset",
";",
"enum",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"src",
")",
";",
"if",
"(",
"!",
"base_reg_operand",
"(",
"addis_reg",
",",
"GET_MODE",
"(",
"addis_reg",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"fusion_gpr_addis",
"(",
"addis_value",
",",
"GET_MODE",
"(",
"addis_value",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"FLOAT_EXTEND",
"||",
"GET_CODE",
"(",
"src",
")",
"==",
"ZERO_EXTEND",
")",
"src",
"=",
"XEXP",
"(",
"src",
",",
"0",
")",
";",
"if",
"(",
"fpr_reg_operand",
"(",
"src",
",",
"mode",
")",
"||",
"int_reg_operand",
"(",
"src",
",",
"mode",
")",
")",
"{",
"if",
"(",
"!",
"MEM_P",
"(",
"dest",
")",
")",
"return",
"false",
";",
"mem",
"=",
"dest",
";",
"}",
"else",
"if",
"(",
"MEM_P",
"(",
"src",
")",
")",
"{",
"if",
"(",
"!",
"fpr_reg_operand",
"(",
"dest",
",",
"mode",
")",
"&&",
"!",
"int_reg_operand",
"(",
"dest",
",",
"mode",
")",
")",
"return",
"false",
";",
"mem",
"=",
"src",
";",
"}",
"else",
"return",
"false",
";",
"addr",
"=",
"XEXP",
"(",
"mem",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"PLUS",
")",
"{",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"addis_reg",
",",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
")",
"return",
"false",
";",
"return",
"satisfies_constraint_I",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"LO_SUM",
")",
"{",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"addis_reg",
",",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
")",
"return",
"false",
";",
"offset",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"if",
"(",
"TARGET_XCOFF",
"||",
"(",
"TARGET_ELF",
"&&",
"TARGET_POWERPC64",
")",
")",
"return",
"small_toc_ref",
"(",
"offset",
",",
"GET_MODE",
"(",
"offset",
")",
")",
";",
"else",
"if",
"(",
"TARGET_ELF",
"&&",
"!",
"TARGET_POWERPC64",
")",
"return",
"CONSTANT_P",
"(",
"offset",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"peephole2",
"can",
"combine",
"a",
"load/store",
"involving",
"a",
"combination",
"of",
"an",
"addis",
"instruction",
"and",
"the",
"memory",
"operation",
".",
"This",
"was",
"added",
"to",
"the",
"ISA",
"3.0",
"(",
"power9",
")",
"hardware",
"."
] | [
"rs6000",
"0",
"0",
"0",
"1",
"0",
"1"
] | rs60005 | fusion_p9_p | rs6000 | CPU | GCC | 19,242 | 288 | 1 | [] |
[
"<s>",
"void",
"init_68881_table",
"(",
"void",
")",
"{",
"int",
"i",
";",
"REAL_VALUE_TYPE",
"r",
";",
"machine_mode",
"mode",
";",
"mode",
"=",
"SFmode",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"7",
";",
"i",
"++",
")",
"{",
"if",
"(",
"i",
"==",
"6",
")",
"mode",
"=",
"DFmode",
";",
"r",
"=",
"REAL_VALUE_ATOF",
"(",
"strings_68881",
"[",
"i",
"]",
",",
"mode",
")",
";",
"values_68881",
"[",
"i",
"]",
"=",
"r",
";",
"}",
"inited_68881_table",
"=",
"1",
";",
"}",
"</s>"
] | [
"Set",
"up",
"values_68881",
"array",
"by",
"converting",
"the",
"decimal",
"values",
"strings_68881",
"to",
"binary",
"."
] | [
"m68k",
"0",
"7",
"6",
"1"
] | m68k | init_68881_table | m68k | MPU | GCC | 19,243 | 68 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyTTIImpl",
"::",
"haveFastSqrt",
"(",
"Type",
"*",
"Ty",
")",
"const",
"{",
"assert",
"(",
"Ty",
"->",
"isFPOrFPVectorTy",
"(",
")",
"&&",
"\"Ty must be floating point\"",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"hardware",
"has",
"a",
"fast",
"square-root",
"instruction",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"Ty must be floating point\""
] | WebAssemblyTargetTransformInfo10 | haveFastSqrt | WebAssembly | Virtual ISA | LLVM | 19,244 | 26 | 1 | [] |
[
"<s>",
"static",
"int",
"aarch64_sched_issue_rate",
"(",
"void",
")",
"{",
"return",
"aarch64_tune_params",
"->",
"issue_rate",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"instructions",
"that",
"can",
"be",
"issued",
"per",
"cycle",
"."
] | [
"aarch64"
] | aarch642 | aarch64_sched_issue_rate | aarch64 | CPU | GCC | 19,245 | 13 | 1 | [] |
[
"<s>",
"void",
"output_ascii",
"(",
"FILE",
"*",
"file",
",",
"const",
"char",
"*",
"p",
",",
"int",
"n",
")",
"{",
"char",
"c",
";",
"int",
"i",
",",
"count_string",
";",
"const",
"char",
"*",
"for_string",
"=",
"\"\\t.byte \\\"\"",
";",
"const",
"char",
"*",
"for_decimal",
"=",
"\"\\t.byte \"",
";",
"const",
"char",
"*",
"to_close",
"=",
"NULL",
";",
"count_string",
"=",
"0",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
")",
"{",
"c",
"=",
"*",
"p",
"++",
";",
"if",
"(",
"c",
">=",
"' '",
"&&",
"c",
"<",
"0177",
")",
"{",
"if",
"(",
"for_string",
")",
"fputs",
"(",
"for_string",
",",
"file",
")",
";",
"putc",
"(",
"c",
",",
"file",
")",
";",
"if",
"(",
"c",
"==",
"'\"'",
")",
"{",
"putc",
"(",
"c",
",",
"file",
")",
";",
"++",
"count_string",
";",
"}",
"for_string",
"=",
"NULL",
";",
"for_decimal",
"=",
"\"\\\"\\n\\t.byte \"",
";",
"to_close",
"=",
"\"\\\"\\n\"",
";",
"++",
"count_string",
";",
"if",
"(",
"count_string",
">=",
"512",
")",
"{",
"fputs",
"(",
"to_close",
",",
"file",
")",
";",
"for_string",
"=",
"\"\\t.byte \\\"\"",
";",
"for_decimal",
"=",
"\"\\t.byte \"",
";",
"to_close",
"=",
"NULL",
";",
"count_string",
"=",
"0",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"for_decimal",
")",
"fputs",
"(",
"for_decimal",
",",
"file",
")",
";",
"fprintf",
"(",
"file",
",",
"\"%d\"",
",",
"c",
")",
";",
"for_string",
"=",
"\"\\n\\t.byte \\\"\"",
";",
"for_decimal",
"=",
"\", \"",
";",
"to_close",
"=",
"\"\\n\"",
";",
"count_string",
"=",
"0",
";",
"}",
"}",
"if",
"(",
"to_close",
")",
"fputs",
"(",
"to_close",
",",
"file",
")",
";",
"}",
"</s>"
] | [
"Output",
"an",
"assembler",
"pseudo-op",
"to",
"write",
"an",
"ASCII",
"string",
"of",
"N",
"characters",
"starting",
"at",
"P",
"to",
"FILE",
".",
"On",
"the",
"RS/6000",
",",
"we",
"have",
"to",
"do",
"this",
"using",
"the",
".byte",
"operation",
"and",
"write",
"out",
"special",
"characters",
"outside",
"the",
"quoted",
"string",
".",
"Also",
",",
"the",
"assembler",
"is",
"broken",
";",
"very",
"long",
"strings",
"are",
"truncated",
",",
"so",
"we",
"must",
"artificially",
"break",
"them",
"up",
"early",
"."
] | [
"rs6000",
"\"\\t.byte \\\"\"",
"\"\\t.byte \"",
"0",
"0",
"0177",
"\"\\\"\\n\\t.byte \"",
"\"\\\"\\n\"",
"512",
"\"\\t.byte \\\"\"",
"\"\\t.byte \"",
"0",
"\"%d\"",
"\"\\n\\t.byte \\\"\"",
"\", \"",
"\"\\n\"",
"0"
] | rs6000 | output_ascii | rs6000 | CPU | GCC | 19,246 | 215 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"SITargetLowering",
"::",
"legalizeTargetIndependentNode",
"(",
"SDNode",
"*",
"Node",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"Node",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"CopyToReg",
")",
"{",
"RegisterSDNode",
"*",
"DestReg",
"=",
"cast",
"<",
"RegisterSDNode",
">",
"(",
"Node",
"->",
"getOperand",
"(",
"1",
")",
")",
";",
"SDValue",
"SrcVal",
"=",
"Node",
"->",
"getOperand",
"(",
"2",
")",
";",
"if",
"(",
"SrcVal",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"i1",
"&&",
"Register",
"::",
"isPhysicalRegister",
"(",
"DestReg",
"->",
"getReg",
"(",
")",
")",
")",
"{",
"SDLoc",
"SL",
"(",
"Node",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
";",
"SDValue",
"VReg",
"=",
"DAG",
".",
"getRegister",
"(",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VReg_1RegClass",
")",
",",
"MVT",
"::",
"i1",
")",
";",
"SDNode",
"*",
"Glued",
"=",
"Node",
"->",
"getGluedNode",
"(",
")",
";",
"SDValue",
"ToVReg",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Node",
"->",
"getOperand",
"(",
"0",
")",
",",
"SL",
",",
"VReg",
",",
"SrcVal",
",",
"SDValue",
"(",
"Glued",
",",
"Glued",
"?",
"Glued",
"->",
"getNumValues",
"(",
")",
"-",
"1",
":",
"0",
")",
")",
";",
"SDValue",
"ToResultReg",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"ToVReg",
",",
"SL",
",",
"SDValue",
"(",
"DestReg",
",",
"0",
")",
",",
"VReg",
",",
"ToVReg",
".",
"getValue",
"(",
"1",
")",
")",
";",
"DAG",
".",
"ReplaceAllUsesWith",
"(",
"Node",
",",
"ToResultReg",
".",
"getNode",
"(",
")",
")",
";",
"DAG",
".",
"RemoveDeadNode",
"(",
"Node",
")",
";",
"return",
"ToResultReg",
".",
"getNode",
"(",
")",
";",
"}",
"}",
"SmallVector",
"<",
"SDValue",
",",
"8",
">",
"Ops",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Node",
"->",
"getNumOperands",
"(",
")",
";",
"++",
"i",
")",
"{",
"if",
"(",
"!",
"isFrameIndexOp",
"(",
"Node",
"->",
"getOperand",
"(",
"i",
")",
")",
")",
"{",
"Ops",
".",
"push_back",
"(",
"Node",
"->",
"getOperand",
"(",
"i",
")",
")",
";",
"continue",
";",
"}",
"SDLoc",
"DL",
"(",
"Node",
")",
";",
"Ops",
".",
"push_back",
"(",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"AMDGPU",
"::",
"S_MOV_B32",
",",
"DL",
",",
"Node",
"->",
"getOperand",
"(",
"i",
")",
".",
"getValueType",
"(",
")",
",",
"Node",
"->",
"getOperand",
"(",
"i",
")",
")",
",",
"0",
")",
")",
";",
"}",
"return",
"DAG",
".",
"UpdateNodeOperands",
"(",
"Node",
",",
"Ops",
")",
";",
"}",
"</s>"
] | [
"Legalize",
"target",
"independent",
"instructions",
"(",
"e.g",
"."
] | [
"AMDGPU",
"SI",
"ISD::CopyToReg",
"1",
"2",
"MVT::i1",
"AMDGPU::VReg_1RegClass",
"MVT::i1",
"0",
"1",
"0",
"0",
"1",
"8",
"0",
"AMDGPU::S_MOV_B32",
"0"
] | SIISelLowering106 | legalizeTargetIndependentNode | AMDGPU | GPU | LLVM | 19,247 | 340 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_regs_ever_clobbered",
"(",
"int",
"*",
"regs_ever_clobbered",
")",
"{",
"basic_block",
"cur_bb",
";",
"rtx",
"cur_insn",
";",
"unsigned",
"int",
"i",
";",
"memset",
"(",
"regs_ever_clobbered",
",",
"0",
",",
"16",
"*",
"sizeof",
"(",
"int",
")",
")",
";",
"if",
"(",
"!",
"current_function_is_leaf",
")",
"{",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"16",
";",
"i",
"++",
")",
"regs_ever_clobbered",
"[",
"i",
"]",
"=",
"call_really_used_regs",
"[",
"i",
"]",
";",
"}",
"if",
"(",
"current_function_calls_eh_return",
"||",
"cfun",
"->",
"machine",
"->",
"has_landing_pad_p",
")",
"for",
"(",
"i",
"=",
"0",
";",
"EH_RETURN_DATA_REGNO",
"(",
"i",
")",
"!=",
"INVALID_REGNUM",
";",
"i",
"++",
")",
"if",
"(",
"current_function_calls_eh_return",
"||",
"(",
"cfun",
"->",
"machine",
"->",
"has_landing_pad_p",
"&&",
"regs_ever_live",
"[",
"EH_RETURN_DATA_REGNO",
"(",
"i",
")",
"]",
")",
")",
"regs_ever_clobbered",
"[",
"EH_RETURN_DATA_REGNO",
"(",
"i",
")",
"]",
"=",
"1",
";",
"if",
"(",
"current_function_has_nonlocal_label",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"16",
";",
"i",
"++",
")",
"if",
"(",
"!",
"call_really_used_regs",
"[",
"i",
"]",
")",
"regs_ever_clobbered",
"[",
"i",
"]",
"=",
"1",
";",
"FOR_EACH_BB",
"(",
"cur_bb",
")",
"{",
"FOR_BB_INSNS",
"(",
"cur_bb",
",",
"cur_insn",
")",
"{",
"if",
"(",
"INSN_P",
"(",
"cur_insn",
")",
")",
"note_stores",
"(",
"PATTERN",
"(",
"cur_insn",
")",
",",
"s390_reg_clobbered_rtx",
",",
"regs_ever_clobbered",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Walks",
"through",
"all",
"basic",
"blocks",
"of",
"the",
"current",
"function",
"looking",
"for",
"clobbered",
"hard",
"regs",
"using",
"s390_reg_clobbered_rtx",
".",
"The",
"fields",
"of",
"the",
"passed",
"integer",
"array",
"REGS_EVER_CLOBBERED",
"are",
"set",
"to",
"one",
"for",
"each",
"of",
"those",
"regs",
"."
] | [
"s390",
"0",
"16",
"0",
"16",
"0",
"1",
"0",
"16",
"1"
] | s3903 | s390_regs_ever_clobbered | s390 | MPU | GCC | 19,248 | 185 | 1 | [] |
[
"<s>",
"bool",
"SIRegisterInfo",
"::",
"isFrameOffsetLegal",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"Register",
"BaseReg",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"if",
"(",
"!",
"SIInstrInfo",
"::",
"isMUBUF",
"(",
"*",
"MI",
")",
"&&",
"!",
"!",
"SIInstrInfo",
"::",
"isFLATScratch",
"(",
"*",
"MI",
")",
")",
"return",
"false",
";",
"int64_t",
"NewOffset",
"=",
"Offset",
"+",
"getScratchInstrOffset",
"(",
"MI",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isMUBUF",
"(",
"*",
"MI",
")",
")",
"return",
"SIInstrInfo",
"::",
"isLegalMUBUFImmOffset",
"(",
"NewOffset",
")",
";",
"const",
"SIInstrInfo",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"return",
"TII",
"->",
"isLegalFLATOffset",
"(",
"NewOffset",
",",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"a",
"given",
"base",
"register",
"plus",
"offset",
"immediate",
"is",
"encodable",
"to",
"resolve",
"a",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"AMDGPU"
] | SIRegisterInfo113 | isFrameOffsetLegal | AMDGPU | GPU | LLVM | 19,249 | 96 | 1 | [] |
[
"<s>",
"static",
"int",
"thumb2_legitimate_index_p",
"(",
"machine_mode",
"mode",
",",
"rtx",
"index",
",",
"int",
"strict_p",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"index",
")",
";",
"if",
"(",
"TARGET_HARD_FLOAT",
"&&",
"(",
"mode",
"==",
"SFmode",
"||",
"mode",
"==",
"DFmode",
")",
")",
"return",
"(",
"code",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"index",
")",
"<",
"1024",
"&&",
"INTVAL",
"(",
"index",
")",
">",
"-",
"256",
"&&",
"(",
"INTVAL",
"(",
"index",
")",
"&",
"3",
")",
"==",
"0",
")",
";",
"if",
"(",
"TARGET_REALLY_IWMMXT",
"&&",
"VALID_IWMMXT_REG_MODE",
"(",
"mode",
")",
")",
"{",
"if",
"(",
"!",
"TARGET_LDRD",
"||",
"mode",
"!=",
"DImode",
")",
"return",
"(",
"code",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"index",
")",
"<",
"1024",
"&&",
"INTVAL",
"(",
"index",
")",
">",
"-",
"1024",
"&&",
"(",
"INTVAL",
"(",
"index",
")",
"&",
"3",
")",
"==",
"0",
")",
";",
"}",
"if",
"(",
"TARGET_NEON",
"&&",
"VALID_NEON_QREG_MODE",
"(",
"mode",
")",
")",
"return",
"(",
"code",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"index",
")",
"<",
"1016",
"&&",
"INTVAL",
"(",
"index",
")",
">",
"-",
"1024",
"&&",
"(",
"INTVAL",
"(",
"index",
")",
"&",
"3",
")",
"==",
"0",
")",
";",
"if",
"(",
"TARGET_NEON",
"&&",
"VALID_NEON_DREG_MODE",
"(",
"mode",
")",
")",
"return",
"(",
"code",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"index",
")",
"<",
"1024",
"&&",
"INTVAL",
"(",
"index",
")",
">",
"-",
"1024",
"&&",
"(",
"INTVAL",
"(",
"index",
")",
"&",
"3",
")",
"==",
"0",
")",
";",
"if",
"(",
"arm_address_register_rtx_p",
"(",
"index",
",",
"strict_p",
")",
"&&",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"4",
")",
")",
"return",
"1",
";",
"if",
"(",
"mode",
"==",
"DImode",
"||",
"mode",
"==",
"DFmode",
")",
"{",
"if",
"(",
"code",
"==",
"CONST_INT",
")",
"{",
"HOST_WIDE_INT",
"val",
"=",
"INTVAL",
"(",
"index",
")",
";",
"return",
"val",
">",
"-",
"256",
"&&",
"val",
"<",
"256",
"&&",
"(",
"val",
"&",
"3",
")",
"==",
"0",
";",
"}",
"else",
"return",
"0",
";",
"}",
"if",
"(",
"code",
"==",
"MULT",
")",
"{",
"rtx",
"xiop0",
"=",
"XEXP",
"(",
"index",
",",
"0",
")",
";",
"rtx",
"xiop1",
"=",
"XEXP",
"(",
"index",
",",
"1",
")",
";",
"return",
"(",
"(",
"arm_address_register_rtx_p",
"(",
"xiop0",
",",
"strict_p",
")",
"&&",
"thumb2_index_mul_operand",
"(",
"xiop1",
")",
")",
"||",
"(",
"arm_address_register_rtx_p",
"(",
"xiop1",
",",
"strict_p",
")",
"&&",
"thumb2_index_mul_operand",
"(",
"xiop0",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"code",
"==",
"ASHIFT",
")",
"{",
"rtx",
"op",
"=",
"XEXP",
"(",
"index",
",",
"1",
")",
";",
"return",
"(",
"arm_address_register_rtx_p",
"(",
"XEXP",
"(",
"index",
",",
"0",
")",
",",
"strict_p",
")",
"&&",
"CONST_INT_P",
"(",
"op",
")",
"&&",
"INTVAL",
"(",
"op",
")",
">",
"0",
"&&",
"INTVAL",
"(",
"op",
")",
"<=",
"3",
")",
";",
"}",
"return",
"(",
"code",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"index",
")",
"<",
"4096",
"&&",
"INTVAL",
"(",
"index",
")",
">",
"-",
"256",
")",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"INDEX",
"is",
"a",
"valid",
"Thumb-2",
"address",
"index",
"operand",
"."
] | [
"arm",
"1024",
"256",
"3",
"0",
"1024",
"1024",
"3",
"0",
"1016",
"1024",
"3",
"0",
"1024",
"1024",
"3",
"0",
"4",
"1",
"256",
"256",
"3",
"0",
"0",
"0",
"1",
"1",
"0",
"0",
"3",
"4096",
"256"
] | arm6 | thumb2_legitimate_index_p | arm | CPU | GCC | 19,250 | 413 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"AFI",
"->",
"getGlobalBaseReg",
"(",
")",
"==",
"0",
")",
"return",
"false",
";",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"STI",
".",
"isThumb1Only",
"(",
")",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"MF",
".",
"getTarget",
"(",
")",
";",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"PIC_",
")",
"return",
"false",
";",
"LLVMContext",
"*",
"Context",
"=",
"&",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"unsigned",
"ARMPCLabelIndex",
"=",
"AFI",
"->",
"createPICLabelUId",
"(",
")",
";",
"unsigned",
"PCAdj",
"=",
"STI",
".",
"isThumb",
"(",
")",
"?",
"4",
":",
"8",
";",
"ARMConstantPoolValue",
"*",
"CPV",
"=",
"ARMConstantPoolSymbol",
"::",
"Create",
"(",
"*",
"Context",
",",
"\"_GLOBAL_OFFSET_TABLE_\"",
",",
"ARMPCLabelIndex",
",",
"PCAdj",
")",
";",
"unsigned",
"Align",
"=",
"TM",
".",
"getDataLayout",
"(",
")",
"->",
"getPrefTypeAlignment",
"(",
"Type",
"::",
"getInt32PtrTy",
"(",
"*",
"Context",
")",
")",
";",
"unsigned",
"Idx",
"=",
"MF",
".",
"getConstantPool",
"(",
")",
"->",
"getConstantPoolIndex",
"(",
"CPV",
",",
"Align",
")",
";",
"MachineBasicBlock",
"&",
"FirstMBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"FirstMBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"FirstMBB",
".",
"findDebugLoc",
"(",
"MBBI",
")",
";",
"unsigned",
"TempReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"&",
"ARM",
"::",
"rGPRRegClass",
")",
";",
"unsigned",
"Opc",
"=",
"STI",
".",
"isThumb2",
"(",
")",
"?",
"ARM",
"::",
"t2LDRpci",
":",
"ARM",
"::",
"LDRcp",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"TempReg",
")",
".",
"addConstantPoolIndex",
"(",
"Idx",
")",
";",
"if",
"(",
"Opc",
"==",
"ARM",
"::",
"LDRcp",
")",
"MIB",
".",
"addImm",
"(",
"0",
")",
";",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"unsigned",
"GlobalBaseReg",
"=",
"AFI",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"Opc",
"=",
"STI",
".",
"isThumb2",
"(",
")",
"?",
"ARM",
"::",
"tPICADD",
":",
"ARM",
"::",
"PICADD",
";",
"MIB",
"=",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"GlobalBaseReg",
")",
".",
"addReg",
"(",
"TempReg",
")",
".",
"addImm",
"(",
"ARMPCLabelIndex",
")",
";",
"if",
"(",
"Opc",
"==",
"ARM",
"::",
"PICADD",
")",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"0",
"ARM",
"ARM",
"ARM",
"4",
"8",
"ARM",
"ARM",
"\"_GLOBAL_OFFSET_TABLE_\"",
"ARM",
"ARM::rGPRRegClass",
"ARM::t2LDRpci",
"ARM::LDRcp",
"ARM::LDRcp",
"0",
"ARM::tPICADD",
"ARM::PICADD",
"ARM",
"ARM::PICADD"
] | ARMInstrInfo30 | runOnMachineFunction | ARM | CPU | LLVM | 19,251 | 377 | 1 | [] |
[
"<s>",
"static",
"bool",
"csky_return_in_memory",
"(",
"const_tree",
"type",
",",
"const_tree",
"fntype",
"ATTRIBUTE_UNUSED",
")",
"{",
"const",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"return",
"(",
"size",
"==",
"-",
"1",
"||",
"size",
">",
"2",
"*",
"UNITS_PER_WORD",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_RETURN_IN_MEMORY",
"to",
"decide",
"whether",
"TYPE",
"should",
"be",
"returned",
"in",
"memory",
"(",
"true",
")",
"or",
"in",
"a",
"register",
"(",
"false",
")",
".",
"FNTYPE",
"is",
"the",
"type",
"of",
"the",
"function",
"making",
"the",
"call",
"."
] | [
"csky",
"1",
"2"
] | csky | csky_return_in_memory | csky | CPU | GCC | 19,252 | 36 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"ConstraintType",
"mprocTargetLowering",
"::",
"getConstraintType",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"return",
"C_RegisterClass",
";",
"default",
":",
"break",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getConstraintType",
"(",
"Constraint",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constraint",
"letter",
",",
"return",
"the",
"type",
"of",
"constraint",
"for",
"this",
"target",
"."
] | [
"mproc",
"mproc",
"1",
"0"
] | mprocISelLowering | getConstraintType | mproc | Virtual ISA | LLVM | 19,253 | 56 | 1 | [] |
[
"<s>",
"void",
"F2003fMCAsmStreamer",
"::",
"emitRawComment",
"(",
"const",
"Twine",
"&",
"T",
",",
"bool",
"TabPrefix",
")",
"{",
"OS",
"<<",
"MAI",
"->",
"getCommentString",
"(",
")",
"<<",
"T",
";",
"EmitEOL",
"(",
")",
";",
"}",
"</s>"
] | [
"Print",
"T",
"and",
"prefix",
"it",
"with",
"the",
"comment",
"string",
"(",
"normally",
"#",
")",
"and",
"optionally",
"a",
"tab",
"."
] | [
"F2003f",
"F2003f"
] | F2003fMCAsmStreamer | emitRawComment | F2003f | CPU | LLVM | 19,254 | 29 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"SIInstrInfo",
"::",
"getOpRegClass",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"OpNo",
")",
"const",
"{",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"MI",
".",
"isVariadic",
"(",
")",
"||",
"OpNo",
">=",
"Desc",
".",
"getNumOperands",
"(",
")",
"||",
"Desc",
".",
"OpInfo",
"[",
"OpNo",
"]",
".",
"RegClass",
"==",
"-",
"1",
")",
"{",
"Register",
"Reg",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
".",
"isVirtual",
"(",
")",
")",
"return",
"MRI",
".",
"getRegClass",
"(",
"Reg",
")",
";",
"return",
"RI",
".",
"getPhysRegClass",
"(",
"Reg",
")",
";",
"}",
"unsigned",
"RCID",
"=",
"Desc",
".",
"OpInfo",
"[",
"OpNo",
"]",
".",
"RegClass",
";",
"return",
"adjustAllocatableRegClass",
"(",
"ST",
",",
"RI",
",",
"MRI",
",",
"Desc",
",",
"RCID",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"correct",
"register",
"class",
"for",
"OpNo",
"."
] | [
"AMDGPU",
"SI",
"1"
] | SIInstrInfo11 | getOpRegClass | AMDGPU | GPU | LLVM | 19,255 | 147 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"const",
"TargetRegisterClass",
"*",
",",
"uint8_t",
">",
"HexagonTargetLowering",
"::",
"findRepresentativeClass",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"MVT",
"VT",
")",
"const",
"{",
"const",
"TargetRegisterClass",
"*",
"RRC",
"=",
"nullptr",
";",
"uint8_t",
"Cost",
"=",
"1",
";",
"switch",
"(",
"VT",
".",
"SimpleTy",
")",
"{",
"default",
":",
"return",
"TargetLowering",
"::",
"findRepresentativeClass",
"(",
"TRI",
",",
"VT",
")",
";",
"case",
"MVT",
"::",
"v64i8",
":",
"case",
"MVT",
"::",
"v32i16",
":",
"case",
"MVT",
"::",
"v16i32",
":",
"RRC",
"=",
"&",
"Hexagon",
"::",
"HvxVRRegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"v128i8",
":",
"case",
"MVT",
"::",
"v64i16",
":",
"case",
"MVT",
"::",
"v32i32",
":",
"if",
"(",
"Subtarget",
".",
"hasV60TOps",
"(",
")",
"&&",
"Subtarget",
".",
"useHVXOps",
"(",
")",
"&&",
"Subtarget",
".",
"useHVX128BOps",
"(",
")",
")",
"RRC",
"=",
"&",
"Hexagon",
"::",
"HvxVRRegClass",
";",
"else",
"RRC",
"=",
"&",
"Hexagon",
"::",
"HvxWRRegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"v256i8",
":",
"case",
"MVT",
"::",
"v128i16",
":",
"case",
"MVT",
"::",
"v64i32",
":",
"RRC",
"=",
"&",
"Hexagon",
"::",
"HvxWRRegClass",
";",
"break",
";",
"}",
"return",
"std",
"::",
"make_pair",
"(",
"RRC",
",",
"Cost",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"largest",
"legal",
"super-reg",
"register",
"class",
"of",
"the",
"register",
"class",
"for",
"the",
"specified",
"type",
"and",
"its",
"associated",
"``",
"cost",
"''",
"."
] | [
"Hexagon",
"Hexagon",
"1",
"MVT::v64i8",
"MVT::v32i16",
"MVT::v16i32",
"Hexagon::HvxVRRegClass",
"MVT::v128i8",
"MVT::v64i16",
"MVT::v32i32",
"Hexagon::HvxVRRegClass",
"Hexagon::HvxWRRegClass",
"MVT::v256i8",
"MVT::v128i16",
"MVT::v64i32",
"Hexagon::HvxWRRegClass"
] | HexagonISelLowering (2)1 | findRepresentativeClass | Hexagon | DSP | LLVM | 19,256 | 167 | 1 | [] |
[
"<s>",
"bool",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"unsigned",
"ConstraintID",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"override",
"{",
"switch",
"(",
"ConstraintID",
")",
"{",
"default",
":",
"errs",
"(",
")",
"<<",
"\"ConstraintID: \"",
"<<",
"ConstraintID",
"<<",
"\"\\n\"",
";",
"llvm_unreachable",
"(",
"\"Unexpected asm memory constraint\"",
")",
";",
"case",
"InlineAsm",
"::",
"Constraint_es",
":",
"case",
"InlineAsm",
"::",
"Constraint_m",
":",
"case",
"InlineAsm",
"::",
"Constraint_o",
":",
"case",
"InlineAsm",
"::",
"Constraint_Q",
":",
"case",
"InlineAsm",
"::",
"Constraint_Z",
":",
"case",
"InlineAsm",
"::",
"Constraint_Zy",
":",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"TRC",
"=",
"TRI",
"->",
"getPointerRegClass",
"(",
"*",
"MF",
",",
"1",
")",
";",
"SDLoc",
"dl",
"(",
"Op",
")",
";",
"SDValue",
"RC",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"TRC",
"->",
"getID",
"(",
")",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"NewOp",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"TargetOpcode",
"::",
"COPY_TO_REGCLASS",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
",",
"RC",
")",
",",
"0",
")",
";",
"OutOps",
".",
"push_back",
"(",
"NewOp",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"PowerPC",
"\"ConstraintID: \"",
"\"\\n\"",
"\"Unexpected asm memory constraint\"",
"1",
"MVT::i32",
"0"
] | PPCISelDAGToDAG1 | SelectInlineAsmMemoryOperand | PowerPC | CPU | LLVM | 19,257 | 170 | 1 | [] |
[
"<s>",
"static",
"rtx_insn",
"*",
"alphaev5_next_group",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"*",
"pin_use",
",",
"int",
"*",
"plen",
")",
"{",
"int",
"len",
",",
"in_use",
";",
"len",
"=",
"in_use",
"=",
"0",
";",
"if",
"(",
"!",
"INSN_P",
"(",
"insn",
")",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"CLOBBER",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"USE",
")",
"goto",
"next_and_done",
";",
"while",
"(",
"1",
")",
"{",
"enum",
"alphaev5_pipe",
"pipe",
";",
"pipe",
"=",
"alphaev5_insn_pipe",
"(",
"insn",
")",
";",
"switch",
"(",
"pipe",
")",
"{",
"case",
"EV5_STOP",
":",
"if",
"(",
"in_use",
")",
"goto",
"done",
";",
"if",
"(",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"len",
"=",
"-",
"1",
";",
"else",
"len",
"=",
"get_attr_length",
"(",
"insn",
")",
";",
"goto",
"next_and_done",
";",
"case",
"EV5_E01",
":",
"if",
"(",
"in_use",
"&",
"EV5_E0",
")",
"{",
"if",
"(",
"in_use",
"&",
"EV5_E1",
")",
"goto",
"done",
";",
"in_use",
"|=",
"EV5_E1",
";",
"}",
"else",
"in_use",
"|=",
"EV5_E0",
"|",
"EV5_E01",
";",
"break",
";",
"case",
"EV5_E0",
":",
"if",
"(",
"in_use",
"&",
"EV5_E0",
")",
"{",
"if",
"(",
"!",
"(",
"in_use",
"&",
"EV5_E01",
")",
"||",
"(",
"in_use",
"&",
"EV5_E1",
")",
")",
"goto",
"done",
";",
"in_use",
"|=",
"EV5_E1",
";",
"}",
"in_use",
"|=",
"EV5_E0",
";",
"break",
";",
"case",
"EV5_E1",
":",
"if",
"(",
"in_use",
"&",
"EV5_E1",
")",
"goto",
"done",
";",
"in_use",
"|=",
"EV5_E1",
";",
"break",
";",
"case",
"EV5_FAM",
":",
"if",
"(",
"in_use",
"&",
"EV5_FA",
")",
"{",
"if",
"(",
"in_use",
"&",
"EV5_FM",
")",
"goto",
"done",
";",
"in_use",
"|=",
"EV5_FM",
";",
"}",
"else",
"in_use",
"|=",
"EV5_FA",
"|",
"EV5_FAM",
";",
"break",
";",
"case",
"EV5_FA",
":",
"if",
"(",
"in_use",
"&",
"EV5_FA",
")",
"goto",
"done",
";",
"in_use",
"|=",
"EV5_FA",
";",
"break",
";",
"case",
"EV5_FM",
":",
"if",
"(",
"in_use",
"&",
"EV5_FM",
")",
"goto",
"done",
";",
"in_use",
"|=",
"EV5_FM",
";",
"break",
";",
"case",
"EV5_NONE",
":",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"len",
"+=",
"4",
";",
"if",
"(",
"JUMP_P",
"(",
"insn",
")",
")",
"goto",
"next_and_done",
";",
"next",
":",
"insn",
"=",
"next_nonnote_insn",
"(",
"insn",
")",
";",
"if",
"(",
"!",
"insn",
"||",
"!",
"INSN_P",
"(",
"insn",
")",
")",
"goto",
"done",
";",
"if",
"(",
"GET_MODE",
"(",
"insn",
")",
"==",
"TImode",
")",
"goto",
"done",
";",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"CLOBBER",
"||",
"GET_CODE",
"(",
"insn",
")",
"==",
"USE",
")",
"goto",
"next",
";",
"}",
"next_and_done",
":",
"insn",
"=",
"next_nonnote_insn",
"(",
"insn",
")",
";",
"done",
":",
"*",
"plen",
"=",
"len",
";",
"*",
"pin_use",
"=",
"in_use",
";",
"return",
"insn",
";",
"}",
"</s>"
] | [
"IN_USE",
"is",
"a",
"mask",
"of",
"the",
"slots",
"currently",
"filled",
"within",
"the",
"insn",
"group",
".",
"The",
"mask",
"bits",
"come",
"from",
"alphaev5_pipe",
"above",
".",
"If",
"EV5_E01",
"is",
"set",
",",
"then",
"the",
"insn",
"in",
"EV5_E0",
"can",
"be",
"swapped",
"by",
"the",
"hardware",
"into",
"EV5_E1",
".",
"LEN",
"is",
",",
"of",
"course",
",",
"the",
"length",
"of",
"the",
"group",
"in",
"bytes",
"."
] | [
"alpha",
"0",
"1",
"0",
"1",
"4"
] | alpha | alphaev5_next_group | alpha | MPU | GCC | 19,258 | 381 | 1 | [] |
[
"<s>",
"int",
"cris_cfun_uses_pic_table",
"(",
")",
"{",
"return",
"current_function_uses_pic_offset_table",
";",
"}",
"</s>"
] | [
"Return",
"current_function_uses_pic_offset_table",
".",
"For",
"use",
"in",
"cris.md",
",",
"since",
"some",
"generated",
"files",
"do",
"not",
"include",
"function.h",
"."
] | [
"cris"
] | cris2 | cris_cfun_uses_pic_table | cris | MPU | GCC | 19,259 | 9 | 1 | [] |
[
"<s>",
"bool",
"TPCIndexMap",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"p_func",
"=",
"&",
"F",
";",
"p_SE",
"=",
"&",
"getAnalysis",
"<",
"ScalarEvolutionWrapperPass",
">",
"(",
")",
".",
"getSE",
"(",
")",
";",
"p_LI",
"=",
"&",
"getAnalysis",
"<",
"LoopInfoWrapperPass",
">",
"(",
")",
".",
"getLoopInfo",
"(",
")",
";",
"collectDataLoop",
"(",
"F",
",",
"p_SE",
",",
"p_LI",
")",
";",
"sort",
"(",
")",
";",
"print_data",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"TPC",
"TPC"
] | TPCIndexSpace | runOnFunction | TPC | Virtual ISA | LLVM | 19,260 | 64 | 1 | [] |
[
"<s>",
"virtual",
"MVT",
"getScalarShiftAmountTy",
"(",
"EVT",
"LHSTy",
")",
"const",
"{",
"return",
"MVT",
"::",
"i8",
";",
"}",
"</s>"
] | [
"Return",
"the",
"type",
"to",
"use",
"for",
"a",
"scalar",
"shift",
"opcode",
",",
"given",
"the",
"shifted",
"amount",
"type",
"."
] | [
"GBZ80",
"MVT::i8"
] | GBZ80ISelLowering (2) | getScalarShiftAmountTy | GBZ80 | MPU | LLVM | 19,261 | 15 | 1 | [] |
[
"<s>",
"void",
"NyuziInstPrinter",
"::",
"printRegName",
"(",
"raw_ostream",
"&",
"OS",
",",
"unsigned",
"RegNo",
")",
"const",
"{",
"OS",
"<<",
"StringRef",
"(",
"getRegisterName",
"(",
"RegNo",
")",
")",
".",
"lower",
"(",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"assembler",
"register",
"name",
"."
] | [
"Nyuzi",
"Nyuzi"
] | NyuziInstPrinter | printRegName | Nyuzi | GPU | LLVM | 19,262 | 29 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SI Type Rewriter\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU",
"\"SI Type Rewriter\""
] | SITypeRewriter4 | getPassName | AMDGPU | GPU | LLVM | 19,263 | 11 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"*",
"PIC16TargetLowering",
"::",
"EmitInstrWithCustomInserter",
"(",
"MachineInstr",
"*",
"MI",
",",
"MachineBasicBlock",
"*",
"BB",
")",
"const",
"{",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"getTargetMachine",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"unsigned",
"CC",
"=",
"(",
"PIC16CC",
"::",
"CondCodes",
")",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"const",
"BasicBlock",
"*",
"LLVM_BB",
"=",
"BB",
"->",
"getBasicBlock",
"(",
")",
";",
"MachineFunction",
"::",
"iterator",
"It",
"=",
"BB",
";",
"++",
"It",
";",
"MachineBasicBlock",
"*",
"thisMBB",
"=",
"BB",
";",
"MachineFunction",
"*",
"F",
"=",
"BB",
"->",
"getParent",
"(",
")",
";",
"MachineBasicBlock",
"*",
"copy0MBB",
"=",
"F",
"->",
"CreateMachineBasicBlock",
"(",
"LLVM_BB",
")",
";",
"MachineBasicBlock",
"*",
"sinkMBB",
"=",
"F",
"->",
"CreateMachineBasicBlock",
"(",
"LLVM_BB",
")",
";",
"BuildMI",
"(",
"BB",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"PIC16",
"::",
"pic16brcond",
")",
")",
".",
"addMBB",
"(",
"sinkMBB",
")",
".",
"addImm",
"(",
"CC",
")",
";",
"F",
"->",
"insert",
"(",
"It",
",",
"copy0MBB",
")",
";",
"F",
"->",
"insert",
"(",
"It",
",",
"sinkMBB",
")",
";",
"sinkMBB",
"->",
"transferSuccessors",
"(",
"BB",
")",
";",
"BB",
"->",
"addSuccessor",
"(",
"copy0MBB",
")",
";",
"BB",
"->",
"addSuccessor",
"(",
"sinkMBB",
")",
";",
"BB",
"=",
"copy0MBB",
";",
"BB",
"->",
"addSuccessor",
"(",
"sinkMBB",
")",
";",
"BB",
"=",
"sinkMBB",
";",
"BuildMI",
"(",
"BB",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"PIC16",
"::",
"PHI",
")",
",",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
")",
".",
"addMBB",
"(",
"copy0MBB",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
")",
".",
"addMBB",
"(",
"thisMBB",
")",
";",
"F",
"->",
"DeleteMachineInstr",
"(",
"MI",
")",
";",
"return",
"BB",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"be",
"implemented",
"by",
"targets",
"that",
"mark",
"instructions",
"with",
"the",
"'usesCustomInserter",
"'",
"flag",
"."
] | [
"PIC16",
"PIC16",
"PIC16CC::CondCodes",
"3",
"PIC16::pic16brcond",
"PIC16::PHI",
"0",
"2",
"1"
] | PIC16ISelLowering2 | EmitInstrWithCustomInserter | PIC16 | MPU | LLVM | 19,264 | 273 | 1 | [] |
[
"<s>",
"static",
"enum",
"machine_mode",
"rs6000_eh_return_filter_mode",
"(",
"void",
")",
"{",
"return",
"TARGET_32BIT",
"?",
"SImode",
":",
"word_mode",
";",
"}",
"</s>"
] | [
"target",
"hook",
"eh_return_filter_mode"
] | [
"rs6000"
] | rs60003 | rs6000_eh_return_filter_mode | rs6000 | CPU | GCC | 19,265 | 16 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"type_natural_mode",
"(",
"const_tree",
"type",
",",
"const",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"bool",
"in_return",
")",
"{",
"machine_mode",
"mode",
"=",
"TYPE_MODE",
"(",
"type",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"VECTOR_TYPE",
"&&",
"!",
"VECTOR_MODE_P",
"(",
"mode",
")",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"if",
"(",
"(",
"size",
"==",
"8",
"||",
"size",
"==",
"16",
"||",
"size",
"==",
"32",
"||",
"size",
"==",
"64",
")",
"&&",
"TYPE_VECTOR_SUBPARTS",
"(",
"type",
")",
">",
"1",
")",
"{",
"machine_mode",
"innermode",
"=",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
";",
"if",
"(",
"innermode",
"==",
"XFmode",
")",
"return",
"mode",
";",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
"==",
"REAL_TYPE",
")",
"mode",
"=",
"MIN_MODE_VECTOR_FLOAT",
";",
"else",
"mode",
"=",
"MIN_MODE_VECTOR_INT",
";",
"for",
"(",
";",
"mode",
"!=",
"VOIDmode",
";",
"mode",
"=",
"GET_MODE_WIDER_MODE",
"(",
"mode",
")",
")",
"if",
"(",
"GET_MODE_NUNITS",
"(",
"mode",
")",
"==",
"TYPE_VECTOR_SUBPARTS",
"(",
"type",
")",
"&&",
"GET_MODE_INNER",
"(",
"mode",
")",
"==",
"innermode",
")",
"{",
"if",
"(",
"size",
"==",
"64",
"&&",
"!",
"TARGET_AVX512F",
"&&",
"!",
"TARGET_IAMCU",
")",
"{",
"static",
"bool",
"warnedavx512f",
";",
"static",
"bool",
"warnedavx512f_ret",
";",
"if",
"(",
"cum",
"&&",
"cum",
"->",
"warn_avx512f",
"&&",
"!",
"warnedavx512f",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"AVX512F vector argument \"",
"\"without AVX512F enabled changes the ABI\"",
")",
")",
"warnedavx512f",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"in_return",
"&&",
"!",
"warnedavx512f_ret",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"AVX512F vector return \"",
"\"without AVX512F enabled changes the ABI\"",
")",
")",
"warnedavx512f_ret",
"=",
"true",
";",
"}",
"return",
"TYPE_MODE",
"(",
"type",
")",
";",
"}",
"else",
"if",
"(",
"size",
"==",
"32",
"&&",
"!",
"TARGET_AVX",
"&&",
"!",
"TARGET_IAMCU",
")",
"{",
"static",
"bool",
"warnedavx",
";",
"static",
"bool",
"warnedavx_ret",
";",
"if",
"(",
"cum",
"&&",
"cum",
"->",
"warn_avx",
"&&",
"!",
"warnedavx",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"AVX vector argument \"",
"\"without AVX enabled changes the ABI\"",
")",
")",
"warnedavx",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"in_return",
"&&",
"!",
"warnedavx_ret",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"AVX vector return \"",
"\"without AVX enabled changes the ABI\"",
")",
")",
"warnedavx_ret",
"=",
"true",
";",
"}",
"return",
"TYPE_MODE",
"(",
"type",
")",
";",
"}",
"else",
"if",
"(",
"(",
"(",
"size",
"==",
"8",
"&&",
"TARGET_64BIT",
")",
"||",
"size",
"==",
"16",
")",
"&&",
"!",
"TARGET_SSE",
"&&",
"!",
"TARGET_IAMCU",
")",
"{",
"static",
"bool",
"warnedsse",
";",
"static",
"bool",
"warnedsse_ret",
";",
"if",
"(",
"cum",
"&&",
"cum",
"->",
"warn_sse",
"&&",
"!",
"warnedsse",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"SSE vector argument \"",
"\"without SSE enabled changes the ABI\"",
")",
")",
"warnedsse",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"!",
"TARGET_64BIT",
"&&",
"in_return",
"&&",
"!",
"warnedsse_ret",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"SSE vector return \"",
"\"without SSE enabled changes the ABI\"",
")",
")",
"warnedsse_ret",
"=",
"true",
";",
"}",
"}",
"else",
"if",
"(",
"(",
"size",
"==",
"8",
"&&",
"!",
"TARGET_64BIT",
")",
"&&",
"(",
"!",
"cfun",
"||",
"cfun",
"->",
"machine",
"->",
"func_type",
"==",
"TYPE_NORMAL",
")",
"&&",
"!",
"TARGET_MMX",
"&&",
"!",
"TARGET_IAMCU",
")",
"{",
"static",
"bool",
"warnedmmx",
";",
"static",
"bool",
"warnedmmx_ret",
";",
"if",
"(",
"cum",
"&&",
"cum",
"->",
"warn_mmx",
"&&",
"!",
"warnedmmx",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"MMX vector argument \"",
"\"without MMX enabled changes the ABI\"",
")",
")",
"warnedmmx",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"in_return",
"&&",
"!",
"warnedmmx_ret",
")",
"{",
"if",
"(",
"warning",
"(",
"OPT_Wpsabi",
",",
"\"MMX vector return \"",
"\"without MMX enabled changes the ABI\"",
")",
")",
"warnedmmx_ret",
"=",
"true",
";",
"}",
"}",
"return",
"mode",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"return",
"mode",
";",
"}",
"</s>"
] | [
"Return",
"the",
"``",
"natural",
"''",
"mode",
"for",
"TYPE",
".",
"In",
"most",
"cases",
",",
"this",
"is",
"just",
"TYPE_MODE",
".",
"But",
"in",
"the",
"case",
"of",
"vector",
"types",
",",
"it",
"is",
"some",
"vector",
"mode",
".",
"When",
"we",
"have",
"only",
"some",
"of",
"our",
"vector",
"isa",
"extensions",
"enabled",
",",
"then",
"there",
"are",
"some",
"modes",
"for",
"which",
"vector_mode_supported_p",
"is",
"false",
".",
"For",
"these",
"modes",
",",
"the",
"generic",
"vector",
"support",
"in",
"gcc",
"will",
"choose",
"some",
"non-vector",
"mode",
"in",
"order",
"to",
"implement",
"the",
"type",
".",
"By",
"computing",
"the",
"natural",
"mode",
",",
"we",
"'ll",
"select",
"the",
"proper",
"ABI",
"location",
"for",
"the",
"operand",
"and",
"not",
"depend",
"on",
"whatever",
"the",
"middle-end",
"decides",
"to",
"do",
"with",
"these",
"vector",
"types",
"."
] | [
"i386",
"8",
"16",
"32",
"64",
"1",
"64",
"\"AVX512F vector argument \"",
"\"without AVX512F enabled changes the ABI\"",
"\"AVX512F vector return \"",
"\"without AVX512F enabled changes the ABI\"",
"32",
"\"AVX vector argument \"",
"\"without AVX enabled changes the ABI\"",
"\"AVX vector return \"",
"\"without AVX enabled changes the ABI\"",
"8",
"16",
"\"SSE vector argument \"",
"\"without SSE enabled changes the ABI\"",
"\"SSE vector return \"",
"\"without SSE enabled changes the ABI\"",
"8",
"\"MMX vector argument \"",
"\"without MMX enabled changes the ABI\"",
"\"MMX vector return \"",
"\"without MMX enabled changes the ABI\""
] | i3866 | type_natural_mode | i386 | CPU | GCC | 19,266 | 503 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"Equivalent instruction substitution pass\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"Equivalent instruction substitution pass\""
] | EquivSubst | getPassName | X86 | CPU | LLVM | 19,267 | 13 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
",",
"unsigned",
"Align",
",",
"bool",
"*",
"IsFast",
")",
"const",
"{",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"false",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
"||",
"VT",
"==",
"MVT",
"::",
"Other",
")",
"return",
"false",
";",
"if",
"(",
"AddrSpace",
"==",
"AMDGPUAS",
"::",
"LOCAL_ADDRESS",
")",
"{",
"return",
"Align",
"%",
"4",
"==",
"0",
";",
"}",
"if",
"(",
"VT",
".",
"bitsLT",
"(",
"MVT",
"::",
"i32",
")",
")",
"return",
"false",
";",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"true",
";",
"return",
"VT",
".",
"bitsGT",
"(",
"MVT",
"::",
"i32",
")",
"&&",
"Align",
"%",
"4",
"==",
"0",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"AMDGPU",
"SI",
"MVT::Other",
"AMDGPU",
"4",
"0",
"MVT::i32",
"MVT::i32",
"4",
"0"
] | SIISelLowering100 | allowsMisalignedMemoryAccesses | AMDGPU | GPU | LLVM | 19,268 | 104 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"TII",
"=",
"static_cast",
"<",
"const",
"R600InstrInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"BB",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"BB_E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"BB",
"!=",
"BB_E",
";",
"++",
"BB",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"BB",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"CF_ALU",
")",
"continue",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"E",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"if",
"(",
"isALU",
"(",
"I",
")",
")",
"I",
"=",
"MakeALUClause",
"(",
"MBB",
",",
"I",
")",
";",
"else",
"++",
"I",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"R600"
] | R600EmitClauseMarkers1 | runOnMachineFunction | R600 | GPU | LLVM | 19,269 | 135 | 1 | [] |
[
"<s>",
"bool",
"LatticeCell",
"::",
"add",
"(",
"uint32_t",
"Property",
")",
"{",
"bool",
"Changed",
"=",
"convertToProperty",
"(",
")",
";",
"uint32_t",
"Ps",
"=",
"properties",
"(",
")",
";",
"if",
"(",
"Ps",
"==",
"(",
"Ps",
"&",
"Property",
")",
")",
"return",
"Changed",
";",
"Properties",
"=",
"Property",
"&",
"Ps",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Add",
"a",
"string",
"to",
"the",
"builder",
"."
] | [
"Hexagon"
] | HexagonConstPropagation | add | Hexagon | DSP | LLVM | 19,270 | 46 | 1 | [] |
[
"<s>",
"bool",
"AVRInstrInfo",
"::",
"reverseBranchCondition",
"(",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
")",
"const",
"{",
"assert",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"\"Invalid AVR branch condition!\"",
")",
";",
"AVRCC",
"::",
"CondCodes",
"CC",
"=",
"static_cast",
"<",
"AVRCC",
"::",
"CondCodes",
">",
"(",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
";",
"Cond",
"[",
"0",
"]",
".",
"setImm",
"(",
"getOppositeCondition",
"(",
"CC",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Reverses",
"the",
"branch",
"condition",
"of",
"the",
"specified",
"condition",
"list",
",",
"returning",
"false",
"on",
"success",
"and",
"true",
"if",
"it",
"can",
"not",
"be",
"reversed",
"."
] | [
"AVR",
"AVR",
"1",
"\"Invalid AVR branch condition!\"",
"AVRCC::CondCodes",
"AVRCC::CondCodes",
"0",
"0"
] | AVRInstrInfo | reverseBranchCondition | AVR | MPU | LLVM | 19,271 | 66 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m68k_delegitimize_address",
"(",
"rtx",
"orig_x",
")",
"{",
"rtx",
"x",
";",
"struct",
"m68k_address",
"addr",
";",
"rtx",
"unspec",
";",
"orig_x",
"=",
"delegitimize_mem_from_attrs",
"(",
"orig_x",
")",
";",
"x",
"=",
"orig_x",
";",
"if",
"(",
"MEM_P",
"(",
"x",
")",
")",
"x",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"!=",
"PLUS",
"||",
"GET_MODE",
"(",
"x",
")",
"!=",
"Pmode",
")",
"return",
"orig_x",
";",
"if",
"(",
"!",
"m68k_decompose_address",
"(",
"GET_MODE",
"(",
"x",
")",
",",
"x",
",",
"false",
",",
"&",
"addr",
")",
"||",
"addr",
".",
"offset",
"==",
"NULL_RTX",
"||",
"GET_CODE",
"(",
"addr",
".",
"offset",
")",
"!=",
"CONST",
")",
"return",
"orig_x",
";",
"unspec",
"=",
"XEXP",
"(",
"addr",
".",
"offset",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"unspec",
")",
"==",
"PLUS",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"unspec",
",",
"1",
")",
")",
")",
"unspec",
"=",
"XEXP",
"(",
"unspec",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"unspec",
")",
"!=",
"UNSPEC",
"||",
"(",
"XINT",
"(",
"unspec",
",",
"1",
")",
"!=",
"UNSPEC_RELOC16",
"&&",
"XINT",
"(",
"unspec",
",",
"1",
")",
"!=",
"UNSPEC_RELOC32",
")",
")",
"return",
"orig_x",
";",
"x",
"=",
"XVECEXP",
"(",
"unspec",
",",
"0",
",",
"0",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"LABEL_REF",
")",
";",
"if",
"(",
"unspec",
"!=",
"XEXP",
"(",
"addr",
".",
"offset",
",",
"0",
")",
")",
"x",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"x",
",",
"XEXP",
"(",
"XEXP",
"(",
"addr",
".",
"offset",
",",
"0",
")",
",",
"1",
")",
")",
";",
"if",
"(",
"addr",
".",
"index",
")",
"{",
"rtx",
"idx",
"=",
"addr",
".",
"index",
";",
"if",
"(",
"addr",
".",
"scale",
"!=",
"1",
")",
"idx",
"=",
"gen_rtx_MULT",
"(",
"Pmode",
",",
"idx",
",",
"GEN_INT",
"(",
"addr",
".",
"scale",
")",
")",
";",
"x",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"idx",
",",
"x",
")",
";",
"}",
"if",
"(",
"addr",
".",
"base",
")",
"x",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"addr",
".",
"base",
",",
"x",
")",
";",
"if",
"(",
"MEM_P",
"(",
"orig_x",
")",
")",
"x",
"=",
"replace_equiv_address_nv",
"(",
"orig_x",
",",
"x",
")",
";",
"return",
"x",
";",
"}",
"</s>"
] | [
"In",
"the",
"name",
"of",
"slightly",
"smaller",
"debug",
"output",
",",
"and",
"to",
"cater",
"to",
"general",
"assembler",
"lossage",
",",
"recognize",
"various",
"UNSPEC",
"sequences",
"and",
"turn",
"them",
"back",
"into",
"a",
"direct",
"symbol",
"reference",
"."
] | [
"m68k",
"0",
"0",
"1",
"0",
"1",
"1",
"0",
"0",
"0",
"0",
"1",
"1"
] | m68k | m68k_delegitimize_address | m68k | MPU | GCC | 19,272 | 324 | 1 | [] |
[
"<s>",
"int",
"m32c_cannot_change_mode_class",
"(",
"enum",
"machine_mode",
"from",
",",
"enum",
"machine_mode",
"to",
",",
"int",
"rclass",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"cannot change from %s to %s in %s\\n\"",
",",
"mode_name",
"[",
"from",
"]",
",",
"mode_name",
"[",
"to",
"]",
",",
"class_names",
"[",
"rclass",
"]",
")",
";",
"if",
"(",
"to",
"==",
"QImode",
")",
"return",
"(",
"class_contents",
"[",
"rclass",
"]",
"[",
"0",
"]",
"&",
"0x1ffa",
")",
";",
"if",
"(",
"class_contents",
"[",
"rclass",
"]",
"[",
"0",
"]",
"&",
"0x0005",
"&&",
"GET_MODE_SIZE",
"(",
"from",
")",
">",
"1",
")",
"return",
"0",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"from",
")",
">",
"2",
")",
"return",
"0",
";",
"return",
"1",
";",
"}",
"</s>"
] | [
"Implements",
"CANNOT_CHANGE_MODE_CLASS",
".",
"Only",
"r0",
"and",
"r1",
"can",
"change",
"to",
"QI",
"(",
"r0l",
",",
"r1l",
")",
"because",
"the",
"chip",
"does",
"n't",
"support",
"QI",
"ops",
"on",
"other",
"registers",
"(",
"well",
",",
"it",
"does",
"on",
"a0/a1",
"but",
"if",
"we",
"let",
"gcc",
"do",
"that",
",",
"reload",
"suffers",
")",
".",
"Otherwise",
",",
"we",
"allow",
"changes",
"to",
"larger",
"modes",
"."
] | [
"m32c",
"\"cannot change from %s to %s in %s\\n\"",
"0",
"0x1ffa",
"0",
"0x0005",
"1",
"0",
"2",
"0",
"1"
] | m32c2 | m32c_cannot_change_mode_class | m32c | MPU | GCC | 19,273 | 94 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Imm",
".",
"isPosZero",
"(",
")",
"&&",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
"||",
"VT",
"==",
"MVT",
"::",
"f64",
"||",
"VT",
"==",
"MVT",
"::",
"f32",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Legal fp imm: materialize 0 using the zero register\\n\"",
")",
";",
"return",
"true",
";",
"}",
"StringRef",
"FPType",
";",
"bool",
"IsLegal",
"=",
"false",
";",
"SmallString",
"<",
"128",
">",
"ImmStrVal",
";",
"Imm",
".",
"toString",
"(",
"ImmStrVal",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
")",
"{",
"FPType",
"=",
"\"f64\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP64Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"{",
"FPType",
"=",
"\"f32\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP32Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
"&&",
"Subtarget",
"->",
"hasFullFP16",
"(",
")",
")",
"{",
"FPType",
"=",
"\"f16\"",
";",
"IsLegal",
"=",
"AArch64_AM",
"::",
"getFP16Imm",
"(",
"Imm",
")",
"!=",
"-",
"1",
";",
"}",
"if",
"(",
"IsLegal",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Legal \"",
"<<",
"FPType",
"<<",
"\" imm value: \"",
"<<",
"ImmStrVal",
"<<",
"\"\\n\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"FPType",
".",
"empty",
"(",
")",
")",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Illegal \"",
"<<",
"FPType",
"<<",
"\" imm value: \"",
"<<",
"ImmStrVal",
"<<",
"\"\\n\"",
")",
";",
"else",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Illegal fp imm \"",
"<<",
"ImmStrVal",
"<<",
"\": unsupported fp type\\n\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"AArch64",
"AArch64",
"MVT::f16",
"MVT::f64",
"MVT::f32",
"\"Legal fp imm: materialize 0 using the zero register\\n\"",
"128",
"MVT::f64",
"\"f64\"",
"AArch64_AM::getFP64Imm",
"1",
"MVT::f32",
"\"f32\"",
"AArch64_AM::getFP32Imm",
"1",
"MVT::f16",
"\"f16\"",
"AArch64_AM::getFP16Imm",
"1",
"\"Legal \"",
"\" imm value: \"",
"\"\\n\"",
"\"Illegal \"",
"\" imm value: \"",
"\"\\n\"",
"\"Illegal fp imm \"",
"\": unsupported fp type\\n\""
] | AArch64ISelLowering18 | isFPImmLegal | AArch64 | CPU | LLVM | 19,274 | 234 | 1 | [] |
[
"<s>",
"bool",
"loongarch_split_symbol",
"(",
"rtx",
"temp",
",",
"rtx",
"addr",
",",
"machine_mode",
"mode",
",",
"rtx",
"*",
"low_out",
")",
"{",
"enum",
"loongarch_symbol_type",
"symbol_type",
";",
"if",
"(",
"!",
"TARGET_EXPLICIT_RELOCS",
")",
"return",
"false",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"HIGH",
"&&",
"mode",
"==",
"MAX_MACHINE_MODE",
")",
"||",
"!",
"loongarch_symbolic_constant_p",
"(",
"addr",
",",
"&",
"symbol_type",
")",
"||",
"loongarch_symbol_insns",
"(",
"symbol_type",
",",
"mode",
")",
"==",
"0",
"||",
"!",
"loongarch_split_symbol_type",
"(",
"symbol_type",
")",
")",
"return",
"false",
";",
"rtx",
"high",
",",
"temp1",
"=",
"NULL",
";",
"if",
"(",
"temp",
"==",
"NULL",
")",
"temp",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"high",
"=",
"gen_rtx_HIGH",
"(",
"Pmode",
",",
"copy_rtx",
"(",
"addr",
")",
")",
";",
"high",
"=",
"loongarch_force_temporary",
"(",
"temp",
",",
"high",
")",
";",
"if",
"(",
"loongarch_symbol_extreme_p",
"(",
"symbol_type",
")",
"&&",
"can_create_pseudo_p",
"(",
")",
")",
"{",
"gcc_assert",
"(",
"TARGET_EXPLICIT_RELOCS",
")",
";",
"temp1",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_move_insn",
"(",
"temp1",
",",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"0",
")",
",",
"addr",
")",
")",
";",
"emit_insn",
"(",
"gen_lui_h_lo20",
"(",
"temp1",
",",
"temp1",
",",
"addr",
")",
")",
";",
"emit_insn",
"(",
"gen_lui_h_hi12",
"(",
"temp1",
",",
"temp1",
",",
"addr",
")",
")",
";",
"}",
"if",
"(",
"low_out",
")",
"switch",
"(",
"symbol_type",
")",
"{",
"case",
"SYMBOL_PCREL64",
":",
"if",
"(",
"can_create_pseudo_p",
"(",
")",
")",
"{",
"*",
"low_out",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"high",
",",
"temp1",
")",
";",
"break",
";",
"}",
"case",
"SYMBOL_PCREL",
":",
"*",
"low_out",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"high",
",",
"addr",
")",
";",
"break",
";",
"case",
"SYMBOL_GOT_DISP",
":",
"{",
"if",
"(",
"TARGET_CMODEL_EXTREME",
"&&",
"can_create_pseudo_p",
"(",
")",
")",
"*",
"low_out",
"=",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"high",
",",
"temp1",
")",
")",
";",
"else",
"{",
"rtx",
"low",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"high",
",",
"addr",
")",
";",
"rtx",
"mem",
"=",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"low",
")",
";",
"*",
"low_out",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"mem",
")",
",",
"UNSPEC_LOAD_FROM_GOT",
")",
";",
"}",
"break",
";",
"}",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"If",
"MODE",
"is",
"MAX_MACHINE_MODE",
",",
"ADDR",
"appears",
"as",
"a",
"move",
"operand",
",",
"otherwise",
"it",
"appears",
"in",
"a",
"MEM",
"of",
"that",
"mode",
".",
"Return",
"true",
"if",
"ADDR",
"is",
"a",
"legitimate",
"constant",
"in",
"that",
"context",
"and",
"can",
"be",
"split",
"into",
"high",
"and",
"low",
"parts",
".",
"If",
"so",
",",
"and",
"if",
"LOW_OUT",
"is",
"nonnull",
",",
"emit",
"the",
"high",
"part",
"and",
"store",
"the",
"low",
"part",
"in",
"*",
"LOW_OUT",
".",
"Leave",
"*",
"LOW_OUT",
"unchanged",
"otherwise",
".",
"Return",
"false",
"if",
"build",
"with",
"'-mno-explicit-relocs",
"'",
".",
"TEMP",
"is",
"as",
"for",
"loongarch_force_temporary",
"and",
"is",
"used",
"to",
"load",
"the",
"high",
"part",
"into",
"a",
"register",
".",
"When",
"MODE",
"is",
"MAX_MACHINE_MODE",
",",
"the",
"low",
"part",
"is",
"guaranteed",
"to",
"be",
"a",
"legitimize",
"SET_SRC",
"for",
"an",
".md",
"pattern",
",",
"otherwise",
"the",
"low",
"part",
"is",
"guaranteed",
"to",
"be",
"a",
"legitimate",
"address",
"for",
"mode",
"MODE",
"."
] | [
"loongarch",
"0",
"0",
"1"
] | loongarch1 | loongarch_split_symbol | loongarch | CPU | GCC | 19,275 | 316 | 1 | [] |
[
"<s>",
"StackOffset",
"AArch64FrameLowering",
"::",
"getNonLocalFrameIndexReference",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
")",
"const",
"{",
"return",
"StackOffset",
"::",
"getFixed",
"(",
"getSEHFrameIndexOffset",
"(",
"MF",
",",
"FI",
")",
")",
";",
"}",
"</s>"
] | [
"getNonLocalFrameIndexReference",
"-",
"This",
"method",
"returns",
"the",
"offset",
"used",
"to",
"reference",
"a",
"frame",
"index",
"location",
"."
] | [
"AArch64",
"AArch64"
] | AArch64FrameLowering (2)1 | getNonLocalFrameIndexReference | AArch64 | CPU | LLVM | 19,276 | 29 | 1 | [] |
[
"<s>",
"void",
"print",
"(",
"raw_ostream",
"&",
"OS",
",",
"const",
"TargetMachine",
"*",
"TM",
"=",
"nullptr",
")",
"const",
"{",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"TM",
"?",
"TM",
"->",
"getRegisterInfo",
"(",
")",
":",
"nullptr",
";",
"if",
"(",
"isReg",
"(",
")",
")",
"{",
"OS",
"<<",
"PrintReg",
"(",
"Contents",
".",
"R",
".",
"Reg",
",",
"TRI",
",",
"Contents",
".",
"R",
".",
"Sub",
")",
";",
"}",
"if",
"(",
"isImm",
"(",
")",
")",
"{",
"OS",
"<<",
"Contents",
".",
"ImmVal",
";",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"Hexagon"
] | HexagonHardwareLoops | print | Hexagon | DSP | LLVM | 19,277 | 73 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isCommutativeBinOp",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"X86ISD",
"::",
"PCMPEQ",
":",
"case",
"X86ISD",
"::",
"PMULDQ",
":",
"case",
"X86ISD",
"::",
"PMULUDQ",
":",
"case",
"X86ISD",
"::",
"FMAXC",
":",
"case",
"X86ISD",
"::",
"FMINC",
":",
"case",
"X86ISD",
"::",
"FAND",
":",
"case",
"X86ISD",
"::",
"FOR",
":",
"case",
"X86ISD",
"::",
"FXOR",
":",
"return",
"true",
";",
"}",
"return",
"TargetLoweringBase",
"::",
"isCommutativeBinOp",
"(",
"Opcode",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"opcode",
"is",
"a",
"commutative",
"binary",
"operation",
"."
] | [
"X86",
"X86",
"X86ISD::PCMPEQ",
"X86ISD::PMULDQ",
"X86ISD::PMULUDQ",
"X86ISD::FMAXC",
"X86ISD::FMINC",
"X86ISD::FAND",
"X86ISD::FOR",
"X86ISD::FXOR"
] | X86ISelLowering (2)6 | isCommutativeBinOp | X86 | CPU | LLVM | 19,278 | 68 | 1 | [] |
[
"<s>",
"bool",
"BPFCheckAndAdjustIR",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"checkIR",
"(",
"M",
")",
";",
"return",
"adjustIR",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"BPF",
"BPF"
] | BPFCheckAndAdjustIR | runOnModule | BPF | Virtual ISA | LLVM | 19,279 | 22 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"RISCVTargetLowering",
"::",
"shouldExpandAtomicRMWInIR",
"(",
"AtomicRMWInst",
"*",
"AI",
")",
"const",
"{",
"if",
"(",
"AI",
"->",
"isFloatingPointOperation",
"(",
")",
")",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"unsigned",
"Size",
"=",
"AI",
"->",
"getType",
"(",
")",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"Size",
"==",
"8",
"||",
"Size",
"==",
"16",
")",
"return",
"AtomicExpansionKind",
"::",
"MaskedIntrinsic",
";",
"return",
"AtomicExpansionKind",
"::",
"None",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"IR-level",
"AtomicExpand",
"pass",
"should",
"expand",
"the",
"given",
"AtomicRMW",
",",
"if",
"at",
"all",
"."
] | [
"RISCV",
"RISCV",
"8",
"16"
] | RISCVISelLowering | shouldExpandAtomicRMWInIR | RISCV | CPU | LLVM | 19,280 | 60 | 1 | [] |
[
"<s>",
"bool",
"FPGATTIImpl",
"::",
"isLegalAddImmediate",
"(",
"int64_t",
"Imm",
")",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"immediate",
"is",
"legal",
"add",
"immediate",
",",
"that",
"is",
"the",
"target",
"has",
"add",
"instructions",
"which",
"can",
"add",
"a",
"register",
"and",
"the",
"immediate",
"without",
"having",
"to",
"materialize",
"the",
"immediate",
"into",
"a",
"register",
"."
] | [
"FPGA",
"FPGA"
] | FPGATargetTransformInfo | isLegalAddImmediate | FPGA | CPU | LLVM | 19,281 | 13 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"hasLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"SmallVectorImpl",
"<",
"const",
"MachineMemOperand",
"*",
">",
"&",
"Accesses",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isBundle",
"(",
")",
")",
"{",
"const",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"MII",
"=",
"MI",
".",
"getIterator",
"(",
")",
";",
"for",
"(",
"++",
"MII",
";",
"MII",
"!=",
"MBB",
"->",
"instr_end",
"(",
")",
"&&",
"MII",
"->",
"isInsideBundle",
"(",
")",
";",
"++",
"MII",
")",
"if",
"(",
"TargetInstrInfo",
"::",
"hasLoadFromStackSlot",
"(",
"*",
"MII",
",",
"Accesses",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"return",
"TargetInstrInfo",
"::",
"hasLoadFromStackSlot",
"(",
"MI",
",",
"Accesses",
")",
";",
"}",
"</s>"
] | [
"If",
"the",
"specified",
"machine",
"instruction",
"has",
"a",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"true",
"along",
"with",
"the",
"FrameIndices",
"of",
"the",
"loaded",
"stack",
"slot",
"and",
"the",
"machine",
"mem",
"operands",
"containing",
"the",
"reference",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonInstrInfo (2)2 | hasLoadFromStackSlot | Hexagon | DSP | LLVM | 19,282 | 104 | 1 | [] |
[
"<s>",
"bool",
"DLXAsmPrinter",
"::",
"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",
"."
] | [
"DLX",
"DLX"
] | DLXAsmPrinter | isBlockOnlyReachableByFallthrough | DLX | CPU | LLVM | 19,283 | 109 | 1 | [] |
[
"<s>",
"std",
"::",
"string",
"AMDGPUIntrinsicInfo",
"::",
"getName",
"(",
"unsigned",
"int",
"IntrID",
",",
"Type",
"*",
"*",
"Tys",
",",
"unsigned",
"int",
"numTys",
")",
"const",
"{",
"static",
"const",
"char",
"*",
"const",
"names",
"[",
"]",
"=",
"{",
"}",
";",
"if",
"(",
"IntrID",
"<",
"Intrinsic",
"::",
"num_intrinsics",
")",
"{",
"return",
"0",
";",
"}",
"assert",
"(",
"IntrID",
"<",
"AMDGPUIntrinsic",
"::",
"num_AMDGPU_intrinsics",
"&&",
"\"Invalid intrinsic ID\"",
")",
";",
"std",
"::",
"string",
"Result",
"(",
"names",
"[",
"IntrID",
"-",
"Intrinsic",
"::",
"num_intrinsics",
"]",
")",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"with",
"the",
"name",
"of",
"the",
"plan",
"and",
"the",
"applicable",
"VFs",
"and",
"UFs",
"."
] | [
"R600",
"Intrinsic::num_intrinsics",
"0",
"AMDGPUIntrinsic::num_AMDGPU_intrinsics",
"\"Invalid intrinsic ID\"",
"Intrinsic::num_intrinsics"
] | AMDILIntrinsicInfo | getName | R600 | GPU | LLVM | 19,284 | 77 | 1 | [] |
[
"<s>",
"bool",
"writeNopData",
"(",
"uint64_t",
"Count",
",",
"MCObjectWriter",
"*",
"OW",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Write",
"an",
"(",
"optimal",
")",
"nop",
"sequence",
"of",
"Count",
"bytes",
"to",
"the",
"given",
"output",
"."
] | [
"TOY"
] | TOYAsmBackend | writeNopData | TOY | CPU | LLVM | 19,285 | 16 | 1 | [] |
[
"<s>",
"static",
"bool",
"sparc_modes_tieable_p",
"(",
"machine_mode",
"mode1",
",",
"machine_mode",
"mode2",
")",
"{",
"enum",
"mode_class",
"mclass1",
",",
"mclass2",
";",
"unsigned",
"short",
"size1",
",",
"size2",
";",
"if",
"(",
"mode1",
"==",
"mode2",
")",
"return",
"true",
";",
"mclass1",
"=",
"GET_MODE_CLASS",
"(",
"mode1",
")",
";",
"mclass2",
"=",
"GET_MODE_CLASS",
"(",
"mode2",
")",
";",
"if",
"(",
"mclass1",
"!=",
"mclass2",
")",
"return",
"false",
";",
"if",
"(",
"!",
"TARGET_V9",
")",
"return",
"true",
";",
"if",
"(",
"mclass1",
"!=",
"MODE_FLOAT",
"&&",
"mclass1",
"!=",
"MODE_VECTOR_INT",
")",
"return",
"true",
";",
"size1",
"=",
"GET_MODE_SIZE",
"(",
"mode1",
")",
";",
"size2",
"=",
"GET_MODE_SIZE",
"(",
"mode2",
")",
";",
"if",
"(",
"(",
"size1",
">",
"4",
"&&",
"size2",
"==",
"4",
")",
"||",
"(",
"size2",
">",
"4",
"&&",
"size1",
"==",
"4",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"it",
"is",
"a",
"good",
"idea",
"to",
"tie",
"two",
"pseudo",
"registers",
"when",
"one",
"has",
"mode",
"MODE1",
"and",
"one",
"has",
"mode",
"MODE2",
".",
"If",
"HARD_REGNO_MODE_OK",
"could",
"produce",
"different",
"values",
"for",
"MODE1",
"and",
"MODE2",
",",
"for",
"any",
"hard",
"reg",
",",
"then",
"this",
"must",
"be",
"FALSE",
"for",
"correct",
"output",
".",
"For",
"V9",
"we",
"have",
"to",
"deal",
"with",
"the",
"fact",
"that",
"only",
"the",
"lower",
"32",
"floating",
"point",
"registers",
"are",
"32-bit",
"addressable",
"."
] | [
"sparc",
"4",
"4",
"4",
"4"
] | sparc | sparc_modes_tieable_p | sparc | CPU | GCC | 19,286 | 119 | 1 | [] |
[
"<s>",
"bool",
"mep_ipipe_ldc_p",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"pat",
",",
"src",
";",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"PARALLEL",
")",
"pat",
"=",
"XVECEXP",
"(",
"pat",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"SET",
")",
"{",
"src",
"=",
"SET_SRC",
"(",
"pat",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"UNSPEC",
"||",
"GET_CODE",
"(",
"src",
")",
"==",
"UNSPEC_VOLATILE",
")",
"src",
"=",
"XVECEXP",
"(",
"src",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"REG_P",
"(",
"src",
")",
")",
"switch",
"(",
"REGNO",
"(",
"src",
")",
")",
"{",
"case",
"PSW_REGNO",
":",
"case",
"LP_REGNO",
":",
"case",
"SAR_REGNO",
":",
"case",
"HI_REGNO",
":",
"case",
"LO_REGNO",
":",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"INSN",
"is",
"an",
"ldc",
"instruction",
"that",
"issues",
"to",
"the",
"MeP-h1",
"integer",
"pipeline",
".",
"This",
"is",
"true",
"for",
"instructions",
"that",
"read",
"from",
"PSW",
",",
"LP",
",",
"SAR",
",",
"HI",
"and",
"LO",
"."
] | [
"mep",
"0",
"0",
"0",
"0"
] | mep | mep_ipipe_ldc_p | mep | CPU | GCC | 19,287 | 123 | 1 | [] |
[
"<s>",
"void",
"AArch64FrameLowering",
"::",
"resetCFIToInitialState",
"(",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"auto",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"auto",
"&",
"TRI",
"=",
"static_cast",
"<",
"const",
"AArch64RegisterInfo",
"&",
">",
"(",
"*",
"Subtarget",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"const",
"auto",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getInfo",
"<",
"AArch64FunctionInfo",
">",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"CFIDesc",
"=",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"CFI_INSTRUCTION",
")",
";",
"DebugLoc",
"DL",
";",
"MachineBasicBlock",
"::",
"iterator",
"InsertPt",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"unsigned",
"CFIIndex",
"=",
"MF",
".",
"addFrameInst",
"(",
"MCCFIInstruction",
"::",
"cfiDefCfa",
"(",
"nullptr",
",",
"TRI",
".",
"getDwarfRegNum",
"(",
"AArch64",
"::",
"SP",
",",
"true",
")",
",",
"0",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"CFIDesc",
")",
".",
"addCFIIndex",
"(",
"CFIIndex",
")",
";",
"if",
"(",
"MFI",
".",
"shouldSignReturnAddress",
"(",
")",
")",
"{",
"CFIIndex",
"=",
"MF",
".",
"addFrameInst",
"(",
"MCCFIInstruction",
"::",
"createNegateRAState",
"(",
"nullptr",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"CFIDesc",
")",
".",
"addCFIIndex",
"(",
"CFIIndex",
")",
";",
"}",
"if",
"(",
"needsShadowCallStackPrologueEpilogue",
"(",
"MF",
")",
")",
"insertCFISameValue",
"(",
"CFIDesc",
",",
"MF",
",",
"MBB",
",",
"InsertPt",
",",
"TRI",
".",
"getDwarfRegNum",
"(",
"AArch64",
"::",
"X18",
",",
"true",
")",
")",
";",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"getCalleeSavedInfo",
"(",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"Info",
":",
"CSI",
")",
"{",
"unsigned",
"Reg",
"=",
"Info",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"TRI",
".",
"regNeedsCFI",
"(",
"Reg",
",",
"Reg",
")",
")",
"continue",
";",
"insertCFISameValue",
"(",
"CFIDesc",
",",
"MF",
",",
"MBB",
",",
"InsertPt",
",",
"TRI",
".",
"getDwarfRegNum",
"(",
"Reg",
",",
"true",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"CFI",
"instructions",
"that",
"recreate",
"the",
"state",
"of",
"the",
"unwind",
"information",
"upon",
"fucntion",
"entry",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64::SP",
"0",
"AArch64::X18"
] | AArch64FrameLowering38 | resetCFIToInitialState | AArch64 | CPU | LLVM | 19,288 | 299 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"MCP",
"=",
"MF",
".",
"getConstantPool",
"(",
")",
";",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"MF",
".",
"getTarget",
"(",
")",
";",
"for",
"(",
"auto",
"*",
"GV",
":",
"AFI",
"->",
"getGlobalsPromotedToConstantPool",
"(",
")",
")",
"PromotedGlobals",
".",
"insert",
"(",
"GV",
")",
";",
"unsigned",
"OptimizationGoal",
";",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"OptimizeNone",
")",
")",
"OptimizationGoal",
"=",
"6",
";",
"else",
"if",
"(",
"F",
".",
"optForMinSize",
"(",
")",
")",
"OptimizationGoal",
"=",
"4",
";",
"else",
"if",
"(",
"F",
".",
"optForSize",
"(",
")",
")",
"OptimizationGoal",
"=",
"3",
";",
"else",
"if",
"(",
"TM",
".",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"Aggressive",
")",
"OptimizationGoal",
"=",
"2",
";",
"else",
"if",
"(",
"TM",
".",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"None",
")",
"OptimizationGoal",
"=",
"1",
";",
"else",
"OptimizationGoal",
"=",
"5",
";",
"if",
"(",
"OptimizationGoals",
"==",
"-",
"1",
")",
"OptimizationGoals",
"=",
"OptimizationGoal",
";",
"else",
"if",
"(",
"OptimizationGoals",
"!=",
"(",
"int",
")",
"OptimizationGoal",
")",
"OptimizationGoals",
"=",
"0",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetCOFF",
"(",
")",
")",
"{",
"bool",
"Internal",
"=",
"F",
".",
"hasInternalLinkage",
"(",
")",
";",
"COFF",
"::",
"SymbolStorageClass",
"Scl",
"=",
"Internal",
"?",
"COFF",
"::",
"IMAGE_SYM_CLASS_STATIC",
":",
"COFF",
"::",
"IMAGE_SYM_CLASS_EXTERNAL",
";",
"int",
"Type",
"=",
"COFF",
"::",
"IMAGE_SYM_DTYPE_FUNCTION",
"<<",
"COFF",
"::",
"SCT_COMPLEX_TYPE_SHIFT",
";",
"OutStreamer",
"->",
"BeginCOFFSymbolDef",
"(",
"CurrentFnSym",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolStorageClass",
"(",
"Scl",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolType",
"(",
"Type",
")",
";",
"OutStreamer",
"->",
"EndCOFFSymbolDef",
"(",
")",
";",
"}",
"EmitFunctionBody",
"(",
")",
";",
"emitXRayTable",
"(",
")",
";",
"if",
"(",
"!",
"ThumbIndirectPads",
".",
"empty",
"(",
")",
")",
"{",
"OutStreamer",
"->",
"EmitAssemblerFlag",
"(",
"MCAF_Code16",
")",
";",
"EmitAlignment",
"(",
"1",
")",
";",
"for",
"(",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"MCSymbol",
"*",
">",
"&",
"TIP",
":",
"ThumbIndirectPads",
")",
"{",
"OutStreamer",
"->",
"EmitLabel",
"(",
"TIP",
".",
"second",
")",
";",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"MCInstBuilder",
"(",
"ARM",
"::",
"tBX",
")",
".",
"addReg",
"(",
"TIP",
".",
"first",
")",
".",
"addImm",
"(",
"ARMCC",
"::",
"AL",
")",
".",
"addReg",
"(",
"0",
")",
")",
";",
"}",
"ThumbIndirectPads",
".",
"clear",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"6",
"4",
"3",
"2",
"1",
"5",
"1",
"0",
"1",
"ARM::tBX",
"ARMCC::AL",
"0"
] | ARMAsmPrinter103 | runOnMachineFunction | ARM | CPU | LLVM | 19,289 | 367 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64TargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"SDLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"CCAssignFnForNode",
"(",
"CallConv",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Memory locations not expected for call return\"",
")",
";",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"InFlag",
")",
";",
"Chain",
"=",
"Val",
".",
"getValue",
"(",
"1",
")",
";",
"InFlag",
"=",
"Val",
".",
"getValue",
"(",
"2",
")",
";",
"switch",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown loc info!\"",
")",
";",
"case",
"CCValAssign",
"::",
"Full",
":",
"break",
";",
"case",
"CCValAssign",
"::",
"BCvt",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"dl",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"Val",
")",
";",
"break",
";",
"case",
"CCValAssign",
"::",
"ZExt",
":",
"case",
"CCValAssign",
"::",
"SExt",
":",
"case",
"CCValAssign",
"::",
"AExt",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"dl",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"Val",
")",
";",
"break",
";",
"}",
"InVals",
".",
"push_back",
"(",
"Val",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"AArch64",
"AArch64",
"ISD::InputArg",
"16",
"0",
"\"Memory locations not expected for call return\"",
"1",
"2",
"\"Unknown loc info!\"",
"ISD::BITCAST",
"ISD::TRUNCATE"
] | AArch64ISelLowering109 | LowerCallResult | AArch64 | CPU | LLVM | 19,290 | 276 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_output_softstack_switch",
"(",
"FILE",
"*",
"file",
",",
"bool",
"entering",
",",
"rtx",
"ptr",
",",
"rtx",
"size",
",",
"rtx",
"align",
")",
"{",
"gcc_assert",
"(",
"REG_P",
"(",
"ptr",
")",
"&&",
"!",
"HARD_REGISTER_P",
"(",
"ptr",
")",
")",
";",
"if",
"(",
"crtl",
"->",
"is_leaf",
"&&",
"!",
"cfun",
"->",
"machine",
"->",
"simt_stack_size",
")",
"return",
";",
"int",
"bits",
"=",
"POINTER_SIZE",
",",
"regno",
"=",
"REGNO",
"(",
"ptr",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t{\\n\"",
")",
";",
"if",
"(",
"entering",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\t\\tcvta.local.u%d %%r%d, %%simtstack_ar + \"",
"HOST_WIDE_INT_PRINT_DEC",
"\";\\n\"",
",",
"bits",
",",
"regno",
",",
"cfun",
"->",
"machine",
"->",
"simt_stack_size",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t\\tsub.u%d %%r%d, %%r%d, \"",
",",
"bits",
",",
"regno",
",",
"regno",
")",
";",
"if",
"(",
"CONST_INT_P",
"(",
"size",
")",
")",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
",",
"ROUND_UP",
"(",
"UINTVAL",
"(",
"size",
")",
",",
"GET_MODE_SIZE",
"(",
"DImode",
")",
")",
")",
";",
"else",
"output_reg",
"(",
"file",
",",
"REGNO",
"(",
"size",
")",
",",
"VOIDmode",
")",
";",
"fputs",
"(",
"\";\\n\"",
",",
"file",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"size",
")",
"||",
"UINTVAL",
"(",
"align",
")",
">",
"GET_MODE_SIZE",
"(",
"DImode",
")",
")",
"fprintf",
"(",
"file",
",",
"\"\\t\\tand.b%d %%r%d, %%r%d, -\"",
"HOST_WIDE_INT_PRINT_DEC",
"\";\\n\"",
",",
"bits",
",",
"regno",
",",
"regno",
",",
"UINTVAL",
"(",
"align",
")",
")",
";",
"}",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"has_softstack",
")",
"{",
"const",
"char",
"*",
"reg_stack",
"=",
"reg_names",
"[",
"STACK_POINTER_REGNUM",
"]",
";",
"if",
"(",
"entering",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\t\\tst.u%d [%%r%d + -%d], %s;\\n\"",
",",
"bits",
",",
"regno",
",",
"bits",
"/",
"8",
",",
"reg_stack",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t\\tsub.u%d %s, %%r%d, %d;\\n\"",
",",
"bits",
",",
"reg_stack",
",",
"regno",
",",
"bits",
"/",
"8",
")",
";",
"}",
"else",
"{",
"fprintf",
"(",
"file",
",",
"\"\\t\\tld.u%d %s, [%%r%d + -%d];\\n\"",
",",
"bits",
",",
"reg_stack",
",",
"regno",
",",
"bits",
"/",
"8",
")",
";",
"}",
"nvptx_output_set_softstack",
"(",
"REGNO",
"(",
"stack_pointer_rtx",
")",
")",
";",
"}",
"fprintf",
"(",
"file",
",",
"\"\\t}\\n\"",
")",
";",
"}",
"</s>"
] | [
"Output",
"code",
"for",
"allocating",
"per-lane",
"storage",
"and",
"switching",
"soft-stack",
"pointer",
".",
"ENTERING",
"indicates",
"whether",
"we",
"are",
"entering",
"or",
"leaving",
"non-uniform",
"execution",
".",
"PTR",
"is",
"the",
"register",
"pointing",
"to",
"allocated",
"storage",
",",
"it",
"is",
"assigned",
"to",
"on",
"entering",
"and",
"used",
"to",
"restore",
"state",
"on",
"leaving",
".",
"SIZE",
"and",
"ALIGN",
"are",
"used",
"only",
"on",
"entering",
"."
] | [
"nvptx",
"\"\\t{\\n\"",
"\"\\t\\tcvta.local.u%d %%r%d, %%simtstack_ar + \"",
"\";\\n\"",
"\"\\t\\tsub.u%d %%r%d, %%r%d, \"",
"\";\\n\"",
"\"\\t\\tand.b%d %%r%d, %%r%d, -\"",
"\";\\n\"",
"\"\\t\\tst.u%d [%%r%d + -%d], %s;\\n\"",
"8",
"\"\\t\\tsub.u%d %s, %%r%d, %d;\\n\"",
"8",
"\"\\t\\tld.u%d %s, [%%r%d + -%d];\\n\"",
"8",
"\"\\t}\\n\""
] | nvptx | nvptx_output_softstack_switch | nvptx | GPU | GCC | 19,291 | 288 | 1 | [] |
[
"<s>",
"void",
"X86PassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"&",
"LiveRangeShrinkID",
")",
";",
"addPass",
"(",
"createX86FixupSetCC",
"(",
")",
")",
";",
"addPass",
"(",
"createX86OptimizeLEAs",
"(",
")",
")",
";",
"addPass",
"(",
"createX86CallFrameOptimization",
"(",
")",
")",
";",
"addPass",
"(",
"createX86AvoidStoreForwardingBlocks",
"(",
")",
")",
";",
"}",
"if",
"(",
"EnableSpeculativeLoadHardening",
")",
"addPass",
"(",
"createX86SpeculativeLoadHardeningPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86FlagsCopyLoweringPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86WinAllocaExpander",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine120 | addPreRegAlloc | X86 | CPU | LLVM | 19,292 | 79 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_multiplication_cost",
"(",
"const",
"struct",
"processor_costs",
"*",
"cost",
",",
"enum",
"machine_mode",
"mode",
")",
"{",
"machine_mode",
"inner_mode",
"=",
"mode",
";",
"if",
"(",
"VECTOR_MODE_P",
"(",
"mode",
")",
")",
"inner_mode",
"=",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"if",
"(",
"SSE_FLOAT_MODE_P",
"(",
"mode",
")",
"&&",
"TARGET_SSE_MATH",
")",
"return",
"inner_mode",
"==",
"DFmode",
"?",
"cost",
"->",
"mulsd",
":",
"cost",
"->",
"mulss",
";",
"else",
"if",
"(",
"X87_FLOAT_MODE_P",
"(",
"mode",
")",
")",
"return",
"cost",
"->",
"fmul",
";",
"else",
"if",
"(",
"FLOAT_MODE_P",
"(",
"mode",
")",
")",
"return",
"ix86_vec_cost",
"(",
"mode",
",",
"inner_mode",
"==",
"DFmode",
"?",
"cost",
"->",
"mulsd",
":",
"cost",
"->",
"mulss",
",",
"true",
")",
";",
"else",
"if",
"(",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_VECTOR_INT",
")",
"{",
"if",
"(",
"TARGET_AVX512DQ",
")",
"return",
"ix86_vec_cost",
"(",
"mode",
",",
"cost",
"->",
"mulss",
",",
"true",
")",
";",
"if",
"(",
"mode",
"==",
"V16QImode",
"||",
"mode",
"==",
"V32QImode",
")",
"{",
"int",
"extra",
"=",
"11",
";",
"if",
"(",
"TARGET_XOP",
"&&",
"mode",
"==",
"V16QImode",
")",
"extra",
"=",
"5",
";",
"else",
"if",
"(",
"TARGET_SSSE3",
")",
"extra",
"=",
"6",
";",
"return",
"ix86_vec_cost",
"(",
"mode",
",",
"cost",
"->",
"mulss",
"*",
"2",
"+",
"cost",
"->",
"sse_op",
"*",
"extra",
",",
"true",
")",
";",
"}",
"else",
"if",
"(",
"mode",
"==",
"V2DImode",
"||",
"mode",
"==",
"V4DImode",
")",
"{",
"if",
"(",
"TARGET_XOP",
"&&",
"mode",
"==",
"V2DImode",
")",
"return",
"ix86_vec_cost",
"(",
"mode",
",",
"cost",
"->",
"mulss",
"*",
"2",
"+",
"cost",
"->",
"sse_op",
"*",
"3",
",",
"true",
")",
";",
"else",
"return",
"ix86_vec_cost",
"(",
"mode",
",",
"cost",
"->",
"mulss",
"*",
"3",
"+",
"cost",
"->",
"sse_op",
"*",
"5",
",",
"true",
")",
";",
"}",
"else",
"if",
"(",
"mode",
"==",
"V4SImode",
"&&",
"!",
"(",
"TARGET_SSE4_1",
"||",
"TARGET_AVX",
")",
")",
"return",
"ix86_vec_cost",
"(",
"mode",
",",
"cost",
"->",
"mulss",
"*",
"2",
"+",
"cost",
"->",
"sse_op",
"*",
"5",
",",
"true",
")",
";",
"else",
"return",
"ix86_vec_cost",
"(",
"mode",
",",
"cost",
"->",
"mulss",
",",
"true",
")",
";",
"}",
"else",
"return",
"(",
"cost",
"->",
"mult_init",
"[",
"MODE_INDEX",
"(",
"mode",
")",
"]",
"+",
"cost",
"->",
"mult_bit",
"*",
"7",
")",
";",
"}",
"</s>"
] | [
"Return",
"cost",
"of",
"multiplication",
"in",
"MODE",
"."
] | [
"i386",
"11",
"5",
"6",
"2",
"2",
"3",
"3",
"5",
"2",
"5",
"7"
] | i3867 | ix86_multiplication_cost | i386 | CPU | GCC | 19,293 | 313 | 1 | [] |
[
"<s>",
"void",
"ARMCallLowering",
"::",
"splitToValueTypes",
"(",
"const",
"ArgInfo",
"&",
"OrigArg",
",",
"SmallVectorImpl",
"<",
"ArgInfo",
">",
"&",
"SplitArgs",
",",
"MachineFunction",
"&",
"MF",
",",
"const",
"SplitArgTy",
"&",
"PerformArgSplit",
")",
"const",
"{",
"const",
"ARMTargetLowering",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"ARMTargetLowering",
">",
"(",
")",
";",
"LLVMContext",
"&",
"Ctx",
"=",
"OrigArg",
".",
"Ty",
"->",
"getContext",
"(",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"SmallVector",
"<",
"EVT",
",",
"4",
">",
"SplitVTs",
";",
"ComputeValueVTs",
"(",
"TLI",
",",
"DL",
",",
"OrigArg",
".",
"Ty",
",",
"SplitVTs",
",",
"nullptr",
",",
"nullptr",
",",
"0",
")",
";",
"if",
"(",
"SplitVTs",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"auto",
"Flags",
"=",
"OrigArg",
".",
"Flags",
";",
"unsigned",
"OriginalAlignment",
"=",
"DL",
".",
"getABITypeAlignment",
"(",
"OrigArg",
".",
"Ty",
")",
";",
"Flags",
".",
"setOrigAlign",
"(",
"OriginalAlignment",
")",
";",
"SplitArgs",
".",
"emplace_back",
"(",
"OrigArg",
".",
"Reg",
",",
"SplitVTs",
"[",
"0",
"]",
".",
"getTypeForEVT",
"(",
"Ctx",
")",
",",
"Flags",
",",
"OrigArg",
".",
"IsFixed",
")",
";",
"return",
";",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"SplitVTs",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"EVT",
"SplitVT",
"=",
"SplitVTs",
"[",
"i",
"]",
";",
"Type",
"*",
"SplitTy",
"=",
"SplitVT",
".",
"getTypeForEVT",
"(",
"Ctx",
")",
";",
"auto",
"Flags",
"=",
"OrigArg",
".",
"Flags",
";",
"unsigned",
"OriginalAlignment",
"=",
"DL",
".",
"getABITypeAlignment",
"(",
"SplitTy",
")",
";",
"Flags",
".",
"setOrigAlign",
"(",
"OriginalAlignment",
")",
";",
"bool",
"NeedsConsecutiveRegisters",
"=",
"TLI",
".",
"functionArgumentNeedsConsecutiveRegisters",
"(",
"SplitTy",
",",
"F",
".",
"getCallingConv",
"(",
")",
",",
"F",
".",
"isVarArg",
"(",
")",
")",
";",
"if",
"(",
"NeedsConsecutiveRegisters",
")",
"{",
"Flags",
".",
"setInConsecutiveRegs",
"(",
")",
";",
"if",
"(",
"i",
"==",
"e",
"-",
"1",
")",
"Flags",
".",
"setInConsecutiveRegsLast",
"(",
")",
";",
"}",
"unsigned",
"PartReg",
"=",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"getLLTForType",
"(",
"*",
"SplitTy",
",",
"DL",
")",
")",
";",
"SplitArgs",
".",
"push_back",
"(",
"ArgInfo",
"{",
"PartReg",
",",
"SplitTy",
",",
"Flags",
",",
"OrigArg",
".",
"IsFixed",
"}",
")",
";",
"PerformArgSplit",
"(",
"PartReg",
")",
";",
"}",
"}",
"</s>"
] | [
"Break",
"OrigArgInfo",
"into",
"one",
"or",
"more",
"pieces",
"the",
"calling",
"convention",
"can",
"process",
",",
"returned",
"in",
"SplitArgs",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"4",
"0",
"1",
"0",
"0",
"1"
] | ARMCallLowering33 | splitToValueTypes | ARM | CPU | LLVM | 19,294 | 332 | 1 | [] |
[
"<s>",
"void",
"rs6000_split_signbit",
"(",
"rtx",
"dest",
",",
"rtx",
"src",
")",
"{",
"machine_mode",
"d_mode",
"=",
"GET_MODE",
"(",
"dest",
")",
";",
"machine_mode",
"s_mode",
"=",
"GET_MODE",
"(",
"src",
")",
";",
"rtx",
"dest_di",
"=",
"(",
"d_mode",
"==",
"DImode",
")",
"?",
"dest",
":",
"gen_lowpart",
"(",
"DImode",
",",
"dest",
")",
";",
"rtx",
"shift_reg",
"=",
"dest_di",
";",
"gcc_assert",
"(",
"FLOAT128_IEEE_P",
"(",
"s_mode",
")",
"&&",
"TARGET_POWERPC64",
")",
";",
"if",
"(",
"MEM_P",
"(",
"src",
")",
")",
"{",
"rtx",
"mem",
"=",
"(",
"WORDS_BIG_ENDIAN",
"?",
"adjust_address",
"(",
"src",
",",
"DImode",
",",
"0",
")",
":",
"adjust_address",
"(",
"src",
",",
"DImode",
",",
"8",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dest_di",
",",
"mem",
")",
")",
";",
"}",
"else",
"{",
"unsigned",
"int",
"r",
"=",
"reg_or_subregno",
"(",
"src",
")",
";",
"if",
"(",
"INT_REGNO_P",
"(",
"r",
")",
")",
"shift_reg",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"r",
"+",
"(",
"BYTES_BIG_ENDIAN",
"==",
"0",
")",
")",
";",
"else",
"{",
"gcc_assert",
"(",
"VSX_REGNO_P",
"(",
"r",
")",
")",
";",
"if",
"(",
"s_mode",
"==",
"KFmode",
")",
"emit_insn",
"(",
"gen_signbitkf2_dm2",
"(",
"dest_di",
",",
"src",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_signbittf2_dm2",
"(",
"dest_di",
",",
"src",
")",
")",
";",
"}",
"}",
"emit_insn",
"(",
"gen_lshrdi3",
"(",
"dest_di",
",",
"shift_reg",
",",
"GEN_INT",
"(",
"63",
")",
")",
")",
";",
"return",
";",
"}",
"</s>"
] | [
"Split",
"a",
"signbit",
"operation",
"on",
"64-bit",
"machines",
"with",
"direct",
"move",
".",
"Also",
"allow",
"for",
"the",
"value",
"to",
"come",
"from",
"memory",
"or",
"if",
"it",
"is",
"already",
"loaded",
"into",
"a",
"GPR",
"."
] | [
"rs6000",
"0",
"8",
"0",
"63"
] | rs60006 | rs6000_split_signbit | rs6000 | CPU | GCC | 19,295 | 193 | 1 | [] |
[
"<s>",
"bool",
"empty",
"(",
")",
"const",
"{",
"return",
"Edges",
".",
"empty",
"(",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"this",
"version",
"information",
"is",
"empty",
"(",
"e.g.",
",",
"all",
"version",
"components",
"are",
"zero",
")",
"."
] | [
"X86"
] | X86DomainReassignment | empty | X86 | CPU | LLVM | 19,296 | 14 | 1 | [] |
[
"<s>",
"unsigned",
"SIInstrInfo",
"::",
"getNumWaitStates",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"if",
"(",
"MI",
".",
"isMetaInstruction",
"(",
")",
")",
"return",
"0",
";",
"return",
"1",
";",
"case",
"AMDGPU",
"::",
"S_NOP",
":",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
"+",
"1",
";",
"case",
"AMDGPU",
"::",
"SI_MASKED_UNREACHABLE",
":",
"case",
"AMDGPU",
"::",
"WAVE_BARRIER",
":",
"return",
"0",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"wait",
"states",
"that",
"result",
"from",
"executing",
"this",
"instruction",
"."
] | [
"AMDGPU",
"SI",
"0",
"1",
"AMDGPU::S_NOP",
"0",
"1",
"AMDGPU::SI_MASKED_UNREACHABLE",
"AMDGPU::WAVE_BARRIER",
"0"
] | SIInstrInfo11 | getNumWaitStates | AMDGPU | GPU | LLVM | 19,297 | 70 | 1 | [] |
[
"<s>",
"unsigned",
"XCoreTargetLowering",
"::",
"getJumpTableEncoding",
"(",
")",
"const",
"{",
"return",
"MachineJumpTableInfo",
"::",
"EK_Inline",
";",
"}",
"</s>"
] | [
"Return",
"the",
"entry",
"encoding",
"for",
"a",
"jump",
"table",
"in",
"the",
"current",
"function",
"."
] | [
"XCore",
"XCore"
] | XCoreISelLowering (2) | getJumpTableEncoding | XCore | MPU | LLVM | 19,298 | 14 | 1 | [] |
[
"<s>",
"virtual",
"const",
"SparcRegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"Sparc",
"Sparc"
] | SparcTargetMachine | getRegisterInfo | Sparc | CPU | LLVM | 19,299 | 18 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.