ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"static",
"inline",
"bool",
"avr_reg_ok_for_addr_p",
"(",
"rtx",
"reg",
",",
"addr_space_t",
"as",
",",
"RTX_CODE",
"outer_code",
",",
"bool",
"strict",
")",
"{",
"return",
"(",
"REG_P",
"(",
"reg",
")",
"&&",
"(",
"avr_regno_mode_code_ok_for_base_p",
"(",
"REGNO",
"(",
"reg",
")",
",",
"QImode",
",",
"as",
",",
"outer_code",
",",
"UNKNOWN",
")",
"||",
"(",
"!",
"strict",
"&&",
"REGNO",
"(",
"reg",
")",
">=",
"FIRST_PSEUDO_REGISTER",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"for",
"`",
"avr_legitimate_address_p",
"'",
"."
] | [
"avr"
] | avr | avr_reg_ok_for_addr_p | avr | MPU | GCC | 10,800 | 57 | 1 | [] |
[
"<s>",
"bool",
"PatmosInstrInfo",
"::",
"PredicateInstruction",
"(",
"MachineInstr",
"&",
"MI",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
")",
"const",
"{",
"assert",
"(",
"!",
"MI",
".",
"isBundle",
"(",
")",
"&&",
"\"PatmosInstrInfo::PredicateInstruction() can't handle bundles\"",
")",
";",
"if",
"(",
"MI",
".",
"isPredicable",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"isPredicated",
"(",
"MI",
")",
"&&",
"\"Cannot predicate an instruction already predicated.\"",
")",
";",
"int",
"i",
"=",
"MI",
".",
"findFirstPredOperandIdx",
"(",
")",
";",
"assert",
"(",
"i",
"!=",
"-",
"1",
")",
";",
"MachineOperand",
"&",
"PO1",
"=",
"MI",
".",
"getOperand",
"(",
"i",
")",
";",
"MachineOperand",
"&",
"PO2",
"=",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"1",
")",
";",
"assert",
"(",
"PO1",
".",
"isReg",
"(",
")",
"&&",
"PO2",
".",
"isImm",
"(",
")",
"&&",
"\"Unexpected Patmos predicate operand\"",
")",
";",
"PO1",
".",
"setReg",
"(",
"Cond",
"[",
"0",
"]",
".",
"getReg",
"(",
")",
")",
";",
"PO2",
".",
"setImm",
"(",
"Cond",
"[",
"1",
"]",
".",
"getImm",
"(",
")",
")",
";",
"fixOpcodeForGuard",
"(",
"MI",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Convert",
"the",
"instruction",
"into",
"a",
"predicated",
"instruction",
"."
] | [
"Patmos",
"Patmos",
"\"PatmosInstrInfo::PredicateInstruction() can't handle bundles\"",
"\"Cannot predicate an instruction already predicated.\"",
"1",
"1",
"\"Unexpected Patmos predicate operand\"",
"0",
"1"
] | PatmosInstrInfo1 | PredicateInstruction | Patmos | VLIW | LLVM | 10,801 | 148 | 1 | [] |
[
"<s>",
"void",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCInst",
"&",
"Res",
")",
"const",
"override",
"{",
"report_fatal_error",
"(",
"\"ECLairAsmBackend::relaxInstruction() unimplemented\"",
")",
";",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"ECLair",
"\"ECLairAsmBackend::relaxInstruction() unimplemented\""
] | ECLairAsmBackend | relaxInstruction | ECLair | MPU | LLVM | 10,802 | 26 | 1 | [] |
[
"<s>",
"unsigned",
"PPCInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"PPC",
"::",
"LD",
":",
"case",
"PPC",
"::",
"LWZ",
":",
"case",
"PPC",
"::",
"LFS",
":",
"case",
"PPC",
"::",
"LFD",
":",
"case",
"PPC",
"::",
"RESTORE_CR",
":",
"case",
"PPC",
"::",
"RESTORE_CRBIT",
":",
"case",
"PPC",
"::",
"LVX",
":",
"case",
"PPC",
"::",
"LXVD2X",
":",
"case",
"PPC",
"::",
"LXV",
":",
"case",
"PPC",
"::",
"QVLFDX",
":",
"case",
"PPC",
"::",
"QVLFSXs",
":",
"case",
"PPC",
"::",
"QVLFDXb",
":",
"case",
"PPC",
"::",
"RESTORE_VRSAVE",
":",
"case",
"PPC",
"::",
"SPILLTOVSR_LD",
":",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isImm",
"(",
")",
"&&",
"!",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isFI",
"(",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"PowerPC",
"PPC",
"PPC::LD",
"PPC::LWZ",
"PPC::LFS",
"PPC::LFD",
"PPC::RESTORE_CR",
"PPC::RESTORE_CRBIT",
"PPC::LVX",
"PPC::LXVD2X",
"PPC::LXV",
"PPC::QVLFDX",
"PPC::QVLFSXs",
"PPC::QVLFDXb",
"PPC::RESTORE_VRSAVE",
"PPC::SPILLTOVSR_LD",
"1",
"1",
"2",
"2",
"0",
"0"
] | PPCInstrInfo102 | isLoadFromStackSlot | PowerPC | CPU | LLVM | 10,803 | 169 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"getMatchingSuperRegClass",
"(",
"const",
"TargetRegisterClass",
"*",
"A",
",",
"const",
"TargetRegisterClass",
"*",
"B",
",",
"unsigned",
"Idx",
")",
"const",
"override",
"{",
"return",
"A",
";",
"}",
"</s>"
] | [
"getMatchingSuperRegClass",
"-",
"Return",
"a",
"subclass",
"of",
"the",
"specified",
"register",
"class",
"A",
"so",
"that",
"each",
"register",
"in",
"it",
"has",
"a",
"sub-register",
"of",
"the",
"specified",
"sub-register",
"index",
"which",
"is",
"in",
"the",
"specified",
"register",
"class",
"B",
"."
] | [
"Patmos"
] | PatmosRegisterInfo1 | getMatchingSuperRegClass | Patmos | VLIW | LLVM | 10,804 | 25 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"MCP",
"=",
"MF",
".",
"getConstantPool",
"(",
")",
";",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetNaCl",
"(",
")",
")",
"{",
"NaClAlignAllJumpTargetsAndConstantPools",
"(",
"MF",
")",
";",
"}",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetCOFF",
"(",
")",
")",
"{",
"bool",
"Internal",
"=",
"MF",
".",
"getFunction",
"(",
")",
"->",
"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",
"(",
")",
";",
"if",
"(",
"!",
"ThumbIndirectPads",
".",
"empty",
"(",
")",
")",
"{",
"OutStreamer",
".",
"EmitAssemblerFlag",
"(",
"MCAF_Code16",
")",
";",
"EmitAlignment",
"(",
"1",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"ThumbIndirectPads",
".",
"size",
"(",
")",
";",
"i",
"<",
"e",
";",
"i",
"++",
")",
"{",
"OutStreamer",
".",
"EmitLabel",
"(",
"ThumbIndirectPads",
"[",
"i",
"]",
".",
"second",
")",
";",
"EmitToStreamer",
"(",
"OutStreamer",
",",
"MCInstBuilder",
"(",
"ARM",
"::",
"tBX",
")",
".",
"addReg",
"(",
"ThumbIndirectPads",
"[",
"i",
"]",
".",
"first",
")",
".",
"addImm",
"(",
"ARMCC",
"::",
"AL",
")",
".",
"addReg",
"(",
"0",
")",
")",
";",
"}",
"ThumbIndirectPads",
".",
"clear",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"1",
"0",
"ARM::tBX",
"ARMCC::AL",
"0"
] | ARMAsmPrinter22 | runOnMachineFunction | ARM | CPU | LLVM | 10,805 | 244 | 1 | [] |
[
"<s>",
"unsigned",
"RISCVAsmParser",
"::",
"validateTargetOperandClass",
"(",
"MCParsedAsmOperand",
"&",
"AsmOp",
",",
"unsigned",
"Kind",
")",
"{",
"RISCVOperand",
"&",
"Op",
"=",
"static_cast",
"<",
"RISCVOperand",
"&",
">",
"(",
"AsmOp",
")",
";",
"if",
"(",
"!",
"Op",
".",
"isReg",
"(",
")",
")",
"return",
"Match_InvalidOperand",
";",
"Register",
"Reg",
"=",
"Op",
".",
"getReg",
"(",
")",
";",
"bool",
"IsRegFPR64",
"=",
"RISCVMCRegisterClasses",
"[",
"RISCV",
"::",
"FPR64RegClassID",
"]",
".",
"contains",
"(",
"Reg",
")",
";",
"bool",
"IsRegFPR64C",
"=",
"RISCVMCRegisterClasses",
"[",
"RISCV",
"::",
"FPR64CRegClassID",
"]",
".",
"contains",
"(",
"Reg",
")",
";",
"if",
"(",
"(",
"IsRegFPR64",
"&&",
"Kind",
"==",
"MCK_FPR16",
")",
"||",
"(",
"IsRegFPR64C",
"&&",
"Kind",
"==",
"MCK_FPR32C",
")",
")",
"{",
"Op",
".",
"Reg",
".",
"RegNum",
"=",
"convertFPR64ToFPR32",
"(",
"Reg",
")",
";",
"return",
"Match_Success",
";",
"}",
"return",
"Match_InvalidOperand",
";",
"}",
"</s>"
] | [
"Allow",
"a",
"target",
"to",
"add",
"special",
"case",
"operand",
"matching",
"for",
"things",
"that",
"tblgen",
"doesn't/ca",
"n't",
"handle",
"effectively",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"RISCV::FPR64RegClassID",
"RISCV",
"RISCV::FPR64CRegClassID"
] | RISCVAsmParser36 | validateTargetOperandClass | RISCV | CPU | LLVM | 10,806 | 115 | 1 | [] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Wasn't expecting to be able to lower this!\"",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"LowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"LowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"llvm_unreachable",
"(",
"\"TLS not implemented for PPC\"",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"LowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SETCC",
":",
"return",
"LowerSETCC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INIT_TRAMPOLINE",
":",
"return",
"LowerINIT_TRAMPOLINE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ADJUST_TRAMPOLINE",
":",
"return",
"LowerADJUST_TRAMPOLINE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"VAARG",
":",
"return",
"LowerVAARG",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"STACKRESTORE",
":",
"return",
"LowerSTACKRESTORE",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_UINT",
":",
"case",
"ISD",
"::",
"FP_TO_SINT",
":",
"return",
"LowerFP_TO_INT",
"(",
"Op",
",",
"DAG",
",",
"Op",
".",
"getDebugLoc",
"(",
")",
")",
";",
"case",
"ISD",
"::",
"SINT_TO_FP",
":",
"return",
"LowerSINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FLT_ROUNDS_",
":",
"return",
"LowerFLT_ROUNDS_",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL_PARTS",
":",
"return",
"LowerSHL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRL_PARTS",
":",
"return",
"LowerSRL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRA_PARTS",
":",
"return",
"LowerSRA_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BUILD_VECTOR",
":",
"return",
"LowerBUILD_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VECTOR_SHUFFLE",
":",
"return",
"LowerVECTOR_SHUFFLE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SCALAR_TO_VECTOR",
":",
"return",
"LowerSCALAR_TO_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"LowerMUL",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"PowerPC",
"PPC",
"\"Wasn't expecting to be able to lower this!\"",
"ISD::ConstantPool",
"ISD::BlockAddress",
"ISD::GlobalAddress",
"ISD::GlobalTLSAddress",
"\"TLS not implemented for PPC\"",
"ISD::JumpTable",
"ISD::SETCC",
"ISD::INIT_TRAMPOLINE",
"ISD::ADJUST_TRAMPOLINE",
"ISD::VASTART",
"PPC",
"ISD::VAARG",
"PPC",
"ISD::STACKRESTORE",
"PPC",
"ISD::DYNAMIC_STACKALLOC",
"PPC",
"ISD::SELECT_CC",
"ISD::FP_TO_UINT",
"ISD::FP_TO_SINT",
"ISD::SINT_TO_FP",
"ISD::FLT_ROUNDS_",
"ISD::SHL_PARTS",
"ISD::SRL_PARTS",
"ISD::SRA_PARTS",
"ISD::BUILD_VECTOR",
"ISD::VECTOR_SHUFFLE",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::SCALAR_TO_VECTOR",
"ISD::MUL",
"ISD::RETURNADDR",
"ISD::FRAMEADDR"
] | PPCISelLowering113 | LowerOperation | PowerPC | CPU | LLVM | 10,807 | 386 | 1 | [] |
[
"<s>",
"static",
"tree",
"nvptx_reduction_update",
"(",
"location_t",
"loc",
",",
"gimple_stmt_iterator",
"*",
"gsi",
",",
"tree",
"ptr",
",",
"tree",
"var",
",",
"tree_code",
"op",
",",
"int",
"level",
")",
"{",
"tree",
"type",
"=",
"TREE_TYPE",
"(",
"var",
")",
";",
"tree",
"size",
"=",
"TYPE_SIZE",
"(",
"type",
")",
";",
"if",
"(",
"size",
"==",
"TYPE_SIZE",
"(",
"unsigned_type_node",
")",
"||",
"size",
"==",
"TYPE_SIZE",
"(",
"long_long_unsigned_type_node",
")",
")",
"return",
"nvptx_lockless_update",
"(",
"loc",
",",
"gsi",
",",
"ptr",
",",
"var",
",",
"op",
")",
";",
"else",
"return",
"nvptx_lockfull_update",
"(",
"loc",
",",
"gsi",
",",
"ptr",
",",
"var",
",",
"op",
",",
"level",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"sequence",
"to",
"update",
"a",
"reduction",
"accumlator",
"at",
"*",
"PTR",
"with",
"the",
"value",
"held",
"in",
"VAR",
"using",
"operator",
"OP",
".",
"Return",
"the",
"updated",
"value",
".",
"TODO",
":",
"optimize",
"for",
"atomic",
"ops",
"and",
"indepedent",
"complex",
"ops",
"."
] | [
"nvptx"
] | nvptx | nvptx_reduction_update | nvptx | GPU | GCC | 10,808 | 88 | 1 | [] |
[
"<s>",
"void",
"arc_final_prescan_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"opvec",
"ATTRIBUTE_UNUSED",
",",
"int",
"noperands",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"TARGET_DUMPISIZE",
")",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\n; at %04x\\n\"",
",",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"insn",
")",
")",
")",
";",
"if",
"(",
"!",
"cfun",
"->",
"machine",
"->",
"prescan_initialized",
")",
"{",
"memset",
"(",
"&",
"arc_ccfsm_current",
",",
"0",
",",
"sizeof",
"arc_ccfsm_current",
")",
";",
"cfun",
"->",
"machine",
"->",
"prescan_initialized",
"=",
"1",
";",
"}",
"arc_ccfsm_advance",
"(",
"insn",
",",
"&",
"arc_ccfsm_current",
")",
";",
"}",
"</s>"
] | [
"The",
"state",
"of",
"the",
"fsm",
"controlling",
"condition",
"codes",
"are",
":",
"0",
":",
"normal",
",",
"do",
"nothing",
"special",
"1",
":",
"do",
"n't",
"output",
"this",
"insn",
"2",
":",
"do",
"n't",
"output",
"this",
"insn",
"3",
":",
"make",
"insns",
"conditional",
"4",
":",
"make",
"insns",
"conditional",
"State",
"transitions",
"(",
"state-",
">",
"state",
"by",
"whom",
",",
"under",
"what",
"condition",
")",
":",
"0",
"-",
">",
"1",
"final_prescan_insn",
",",
"if",
"insn",
"is",
"conditional",
"branch",
"0",
"-",
">",
"2",
"final_prescan_insn",
",",
"if",
"the",
"`",
"target",
"'",
"is",
"an",
"unconditional",
"branch",
"1",
"-",
">",
"3",
"branch",
"patterns",
",",
"after",
"having",
"not",
"output",
"the",
"conditional",
"branch",
"2",
"-",
">",
"4",
"branch",
"patterns",
",",
"after",
"having",
"not",
"output",
"the",
"conditional",
"branch",
"3",
"-",
">",
"0",
"(",
"*",
"targetm.asm_out.internal_label",
")",
",",
"if",
"the",
"`",
"target",
"'",
"label",
"is",
"reached",
"(",
"the",
"target",
"label",
"has",
"CODE_LABEL_NUMBER",
"equal",
"to",
"arc_ccfsm_target_label",
")",
".",
"4",
"-",
">",
"0",
"final_prescan_insn",
",",
"if",
"`",
"target",
"'",
"unconditional",
"branch",
"is",
"reached",
"If",
"the",
"jump",
"clobbers",
"the",
"conditions",
"then",
"we",
"use",
"states",
"2",
"and",
"4",
".",
"A",
"similar",
"thing",
"can",
"be",
"done",
"with",
"conditional",
"return",
"insns",
".",
"We",
"also",
"handle",
"separating",
"branches",
"from",
"sets",
"of",
"the",
"condition",
"code",
".",
"This",
"is",
"done",
"here",
"because",
"knowledge",
"of",
"the",
"ccfsm",
"state",
"is",
"required",
",",
"we",
"may",
"not",
"be",
"outputting",
"the",
"branch",
"."
] | [
"arc",
"\"\\n; at %04x\\n\"",
"0",
"1"
] | arc | arc_final_prescan_insn | arc | MPU | GCC | 10,809 | 75 | 1 | [] |
[
"<s>",
"static",
"tree",
"alpha_builtin_decl",
"(",
"unsigned",
"code",
",",
"bool",
"initialize_p",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"code",
">=",
"ALPHA_BUILTIN_max",
")",
"return",
"error_mark_node",
";",
"return",
"alpha_builtins",
"[",
"code",
"]",
";",
"}",
"</s>"
] | [
"Return",
"the",
"alpha",
"builtin",
"for",
"CODE",
"."
] | [
"alpha"
] | alpha | alpha_builtin_decl | alpha | MPU | GCC | 10,810 | 28 | 1 | [] |
[
"<s>",
"unsigned",
"getStackAddress",
"(",
"uint64_t",
"Size",
",",
"int64_t",
"Offset",
",",
"MachinePointerInfo",
"&",
"MPO",
")",
"override",
"{",
"LLT",
"p0",
"=",
"LLT",
"::",
"pointer",
"(",
"0",
",",
"64",
")",
";",
"LLT",
"s64",
"=",
"LLT",
"::",
"scalar",
"(",
"64",
")",
";",
"unsigned",
"SPReg",
"=",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"p0",
")",
";",
"MIRBuilder",
".",
"buildCopy",
"(",
"SPReg",
",",
"AArch64",
"::",
"SP",
")",
";",
"unsigned",
"OffsetReg",
"=",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"s64",
")",
";",
"MIRBuilder",
".",
"buildConstant",
"(",
"OffsetReg",
",",
"Offset",
")",
";",
"unsigned",
"AddrReg",
"=",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"p0",
")",
";",
"MIRBuilder",
".",
"buildGEP",
"(",
"AddrReg",
",",
"SPReg",
",",
"OffsetReg",
")",
";",
"MPO",
"=",
"MachinePointerInfo",
"::",
"getStack",
"(",
"MIRBuilder",
".",
"getMF",
"(",
")",
",",
"Offset",
")",
";",
"StackSize",
"=",
"std",
"::",
"max",
"(",
"StackSize",
",",
"Size",
"+",
"Offset",
")",
";",
"return",
"AddrReg",
";",
"}",
"</s>"
] | [
"Materialize",
"a",
"VReg",
"containing",
"the",
"address",
"of",
"the",
"specified",
"stack-based",
"object",
"."
] | [
"AArch64",
"0",
"64",
"64",
"AArch64::SP"
] | AArch64CallLowering23 | getStackAddress | AArch64 | CPU | LLVM | 10,811 | 130 | 1 | [] |
[
"<s>",
"void",
"cris_override_options",
"(",
"void",
")",
"{",
"if",
"(",
"cris_max_stackframe_str",
")",
"{",
"cris_max_stackframe",
"=",
"atoi",
"(",
"cris_max_stackframe_str",
")",
";",
"if",
"(",
"cris_max_stackframe",
"<",
"0",
"||",
"cris_max_stackframe",
">",
"0x20000000",
")",
"internal_error",
"(",
"\"-max-stackframe=%d is not usable, not between 0 and %d\"",
",",
"cris_max_stackframe",
",",
"0x20000000",
")",
";",
"}",
"if",
"(",
"TARGET_SVINTO",
"&&",
"cris_cpu_version",
"<",
"CRIS_CPU_SVINTO",
")",
"cris_cpu_version",
"=",
"CRIS_CPU_SVINTO",
";",
"else",
"if",
"(",
"TARGET_ETRAX4_ADD",
"&&",
"cris_cpu_version",
"<",
"CRIS_CPU_ETRAX4",
")",
"cris_cpu_version",
"=",
"CRIS_CPU_ETRAX4",
";",
"if",
"(",
"cris_cpu_str",
")",
"{",
"cris_cpu_version",
"=",
"(",
"*",
"cris_cpu_str",
"==",
"'v'",
"?",
"atoi",
"(",
"cris_cpu_str",
"+",
"1",
")",
":",
"-",
"1",
")",
";",
"if",
"(",
"strcmp",
"(",
"\"etrax4\"",
",",
"cris_cpu_str",
")",
"==",
"0",
")",
"cris_cpu_version",
"=",
"3",
";",
"if",
"(",
"strcmp",
"(",
"\"svinto\"",
",",
"cris_cpu_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100\"",
",",
"cris_cpu_str",
")",
"==",
"0",
")",
"cris_cpu_version",
"=",
"8",
";",
"if",
"(",
"strcmp",
"(",
"\"ng\"",
",",
"cris_cpu_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100lx\"",
",",
"cris_cpu_str",
")",
"==",
"0",
")",
"cris_cpu_version",
"=",
"10",
";",
"if",
"(",
"cris_cpu_version",
"<",
"0",
"||",
"cris_cpu_version",
">",
"10",
")",
"error",
"(",
"\"unknown CRIS version specification in -march= or -mcpu= : %s\"",
",",
"cris_cpu_str",
")",
";",
"if",
"(",
"cris_cpu_version",
">=",
"CRIS_CPU_ETRAX4",
")",
"target_flags",
"|=",
"MASK_ETRAX4_ADD",
";",
"if",
"(",
"cris_cpu_version",
">=",
"CRIS_CPU_SVINTO",
")",
"target_flags",
"|=",
"(",
"MASK_SVINTO",
"|",
"MASK_ALIGN_BY_32",
"|",
"MASK_STACK_ALIGN",
"|",
"MASK_CONST_ALIGN",
"|",
"MASK_DATA_ALIGN",
")",
";",
"}",
"if",
"(",
"cris_tune_str",
")",
"{",
"int",
"cris_tune",
"=",
"(",
"*",
"cris_tune_str",
"==",
"'v'",
"?",
"atoi",
"(",
"cris_tune_str",
"+",
"1",
")",
":",
"-",
"1",
")",
";",
"if",
"(",
"strcmp",
"(",
"\"etrax4\"",
",",
"cris_tune_str",
")",
"==",
"0",
")",
"cris_tune",
"=",
"3",
";",
"if",
"(",
"strcmp",
"(",
"\"svinto\"",
",",
"cris_tune_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100\"",
",",
"cris_tune_str",
")",
"==",
"0",
")",
"cris_tune",
"=",
"8",
";",
"if",
"(",
"strcmp",
"(",
"\"ng\"",
",",
"cris_tune_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100lx\"",
",",
"cris_tune_str",
")",
"==",
"0",
")",
"cris_tune",
"=",
"10",
";",
"if",
"(",
"cris_tune",
"<",
"0",
"||",
"cris_tune",
">",
"10",
")",
"error",
"(",
"\"unknown CRIS cpu version specification in -mtune= : %s\"",
",",
"cris_tune_str",
")",
";",
"if",
"(",
"cris_tune",
">=",
"CRIS_CPU_SVINTO",
")",
"target_flags",
"|=",
"(",
"MASK_STACK_ALIGN",
"|",
"MASK_CONST_ALIGN",
"|",
"MASK_DATA_ALIGN",
"|",
"MASK_ALIGN_BY_32",
")",
";",
"}",
"if",
"(",
"flag_pic",
")",
"{",
"if",
"(",
"!",
"TARGET_LINUX",
")",
"{",
"error",
"(",
"\"-fPIC and -fpic are not supported in this configuration\"",
")",
";",
"flag_pic",
"=",
"0",
";",
"}",
"flag_no_function_cse",
"=",
"1",
";",
"}",
"if",
"(",
"write_symbols",
"==",
"DWARF2_DEBUG",
"&&",
"!",
"TARGET_ELF",
")",
"{",
"warning",
"(",
"0",
",",
"\"that particular -g option is invalid with -maout and -melinux\"",
")",
";",
"write_symbols",
"=",
"DBX_DEBUG",
";",
"}",
"init_machine_status",
"=",
"cris_init_machine_status",
";",
"}",
"</s>"
] | [
"The",
"OVERRIDE_OPTIONS",
"worker",
".",
"As",
"is",
"the",
"norm",
",",
"this",
"also",
"parses",
"-mfoo=bar",
"type",
"parameters",
"."
] | [
"cris",
"0",
"0x20000000",
"\"-max-stackframe=%d is not usable, not between 0 and %d\"",
"0x20000000",
"1",
"1",
"\"etrax4\"",
"0",
"3",
"\"svinto\"",
"0",
"\"etrax100\"",
"0",
"8",
"\"ng\"",
"0",
"\"etrax100lx\"",
"0",
"10",
"0",
"10",
"\"unknown CRIS version specification in -march= or -mcpu= : %s\"",
"1",
"1",
"\"etrax4\"",
"0",
"3",
"\"svinto\"",
"0",
"\"etrax100\"",
"0",
"8",
"\"ng\"",
"0",
"\"etrax100lx\"",
"0",
"10",
"0",
"10",
"\"unknown CRIS cpu version specification in -mtune= : %s\"",
"\"-fPIC and -fpic are not supported in this configuration\"",
"0",
"1",
"0",
"\"that particular -g option is invalid with -maout and -melinux\""
] | cris3 | cris_override_options | cris | MPU | GCC | 10,812 | 375 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"MipsDAGToDAGISel",
"::",
"getGlobalBaseReg",
"(",
")",
"{",
"unsigned",
"GlobalBaseReg",
"=",
"getInstrInfo",
"(",
")",
"->",
"getGlobalBaseReg",
"(",
"MF",
")",
";",
"return",
"CurDAG",
"->",
"getRegister",
"(",
"GlobalBaseReg",
",",
"TLI",
".",
"getPointerTy",
"(",
")",
")",
".",
"getNode",
"(",
")",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"Mips",
"Mips"
] | MipsISelDAGToDAG11 | getGlobalBaseReg | Mips | CPU | LLVM | 10,813 | 39 | 1 | [] |
[
"<s>",
"static",
"int",
"mips_immediate_operand_p",
"(",
"int",
"code",
",",
"HOST_WIDE_INT",
"x",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"ASHIFT",
":",
"case",
"ASHIFTRT",
":",
"case",
"LSHIFTRT",
":",
"return",
"true",
";",
"case",
"ROTATE",
":",
"case",
"ROTATERT",
":",
"return",
"ISA_HAS_ROR",
";",
"case",
"AND",
":",
"case",
"IOR",
":",
"case",
"XOR",
":",
"return",
"SMALL_OPERAND_UNSIGNED",
"(",
"x",
")",
";",
"case",
"PLUS",
":",
"case",
"LT",
":",
"case",
"LTU",
":",
"return",
"SMALL_OPERAND",
"(",
"x",
")",
";",
"case",
"EQ",
":",
"case",
"NE",
":",
"case",
"GT",
":",
"case",
"GTU",
":",
"return",
"x",
"==",
"0",
";",
"case",
"GE",
":",
"case",
"GEU",
":",
"return",
"x",
"==",
"1",
";",
"case",
"LE",
":",
"return",
"SMALL_OPERAND",
"(",
"x",
"+",
"1",
")",
";",
"case",
"LEU",
":",
"return",
"SMALL_OPERAND",
"(",
"x",
"+",
"1",
")",
"&&",
"x",
"+",
"1",
"!=",
"0",
";",
"case",
"SIGN_EXTRACT",
":",
"case",
"ZERO_EXTRACT",
":",
"return",
"ISA_HAS_EXT_INS",
";",
"default",
":",
"return",
"x",
"==",
"0",
";",
"}",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"there",
"is",
"a",
"non-MIPS16",
"instruction",
"that",
"implements",
"CODE",
"and",
"if",
"that",
"instruction",
"accepts",
"X",
"as",
"an",
"immediate",
"operand",
"."
] | [
"mips",
"0",
"1",
"1",
"1",
"1",
"0",
"0"
] | mips | mips_immediate_operand_p | mips | CPU | GCC | 10,814 | 141 | 1 | [] |
[
"<s>",
"static",
"void",
"x86_print_call_or_nop",
"(",
"FILE",
"*",
"file",
",",
"const",
"char",
"*",
"target",
")",
"{",
"if",
"(",
"flag_nop_mcount",
")",
"fprintf",
"(",
"file",
",",
"\"1:\"",
"ASM_BYTE",
"\"0x0f, 0x1f, 0x44, 0x00, 0x00\\n\"",
")",
";",
"else",
"fprintf",
"(",
"file",
",",
"\"1:\\tcall\\t%s\\n\"",
",",
"target",
")",
";",
"}",
"</s>"
] | [
"Print",
"call",
"to",
"TARGET",
"to",
"FILE",
"."
] | [
"i386",
"\"1:\"",
"\"0x0f, 0x1f, 0x44, 0x00, 0x00\\n\"",
"\"1:\\tcall\\t%s\\n\""
] | i3867 | x86_print_call_or_nop | i386 | CPU | GCC | 10,815 | 38 | 1 | [] |
[
"<s>",
"rtx",
"tilepro_simd_int",
"(",
"rtx",
"num",
",",
"machine_mode",
"mode",
")",
"{",
"HOST_WIDE_INT",
"n",
"=",
"0",
";",
"gcc_assert",
"(",
"CONST_INT_P",
"(",
"num",
")",
")",
";",
"n",
"=",
"INTVAL",
"(",
"num",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"QImode",
":",
"n",
"=",
"0x01010101",
"*",
"(",
"n",
"&",
"0x000000FF",
")",
";",
"break",
";",
"case",
"HImode",
":",
"n",
"=",
"0x00010001",
"*",
"(",
"n",
"&",
"0x0000FFFF",
")",
";",
"break",
";",
"case",
"SImode",
":",
"break",
";",
"case",
"DImode",
":",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"gen_int_si",
"(",
"n",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"simd",
"variant",
"of",
"the",
"constant",
"NUM",
"of",
"mode",
"MODE",
",",
"by",
"replicating",
"it",
"to",
"fill",
"an",
"interger",
"of",
"mode",
"SImode",
".",
"NUM",
"is",
"first",
"truncated",
"to",
"fit",
"in",
"MODE",
"."
] | [
"tilepro",
"0",
"0x01010101",
"0x000000FF",
"0x00010001",
"0x0000FFFF"
] | tilepro2 | tilepro_simd_int | tilepro | VLIW | GCC | 10,816 | 89 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"OutStreamer",
".",
"emitRawComment",
"(",
"Twine",
"(",
"'@'",
")",
"+",
"MF",
".",
"getName",
"(",
")",
"+",
"Twine",
"(",
"':'",
")",
")",
";",
"MCContext",
"&",
"Context",
"=",
"getObjFileLowering",
"(",
")",
".",
"getContext",
"(",
")",
";",
"const",
"MCSectionELF",
"*",
"ConfigSection",
"=",
"Context",
".",
"getELFSection",
"(",
"\".AMDGPU.config\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"0",
",",
"SectionKind",
"::",
"getReadOnly",
"(",
")",
")",
";",
"OutStreamer",
".",
"SwitchSection",
"(",
"ConfigSection",
")",
";",
"const",
"AMDGPUSubtarget",
"&",
"STM",
"=",
"TM",
".",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
")",
";",
"SIProgramInfo",
"KernelInfo",
";",
"if",
"(",
"STM",
".",
"getGeneration",
"(",
")",
">",
"AMDGPUSubtarget",
"::",
"NORTHERN_ISLANDS",
")",
"{",
"getSIProgramInfo",
"(",
"KernelInfo",
",",
"MF",
")",
";",
"EmitProgramInfoSI",
"(",
"MF",
",",
"KernelInfo",
")",
";",
"}",
"else",
"{",
"EmitProgramInfoR600",
"(",
"MF",
")",
";",
"}",
"DisasmLines",
".",
"clear",
"(",
")",
";",
"HexLines",
".",
"clear",
"(",
")",
";",
"DisasmLineMaxLen",
"=",
"0",
";",
"OutStreamer",
".",
"SwitchSection",
"(",
"getObjFileLowering",
"(",
")",
".",
"getTextSection",
"(",
")",
")",
";",
"EmitFunctionBody",
"(",
")",
";",
"if",
"(",
"isVerbose",
"(",
")",
")",
"{",
"const",
"MCSectionELF",
"*",
"CommentSection",
"=",
"Context",
".",
"getELFSection",
"(",
"\".AMDGPU.csdata\"",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"0",
",",
"SectionKind",
"::",
"getReadOnly",
"(",
")",
")",
";",
"OutStreamer",
".",
"SwitchSection",
"(",
"CommentSection",
")",
";",
"if",
"(",
"STM",
".",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"SOUTHERN_ISLANDS",
")",
"{",
"OutStreamer",
".",
"emitRawComment",
"(",
"\" Kernel info:\"",
",",
"false",
")",
";",
"OutStreamer",
".",
"emitRawComment",
"(",
"\" codeLenInByte = \"",
"+",
"Twine",
"(",
"KernelInfo",
".",
"CodeLen",
")",
",",
"false",
")",
";",
"OutStreamer",
".",
"emitRawComment",
"(",
"\" NumSgprs: \"",
"+",
"Twine",
"(",
"KernelInfo",
".",
"NumSGPR",
")",
",",
"false",
")",
";",
"OutStreamer",
".",
"emitRawComment",
"(",
"\" NumVgprs: \"",
"+",
"Twine",
"(",
"KernelInfo",
".",
"NumVGPR",
")",
",",
"false",
")",
";",
"}",
"else",
"{",
"R600MachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"R600MachineFunctionInfo",
">",
"(",
")",
";",
"OutStreamer",
".",
"emitRawComment",
"(",
"Twine",
"(",
"\"SQ_PGM_RESOURCES:STACK_SIZE = \"",
"+",
"Twine",
"(",
"MFI",
"->",
"StackSize",
")",
")",
")",
";",
"}",
"}",
"if",
"(",
"STM",
".",
"dumpCode",
"(",
")",
")",
"{",
"MF",
".",
"dump",
"(",
")",
";",
"if",
"(",
"DisasmEnabled",
")",
"{",
"OutStreamer",
".",
"SwitchSection",
"(",
"Context",
".",
"getELFSection",
"(",
"\".AMDGPU.disasm\"",
",",
"ELF",
"::",
"SHT_NOTE",
",",
"0",
",",
"SectionKind",
"::",
"getReadOnly",
"(",
")",
")",
")",
";",
"for",
"(",
"size_t",
"i",
"=",
"0",
";",
"i",
"<",
"DisasmLines",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"std",
"::",
"string",
"Comment",
"(",
"DisasmLineMaxLen",
"-",
"DisasmLines",
"[",
"i",
"]",
".",
"size",
"(",
")",
",",
"' '",
")",
";",
"Comment",
"+=",
"\" ; \"",
"+",
"HexLines",
"[",
"i",
"]",
"+",
"\"\\n\"",
";",
"OutStreamer",
".",
"EmitBytes",
"(",
"StringRef",
"(",
"DisasmLines",
"[",
"i",
"]",
")",
")",
";",
"OutStreamer",
".",
"EmitBytes",
"(",
"StringRef",
"(",
"Comment",
")",
")",
";",
"}",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"R600",
"\".AMDGPU.config\"",
"0",
"SI",
"SI",
"SI",
"0",
"\".AMDGPU.csdata\"",
"0",
"\" Kernel info:\"",
"\" codeLenInByte = \"",
"\" NumSgprs: \"",
"\" NumVgprs: \"",
"\"SQ_PGM_RESOURCES:STACK_SIZE = \"",
"\".AMDGPU.disasm\"",
"0",
"0",
"\" ; \"",
"\"\\n\""
] | AMDGPUAsmPrinter66 | runOnMachineFunction | R600 | GPU | LLVM | 10,817 | 431 | 1 | [] |
[
"<s>",
"void",
"BPFPassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"const",
"BPFSubtarget",
"*",
"Subtarget",
"=",
"getBPFTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
";",
"addPass",
"(",
"createBPFMIPreEmitCheckingPass",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"if",
"(",
"Subtarget",
"->",
"getHasAlu32",
"(",
")",
"&&",
"!",
"DisableMIPeephole",
")",
"addPass",
"(",
"createBPFMIPreEmitPeepholePass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"BPF",
"BPF",
"BPF",
"BPF",
"BPF",
"BPF"
] | BPFTargetMachine (2)1 | addPreEmitPass | BPF | Virtual ISA | LLVM | 10,818 | 56 | 1 | [] |
[
"<s>",
"void",
"BTFTypeFuncProto",
"::",
"completeType",
"(",
"BTFDebug",
"&",
"BDebug",
")",
"{",
"DITypeRefArray",
"Elements",
"=",
"STy",
"->",
"getTypeArray",
"(",
")",
";",
"auto",
"RetType",
"=",
"Elements",
"[",
"0",
"]",
";",
"BTFType",
".",
"Type",
"=",
"RetType",
"?",
"BDebug",
".",
"getTypeId",
"(",
"RetType",
")",
":",
"0",
";",
"BTFType",
".",
"NameOff",
"=",
"0",
";",
"for",
"(",
"unsigned",
"I",
"=",
"1",
",",
"N",
"=",
"Elements",
".",
"size",
"(",
")",
";",
"I",
"<",
"N",
";",
"++",
"I",
")",
"{",
"struct",
"BTF",
"::",
"BTFParam",
"Param",
";",
"auto",
"Element",
"=",
"Elements",
"[",
"I",
"]",
";",
"if",
"(",
"Element",
")",
"{",
"Param",
".",
"NameOff",
"=",
"BDebug",
".",
"addString",
"(",
"FuncArgNames",
"[",
"I",
"]",
")",
";",
"Param",
".",
"Type",
"=",
"BDebug",
".",
"getTypeId",
"(",
"Element",
")",
";",
"}",
"else",
"{",
"Param",
".",
"NameOff",
"=",
"0",
";",
"Param",
".",
"Type",
"=",
"0",
";",
"}",
"Parameters",
".",
"push_back",
"(",
"Param",
")",
";",
"}",
"}",
"</s>"
] | [
"Complete",
"BTF",
"type",
"generation",
"after",
"all",
"related",
"DebugInfo",
"types",
"have",
"been",
"visited",
"so",
"their",
"BTF",
"type",
"id",
"'s",
"are",
"available",
"for",
"cross",
"referece",
"."
] | [
"BPF",
"0",
"0",
"0",
"1",
"BTF::BTFParam",
"0",
"0"
] | BTFDebug31 | completeType | BPF | Virtual ISA | LLVM | 10,819 | 140 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_builtin_support_vector_misalignment",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"int",
"misalignment",
",",
"bool",
"is_packed",
")",
"{",
"if",
"(",
"TARGET_VSX",
")",
"{",
"if",
"(",
"TARGET_EFFICIENT_UNALIGNED_VSX",
")",
"return",
"true",
";",
"if",
"(",
"optab_handler",
"(",
"movmisalign_optab",
",",
"mode",
")",
"==",
"CODE_FOR_nothing",
")",
"return",
"false",
";",
"if",
"(",
"misalignment",
"==",
"-",
"1",
")",
"{",
"if",
"(",
"rs6000_vector_alignment_reachable",
"(",
"type",
",",
"is_packed",
")",
")",
"{",
"int",
"element_size",
"=",
"TREE_INT_CST_LOW",
"(",
"TYPE_SIZE",
"(",
"type",
")",
")",
";",
"if",
"(",
"element_size",
"==",
"64",
"||",
"element_size",
"==",
"32",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"if",
"(",
"misalignment",
"%",
"4",
"==",
"0",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"vector",
"misalignment",
"factor",
"is",
"supported",
"by",
"the",
"target",
"."
] | [
"rs6000",
"1",
"64",
"32",
"4",
"0"
] | rs6000 | rs6000_builtin_support_vector_misalignment | rs6000 | CPU | GCC | 10,820 | 106 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Hexagon Store Widening\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Hexagon",
"\"Hexagon Store Widening\""
] | HexagonStoreWidening1 | getPassName | Hexagon | DSP | LLVM | 10,821 | 13 | 1 | [] |
[
"<s>",
"bool",
"ix86_avoid_lea_for_addr",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"operands",
"[",
"]",
")",
"{",
"unsigned",
"int",
"regno0",
",",
"regno1",
",",
"regno2",
";",
"int",
"split_cost",
";",
"struct",
"ix86_address",
"parts",
";",
"int",
"ok",
";",
"if",
"(",
"!",
"TARGET_AVOID_LEA_FOR_ADDR",
"||",
"optimize_function_for_size_p",
"(",
"cfun",
")",
")",
"return",
"false",
";",
"if",
"(",
"REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
"||",
"(",
"SImode_address_operand",
"(",
"operands",
"[",
"1",
"]",
",",
"VOIDmode",
")",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"0",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"ix86_ok_to_clobber_flags",
"(",
"insn",
")",
")",
"return",
"false",
";",
"ok",
"=",
"ix86_decompose_address",
"(",
"operands",
"[",
"1",
"]",
",",
"&",
"parts",
")",
";",
"gcc_assert",
"(",
"ok",
")",
";",
"if",
"(",
"(",
"parts",
".",
"base",
"!=",
"NULL_RTX",
")",
"+",
"(",
"parts",
".",
"index",
"!=",
"NULL_RTX",
")",
"+",
"(",
"parts",
".",
"disp",
"!=",
"NULL_RTX",
")",
"+",
"(",
"parts",
".",
"scale",
">",
"1",
")",
"<",
"2",
")",
"return",
"false",
";",
"if",
"(",
"parts",
".",
"disp",
"&&",
"flag_pic",
"&&",
"!",
"LEGITIMATE_PIC_OPERAND_P",
"(",
"parts",
".",
"disp",
")",
")",
"return",
"false",
";",
"regno0",
"=",
"true_regnum",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"regno1",
"=",
"INVALID_REGNUM",
";",
"regno2",
"=",
"INVALID_REGNUM",
";",
"if",
"(",
"parts",
".",
"base",
")",
"regno1",
"=",
"true_regnum",
"(",
"parts",
".",
"base",
")",
";",
"if",
"(",
"parts",
".",
"index",
")",
"regno2",
"=",
"true_regnum",
"(",
"parts",
".",
"index",
")",
";",
"split_cost",
"=",
"0",
";",
"if",
"(",
"parts",
".",
"base",
"||",
"parts",
".",
"index",
")",
"{",
"if",
"(",
"regno1",
"!=",
"regno0",
"&&",
"regno2",
"!=",
"regno0",
")",
"split_cost",
"+=",
"1",
";",
"if",
"(",
"parts",
".",
"base",
"&&",
"parts",
".",
"index",
")",
"split_cost",
"+=",
"1",
";",
"if",
"(",
"parts",
".",
"scale",
">",
"1",
")",
"{",
"if",
"(",
"regno0",
"!=",
"regno1",
")",
"split_cost",
"+=",
"1",
";",
"else",
"if",
"(",
"regno2",
"==",
"regno0",
")",
"split_cost",
"+=",
"4",
";",
"else",
"split_cost",
"+=",
"parts",
".",
"scale",
";",
"}",
"if",
"(",
"parts",
".",
"disp",
"&&",
"parts",
".",
"disp",
"!=",
"const0_rtx",
")",
"split_cost",
"+=",
"1",
";",
"split_cost",
"-=",
"1",
";",
"}",
"return",
"!",
"ix86_lea_outperforms",
"(",
"insn",
",",
"regno0",
",",
"regno1",
",",
"regno2",
",",
"split_cost",
",",
"parts",
".",
"scale",
">",
"1",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"need",
"to",
"split",
"lea",
"into",
"a",
"sequence",
"of",
"instructions",
"to",
"avoid",
"AGU",
"stalls",
"during",
"peephole2",
"."
] | [
"i386",
"1",
"1",
"1",
"0",
"1",
"1",
"2",
"0",
"0",
"1",
"1",
"1",
"1",
"4",
"1",
"1",
"1"
] | i3864 | ix86_avoid_lea_for_addr | i386 | CPU | GCC | 10,822 | 341 | 1 | [] |
[
"<s>",
"unsigned",
"MipsCodeEmitter",
"::",
"getBranchTarget26OpValue",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"OpNo",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"Unimplemented function.\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTarget26OpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"\"Unimplemented function.\"",
"0"
] | MipsCodeEmitter11 | getBranchTarget26OpValue | Mips | CPU | LLVM | 10,823 | 24 | 1 | [] |
[
"<s>",
"void",
"rs6000_asm_output_dwarf_datarel",
"(",
"FILE",
"*",
"file",
",",
"int",
"size",
",",
"const",
"char",
"*",
"label",
")",
"{",
"fputs",
"(",
"integer_asm_op",
"(",
"size",
",",
"FALSE",
")",
",",
"file",
")",
";",
"assemble_name",
"(",
"file",
",",
"label",
")",
";",
"fputs",
"(",
"\"-__gcc_unwind_dbase\"",
",",
"file",
")",
";",
"}",
"</s>"
] | [
"Output",
"a",
"symbol",
"offset",
"relative",
"to",
"the",
"dbase",
"for",
"the",
"current",
"object",
".",
"We",
"use",
"__gcc_unwind_dbase",
"as",
"an",
"arbitrary",
"base",
"for",
"dbase",
"and",
"assume",
"signed",
"offsets",
".",
"__gcc_unwind_dbase",
"is",
"embedded",
"in",
"all",
"executables/libraries",
"through",
"libgcc/config/rs6000/crtdbase.S",
"."
] | [
"powerpcspe",
"\"-__gcc_unwind_dbase\""
] | powerpcspe | rs6000_asm_output_dwarf_datarel | powerpcspe | CPU | GCC | 10,824 | 43 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_valid_floating_const",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"!",
"CONST_DOUBLE_P",
"(",
"x",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"(",
"mode",
"==",
"SFmode",
"||",
"mode",
"==",
"DFmode",
")",
")",
"return",
"false",
";",
"if",
"(",
"aarch64_float_const_zero_rtx_p",
"(",
"x",
")",
")",
"return",
"true",
";",
"return",
"aarch64_float_const_representable_p",
"(",
"x",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"X",
"holds",
"either",
"a",
"quarter-precision",
"or",
"floating-point",
"+0.0",
"constant",
"."
] | [
"aarch64"
] | aarch642 | aarch64_valid_floating_const | aarch64 | CPU | GCC | 10,825 | 55 | 1 | [] |
[
"<s>",
"bool",
"fusion_p9_p",
"(",
"rtx",
"addis_reg",
",",
"rtx",
"addis_value",
",",
"rtx",
"dest",
",",
"rtx",
"src",
")",
"{",
"rtx",
"addr",
",",
"mem",
",",
"offset",
";",
"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",
"."
] | [
"powerpcspe",
"0",
"0",
"0",
"1",
"0",
"1"
] | powerpcspe | fusion_p9_p | powerpcspe | CPU | GCC | 10,826 | 287 | 1 | [] |
[
"<s>",
"bool",
"function_instance",
"::",
"could_trap_p",
"(",
")",
"const",
"{",
"unsigned",
"int",
"flags",
"=",
"call_properties",
"(",
")",
";",
"if",
"(",
"flags",
"&",
"CP_RAISE_FP_EXCEPTIONS",
")",
"return",
"true",
";",
"if",
"(",
"flags",
"&",
"(",
"CP_READ_MEMORY",
"|",
"CP_WRITE_MEMORY",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"calls",
"to",
"the",
"function",
"could",
"raise",
"a",
"signal",
"."
] | [
"aarch64"
] | aarch64-sve-builtins | could_trap_p | aarch64 | CPU | GCC | 10,827 | 42 | 1 | [] |
[
"<s>",
"void",
"R600InstrInfo",
"::",
"clearFlag",
"(",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"Operand",
",",
"unsigned",
"Flag",
")",
"const",
"{",
"unsigned",
"TargetFlags",
"=",
"get",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
".",
"TSFlags",
";",
"if",
"(",
"HAS_NATIVE_OPERANDS",
"(",
"TargetFlags",
")",
")",
"{",
"MachineOperand",
"&",
"FlagOp",
"=",
"getFlagOp",
"(",
"MI",
",",
"Operand",
",",
"Flag",
")",
";",
"FlagOp",
".",
"setImm",
"(",
"0",
")",
";",
"}",
"else",
"{",
"MachineOperand",
"&",
"FlagOp",
"=",
"getFlagOp",
"(",
"MI",
")",
";",
"unsigned",
"InstFlags",
"=",
"FlagOp",
".",
"getImm",
"(",
")",
";",
"InstFlags",
"&=",
"~",
"(",
"Flag",
"<<",
"(",
"NUM_MO_FLAGS",
"*",
"Operand",
")",
")",
";",
"FlagOp",
".",
"setImm",
"(",
"InstFlags",
")",
";",
"}",
"}",
"</s>"
] | [
"Clear",
"the",
"specified",
"flag",
"on",
"the",
"instruction",
"."
] | [
"R600",
"0"
] | R600InstrInfo | clearFlag | R600 | GPU | LLVM | 10,828 | 102 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"SPUInstrInfo",
"::",
"foldMemoryOperandImpl",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineInstr",
"*",
"MI",
",",
"const",
"SmallVectorImpl",
"<",
"unsigned",
">",
"&",
"Ops",
",",
"int",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"Ops",
".",
"size",
"(",
")",
"!=",
"1",
")",
"return",
"0",
";",
"unsigned",
"OpNum",
"=",
"Ops",
"[",
"0",
"]",
";",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"MachineInstr",
"*",
"NewMI",
"=",
"0",
";",
"switch",
"(",
"Opc",
")",
"{",
"case",
"SPU",
"::",
"ORv16i8",
":",
"case",
"SPU",
"::",
"ORv8i16",
":",
"case",
"SPU",
"::",
"ORv4i32",
":",
"case",
"SPU",
"::",
"ORv2i64",
":",
"case",
"SPU",
"::",
"ORr8",
":",
"case",
"SPU",
"::",
"ORr16",
":",
"case",
"SPU",
"::",
"ORr32",
":",
"case",
"SPU",
"::",
"ORr64",
":",
"case",
"SPU",
"::",
"ORf32",
":",
"case",
"SPU",
"::",
"ORf64",
":",
"if",
"(",
"OpNum",
"==",
"0",
")",
"{",
"unsigned",
"InReg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"bool",
"isKill",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isKill",
"(",
")",
";",
"if",
"(",
"FrameIndex",
"<",
"SPUFrameInfo",
"::",
"maxFrameOffset",
"(",
")",
")",
"{",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MF",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"SPU",
"::",
"STQDr32",
")",
")",
";",
"MIB",
".",
"addReg",
"(",
"InReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
";",
"NewMI",
"=",
"addFrameReference",
"(",
"MIB",
",",
"FrameIndex",
")",
";",
"}",
"}",
"else",
"{",
"unsigned",
"OutReg",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"bool",
"isDead",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"isDead",
"(",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MF",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"Opc",
")",
")",
";",
"MIB",
".",
"addReg",
"(",
"OutReg",
",",
"RegState",
"::",
"Define",
"|",
"getDeadRegState",
"(",
"isDead",
")",
")",
";",
"Opc",
"=",
"(",
"FrameIndex",
"<",
"SPUFrameInfo",
"::",
"maxFrameOffset",
"(",
")",
")",
"?",
"SPU",
"::",
"STQDr32",
":",
"SPU",
"::",
"STQXr32",
";",
"NewMI",
"=",
"addFrameReference",
"(",
"MIB",
",",
"FrameIndex",
")",
";",
"break",
";",
"}",
"}",
"return",
"NewMI",
";",
"}",
"</s>"
] | [
"foldMemoryOperand",
"-",
"Same",
"as",
"the",
"previous",
"version",
"except",
"it",
"allows",
"folding",
"of",
"any",
"load",
"and",
"store",
"from",
"/",
"to",
"any",
"address",
",",
"not",
"just",
"from",
"a",
"specific",
"stack",
"slot",
"."
] | [
"CellSPU",
"SPU",
"1",
"0",
"0",
"0",
"SPU::ORv16i8",
"SPU::ORv8i16",
"SPU::ORv4i32",
"SPU::ORv2i64",
"SPU::ORr8",
"SPU::ORr16",
"SPU::ORr32",
"SPU::ORr64",
"SPU::ORf32",
"SPU::ORf64",
"0",
"1",
"1",
"SPU",
"SPU::STQDr32",
"0",
"0",
"SPU",
"SPU::STQDr32",
"SPU::STQXr32"
] | SPUInstrInfo3 | foldMemoryOperandImpl | CellSPU | MPU | LLVM | 10,829 | 310 | 1 | [] |
[
"<s>",
"void",
"rs6000_emit_popcount",
"(",
"rtx",
"dst",
",",
"rtx",
"src",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"dst",
")",
";",
"rtx",
"tmp1",
",",
"tmp2",
";",
"if",
"(",
"TARGET_POPCNTD",
")",
"{",
"if",
"(",
"mode",
"==",
"SImode",
")",
"emit_insn",
"(",
"gen_popcntdsi2",
"(",
"dst",
",",
"src",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_popcntddi2",
"(",
"dst",
",",
"src",
")",
")",
";",
"return",
";",
"}",
"tmp1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"if",
"(",
"mode",
"==",
"SImode",
")",
"{",
"emit_insn",
"(",
"gen_popcntbsi2",
"(",
"tmp1",
",",
"src",
")",
")",
";",
"tmp2",
"=",
"expand_mult",
"(",
"SImode",
",",
"tmp1",
",",
"GEN_INT",
"(",
"0x01010101",
")",
",",
"NULL_RTX",
",",
"0",
")",
";",
"tmp2",
"=",
"force_reg",
"(",
"SImode",
",",
"tmp2",
")",
";",
"emit_insn",
"(",
"gen_lshrsi3",
"(",
"dst",
",",
"tmp2",
",",
"GEN_INT",
"(",
"24",
")",
")",
")",
";",
"}",
"else",
"{",
"emit_insn",
"(",
"gen_popcntbdi2",
"(",
"tmp1",
",",
"src",
")",
")",
";",
"tmp2",
"=",
"expand_mult",
"(",
"DImode",
",",
"tmp1",
",",
"GEN_INT",
"(",
"(",
"HOST_WIDE_INT",
")",
"0x01010101",
"<<",
"32",
"|",
"0x01010101",
")",
",",
"NULL_RTX",
",",
"0",
")",
";",
"tmp2",
"=",
"force_reg",
"(",
"DImode",
",",
"tmp2",
")",
";",
"emit_insn",
"(",
"gen_lshrdi3",
"(",
"dst",
",",
"tmp2",
",",
"GEN_INT",
"(",
"56",
")",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"popcount",
"intrinsic",
"on",
"TARGET_POPCNTB",
"(",
"Power5",
")",
"and",
"TARGET_POPCNTD",
"(",
"Power7",
")",
"targets",
".",
"DST",
"is",
"the",
"target",
",",
"and",
"SRC",
"is",
"the",
"argument",
"operand",
"."
] | [
"rs6000",
"0x01010101",
"0",
"24",
"0x01010101",
"32",
"0x01010101",
"0",
"56"
] | rs6000 | rs6000_emit_popcount | rs6000 | CPU | GCC | 10,830 | 188 | 1 | [] |
[
"<s>",
"bool",
"Z80PassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"addPass",
"(",
"createZ80ISelDAG",
"(",
"getZ80TargetMachine",
"(",
")",
",",
"getOptLevel",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"Z80",
"Z80",
"Z80",
"Z80"
] | Z80TargetMachine (2) | addInstSelector | Z80 | MPU | LLVM | 10,831 | 25 | 1 | [] |
[
"<s>",
"SDValue",
"MSP430TargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_MSP430",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"Chain",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
",",
"InFlag",
")",
".",
"getValue",
"(",
"1",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"2",
")",
";",
"InVals",
".",
"push_back",
"(",
"Chain",
".",
"getValue",
"(",
"0",
")",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"MSP430",
"MSP430",
"ISD::InputArg",
"16",
"MSP430",
"0",
"1",
"2",
"0"
] | MSP430ISelLowering1 | LowerCallResult | MSP430 | MPU | LLVM | 10,832 | 170 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"SystemZ Assembly Printer\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"SystemZ",
"\"SystemZ Assembly Printer\""
] | SystemZAsmPrinter2 | getPassName | SystemZ | CPU | LLVM | 10,833 | 13 | 1 | [] |
[
"<s>",
"bool",
"PPCDarwinAsmPrinter",
"::",
"doFinalization",
"(",
"Module",
"&",
"M",
")",
"{",
"bool",
"isPPC64",
"=",
"getDataLayout",
"(",
")",
".",
"getPointerSizeInBits",
"(",
")",
"==",
"64",
";",
"const",
"TargetLoweringObjectFileMachO",
"&",
"TLOFMacho",
"=",
"static_cast",
"<",
"const",
"TargetLoweringObjectFileMachO",
"&",
">",
"(",
"getObjFileLowering",
"(",
")",
")",
";",
"if",
"(",
"MMI",
")",
"{",
"MachineModuleInfoMachO",
"&",
"MMIMacho",
"=",
"MMI",
"->",
"getObjFileInfo",
"<",
"MachineModuleInfoMachO",
">",
"(",
")",
";",
"if",
"(",
"MAI",
"->",
"doesSupportExceptionHandling",
"(",
")",
")",
"{",
"for",
"(",
"const",
"Function",
"*",
"Personality",
":",
"MMI",
"->",
"getPersonalities",
"(",
")",
")",
"{",
"if",
"(",
"Personality",
")",
"{",
"MCSymbol",
"*",
"NLPSym",
"=",
"getSymbolWithGlobalValueBase",
"(",
"Personality",
",",
"\"$non_lazy_ptr\"",
")",
";",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"&",
"StubSym",
"=",
"MMIMacho",
".",
"getGVStubEntry",
"(",
"NLPSym",
")",
";",
"StubSym",
"=",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"(",
"getSymbol",
"(",
"Personality",
")",
",",
"true",
")",
";",
"}",
"}",
"}",
"MachineModuleInfoMachO",
"::",
"SymbolListTy",
"Stubs",
"=",
"MMIMacho",
".",
"GetGVStubList",
"(",
")",
";",
"if",
"(",
"!",
"Stubs",
".",
"empty",
"(",
")",
")",
"{",
"OutStreamer",
"->",
"SwitchSection",
"(",
"TLOFMacho",
".",
"getNonLazySymbolPointerSection",
"(",
")",
")",
";",
"EmitAlignment",
"(",
"isPPC64",
"?",
"Align",
"(",
"8",
")",
":",
"Align",
"(",
"4",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"Stubs",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"OutStreamer",
"->",
"EmitLabel",
"(",
"Stubs",
"[",
"i",
"]",
".",
"first",
")",
";",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"&",
"MCSym",
"=",
"Stubs",
"[",
"i",
"]",
".",
"second",
";",
"OutStreamer",
"->",
"EmitSymbolAttribute",
"(",
"MCSym",
".",
"getPointer",
"(",
")",
",",
"MCSA_IndirectSymbol",
")",
";",
"if",
"(",
"MCSym",
".",
"getInt",
"(",
")",
")",
"OutStreamer",
"->",
"EmitIntValue",
"(",
"0",
",",
"isPPC64",
"?",
"8",
":",
"4",
")",
";",
"else",
"OutStreamer",
"->",
"EmitValue",
"(",
"MCSymbolRefExpr",
"::",
"create",
"(",
"MCSym",
".",
"getPointer",
"(",
")",
",",
"OutContext",
")",
",",
"isPPC64",
"?",
"8",
":",
"4",
")",
";",
"}",
"Stubs",
".",
"clear",
"(",
")",
";",
"OutStreamer",
"->",
"AddBlankLine",
"(",
")",
";",
"}",
"}",
"OutStreamer",
"->",
"EmitAssemblerFlag",
"(",
"MCAF_SubsectionsViaSymbols",
")",
";",
"return",
"AsmPrinter",
"::",
"doFinalization",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"doFinalization",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"any",
"necessary",
"clean",
"up",
"after",
"all",
"passes",
"have",
"run",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"64",
"\"$non_lazy_ptr\"",
"PPC",
"8",
"4",
"0",
"0",
"PPC",
"8",
"4",
"PPC",
"8",
"4"
] | PPCAsmPrinter101 | doFinalization | PowerPC | CPU | LLVM | 10,834 | 312 | 1 | [] |
[
"<s>",
"static",
"rtx",
"rs6000_legitimize_tls_address_aix",
"(",
"rtx",
"addr",
",",
"enum",
"tls_model",
"model",
")",
"{",
"rtx",
"sym",
",",
"mem",
",",
"tocref",
",",
"tlsreg",
",",
"tmpreg",
",",
"dest",
",",
"tlsaddr",
";",
"const",
"char",
"*",
"name",
";",
"char",
"*",
"tlsname",
";",
"name",
"=",
"XSTR",
"(",
"addr",
",",
"0",
")",
";",
"if",
"(",
"name",
"[",
"strlen",
"(",
"name",
")",
"-",
"1",
"]",
"!=",
"']'",
"&&",
"(",
"TREE_PUBLIC",
"(",
"SYMBOL_REF_DECL",
"(",
"addr",
")",
")",
"||",
"bss_initializer_p",
"(",
"SYMBOL_REF_DECL",
"(",
"addr",
")",
")",
")",
")",
"{",
"tlsname",
"=",
"XALLOCAVEC",
"(",
"char",
",",
"strlen",
"(",
"name",
")",
"+",
"4",
")",
";",
"strcpy",
"(",
"tlsname",
",",
"name",
")",
";",
"strcat",
"(",
"tlsname",
",",
"bss_initializer_p",
"(",
"SYMBOL_REF_DECL",
"(",
"addr",
")",
")",
"?",
"\"[UL]\"",
":",
"\"[TL]\"",
")",
";",
"tlsaddr",
"=",
"copy_rtx",
"(",
"addr",
")",
";",
"XSTR",
"(",
"tlsaddr",
",",
"0",
")",
"=",
"ggc_strdup",
"(",
"tlsname",
")",
";",
"}",
"else",
"tlsaddr",
"=",
"addr",
";",
"sym",
"=",
"force_const_mem",
"(",
"GET_MODE",
"(",
"tlsaddr",
")",
",",
"tlsaddr",
")",
";",
"if",
"(",
"constant_pool_expr_p",
"(",
"XEXP",
"(",
"sym",
",",
"0",
")",
")",
"&&",
"ASM_OUTPUT_SPECIAL_POOL_ENTRY_P",
"(",
"get_pool_constant",
"(",
"XEXP",
"(",
"sym",
",",
"0",
")",
")",
",",
"Pmode",
")",
")",
"{",
"tocref",
"=",
"create_TOC_reference",
"(",
"XEXP",
"(",
"sym",
",",
"0",
")",
",",
"NULL_RTX",
")",
";",
"mem",
"=",
"gen_const_mem",
"(",
"Pmode",
",",
"tocref",
")",
";",
"set_mem_alias_set",
"(",
"mem",
",",
"get_TOC_alias_set",
"(",
")",
")",
";",
"}",
"else",
"return",
"sym",
";",
"if",
"(",
"model",
"==",
"TLS_MODEL_GLOBAL_DYNAMIC",
"||",
"model",
"==",
"TLS_MODEL_LOCAL_DYNAMIC",
")",
"{",
"name",
"=",
"XSTR",
"(",
"XVECEXP",
"(",
"XEXP",
"(",
"mem",
",",
"0",
")",
",",
"0",
",",
"0",
")",
",",
"0",
")",
";",
"tlsname",
"=",
"XALLOCAVEC",
"(",
"char",
",",
"strlen",
"(",
"name",
")",
"+",
"1",
")",
";",
"strcpy",
"(",
"tlsname",
",",
"\"*LCM\"",
")",
";",
"strcat",
"(",
"tlsname",
",",
"name",
"+",
"3",
")",
";",
"rtx",
"modaddr",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"ggc_strdup",
"(",
"tlsname",
")",
")",
";",
"SYMBOL_REF_FLAGS",
"(",
"modaddr",
")",
"|=",
"SYMBOL_FLAG_LOCAL",
";",
"tocref",
"=",
"create_TOC_reference",
"(",
"modaddr",
",",
"NULL_RTX",
")",
";",
"rtx",
"modmem",
"=",
"gen_const_mem",
"(",
"Pmode",
",",
"tocref",
")",
";",
"set_mem_alias_set",
"(",
"modmem",
",",
"get_TOC_alias_set",
"(",
")",
")",
";",
"rtx",
"modreg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"modreg",
",",
"modmem",
")",
")",
";",
"tmpreg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"tmpreg",
",",
"mem",
")",
")",
";",
"dest",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"if",
"(",
"TARGET_32BIT",
")",
"emit_insn",
"(",
"gen_tls_get_addrsi",
"(",
"dest",
",",
"modreg",
",",
"tmpreg",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_tls_get_addrdi",
"(",
"dest",
",",
"modreg",
",",
"tmpreg",
")",
")",
";",
"return",
"dest",
";",
"}",
"else",
"if",
"(",
"TARGET_32BIT",
")",
"{",
"tlsreg",
"=",
"gen_reg_rtx",
"(",
"SImode",
")",
";",
"emit_insn",
"(",
"gen_tls_get_tpointer",
"(",
"tlsreg",
")",
")",
";",
"}",
"else",
"tlsreg",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"13",
")",
";",
"tmpreg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"tmpreg",
",",
"mem",
")",
")",
";",
"set_unique_reg_note",
"(",
"get_last_insn",
"(",
")",
",",
"REG_EQUAL",
",",
"gen_rtx_MINUS",
"(",
"Pmode",
",",
"addr",
",",
"tlsreg",
")",
")",
";",
"dest",
"=",
"force_reg",
"(",
"Pmode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"tmpreg",
",",
"tlsreg",
")",
")",
";",
"return",
"dest",
";",
"}",
"</s>"
] | [
"AIX",
"Thread-Local",
"Address",
"support",
"."
] | [
"powerpcspe",
"0",
"1",
"4",
"\"[UL]\"",
"\"[TL]\"",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"\"*LCM\"",
"3",
"13"
] | powerpcspe | rs6000_legitimize_tls_address_aix | powerpcspe | CPU | GCC | 10,835 | 490 | 1 | [] |
[
"<s>",
"unsigned",
"push",
"(",
"unsigned",
"Opc",
",",
"MVT",
"Ty",
",",
"std",
"::",
"vector",
"<",
"OpRef",
">",
"&&",
"Ops",
")",
"{",
"NodeTemplate",
"Res",
";",
"Res",
".",
"Opc",
"=",
"Opc",
";",
"Res",
".",
"Ty",
"=",
"Ty",
";",
"Res",
".",
"Ops",
"=",
"Ops",
";",
"return",
"push",
"(",
"Res",
")",
";",
"}",
"</s>"
] | [
"Push",
"the",
"current",
"solver",
"state",
"."
] | [
"Hexagon"
] | HexagonISelDAGToDAGHVX | push | Hexagon | DSP | LLVM | 10,836 | 47 | 1 | [] |
[
"<s>",
"void",
"MipsPassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"addPass",
"(",
"createMipsOptimizePICCallPass",
"(",
")",
")",
";",
"if",
"(",
"getMipsSubtarget",
"(",
")",
".",
"isCheri",
"(",
")",
")",
"{",
"addPass",
"(",
"createCheriAddressingModeFolder",
"(",
")",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"Level",
"::",
"None",
")",
"addPass",
"(",
"&",
"DeadMachineInstructionElimID",
")",
";",
"addPass",
"(",
"createCheri128FailHardPass",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips"
] | MipsTargetMachine55 | addPreRegAlloc | Mips | CPU | LLVM | 10,837 | 59 | 1 | [] |
[
"<s>",
"void",
"ARMConstantIslands",
"::",
"verify",
"(",
")",
"{",
"assert",
"(",
"std",
"::",
"is_sorted",
"(",
"MF",
"->",
"begin",
"(",
")",
",",
"MF",
"->",
"end",
"(",
")",
",",
"[",
"this",
"]",
"(",
"const",
"MachineBasicBlock",
"&",
"LHS",
",",
"const",
"MachineBasicBlock",
"&",
"RHS",
")",
"{",
"return",
"BBInfo",
"[",
"LHS",
".",
"getNumber",
"(",
")",
"]",
".",
"postOffset",
"(",
")",
"<",
"BBInfo",
"[",
"RHS",
".",
"getNumber",
"(",
")",
"]",
".",
"postOffset",
"(",
")",
";",
"}",
")",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Verifying \"",
"<<",
"CPUsers",
".",
"size",
"(",
")",
"<<",
"\" CP users.\\n\"",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CPUsers",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"CPUser",
"&",
"U",
"=",
"CPUsers",
"[",
"i",
"]",
";",
"unsigned",
"UserOffset",
"=",
"getUserOffset",
"(",
"U",
")",
";",
"if",
"(",
"isCPEntryInRange",
"(",
"U",
".",
"MI",
",",
"UserOffset",
",",
"U",
".",
"CPEMI",
",",
"U",
".",
"getMaxDisp",
"(",
")",
"+",
"2",
",",
"U",
".",
"NegOk",
",",
"true",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"OK\\n\"",
")",
";",
"continue",
";",
"}",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Out of range.\\n\"",
")",
";",
"dumpBBs",
"(",
")",
";",
"DEBUG",
"(",
"MF",
"->",
"dump",
"(",
")",
")",
";",
"llvm_unreachable",
"(",
"\"Constant pool entry out of range!\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Check",
"if",
"this",
"register",
"bank",
"is",
"valid",
"."
] | [
"ARM",
"ARM",
"\"Verifying \"",
"\" CP users.\\n\"",
"0",
"2",
"\"OK\\n\"",
"\"Out of range.\\n\"",
"\"Constant pool entry out of range!\""
] | ARMConstantIslandPass16 | verify | ARM | CPU | LLVM | 10,838 | 199 | 1 | [] |
[
"<s>",
"bool",
"trackLivenessAfterRegAlloc",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"live-ins",
"should",
"be",
"tracked",
"after",
"register",
"allocation",
"."
] | [
"Z80"
] | Z80RegisterInfo2 | trackLivenessAfterRegAlloc | Z80 | MPU | LLVM | 10,839 | 15 | 1 | [] |
[
"<s>",
"static",
"bool",
"use_toc_relative_ref",
"(",
"rtx",
"sym",
",",
"machine_mode",
"mode",
")",
"{",
"return",
"(",
"(",
"constant_pool_expr_p",
"(",
"sym",
")",
"&&",
"ASM_OUTPUT_SPECIAL_POOL_ENTRY_P",
"(",
"get_pool_constant",
"(",
"sym",
")",
",",
"get_pool_mode",
"(",
"sym",
")",
")",
")",
"||",
"(",
"TARGET_CMODEL",
"==",
"CMODEL_MEDIUM",
"&&",
"SYMBOL_REF_LOCAL_P",
"(",
"sym",
")",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"POWERPC64_TOC_POINTER_ALIGNMENT",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"iff",
"the",
"given",
"SYMBOL_REF",
"refers",
"to",
"a",
"constant",
"pool",
"entry",
"that",
"we",
"have",
"put",
"in",
"the",
"TOC",
",",
"or",
"for",
"cmodel=medium",
",",
"if",
"the",
"SYMBOL_REF",
"can",
"be",
"addressed",
"relative",
"to",
"the",
"toc",
"pointer",
"."
] | [
"powerpcspe"
] | powerpcspe | use_toc_relative_ref | powerpcspe | CPU | GCC | 10,840 | 53 | 1 | [] |
[
"<s>",
"void",
"output_profile_hook",
"(",
"int",
"labelno",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"TARGET_PROFILE_KERNEL",
")",
"return",
";",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
")",
"{",
"if",
"(",
"NO_PROFILE_COUNTERS",
")",
"emit_library_call",
"(",
"init_one_libfunc",
"(",
"RS6000_MCOUNT",
")",
",",
"0",
",",
"VOIDmode",
",",
"0",
")",
";",
"else",
"{",
"char",
"buf",
"[",
"30",
"]",
";",
"const",
"char",
"*",
"label_name",
";",
"rtx",
"fun",
";",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"buf",
",",
"\"LP\"",
",",
"labelno",
")",
";",
"label_name",
"=",
"(",
"*",
"targetm",
".",
"strip_name_encoding",
")",
"(",
"ggc_strdup",
"(",
"buf",
")",
")",
";",
"fun",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"label_name",
")",
";",
"emit_library_call",
"(",
"init_one_libfunc",
"(",
"RS6000_MCOUNT",
")",
",",
"0",
",",
"VOIDmode",
",",
"1",
",",
"fun",
",",
"Pmode",
")",
";",
"}",
"}",
"else",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_DARWIN",
")",
"{",
"const",
"char",
"*",
"mcount_name",
"=",
"RS6000_MCOUNT",
";",
"int",
"caller_addr_regno",
"=",
"LINK_REGISTER_REGNUM",
";",
"current_function_uses_pic_offset_table",
"=",
"1",
";",
"if",
"(",
"MACHOPIC_INDIRECT",
"&&",
"current_function_uses_pic_offset_table",
")",
"caller_addr_regno",
"=",
"0",
";",
"emit_library_call",
"(",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"mcount_name",
")",
",",
"0",
",",
"VOIDmode",
",",
"1",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"caller_addr_regno",
")",
",",
"Pmode",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"profile",
"function",
"."
] | [
"rs6000",
"0",
"0",
"30",
"\"LP\"",
"0",
"1",
"1",
"0",
"0",
"1"
] | rs60003 | output_profile_hook | rs6000 | CPU | GCC | 10,841 | 169 | 1 | [] |
[
"<s>",
"static",
"void",
"mt_emit_save_regs",
"(",
"enum",
"save_direction",
"direction",
",",
"struct",
"mt_frame_info",
"info",
")",
"{",
"rtx",
"base_reg",
";",
"int",
"regno",
";",
"int",
"reg_mask",
"=",
"info",
".",
"reg_mask",
"&",
"~",
"(",
"FP_MASK",
"|",
"LINK_MASK",
")",
";",
"int",
"offset",
"=",
"info",
".",
"total_size",
";",
"int",
"stack_offset",
"=",
"info",
".",
"total_size",
";",
"if",
"(",
"!",
"info",
".",
"save_fp",
"&&",
"!",
"info",
".",
"save_lr",
"&&",
"!",
"reg_mask",
")",
"return",
";",
"if",
"(",
"CONST_OK_FOR_LETTER_P",
"(",
"offset",
",",
"'O'",
")",
")",
"base_reg",
"=",
"stack_pointer_rtx",
";",
"else",
"{",
"base_reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"GPR_R9",
")",
";",
"offset",
"=",
"0",
";",
"}",
"if",
"(",
"info",
".",
"save_fp",
")",
"{",
"offset",
"-=",
"UNITS_PER_WORD",
";",
"stack_offset",
"-=",
"UNITS_PER_WORD",
";",
"}",
"if",
"(",
"info",
".",
"save_lr",
")",
"{",
"offset",
"-=",
"UNITS_PER_WORD",
";",
"stack_offset",
"-=",
"UNITS_PER_WORD",
";",
"mt_emit_save_restore",
"(",
"direction",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"GPR_LINK",
")",
",",
"gen_rtx_MEM",
"(",
"SImode",
",",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"base_reg",
",",
"GEN_INT",
"(",
"offset",
")",
")",
")",
",",
"stack_offset",
")",
";",
"}",
"for",
"(",
"regno",
"=",
"GPR_R0",
";",
"regno",
"<=",
"GPR_LAST",
";",
"regno",
"++",
")",
"{",
"if",
"(",
"(",
"reg_mask",
"&",
"(",
"1",
"<<",
"regno",
")",
")",
"!=",
"0",
")",
"{",
"offset",
"-=",
"UNITS_PER_WORD",
";",
"stack_offset",
"-=",
"UNITS_PER_WORD",
";",
"mt_emit_save_restore",
"(",
"direction",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"regno",
")",
",",
"gen_rtx_MEM",
"(",
"SImode",
",",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"base_reg",
",",
"GEN_INT",
"(",
"offset",
")",
")",
")",
",",
"stack_offset",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"save",
"registers",
"in",
"the",
"prologue",
"and",
"restore",
"register",
"in",
"epilogue",
"."
] | [
"mt",
"0",
"1",
"0"
] | mt | mt_emit_save_regs | mt | CPU | GCC | 10,842 | 227 | 1 | [] |
[
"<s>",
"unsigned",
"MipsMCCodeEmitter",
"::",
"getBranchTarget26OpValueMM",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
">>",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTarget26OpValueMM",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"1",
"0"
] | MipsMCCodeEmitter (2)1 | getBranchTarget26OpValueMM | Mips | CPU | LLVM | 10,843 | 60 | 1 | [] |
[
"<s>",
"EVT",
"X86TargetLowering",
"::",
"getOptimalMemOpType",
"(",
"uint64_t",
"Size",
",",
"unsigned",
"DstAlign",
",",
"unsigned",
"SrcAlign",
",",
"bool",
"IsMemset",
",",
"bool",
"ZeroMemset",
",",
"bool",
"MemcpyStrSrc",
",",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"if",
"(",
"!",
"F",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoImplicitFloat",
")",
")",
"{",
"if",
"(",
"Size",
">=",
"16",
"&&",
"(",
"!",
"Subtarget",
".",
"isUnalignedMem16Slow",
"(",
")",
"||",
"(",
"(",
"DstAlign",
"==",
"0",
"||",
"DstAlign",
">=",
"16",
")",
"&&",
"(",
"SrcAlign",
"==",
"0",
"||",
"SrcAlign",
">=",
"16",
")",
")",
")",
")",
"{",
"if",
"(",
"Size",
">=",
"32",
"&&",
"Subtarget",
".",
"hasAVX",
"(",
")",
")",
"{",
"return",
"MVT",
"::",
"v32i8",
";",
"}",
"if",
"(",
"Subtarget",
".",
"hasSSE2",
"(",
")",
")",
"return",
"MVT",
"::",
"v16i8",
";",
"if",
"(",
"Subtarget",
".",
"hasSSE1",
"(",
")",
")",
"return",
"MVT",
"::",
"v4f32",
";",
"}",
"else",
"if",
"(",
"(",
"!",
"IsMemset",
"||",
"ZeroMemset",
")",
"&&",
"!",
"MemcpyStrSrc",
"&&",
"Size",
">=",
"8",
"&&",
"!",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"Subtarget",
".",
"hasSSE2",
"(",
")",
")",
"{",
"return",
"MVT",
"::",
"f64",
";",
"}",
"}",
"if",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"Size",
">=",
"8",
")",
"return",
"MVT",
"::",
"i64",
";",
"return",
"MVT",
"::",
"i32",
";",
"}",
"</s>"
] | [
"It",
"returns",
"EVT",
":",
":Other",
"if",
"the",
"type",
"should",
"be",
"determined",
"using",
"generic",
"target-independent",
"logic",
"."
] | [
"X86",
"X86",
"16",
"0",
"16",
"0",
"16",
"32",
"MVT::v32i8",
"MVT::v16i8",
"MVT::v4f32",
"8",
"MVT::f64",
"8",
"MVT::i64",
"MVT::i32"
] | X86ISelLowering | getOptimalMemOpType | X86 | CPU | LLVM | 10,844 | 198 | 1 | [] |
[
"<s>",
"void",
"PatmosInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"Register",
"DestReg",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"Naked",
")",
")",
"{",
"report_fatal_error",
"(",
"\"Trying to fill a register in naked function \"",
"+",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getName",
"(",
")",
"+",
"\": not supported!\"",
",",
"false",
")",
";",
"}",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"Patmos",
"::",
"RRegsRegClass",
")",
"{",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Patmos",
"::",
"LWC",
")",
",",
"DestReg",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"Patmos",
"::",
"PRegsRegClass",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Patmos",
"::",
"PSEUDO_PREG_RELOAD",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"else",
"{",
"errs",
"(",
")",
"<<",
"\"Register: \"",
"<<",
"DestReg",
"<<",
"\"\\n\"",
";",
"llvm_unreachable",
"(",
"\"Register class not handled!\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"Patmos",
"Patmos",
"\"Trying to fill a register in naked function \"",
"\": not supported!\"",
"Patmos::RRegsRegClass",
"Patmos::LWC",
"0",
"Patmos::PRegsRegClass",
"Patmos::PSEUDO_PREG_RELOAD",
"0",
"\"Register: \"",
"\"\\n\"",
"\"Register class not handled!\""
] | PatmosInstrInfo1 | loadRegFromStackSlot | Patmos | VLIW | LLVM | 10,845 | 194 | 1 | [] |
[
"<s>",
"MCObjectWriter",
"*",
"createObjectWriter",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"return",
"createTOYELFObjectWriter",
"(",
"OS",
",",
"MCELFObjectTargetWriter",
"::",
"getOSABI",
"(",
"OSType",
")",
",",
"IsLittle",
",",
"Is64Bit",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"TOY",
"TOY"
] | TOYAsmBackend | createObjectWriter | TOY | CPU | LLVM | 10,846 | 28 | 1 | [] |
[
"<s>",
"void",
"xtensa_adjust_reg_alloc_order",
"(",
"void",
")",
"{",
"static",
"const",
"int",
"reg_windowed_alloc_order",
"[",
"FIRST_PSEUDO_REGISTER",
"]",
"=",
"REG_ALLOC_ORDER",
";",
"static",
"const",
"int",
"reg_call0_alloc_order",
"[",
"FIRST_PSEUDO_REGISTER",
"]",
"=",
"{",
"9",
",",
"10",
",",
"11",
",",
"7",
",",
"6",
",",
"5",
",",
"4",
",",
"3",
",",
"2",
",",
"8",
",",
"0",
",",
"12",
",",
"13",
",",
"14",
",",
"15",
",",
"18",
",",
"19",
",",
"20",
",",
"21",
",",
"22",
",",
"23",
",",
"24",
",",
"25",
",",
"26",
",",
"27",
",",
"28",
",",
"29",
",",
"30",
",",
"31",
",",
"32",
",",
"33",
",",
"34",
",",
"1",
",",
"16",
",",
"17",
",",
"35",
",",
"}",
";",
"memcpy",
"(",
"reg_alloc_order",
",",
"TARGET_WINDOWED_ABI",
"?",
"reg_windowed_alloc_order",
":",
"reg_call0_alloc_order",
",",
"FIRST_PSEUDO_REGISTER",
"*",
"sizeof",
"(",
"int",
")",
")",
";",
"}",
"</s>"
] | [
"Called",
"once",
"at",
"the",
"start",
"of",
"IRA",
",",
"by",
"ADJUST_REG_ALLOC_ORDER",
"."
] | [
"xtensa",
"9",
"10",
"11",
"7",
"6",
"5",
"4",
"3",
"2",
"8",
"0",
"12",
"13",
"14",
"15",
"18",
"19",
"20",
"21",
"22",
"23",
"24",
"25",
"26",
"27",
"28",
"29",
"30",
"31",
"32",
"33",
"34",
"1",
"16",
"17",
"35"
] | xtensa1 | xtensa_adjust_reg_alloc_order | xtensa | MPU | GCC | 10,847 | 118 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"doInitialization",
"(",
"Module",
"&",
")",
"{",
"if",
"(",
"!",
"StatsFile",
".",
"empty",
"(",
")",
"&&",
"!",
"AppendStatsFile",
"&&",
"sys",
"::",
"fs",
"::",
"exists",
"(",
"StatsFile",
")",
")",
"{",
"sys",
"::",
"fs",
"::",
"remove",
"(",
"StatsFile",
".",
"c_str",
"(",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"Patmos"
] | PatmosFunctionSplitter | doInitialization | Patmos | VLIW | LLVM | 10,848 | 48 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"VideocoreTargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"VideocorePassConfig",
"(",
"this",
",",
"PM",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"Videocore",
"Videocore",
"Videocore"
] | VideocoreTargetMachine | createPassConfig | Videocore | DSP | LLVM | 10,849 | 21 | 1 | [] |
[
"<s>",
"void",
"ix86_expand_floorceildf_32",
"(",
"rtx",
"operand0",
",",
"rtx",
"operand1",
",",
"bool",
"do_floor",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"operand0",
")",
";",
"rtx",
"xa",
",",
"TWO52",
",",
"tmp",
",",
"one",
",",
"res",
",",
"mask",
";",
"rtx_code_label",
"*",
"label",
";",
"TWO52",
"=",
"ix86_gen_TWO52",
"(",
"mode",
")",
";",
"res",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_move_insn",
"(",
"res",
",",
"operand1",
")",
";",
"xa",
"=",
"ix86_expand_sse_fabs",
"(",
"res",
",",
"&",
"mask",
")",
";",
"label",
"=",
"ix86_expand_sse_compare_and_jump",
"(",
"UNLE",
",",
"TWO52",
",",
"xa",
",",
"false",
")",
";",
"xa",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"PLUS",
",",
"xa",
",",
"TWO52",
",",
"NULL_RTX",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"xa",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"MINUS",
",",
"xa",
",",
"TWO52",
",",
"xa",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"ix86_sse_copysign_to_positive",
"(",
"xa",
",",
"xa",
",",
"res",
",",
"mask",
")",
";",
"one",
"=",
"force_reg",
"(",
"mode",
",",
"const_double_from_real_value",
"(",
"do_floor",
"?",
"dconst1",
":",
"dconstm1",
",",
"mode",
")",
")",
";",
"tmp",
"=",
"ix86_expand_sse_compare_mask",
"(",
"UNGT",
",",
"xa",
",",
"res",
",",
"!",
"do_floor",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"tmp",
",",
"gen_rtx_AND",
"(",
"mode",
",",
"one",
",",
"tmp",
")",
")",
")",
";",
"tmp",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"MINUS",
",",
"xa",
",",
"tmp",
",",
"NULL_RTX",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"emit_move_insn",
"(",
"res",
",",
"tmp",
")",
";",
"emit_label",
"(",
"label",
")",
";",
"LABEL_NUSES",
"(",
"label",
")",
"=",
"1",
";",
"emit_move_insn",
"(",
"operand0",
",",
"res",
")",
";",
"}",
"</s>"
] | [
"Expand",
"SSE2",
"sequence",
"for",
"computing",
"floor",
"or",
"ceil",
"from",
"OPERAND1",
"storing",
"into",
"OPERAND0",
"."
] | [
"i386",
"0",
"0",
"0",
"1"
] | i3864 | ix86_expand_floorceildf_32 | i386 | CPU | GCC | 10,850 | 228 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"ARMElfTargetObjectFile",
"::",
"getTTypeGlobalReference",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"unsigned",
"Encoding",
",",
"const",
"TargetMachine",
"&",
"TM",
",",
"MachineModuleInfo",
"*",
"MMI",
",",
"MCStreamer",
"&",
"Streamer",
")",
"const",
"{",
"if",
"(",
"TM",
".",
"getMCAsmInfo",
"(",
")",
"->",
"getExceptionHandlingType",
"(",
")",
"!=",
"ExceptionHandling",
"::",
"ARM",
")",
"return",
"TargetLoweringObjectFileELF",
"::",
"getTTypeGlobalReference",
"(",
"GV",
",",
"Encoding",
",",
"TM",
",",
"MMI",
",",
"Streamer",
")",
";",
"assert",
"(",
"Encoding",
"==",
"DW_EH_PE_absptr",
"&&",
"\"Can handle absptr encoding only\"",
")",
";",
"return",
"MCSymbolRefExpr",
"::",
"create",
"(",
"TM",
".",
"getSymbol",
"(",
"GV",
")",
",",
"MCSymbolRefExpr",
"::",
"VK_ARM_TARGET2",
",",
"getContext",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"The",
"mach-o",
"version",
"of",
"this",
"method",
"defaults",
"to",
"returning",
"a",
"stub",
"reference",
"."
] | [
"ARM",
"ARM",
"ARM",
"\"Can handle absptr encoding only\"",
"ARM"
] | ARMTargetObjectFile (2)1 | getTTypeGlobalReference | ARM | CPU | LLVM | 10,851 | 93 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"PPCInstrInfo",
"::",
"commuteInstruction",
"(",
"MachineInstr",
"*",
"MI",
",",
"bool",
"NewMI",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"!=",
"PPC",
"::",
"RLWIMI",
")",
"return",
"TargetInstrInfoImpl",
"::",
"commuteInstruction",
"(",
"MI",
",",
"NewMI",
")",
";",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
"!=",
"0",
")",
"return",
"0",
";",
"unsigned",
"Reg0",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"Reg1",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"Reg2",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"bool",
"Reg1IsKill",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isKill",
"(",
")",
";",
"bool",
"Reg2IsKill",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isKill",
"(",
")",
";",
"bool",
"ChangeReg0",
"=",
"false",
";",
"if",
"(",
"Reg0",
"==",
"Reg1",
")",
"{",
"assert",
"(",
"MI",
"->",
"getDesc",
"(",
")",
".",
"getOperandConstraint",
"(",
"0",
",",
"TOI",
"::",
"TIED_TO",
")",
"&&",
"\"Expecting a two-address instruction!\"",
")",
";",
"Reg2IsKill",
"=",
"false",
";",
"ChangeReg0",
"=",
"true",
";",
"}",
"unsigned",
"MB",
"=",
"MI",
"->",
"getOperand",
"(",
"4",
")",
".",
"getImm",
"(",
")",
";",
"unsigned",
"ME",
"=",
"MI",
"->",
"getOperand",
"(",
"5",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"NewMI",
")",
"{",
"unsigned",
"Reg0",
"=",
"ChangeReg0",
"?",
"Reg2",
":",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"bool",
"Reg0IsDead",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"isDead",
"(",
")",
";",
"return",
"BuildMI",
"(",
"MF",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"MI",
"->",
"getDesc",
"(",
")",
")",
".",
"addReg",
"(",
"Reg0",
",",
"RegState",
"::",
"Define",
"|",
"getDeadRegState",
"(",
"Reg0IsDead",
")",
")",
".",
"addReg",
"(",
"Reg2",
",",
"getKillRegState",
"(",
"Reg2IsKill",
")",
")",
".",
"addReg",
"(",
"Reg1",
",",
"getKillRegState",
"(",
"Reg1IsKill",
")",
")",
".",
"addImm",
"(",
"(",
"ME",
"+",
"1",
")",
"&",
"31",
")",
".",
"addImm",
"(",
"(",
"MB",
"-",
"1",
")",
"&",
"31",
")",
";",
"}",
"if",
"(",
"ChangeReg0",
")",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"setReg",
"(",
"Reg2",
")",
";",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"setReg",
"(",
"Reg1",
")",
";",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"setReg",
"(",
"Reg2",
")",
";",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"setIsKill",
"(",
"Reg1IsKill",
")",
";",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"setIsKill",
"(",
"Reg2IsKill",
")",
";",
"MI",
"->",
"getOperand",
"(",
"4",
")",
".",
"setImm",
"(",
"(",
"ME",
"+",
"1",
")",
"&",
"31",
")",
";",
"MI",
"->",
"getOperand",
"(",
"5",
")",
".",
"setImm",
"(",
"(",
"MB",
"-",
"1",
")",
"&",
"31",
")",
";",
"return",
"MI",
";",
"}",
"</s>"
] | [
"This",
"method",
"commutes",
"the",
"operands",
"of",
"the",
"given",
"machine",
"instruction",
"MI",
"."
] | [
"PowerPC",
"PPC",
"PPC::RLWIMI",
"3",
"0",
"0",
"0",
"1",
"2",
"1",
"2",
"0",
"\"Expecting a two-address instruction!\"",
"4",
"5",
"0",
"0",
"1",
"31",
"1",
"31",
"0",
"2",
"1",
"2",
"1",
"4",
"1",
"31",
"5",
"1",
"31"
] | PPCInstrInfo22 | commuteInstruction | PowerPC | CPU | LLVM | 10,852 | 425 | 1 | [] |
[
"<s>",
"int",
"ARMBaseInstrInfo",
"::",
"getInstrLatency",
"(",
"const",
"InstrItineraryData",
"*",
"ItinData",
",",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"*",
"PredCost",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"isCopyLike",
"(",
")",
"||",
"MI",
"->",
"isInsertSubreg",
"(",
")",
"||",
"MI",
"->",
"isRegSequence",
"(",
")",
"||",
"MI",
"->",
"isImplicitDef",
"(",
")",
")",
"return",
"1",
";",
"if",
"(",
"!",
"ItinData",
"||",
"ItinData",
"->",
"isEmpty",
"(",
")",
")",
"return",
"1",
";",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"unsigned",
"Class",
"=",
"MCID",
".",
"getSchedClass",
"(",
")",
";",
"unsigned",
"UOps",
"=",
"ItinData",
"->",
"Itineraries",
"[",
"Class",
"]",
".",
"NumMicroOps",
";",
"if",
"(",
"PredCost",
"&&",
"MCID",
".",
"hasImplicitDefOfPhysReg",
"(",
"ARM",
"::",
"CPSR",
")",
")",
"*",
"PredCost",
"=",
"1",
";",
"if",
"(",
"UOps",
")",
"return",
"ItinData",
"->",
"getStageLatency",
"(",
"Class",
")",
";",
"return",
"getNumMicroOps",
"(",
"ItinData",
",",
"MI",
")",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"instruction",
"latency",
"of",
"a",
"given",
"instruction",
"."
] | [
"ARM",
"ARM",
"1",
"1",
"ARM::CPSR",
"1"
] | ARMBaseInstrInfo108 | getInstrLatency | ARM | CPU | LLVM | 10,853 | 135 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"rvexDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"Node",
"->",
"getDebugLoc",
"(",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"Selecting: \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"== \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"return",
"NULL",
";",
"}",
"EVT",
"NodeTy",
"=",
"Node",
"->",
"getValueType",
"(",
"0",
")",
";",
"unsigned",
"MultOpc",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"MULHS",
":",
"case",
"ISD",
"::",
"MULHU",
":",
"{",
"MultOpc",
"=",
"(",
"Opcode",
"==",
"ISD",
"::",
"MULHU",
"?",
"rvex",
"::",
"MULTu",
":",
"rvex",
"::",
"MULT",
")",
";",
"return",
"SelectMULT",
"(",
"Node",
",",
"MultOpc",
",",
"dl",
",",
"NodeTy",
",",
"false",
",",
"true",
")",
".",
"second",
";",
"}",
"case",
"ISD",
"::",
"GLOBAL_OFFSET_TABLE",
":",
"return",
"getGlobalBaseReg",
"(",
")",
";",
"case",
"ISD",
"::",
"Constant",
":",
"{",
"const",
"ConstantSDNode",
"*",
"CN",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Node",
")",
";",
"unsigned",
"Size",
"=",
"CN",
"->",
"getValueSizeInBits",
"(",
"0",
")",
";",
"if",
"(",
"Size",
"==",
"32",
")",
"break",
";",
"}",
"}",
"SDNode",
"*",
"ResNode",
"=",
"SelectCode",
"(",
"Node",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"=> \"",
")",
";",
"if",
"(",
"ResNode",
"==",
"NULL",
"||",
"ResNode",
"==",
"Node",
")",
"DEBUG",
"(",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
")",
";",
"else",
"DEBUG",
"(",
"ResNode",
"->",
"dump",
"(",
"CurDAG",
")",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"return",
"ResNode",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"rvex",
"rvex",
"\"Selecting: \"",
"\"\\n\"",
"\"== \"",
"\"\\n\"",
"0",
"ISD::MULHS",
"ISD::MULHU",
"ISD::MULHU",
"rvex::MULTu",
"rvex::MULT",
"ISD::GLOBAL_OFFSET_TABLE",
"ISD::Constant",
"0",
"32",
"\"=> \"",
"\"\\n\""
] | rvexISelDAGToDAG | Select | rvex | VLIW | LLVM | 10,854 | 267 | 1 | [] |
[
"<s>",
"static",
"bool",
"arc_vector_mode_supported_p",
"(",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"!",
"TARGET_SIMD_SET",
")",
"return",
"false",
";",
"if",
"(",
"(",
"mode",
"==",
"V4SImode",
")",
"||",
"(",
"mode",
"==",
"V8HImode",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implements",
"target",
"hook",
"vector_mode_supported_p",
"."
] | [
"arc"
] | arc4 | arc_vector_mode_supported_p | arc | MPU | GCC | 10,855 | 37 | 1 | [] |
[
"<s>",
"enum",
"tls_model",
"tls_symbolic_operand",
"(",
"rtx",
"op",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"!=",
"SYMBOL_REF",
")",
"return",
"TLS_MODEL_NONE",
";",
"return",
"SYMBOL_REF_TLS_MODEL",
"(",
"op",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"TLS",
"type",
"for",
"TLS",
"symbols",
",",
"0",
"for",
"otherwise",
"."
] | [
"sh"
] | sh | tls_symbolic_operand | sh | CPU | GCC | 10,856 | 31 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"AArch64RegisterInfo",
"::",
"getCallPreservedMask",
"(",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"GHC",
")",
"return",
"CSR_AArch64_NoRegs_RegMask",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"AnyReg",
")",
"return",
"CSR_AArch64_AllRegs_RegMask",
";",
"else",
"return",
"CSR_AArch64_AAPCS_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64RegisterInfo63 | getCallPreservedMask | AArch64 | CPU | LLVM | 10,857 | 41 | 1 | [] |
[
"<s>",
"Optional",
"<",
"DestSourcePair",
">",
"ARMBaseInstrInfo",
"::",
"isAddImmediate",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int64_t",
"&",
"Offset",
")",
"const",
"{",
"int",
"Sign",
"=",
"1",
";",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"ARM",
"::",
"SUBri",
")",
"Sign",
"=",
"-",
"1",
";",
"else",
"if",
"(",
"Opcode",
"!=",
"ARM",
"::",
"ADDri",
")",
"return",
"None",
";",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isReg",
"(",
")",
"||",
"!",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"||",
"!",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
")",
"return",
"None",
";",
"Offset",
"=",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"*",
"Sign",
";",
"return",
"DestSourcePair",
"{",
"MI",
".",
"getOperand",
"(",
"0",
")",
",",
"MI",
".",
"getOperand",
"(",
"1",
")",
"}",
";",
"}",
"</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",
"2",
"0",
"1"
] | ARMBaseInstrInfo129 | isAddImmediate | ARM | CPU | LLVM | 10,858 | 133 | 1 | [] |
[
"<s>",
"void",
"VEAsmPrinter",
"::",
"emitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"TargetOpcode",
"::",
"DBG_VALUE",
":",
"return",
";",
"case",
"VE",
"::",
"GETGOT",
":",
"lowerGETGOTAndEmitMCInsts",
"(",
"MI",
",",
"getSubtargetInfo",
"(",
")",
")",
";",
"return",
";",
"case",
"VE",
"::",
"GETFUNPLT",
":",
"lowerGETFunPLTAndEmitMCInsts",
"(",
"MI",
",",
"getSubtargetInfo",
"(",
")",
")",
";",
"return",
";",
"}",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"I",
"=",
"MI",
"->",
"getIterator",
"(",
")",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"E",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"instr_end",
"(",
")",
";",
"do",
"{",
"MCInst",
"TmpInst",
";",
"LowerVEMachineInstrToMCInst",
"(",
"&",
"*",
"I",
",",
"TmpInst",
",",
"*",
"this",
")",
";",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"TmpInst",
")",
";",
"}",
"while",
"(",
"(",
"++",
"I",
"!=",
"E",
")",
"&&",
"I",
"->",
"isInsideBundle",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"to",
"emit",
"instructions",
"."
] | [
"VE",
"VE",
"VE::GETGOT",
"VE::GETFUNPLT",
"VE"
] | VEAsmPrinter8 | emitInstruction | VE | CPU | LLVM | 10,859 | 133 | 1 | [] |
[
"<s>",
"void",
"NVPTXInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"NVPTX",
"NVPTX"
] | NVPTXInstPrinter13 | printInst | NVPTX | GPU | LLVM | 10,860 | 38 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_return_in_msb",
"(",
"const_tree",
"valtype",
")",
"{",
"machine_mode",
"dummy_mode",
";",
"int",
"dummy_int",
";",
"if",
"(",
"!",
"BYTES_BIG_ENDIAN",
")",
"return",
"false",
";",
"if",
"(",
"!",
"aarch64_composite_type_p",
"(",
"valtype",
",",
"TYPE_MODE",
"(",
"valtype",
")",
")",
"||",
"int_size_in_bytes",
"(",
"valtype",
")",
"<=",
"0",
"||",
"int_size_in_bytes",
"(",
"valtype",
")",
">",
"16",
")",
"return",
"false",
";",
"if",
"(",
"aarch64_vfp_is_call_or_return_candidate",
"(",
"TYPE_MODE",
"(",
"valtype",
")",
",",
"valtype",
",",
"&",
"dummy_mode",
",",
"&",
"dummy_int",
",",
"NULL",
",",
"false",
")",
")",
"return",
"false",
";",
"pure_scalable_type_info",
"pst_info",
";",
"if",
"(",
"pst_info",
".",
"analyze_registers",
"(",
"valtype",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"VALTYPE",
"is",
"padded",
"to",
"its",
"least",
"significant",
"bits",
"."
] | [
"aarch64",
"0",
"16"
] | aarch64 | aarch64_return_in_msb | aarch64 | CPU | GCC | 10,861 | 96 | 1 | [] |
[
"<s>",
"static",
"bool",
"h8300_can_eliminate",
"(",
"const",
"int",
"from",
"ATTRIBUTE_UNUSED",
",",
"const",
"int",
"to",
")",
"{",
"return",
"(",
"to",
"==",
"STACK_POINTER_REGNUM",
"?",
"!",
"frame_pointer_needed",
":",
"true",
")",
";",
"}",
"</s>"
] | [
"Given",
"FROM",
"and",
"TO",
"register",
"numbers",
",",
"say",
"whether",
"this",
"elimination",
"is",
"allowed",
".",
"Frame",
"pointer",
"elimination",
"is",
"automatically",
"handled",
".",
"For",
"the",
"h8300",
",",
"if",
"frame",
"pointer",
"elimination",
"is",
"being",
"done",
",",
"we",
"would",
"like",
"to",
"convert",
"ap",
"and",
"rp",
"into",
"sp",
",",
"not",
"fp",
".",
"All",
"other",
"eliminations",
"are",
"valid",
"."
] | [
"h8300"
] | h8300 | h8300_can_eliminate | h8300 | MPU | GCC | 10,862 | 27 | 1 | [] |
[
"<s>",
"bool",
"X86FastISel",
"::",
"isTypeLegal",
"(",
"Type",
"*",
"Ty",
",",
"MVT",
"&",
"VT",
",",
"bool",
"AllowI1",
")",
"{",
"EVT",
"evt",
"=",
"TLI",
".",
"getValueType",
"(",
"Ty",
",",
"true",
")",
";",
"if",
"(",
"evt",
"==",
"MVT",
"::",
"Other",
"||",
"!",
"evt",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"VT",
"=",
"evt",
".",
"getSimpleVT",
"(",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"&&",
"!",
"X86ScalarSSEf64",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
"&&",
"!",
"X86ScalarSSEf32",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f80",
")",
"return",
"false",
";",
"return",
"(",
"AllowI1",
"&&",
"VT",
"==",
"MVT",
"::",
"i1",
")",
"||",
"TLI",
".",
"isTypeLegal",
"(",
"VT",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"type",
"is",
"legal",
"."
] | [
"X86",
"X86",
"MVT::Other",
"MVT::f64",
"X86",
"MVT::f32",
"X86",
"MVT::f80",
"MVT::i1"
] | X86FastISel (2) | isTypeLegal | X86 | CPU | LLVM | 10,863 | 113 | 1 | [] |
[
"<s>",
"static",
"int",
"n_dregs_to_save",
"(",
"bool",
"is_inthandler",
",",
"bool",
"consecutive",
")",
"{",
"int",
"count",
"=",
"0",
";",
"unsigned",
"i",
";",
"for",
"(",
"i",
"=",
"REG_R7",
"+",
"1",
";",
"i",
"--",
"!=",
"REG_R0",
";",
")",
"{",
"if",
"(",
"must_save_p",
"(",
"is_inthandler",
",",
"i",
")",
")",
"count",
"++",
";",
"else",
"if",
"(",
"consecutive",
")",
"return",
"count",
";",
"}",
"return",
"count",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"number",
"of",
"DREGS",
"to",
"save",
"with",
"a",
"push_multiple",
"operation",
".",
"This",
"could",
"include",
"registers",
"that",
"are",
"n't",
"modified",
"in",
"the",
"function",
",",
"since",
"push_multiple",
"only",
"takes",
"a",
"range",
"of",
"registers",
".",
"If",
"IS_INTHANDLER",
",",
"then",
"everything",
"that",
"is",
"live",
"must",
"be",
"saved",
",",
"even",
"if",
"normally",
"call-clobbered",
"."
] | [
"bfin",
"0",
"1"
] | bfin | n_dregs_to_save | bfin | DSP | GCC | 10,864 | 59 | 1 | [] |
[
"<s>",
"bool",
"TPCExpandHWRegCopies",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Func",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"Func",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"EnableTPCExpandHWRegCopies",
")",
"return",
"false",
";",
"MF",
"=",
"&",
"Func",
";",
"MRI",
"=",
"&",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"TII",
"=",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"NumReplaced",
"=",
"0",
";",
"MachineBasicBlock",
"*",
"MBB",
";",
"MachineInstrBuilder",
"MIB",
";",
"typedef",
"enum",
"{",
"none",
",",
"zpreg",
"}",
"TCopyKind",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBBI",
"=",
"MF",
"->",
"begin",
"(",
")",
",",
"MBBE",
"=",
"MF",
"->",
"end",
"(",
")",
";",
"MBBI",
"!=",
"MBBE",
";",
"++",
"MBBI",
")",
"{",
"MBB",
"=",
"&",
"*",
"MBBI",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"mi",
"=",
"MBB",
"->",
"begin",
"(",
")",
",",
"me",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"mi",
"!=",
"me",
";",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"nmi",
"=",
"std",
"::",
"next",
"(",
"mi",
")",
";",
"MachineInstr",
"*",
"MI",
"=",
"&",
"*",
"mi",
";",
"auto",
"opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"opc",
"==",
"TargetOpcode",
"::",
"COPY",
")",
"{",
"MachineOperand",
"des",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"des",
".",
"isReg",
"(",
")",
")",
"{",
"Register",
"destreg",
"=",
"des",
".",
"getReg",
"(",
")",
";",
"TCopyKind",
"CopyKind",
"=",
"TCopyKind",
"(",
"none",
")",
";",
"if",
"(",
"!",
"destreg",
".",
"isPhysical",
"(",
")",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"RC",
";",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"RC",
"=",
"MRI",
".",
"getRegClass",
"(",
"destreg",
")",
";",
"}",
"}",
"}",
"mi",
"=",
"nmi",
";",
"}",
"}",
"return",
"NumReplaced",
">",
"0",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"TPC",
"TPC",
"TPC",
"0",
"0",
"0"
] | TPCExpandHWRegCopies | runOnMachineFunction | TPC | Virtual ISA | LLVM | 10,865 | 272 | 1 | [] |
[
"<s>",
"Optional",
"<",
"MCFixupKind",
">",
"RISCVAsmBackend",
"::",
"getFixupKind",
"(",
"StringRef",
"Name",
")",
"const",
"{",
"if",
"(",
"STI",
".",
"getTargetTriple",
"(",
")",
".",
"isOSBinFormatELF",
"(",
")",
")",
"{",
"unsigned",
"Type",
";",
"Type",
"=",
"llvm",
"::",
"StringSwitch",
"<",
"unsigned",
">",
"(",
"Name",
")",
".",
"Default",
"(",
"-",
"1u",
")",
";",
"if",
"(",
"Type",
"!=",
"-",
"1u",
")",
"return",
"static_cast",
"<",
"MCFixupKind",
">",
"(",
"FirstLiteralRelocationKind",
"+",
"Type",
")",
";",
"}",
"return",
"None",
";",
"}",
"</s>"
] | [
"getFixupKind",
"-",
"Get",
"the",
"fixup",
"kind",
"of",
"this",
"expression",
"."
] | [
"RI5CY",
"RISCV",
"1u",
"1u"
] | RISCVAsmBackend | getFixupKind | RI5CY | CPU | LLVM | 10,866 | 70 | 1 | [] |
[
"<s>",
"bool",
"X86FrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"Reg",
")",
"||",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"continue",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"}",
"unsigned",
"Opc",
"=",
"STI",
".",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"POP64r",
":",
"X86",
"::",
"POP32r",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"Reg",
")",
"&&",
"!",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"continue",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"Reg",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] | [
"X86",
"X86",
"0",
"X86::GR64RegClass",
"X86::GR32RegClass",
"X86::POP64r",
"X86::POP32r",
"0",
"X86::GR64RegClass",
"X86::GR32RegClass"
] | X86FrameLowering103 | restoreCalleeSavedRegisters | X86 | CPU | LLVM | 10,867 | 245 | 1 | [] |
[
"<s>",
"static",
"bool",
"isSafeToMove",
"(",
"const",
"MachineInstr",
"*",
"Def",
",",
"const",
"MachineInstr",
"*",
"Insert",
",",
"AliasAnalysis",
"&",
"AA",
",",
"const",
"MachineRegisterInfo",
"&",
"MRI",
")",
"{",
"assert",
"(",
"Def",
"->",
"getParent",
"(",
")",
"==",
"Insert",
"->",
"getParent",
"(",
")",
")",
";",
"if",
"(",
"Def",
"->",
"getOpcode",
"(",
")",
"==",
"WebAssembly",
"::",
"CATCH",
"||",
"Def",
"->",
"getOpcode",
"(",
")",
"==",
"WebAssembly",
"::",
"EXTRACT_EXCEPTION_I32",
")",
"{",
"const",
"MachineBasicBlock",
"*",
"MBB",
"=",
"Def",
"->",
"getParent",
"(",
")",
";",
"auto",
"NextI",
"=",
"std",
"::",
"next",
"(",
"MachineBasicBlock",
"::",
"const_iterator",
"(",
"Def",
")",
")",
";",
"for",
"(",
"auto",
"E",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"NextI",
"!=",
"E",
"&&",
"NextI",
"->",
"isDebugInstr",
"(",
")",
";",
"++",
"NextI",
")",
";",
"if",
"(",
"NextI",
"!=",
"Insert",
")",
"return",
"false",
";",
"}",
"SmallVector",
"<",
"unsigned",
",",
"4",
">",
"MutableRegisters",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"Def",
"->",
"operands",
"(",
")",
")",
"{",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
"||",
"MO",
".",
"isUndef",
"(",
")",
")",
"continue",
";",
"Register",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"MO",
".",
"isDead",
"(",
")",
"&&",
"Insert",
"->",
"definesRegister",
"(",
"Reg",
")",
"&&",
"!",
"Insert",
"->",
"readsRegister",
"(",
"Reg",
")",
")",
"continue",
";",
"if",
"(",
"Register",
"::",
"isPhysicalRegister",
"(",
"Reg",
")",
")",
"{",
"if",
"(",
"Reg",
"==",
"WebAssembly",
"::",
"ARGUMENTS",
")",
"continue",
";",
"if",
"(",
"!",
"MRI",
".",
"isPhysRegModified",
"(",
"Reg",
")",
")",
"continue",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"MO",
".",
"isDef",
"(",
")",
"&&",
"!",
"MRI",
".",
"hasOneDef",
"(",
"Reg",
")",
")",
"MutableRegisters",
".",
"push_back",
"(",
"Reg",
")",
";",
"}",
"bool",
"Read",
"=",
"false",
",",
"Write",
"=",
"false",
",",
"Effects",
"=",
"false",
",",
"StackPointer",
"=",
"false",
";",
"query",
"(",
"*",
"Def",
",",
"AA",
",",
"Read",
",",
"Write",
",",
"Effects",
",",
"StackPointer",
")",
";",
"bool",
"HasMutableRegisters",
"=",
"!",
"MutableRegisters",
".",
"empty",
"(",
")",
";",
"if",
"(",
"!",
"Read",
"&&",
"!",
"Write",
"&&",
"!",
"Effects",
"&&",
"!",
"StackPointer",
"&&",
"!",
"HasMutableRegisters",
")",
"return",
"true",
";",
"MachineBasicBlock",
"::",
"const_iterator",
"D",
"(",
"Def",
")",
",",
"I",
"(",
"Insert",
")",
";",
"for",
"(",
"--",
"I",
";",
"I",
"!=",
"D",
";",
"--",
"I",
")",
"{",
"bool",
"InterveningRead",
"=",
"false",
";",
"bool",
"InterveningWrite",
"=",
"false",
";",
"bool",
"InterveningEffects",
"=",
"false",
";",
"bool",
"InterveningStackPointer",
"=",
"false",
";",
"query",
"(",
"*",
"I",
",",
"AA",
",",
"InterveningRead",
",",
"InterveningWrite",
",",
"InterveningEffects",
",",
"InterveningStackPointer",
")",
";",
"if",
"(",
"Effects",
"&&",
"InterveningEffects",
")",
"return",
"false",
";",
"if",
"(",
"Read",
"&&",
"InterveningWrite",
")",
"return",
"false",
";",
"if",
"(",
"Write",
"&&",
"(",
"InterveningRead",
"||",
"InterveningWrite",
")",
")",
"return",
"false",
";",
"if",
"(",
"StackPointer",
"&&",
"InterveningStackPointer",
")",
"return",
"false",
";",
"for",
"(",
"unsigned",
"Reg",
":",
"MutableRegisters",
")",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"I",
"->",
"operands",
"(",
")",
")",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
"&&",
"MO",
".",
"isDef",
"(",
")",
"&&",
"MO",
".",
"getReg",
"(",
")",
"==",
"Reg",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"safe",
"to",
"move",
"this",
"instruction",
"."
] | [
"WebAssembly",
"WebAssembly::CATCH",
"WebAssembly::EXTRACT_EXCEPTION_I32",
"4",
"WebAssembly::ARGUMENTS"
] | WebAssemblyRegStackify38 | isSafeToMove | WebAssembly | Virtual ISA | LLVM | 10,868 | 472 | 1 | [] |
[
"<s>",
"void",
"X86DAGToDAGISel",
"::",
"PreprocessISelDAG",
"(",
")",
"{",
"OptForSize",
"=",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getAttributes",
"(",
")",
".",
"hasAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"Attribute",
"::",
"OptimizeForSize",
")",
";",
"for",
"(",
"SelectionDAG",
"::",
"allnodes_iterator",
"I",
"=",
"CurDAG",
"->",
"allnodes_begin",
"(",
")",
",",
"E",
"=",
"CurDAG",
"->",
"allnodes_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"SDNode",
"*",
"N",
"=",
"I",
"++",
";",
"if",
"(",
"OptLevel",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"(",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"CALL",
"&&",
"!",
"Subtarget",
"->",
"callRegIndirect",
"(",
")",
")",
"||",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"TC_RETURN",
"&&",
"(",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"||",
"getTargetMachine",
"(",
")",
".",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"PIC_",
")",
")",
")",
")",
"{",
"bool",
"HasCallSeq",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"X86ISD",
"::",
"CALL",
";",
"SDValue",
"Chain",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"Load",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"!",
"isCalleeLoad",
"(",
"Load",
",",
"Chain",
",",
"HasCallSeq",
")",
")",
"continue",
";",
"MoveBelowOrigChain",
"(",
"CurDAG",
",",
"Load",
",",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"Chain",
")",
";",
"++",
"NumLoadMoved",
";",
"continue",
";",
"}",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"FP_ROUND",
"&&",
"N",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"FP_EXTEND",
")",
"continue",
";",
"EVT",
"SrcVT",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
".",
"getValueType",
"(",
")",
";",
"EVT",
"DstVT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"if",
"(",
"SrcVT",
".",
"isVector",
"(",
")",
"||",
"DstVT",
".",
"isVector",
"(",
")",
")",
"continue",
";",
"X86TargetLowering",
"*",
"X86Lowering",
"=",
"(",
"X86TargetLowering",
"*",
")",
"getTargetLowering",
"(",
")",
";",
"bool",
"SrcIsSSE",
"=",
"X86Lowering",
"->",
"isScalarFPTypeInSSEReg",
"(",
"SrcVT",
")",
";",
"bool",
"DstIsSSE",
"=",
"X86Lowering",
"->",
"isScalarFPTypeInSSEReg",
"(",
"DstVT",
")",
";",
"if",
"(",
"SrcIsSSE",
"&&",
"DstIsSSE",
")",
"continue",
";",
"if",
"(",
"!",
"SrcIsSSE",
"&&",
"!",
"DstIsSSE",
")",
"{",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"FP_EXTEND",
")",
"continue",
";",
"if",
"(",
"N",
"->",
"getConstantOperandVal",
"(",
"1",
")",
")",
"continue",
";",
"}",
"EVT",
"MemVT",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"FP_ROUND",
")",
"MemVT",
"=",
"DstVT",
";",
"else",
"MemVT",
"=",
"SrcIsSSE",
"?",
"SrcVT",
":",
"DstVT",
";",
"SDValue",
"MemTmp",
"=",
"CurDAG",
"->",
"CreateStackTemporary",
"(",
"MemVT",
")",
";",
"SDLoc",
"dl",
"(",
"N",
")",
";",
"SDValue",
"Store",
"=",
"CurDAG",
"->",
"getTruncStore",
"(",
"CurDAG",
"->",
"getEntryNode",
"(",
")",
",",
"dl",
",",
"N",
"->",
"getOperand",
"(",
"0",
")",
",",
"MemTmp",
",",
"MachinePointerInfo",
"(",
")",
",",
"MemVT",
",",
"false",
",",
"false",
",",
"0",
")",
";",
"SDValue",
"Result",
"=",
"CurDAG",
"->",
"getExtLoad",
"(",
"ISD",
"::",
"EXTLOAD",
",",
"dl",
",",
"DstVT",
",",
"Store",
",",
"MemTmp",
",",
"MachinePointerInfo",
"(",
")",
",",
"MemVT",
",",
"false",
",",
"false",
",",
"0",
")",
";",
"--",
"I",
";",
"CurDAG",
"->",
"ReplaceAllUsesOfValueWith",
"(",
"SDValue",
"(",
"N",
",",
"0",
")",
",",
"Result",
")",
";",
"++",
"I",
";",
"CurDAG",
"->",
"DeleteNode",
"(",
"N",
")",
";",
"}",
"}",
"</s>"
] | [
"PreprocessISelDAG",
"-",
"This",
"hook",
"allows",
"targets",
"to",
"hack",
"on",
"the",
"graph",
"before",
"instruction",
"selection",
"starts",
"."
] | [
"X86",
"X86",
"X86ISD::CALL",
"X86ISD::TC_RETURN",
"X86ISD::CALL",
"0",
"1",
"0",
"ISD::FP_ROUND",
"ISD::FP_EXTEND",
"0",
"0",
"X86",
"X86",
"X86",
"X86",
"X86",
"ISD::FP_EXTEND",
"1",
"ISD::FP_ROUND",
"0",
"0",
"ISD::EXTLOAD",
"0",
"0"
] | X86ISelDAGToDAG4 | PreprocessISelDAG | X86 | CPU | LLVM | 10,869 | 476 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"isStackSlotCopy",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"DestFrameIndex",
",",
"int",
"&",
"SrcFrameIndex",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getFrameInfo",
"(",
")",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"!=",
"SystemZ",
"::",
"MVC",
"||",
"!",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"isFI",
"(",
")",
"||",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"!=",
"0",
"||",
"!",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"isFI",
"(",
")",
"||",
"MI",
"->",
"getOperand",
"(",
"4",
")",
".",
"getImm",
"(",
")",
"!=",
"0",
")",
"return",
"false",
";",
"int64_t",
"Length",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"unsigned",
"FI1",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"FI2",
"=",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"getIndex",
"(",
")",
";",
"if",
"(",
"MFI",
"->",
"getObjectSize",
"(",
"FI1",
")",
"!=",
"Length",
"||",
"MFI",
"->",
"getObjectSize",
"(",
"FI2",
")",
"!=",
"Length",
")",
"return",
"false",
";",
"DestFrameIndex",
"=",
"FI1",
";",
"SrcFrameIndex",
"=",
"FI2",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"copy",
"of",
"one",
"stack",
"slot",
"to",
"another",
"and",
"has",
"no",
"other",
"effect",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ::MVC",
"0",
"1",
"0",
"3",
"4",
"0",
"2",
"0",
"3"
] | SystemZInstrInfo (2) | isStackSlotCopy | SystemZ | CPU | LLVM | 10,870 | 181 | 1 | [] |
[
"<s>",
"void",
"nios2_adjust_call_address",
"(",
"rtx",
"*",
"call_op",
",",
"rtx",
"reg",
")",
"{",
"if",
"(",
"MEM_P",
"(",
"*",
"call_op",
")",
")",
"call_op",
"=",
"&",
"XEXP",
"(",
"*",
"call_op",
",",
"0",
")",
";",
"rtx",
"addr",
"=",
"*",
"call_op",
";",
"if",
"(",
"flag_pic",
"&&",
"CONSTANT_P",
"(",
"addr",
")",
")",
"{",
"rtx",
"tmp",
"=",
"reg",
"?",
"reg",
":",
"NULL_RTX",
";",
"if",
"(",
"!",
"reg",
")",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"addr",
"=",
"nios2_load_pic_address",
"(",
"addr",
",",
"UNSPEC_PIC_CALL_SYM",
",",
"tmp",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"reg",
",",
"addr",
")",
")",
";",
"*",
"call_op",
"=",
"reg",
";",
"}",
"}",
"</s>"
] | [
"The",
"function",
"with",
"address",
"*",
"ADDR",
"is",
"being",
"called",
".",
"If",
"the",
"address",
"needs",
"to",
"be",
"loaded",
"from",
"the",
"GOT",
",",
"emit",
"the",
"instruction",
"to",
"do",
"so",
"and",
"update",
"*",
"ADDR",
"to",
"point",
"to",
"the",
"rtx",
"for",
"the",
"loaded",
"value",
".",
"If",
"REG",
"!",
"=",
"NULL_RTX",
",",
"it",
"is",
"used",
"as",
"the",
"target/scratch",
"register",
"in",
"the",
"GOT",
"address",
"calculation",
"."
] | [
"nios2",
"0"
] | nios2 | nios2_adjust_call_address | nios2 | MPU | GCC | 10,871 | 95 | 1 | [] |
[
"<s>",
"rtx",
"mep_find_base_term",
"(",
"rtx",
"x",
")",
"{",
"rtx",
"base",
",",
"term",
";",
"int",
"unspec",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"!=",
"PLUS",
")",
"return",
"x",
";",
"base",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"term",
"=",
"XEXP",
"(",
"x",
",",
"1",
")",
";",
"if",
"(",
"has_hard_reg_initial_val",
"(",
"Pmode",
",",
"TP_REGNO",
")",
"&&",
"base",
"==",
"mep_tp_rtx",
"(",
")",
")",
"unspec",
"=",
"UNS_TPREL",
";",
"else",
"if",
"(",
"has_hard_reg_initial_val",
"(",
"Pmode",
",",
"GP_REGNO",
")",
"&&",
"base",
"==",
"mep_gp_rtx",
"(",
")",
")",
"unspec",
"=",
"UNS_GPREL",
";",
"else",
"return",
"x",
";",
"if",
"(",
"GET_CODE",
"(",
"term",
")",
"!=",
"CONST",
")",
"return",
"x",
";",
"term",
"=",
"XEXP",
"(",
"term",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"term",
")",
"!=",
"UNSPEC",
"||",
"XINT",
"(",
"term",
",",
"1",
")",
"!=",
"unspec",
")",
"return",
"x",
";",
"return",
"XVECEXP",
"(",
"term",
",",
"0",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"If",
"X",
"is",
"a",
"machine",
"specific",
"address",
"(",
"i.e",
".",
"a",
"symbol",
"or",
"label",
"being",
"referenced",
"as",
"a",
"displacement",
"from",
"the",
"GOT",
"implemented",
"using",
"an",
"UNSPEC",
")",
",",
"then",
"return",
"the",
"base",
"term",
".",
"Otherwise",
"return",
"X",
"."
] | [
"mep",
"0",
"1",
"0",
"1",
"0",
"0"
] | mep | mep_find_base_term | mep | CPU | GCC | 10,872 | 141 | 1 | [] |
[
"<s>",
"virtual",
"const",
"PIC16InstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"PIC16",
"PIC16"
] | PIC16TargetMachine | getInstrInfo | PIC16 | MPU | LLVM | 10,873 | 14 | 1 | [] |
[
"<s>",
"bool",
"GCNTTIImpl",
"::",
"isSourceOfDivergence",
"(",
"const",
"Value",
"*",
"V",
")",
"const",
"{",
"if",
"(",
"const",
"Argument",
"*",
"A",
"=",
"dyn_cast",
"<",
"Argument",
">",
"(",
"V",
")",
")",
"return",
"!",
"isArgPassedInSGPR",
"(",
"A",
")",
";",
"if",
"(",
"const",
"LoadInst",
"*",
"Load",
"=",
"dyn_cast",
"<",
"LoadInst",
">",
"(",
"V",
")",
")",
"return",
"Load",
"->",
"getPointerAddressSpace",
"(",
")",
"==",
"ST",
"->",
"getAMDGPUAS",
"(",
")",
".",
"PRIVATE_ADDRESS",
"||",
"Load",
"->",
"getPointerAddressSpace",
"(",
")",
"==",
"ST",
"->",
"getAMDGPUAS",
"(",
")",
".",
"FLAT_ADDRESS",
";",
"if",
"(",
"isa",
"<",
"AtomicRMWInst",
">",
"(",
"V",
")",
"||",
"isa",
"<",
"AtomicCmpXchgInst",
">",
"(",
"V",
")",
")",
"return",
"true",
";",
"if",
"(",
"const",
"IntrinsicInst",
"*",
"Intrinsic",
"=",
"dyn_cast",
"<",
"IntrinsicInst",
">",
"(",
"V",
")",
")",
"return",
"AMDGPU",
"::",
"isIntrinsicSourceOfDivergence",
"(",
"Intrinsic",
"->",
"getIntrinsicID",
"(",
")",
")",
";",
"if",
"(",
"isa",
"<",
"CallInst",
">",
"(",
"V",
")",
"||",
"isa",
"<",
"InvokeInst",
">",
"(",
"V",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"whether",
"V",
"is",
"a",
"source",
"of",
"divergence",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU::isIntrinsicSourceOfDivergence"
] | AMDGPUTargetTransformInfo20 | isSourceOfDivergence | AMDGPU | GPU | LLVM | 10,874 | 151 | 1 | [] |
[
"<s>",
"void",
"addExpr",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"MCExpr",
"*",
"Expr",
")",
"const",
"{",
"if",
"(",
"!",
"Expr",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"0",
")",
")",
";",
"else",
"if",
"(",
"const",
"MCConstantExpr",
"*",
"CE",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"Expr",
")",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"CE",
"->",
"getValue",
"(",
")",
")",
")",
";",
"else",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createExpr",
"(",
"Expr",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"new",
"MCExpr",
"operand",
"."
] | [
"AVR",
"0"
] | AVRAsmParser | addExpr | AVR | MPU | LLVM | 10,875 | 77 | 1 | [] |
[
"<s>",
"static",
"int",
"function_arg_partial_bytes",
"(",
"cumulative_args_t",
"cum_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"if",
"(",
"(",
"arg",
".",
"mode",
"==",
"BLKmode",
"||",
"GET_MODE_CLASS",
"(",
"arg",
".",
"mode",
")",
"!=",
"MODE_COMPLEX_INT",
"||",
"GET_MODE_CLASS",
"(",
"arg",
".",
"mode",
")",
"!=",
"MODE_COMPLEX_FLOAT",
")",
"&&",
"cum",
"->",
"arg_words",
"<",
"MAX_ARGS_IN_REGISTERS",
")",
"{",
"int",
"words",
"=",
"(",
"(",
"arg",
".",
"promoted_size_in_bytes",
"(",
")",
"+",
"UNITS_PER_WORD",
"-",
"1",
")",
"/",
"UNITS_PER_WORD",
")",
";",
"if",
"(",
"words",
"+",
"cum",
"->",
"arg_words",
"<=",
"MAX_ARGS_IN_REGISTERS",
")",
"return",
"0",
";",
"return",
"(",
"MAX_ARGS_IN_REGISTERS",
"-",
"cum",
"->",
"arg_words",
")",
"*",
"UNITS_PER_WORD",
";",
"}",
"else",
"if",
"(",
"arg",
".",
"mode",
"==",
"DImode",
"&&",
"cum",
"->",
"arg_words",
"==",
"MAX_ARGS_IN_REGISTERS",
"-",
"1",
")",
"return",
"UNITS_PER_WORD",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"number",
"of",
"bytes",
"of",
"argument",
"to",
"put",
"in",
"registers",
"."
] | [
"microblaze",
"1",
"0",
"1",
"0"
] | microblaze | function_arg_partial_bytes | microblaze | MPU | GCC | 10,876 | 125 | 1 | [] |
[
"<s>",
"void",
"Cpu0MCCodeEmitter",
"::",
"EmitInstruction",
"(",
"uint64_t",
"Val",
",",
"unsigned",
"Size",
",",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Size",
";",
"++",
"i",
")",
"{",
"unsigned",
"Shift",
"=",
"IsLittleEndian",
"?",
"i",
"*",
"8",
":",
"(",
"Size",
"-",
"1",
"-",
"i",
")",
"*",
"8",
";",
"EmitByte",
"(",
"(",
"Val",
">>",
"Shift",
")",
"&",
"0xff",
",",
"OS",
")",
";",
"}",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"Cpu0",
"Cpu0",
"0",
"8",
"1",
"8",
"0xff"
] | Cpu0MCCodeEmitter2 | EmitInstruction | Cpu0 | CPU | LLVM | 10,877 | 66 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"AsmPrinter",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineModuleInfo",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"DwarfWriter",
">",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"ARM"
] | ARMAsmPrinter100 | getAnalysisUsage | ARM | CPU | LLVM | 10,878 | 41 | 1 | [] |
[
"<s>",
"RegisterRef",
"RegisterAggr",
"::",
"normalize",
"(",
"RegisterRef",
"RR",
")",
"const",
"{",
"RegisterId",
"SuperReg",
"=",
"RR",
".",
"Reg",
";",
"while",
"(",
"true",
")",
"{",
"MCSuperRegIterator",
"SR",
"(",
"SuperReg",
",",
"&",
"TRI",
",",
"false",
")",
";",
"if",
"(",
"!",
"SR",
".",
"isValid",
"(",
")",
")",
"break",
";",
"SuperReg",
"=",
"*",
"SR",
";",
"}",
"const",
"TargetRegisterClass",
"&",
"RC",
"=",
"*",
"TRI",
".",
"getMinimalPhysRegClass",
"(",
"RR",
".",
"Reg",
")",
";",
"LaneBitmask",
"Common",
"=",
"RR",
".",
"Mask",
"&",
"RC",
".",
"LaneMask",
";",
"uint32_t",
"Sub",
"=",
"TRI",
".",
"getSubRegIndex",
"(",
"SuperReg",
",",
"RR",
".",
"Reg",
")",
";",
"LaneBitmask",
"SuperMask",
"=",
"TRI",
".",
"composeSubRegIndexLaneMask",
"(",
"Sub",
",",
"Common",
")",
";",
"return",
"RegisterRef",
"(",
"SuperReg",
",",
"SuperMask",
")",
";",
"}",
"</s>"
] | [
"Weight",
"normalization",
"function",
"."
] | [
"Hexagon"
] | RDFGraph7 | normalize | Hexagon | DSP | LLVM | 10,879 | 111 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_is_eh_return_data_register",
"(",
"unsigned",
"int",
"regno",
")",
"{",
"unsigned",
"int",
"i",
",",
"regnum",
";",
"if",
"(",
"!",
"crtl",
"->",
"calls_eh_return",
")",
"return",
"false",
";",
"for",
"(",
"i",
"=",
"0",
";",
"(",
"regnum",
"=",
"EH_RETURN_DATA_REGNO",
"(",
"i",
")",
")",
"!=",
"INVALID_REGNUM",
";",
"i",
"++",
")",
"if",
"(",
"regno",
"==",
"regnum",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"provided",
"REGNO",
"is",
"eh",
"return",
"data",
"register",
"."
] | [
"riscv",
"0"
] | riscv1 | riscv_is_eh_return_data_register | riscv | CPU | GCC | 10,880 | 60 | 1 | [] |
[
"<s>",
"Optional",
"<",
"uint64_t",
">",
"X86MCInstrAnalysis",
"::",
"getMemoryOperandRelocationOffset",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"uint64_t",
"Size",
")",
"const",
"{",
"if",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
"!=",
"X86",
"::",
"LEA64r",
")",
"return",
"None",
";",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"Info",
"->",
"get",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
";",
"int",
"MemOpStart",
"=",
"X86II",
"::",
"getMemoryOperandNo",
"(",
"MCID",
".",
"TSFlags",
")",
";",
"if",
"(",
"MemOpStart",
"==",
"-",
"1",
")",
"return",
"None",
";",
"MemOpStart",
"+=",
"X86II",
"::",
"getOperandBias",
"(",
"MCID",
")",
";",
"const",
"MCOperand",
"&",
"SegReg",
"=",
"Inst",
".",
"getOperand",
"(",
"MemOpStart",
"+",
"X86",
"::",
"AddrSegmentReg",
")",
";",
"const",
"MCOperand",
"&",
"BaseReg",
"=",
"Inst",
".",
"getOperand",
"(",
"MemOpStart",
"+",
"X86",
"::",
"AddrBaseReg",
")",
";",
"const",
"MCOperand",
"&",
"IndexReg",
"=",
"Inst",
".",
"getOperand",
"(",
"MemOpStart",
"+",
"X86",
"::",
"AddrIndexReg",
")",
";",
"const",
"MCOperand",
"&",
"ScaleAmt",
"=",
"Inst",
".",
"getOperand",
"(",
"MemOpStart",
"+",
"X86",
"::",
"AddrScaleAmt",
")",
";",
"const",
"MCOperand",
"&",
"Disp",
"=",
"Inst",
".",
"getOperand",
"(",
"MemOpStart",
"+",
"X86",
"::",
"AddrDisp",
")",
";",
"if",
"(",
"BaseReg",
".",
"getReg",
"(",
")",
"!=",
"X86",
"::",
"RIP",
"||",
"SegReg",
".",
"getReg",
"(",
")",
"!=",
"0",
"||",
"IndexReg",
".",
"getReg",
"(",
")",
"!=",
"0",
"||",
"ScaleAmt",
".",
"getImm",
"(",
")",
"!=",
"1",
"||",
"!",
"Disp",
".",
"isImm",
"(",
")",
")",
"return",
"None",
";",
"assert",
"(",
"Size",
">",
"4",
"&&",
"\"invalid instruction size for rip-relative lea\"",
")",
";",
"return",
"Size",
"-",
"4",
";",
"}",
"</s>"
] | [
"Given",
"an",
"instruction",
"with",
"a",
"memory",
"operand",
"that",
"could",
"require",
"relocation",
",",
"returns",
"the",
"offset",
"within",
"the",
"instruction",
"of",
"that",
"relocation",
"."
] | [
"X86",
"X86",
"X86::LEA64r",
"X86II::getMemoryOperandNo",
"1",
"X86II::getOperandBias",
"X86::AddrSegmentReg",
"X86::AddrBaseReg",
"X86::AddrIndexReg",
"X86::AddrScaleAmt",
"X86::AddrDisp",
"X86::RIP",
"0",
"0",
"1",
"4",
"\"invalid instruction size for rip-relative lea\"",
"4"
] | X86MCTargetDesc13 | getMemoryOperandRelocationOffset | X86 | CPU | LLVM | 10,881 | 221 | 1 | [] |
[
"<s>",
"void",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"const",
"override",
"{",
"unsigned",
"Size",
"=",
"getFixupKindSize",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"assert",
"(",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"Size",
"<=",
"Data",
".",
"size",
"(",
")",
"&&",
"\"Invalid fixup offset!\"",
")",
";",
"assert",
"(",
"(",
"Size",
"==",
"0",
"||",
"isIntN",
"(",
"Size",
"*",
"8",
"+",
"1",
",",
"Value",
")",
")",
"&&",
"\"Value does not fit in the Fixup field\"",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"Size",
";",
"++",
"i",
")",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"i",
"]",
"=",
"uint8_t",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
";",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"X86",
"\"Invalid fixup offset!\"",
"0",
"8",
"1",
"\"Value does not fit in the Fixup field\"",
"0",
"8"
] | X86AsmBackend24 | applyFixup | X86 | CPU | LLVM | 10,882 | 128 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"MipsTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"Mips",
"::",
"CPURegsRegisterClass",
")",
";",
"case",
"'f'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"Mips",
"::",
"FGR32RegisterClass",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
")",
"if",
"(",
"(",
"!",
"Subtarget",
"->",
"isSingleFloat",
"(",
")",
")",
"&&",
"(",
"!",
"Subtarget",
"->",
"isFP64bit",
"(",
")",
")",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"Mips",
"::",
"AFGR64RegisterClass",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"Mips",
"Mips",
"1",
"0",
"0U",
"Mips::CPURegsRegisterClass",
"MVT::f32",
"0U",
"Mips::FGR32RegisterClass",
"MVT::f64",
"0U",
"Mips::AFGR64RegisterClass"
] | MipsISelLowering35 | getRegForInlineAsmConstraint | Mips | CPU | LLVM | 10,883 | 136 | 1 | [] |
[
"<s>",
"int",
"arm_attr_length_pop_multi",
"(",
"rtx",
"*",
"operands",
",",
"bool",
"return_pc",
",",
"bool",
"write_back_p",
")",
"{",
"if",
"(",
"TARGET_ARM",
")",
"return",
"4",
";",
"if",
"(",
"TARGET_THUMB1",
")",
"return",
"2",
";",
"rtx",
"parallel_op",
"=",
"operands",
"[",
"0",
"]",
";",
"unsigned",
"indx",
"=",
"XVECLEN",
"(",
"parallel_op",
",",
"0",
")",
"-",
"1",
";",
"unsigned",
"regno",
"=",
"REGNO",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"unsigned",
"first_indx",
"=",
"0",
";",
"first_indx",
"+=",
"return_pc",
"?",
"1",
":",
"0",
";",
"first_indx",
"+=",
"write_back_p",
"?",
"1",
":",
"0",
";",
"bool",
"pop_p",
"=",
"(",
"regno",
"==",
"SP_REGNUM",
"&&",
"write_back_p",
")",
";",
"bool",
"ldm_p",
"=",
"!",
"pop_p",
";",
"if",
"(",
"ldm_p",
"&&",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"HI_REGS",
")",
"return",
"4",
";",
"for",
"(",
";",
"indx",
">=",
"first_indx",
";",
"indx",
"--",
")",
"{",
"regno",
"=",
"REGNO",
"(",
"XEXP",
"(",
"XVECEXP",
"(",
"parallel_op",
",",
"0",
",",
"indx",
")",
",",
"0",
")",
")",
";",
"if",
"(",
"REGNO_REG_CLASS",
"(",
"regno",
")",
"==",
"HI_REGS",
"&&",
"(",
"regno",
"!=",
"PC_REGNUM",
"||",
"ldm_p",
")",
")",
"return",
"4",
";",
"}",
"return",
"2",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"attribute",
"``",
"length",
"''",
"of",
"insn",
".",
"Currently",
",",
"this",
"function",
"is",
"used",
"for",
"``",
"*",
"load_multiple_with_writeback",
"''",
",",
"``",
"*",
"pop_multiple_with_return",
"''",
"and",
"``",
"*",
"pop_multiple_with_writeback_and_return",
"''",
".",
"OPERANDS",
"is",
"the",
"toplevel",
"PARALLEL",
"rtx",
",",
"RETURN_PC",
"is",
"true",
"if",
"OPERANDS",
"contains",
"return",
"insn",
".",
"WRITE_BACK_P",
"is",
"true",
"if",
"OPERANDS",
"contains",
"insn",
"which",
"explicit",
"updates",
"base",
"register",
"."
] | [
"arm",
"4",
"2",
"0",
"0",
"1",
"1",
"0",
"1",
"0",
"1",
"0",
"4",
"0",
"0",
"4",
"2"
] | arm | arm_attr_length_pop_multi | arm | CPU | GCC | 10,884 | 166 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"TVM DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"TVM",
"\"TVM DAG->DAG Pattern Instruction Selection\""
] | TVMISelDAGToDAG | getPassName | TVM | Virtual ISA | LLVM | 10,885 | 11 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SI Type Rewriter\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU",
"\"SI Type Rewriter\""
] | SITypeRewriter10 | getPassName | AMDGPU | GPU | LLVM | 10,886 | 13 | 1 | [] |
[
"<s>",
"bool",
"RISCVFrameLowering",
"::",
"hasReservedCallFrame",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"isInt",
"<",
"12",
">",
"(",
"MFI",
"->",
"getMaxCallFrameSize",
"(",
")",
"+",
"getStackAlignment",
"(",
")",
")",
"&&",
"!",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasReservedCallFrame",
"-",
"Under",
"normal",
"circumstances",
",",
"when",
"a",
"frame",
"pointer",
"is",
"not",
"required",
",",
"we",
"reserve",
"argument",
"space",
"for",
"call",
"sites",
"in",
"the",
"function",
"immediately",
"on",
"entry",
"to",
"the",
"current",
"function",
"."
] | [
"RISCV",
"RISCV",
"12"
] | RISCVFrameLowering (2)1 | hasReservedCallFrame | RISCV | CPU | LLVM | 10,887 | 48 | 1 | [] |
[
"<s>",
"SMLoc",
"getLoc",
"(",
")",
"const",
"{",
"return",
"getParser",
"(",
")",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"source",
"location",
"of",
"the",
"point",
"where",
"the",
"field",
"was",
"defined",
"."
] | [
"CAHP"
] | CAHPAsmParser | getLoc | CAHP | CPU | LLVM | 10,888 | 20 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_lea_outperforms",
"(",
"rtx_insn",
"*",
"insn",
",",
"unsigned",
"int",
"regno0",
",",
"unsigned",
"int",
"regno1",
",",
"unsigned",
"int",
"regno2",
",",
"int",
"split_cost",
",",
"bool",
"has_scale",
")",
"{",
"int",
"dist_define",
",",
"dist_use",
";",
"if",
"(",
"!",
"TARGET_BONNELL",
")",
"{",
"if",
"(",
"has_scale",
")",
"return",
"true",
";",
"if",
"(",
"split_cost",
"<",
"1",
")",
"return",
"false",
";",
"if",
"(",
"regno0",
"==",
"regno1",
"||",
"regno0",
"==",
"regno2",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"struct",
"recog_data_d",
"recog_data_save",
"=",
"recog_data",
";",
"dist_define",
"=",
"distance_non_agu_define",
"(",
"regno1",
",",
"regno2",
",",
"insn",
")",
";",
"dist_use",
"=",
"distance_agu_use",
"(",
"regno0",
",",
"insn",
")",
";",
"recog_data",
"=",
"recog_data_save",
";",
"if",
"(",
"dist_define",
"<",
"0",
"||",
"dist_define",
">=",
"LEA_MAX_STALL",
")",
"{",
"if",
"(",
"dist_use",
"<",
"0",
"&&",
"split_cost",
"==",
"0",
")",
"return",
"TARGET_64BIT",
"||",
"IX86_LEA_PRIORITY",
";",
"else",
"return",
"true",
";",
"}",
"dist_define",
"+=",
"split_cost",
"+",
"IX86_LEA_PRIORITY",
";",
"if",
"(",
"dist_use",
"<",
"0",
")",
"return",
"dist_define",
">",
"LEA_MAX_STALL",
";",
"return",
"dist_define",
">=",
"dist_use",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"usage",
"of",
"lea",
"INSN",
"has",
"performance",
"advantage",
"over",
"a",
"sequence",
"of",
"instructions",
".",
"Instructions",
"sequence",
"has",
"SPLIT_COST",
"cycles",
"higher",
"latency",
"than",
"lea",
"latency",
"."
] | [
"i386",
"1",
"0",
"0",
"0",
"0"
] | i3861 | ix86_lea_outperforms | i386 | CPU | GCC | 10,889 | 155 | 1 | [] |
[
"<s>",
"RegisterSet",
"&",
"remove",
"(",
"const",
"RegisterSet",
"&",
"Rs",
")",
"{",
"return",
"static_cast",
"<",
"RegisterSet",
"&",
">",
"(",
"BitVector",
"::",
"reset",
"(",
"Rs",
")",
")",
";",
"}",
"</s>"
] | [
"remove",
"-",
"Remove",
"the",
"specified",
"key/value",
"pair",
"from",
"the",
"map",
",",
"but",
"do",
"not",
"erase",
"it",
"."
] | [
"Hexagon"
] | HexagonBitSimplify (2) | remove | Hexagon | DSP | LLVM | 10,890 | 26 | 1 | [] |
[
"<s>",
"unsigned",
"getFlatAddressSpace",
"(",
")",
"const",
"{",
"return",
"AddressSpace",
"::",
"ADDRESS_SPACE_GENERIC",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"address",
"space",
"ID",
"for",
"a",
"target",
"'s",
"'flat",
"'",
"address",
"space",
"."
] | [
"NVPTX"
] | NVPTXTargetTransformInfo | getFlatAddressSpace | NVPTX | GPU | LLVM | 10,891 | 12 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_option_save",
"(",
"struct",
"cl_target_option",
"*",
"ptr",
",",
"struct",
"gcc_options",
"*",
"opts",
"ATTRIBUTE_UNUSED",
",",
"struct",
"gcc_options",
"*",
"opts_set",
"ATTRIBUTE_UNUSED",
")",
"{",
"unsigned",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"nios2_fpu_insn",
")",
";",
"i",
"++",
")",
"ptr",
"->",
"saved_fpu_custom_code",
"[",
"i",
"]",
"=",
"N2FPU_N",
"(",
"i",
")",
";",
"memcpy",
"(",
"ptr",
"->",
"saved_custom_code_status",
",",
"custom_code_status",
",",
"sizeof",
"(",
"custom_code_status",
")",
")",
";",
"memcpy",
"(",
"ptr",
"->",
"saved_custom_code_index",
",",
"custom_code_index",
",",
"sizeof",
"(",
"custom_code_index",
")",
")",
";",
"}",
"</s>"
] | [
"Target",
"attributes",
"can",
"affect",
"per-function",
"option",
"state",
",",
"so",
"we",
"need",
"to",
"save/restore",
"the",
"custom",
"code",
"tracking",
"info",
"using",
"the",
"TARGET_OPTION_SAVE/TARGET_OPTION_RESTORE",
"hooks",
"."
] | [
"nios2",
"0"
] | nios2 | nios2_option_save | nios2 | MPU | GCC | 10,892 | 83 | 1 | [] |
[
"<s>",
"void",
"arm_emit_fp16_const",
"(",
"rtx",
"c",
")",
"{",
"long",
"bits",
";",
"bits",
"=",
"real_to_target",
"(",
"NULL",
",",
"CONST_DOUBLE_REAL_VALUE",
"(",
"c",
")",
",",
"HFmode",
")",
";",
"if",
"(",
"WORDS_BIG_ENDIAN",
")",
"assemble_zeros",
"(",
"2",
")",
";",
"assemble_integer",
"(",
"GEN_INT",
"(",
"bits",
")",
",",
"2",
",",
"BITS_PER_WORD",
",",
"1",
")",
";",
"if",
"(",
"!",
"WORDS_BIG_ENDIAN",
")",
"assemble_zeros",
"(",
"2",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"fp16",
"constant",
"appropriately",
"padded",
"to",
"occupy",
"a",
"4-byte",
"word",
".",
"HFmode",
"constant",
"pool",
"entries",
"are",
"actually",
"loaded",
"with",
"ldr",
"."
] | [
"arm",
"2",
"2",
"1",
"2"
] | arm | arm_emit_fp16_const | arm | CPU | GCC | 10,893 | 58 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_avoid_hazard",
"(",
"rtx",
"after",
",",
"rtx",
"insn",
",",
"int",
"*",
"hilo_delay",
",",
"rtx",
"*",
"delayed_reg",
",",
"rtx",
"lo_reg",
")",
"{",
"rtx",
"pattern",
",",
"set",
";",
"int",
"nops",
",",
"ninsns",
";",
"if",
"(",
"!",
"INSN_P",
"(",
"insn",
")",
")",
"return",
";",
"pattern",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pattern",
")",
"==",
"ASM_INPUT",
"||",
"asm_noperands",
"(",
"pattern",
")",
">=",
"0",
")",
"cfun",
"->",
"machine",
"->",
"all_noreorder_p",
"=",
"false",
";",
"ninsns",
"=",
"get_attr_length",
"(",
"insn",
")",
"/",
"4",
";",
"if",
"(",
"ninsns",
"==",
"0",
")",
"return",
";",
"if",
"(",
"*",
"hilo_delay",
"<",
"2",
"&&",
"reg_set_p",
"(",
"lo_reg",
",",
"pattern",
")",
")",
"nops",
"=",
"2",
"-",
"*",
"hilo_delay",
";",
"else",
"if",
"(",
"*",
"delayed_reg",
"!=",
"0",
"&&",
"reg_referenced_p",
"(",
"*",
"delayed_reg",
",",
"pattern",
")",
")",
"nops",
"=",
"1",
";",
"else",
"nops",
"=",
"0",
";",
"*",
"hilo_delay",
"+=",
"nops",
";",
"while",
"(",
"nops",
"--",
">",
"0",
")",
"emit_insn_after",
"(",
"gen_hazard_nop",
"(",
")",
",",
"after",
")",
";",
"*",
"hilo_delay",
"+=",
"ninsns",
";",
"*",
"delayed_reg",
"=",
"0",
";",
"if",
"(",
"INSN_CODE",
"(",
"insn",
")",
">=",
"0",
")",
"switch",
"(",
"get_attr_hazard",
"(",
"insn",
")",
")",
"{",
"case",
"HAZARD_NONE",
":",
"break",
";",
"case",
"HAZARD_HILO",
":",
"*",
"hilo_delay",
"=",
"0",
";",
"break",
";",
"case",
"HAZARD_DELAY",
":",
"set",
"=",
"single_set",
"(",
"insn",
")",
";",
"gcc_assert",
"(",
"set",
"!=",
"0",
")",
";",
"*",
"delayed_reg",
"=",
"SET_DEST",
"(",
"set",
")",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"Subroutine",
"of",
"mips_reorg",
".",
"If",
"there",
"is",
"a",
"hazard",
"between",
"INSN",
"and",
"a",
"previous",
"instruction",
",",
"avoid",
"it",
"by",
"inserting",
"nops",
"after",
"instruction",
"AFTER",
".",
"*",
"DELAYED_REG",
"and",
"*",
"HILO_DELAY",
"describe",
"the",
"hazards",
"that",
"apply",
"at",
"this",
"point",
".",
"If",
"*",
"DELAYED_REG",
"is",
"non-null",
",",
"INSN",
"must",
"wait",
"a",
"cycle",
"before",
"using",
"the",
"value",
"of",
"that",
"register",
".",
"*",
"HILO_DELAY",
"counts",
"the",
"number",
"of",
"instructions",
"since",
"the",
"last",
"hilo",
"hazard",
"(",
"that",
"is",
",",
"the",
"number",
"of",
"instructions",
"since",
"the",
"last",
"mflo",
"or",
"mfhi",
")",
".",
"After",
"inserting",
"nops",
"for",
"INSN",
",",
"update",
"*",
"DELAYED_REG",
"and",
"*",
"HILO_DELAY",
"for",
"the",
"next",
"instruction",
".",
"LO_REG",
"is",
"an",
"rtx",
"for",
"the",
"LO",
"register",
",",
"used",
"in",
"dependence",
"checking",
"."
] | [
"mips",
"0",
"4",
"0",
"2",
"2",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"0"
] | mips3 | mips_avoid_hazard | mips | CPU | GCC | 10,894 | 228 | 1 | [] |
[
"<s>",
"const",
"unsigned",
"*",
"HexagonRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"static",
"const",
"unsigned",
"CalleeSavedRegsV2",
"[",
"]",
"=",
"{",
"Hexagon",
"::",
"R24",
",",
"Hexagon",
"::",
"R25",
",",
"Hexagon",
"::",
"R26",
",",
"Hexagon",
"::",
"R27",
",",
"0",
"}",
";",
"static",
"const",
"unsigned",
"CalleeSavedRegsV3",
"[",
"]",
"=",
"{",
"Hexagon",
"::",
"R16",
",",
"Hexagon",
"::",
"R17",
",",
"Hexagon",
"::",
"R18",
",",
"Hexagon",
"::",
"R19",
",",
"Hexagon",
"::",
"R20",
",",
"Hexagon",
"::",
"R21",
",",
"Hexagon",
"::",
"R22",
",",
"Hexagon",
"::",
"R23",
",",
"Hexagon",
"::",
"R24",
",",
"Hexagon",
"::",
"R25",
",",
"Hexagon",
"::",
"R26",
",",
"Hexagon",
"::",
"R27",
",",
"0",
"}",
";",
"switch",
"(",
"Subtarget",
".",
"getHexagonArchVersion",
"(",
")",
")",
"{",
"case",
"HexagonSubtarget",
"::",
"V1",
":",
"break",
";",
"case",
"HexagonSubtarget",
"::",
"V2",
":",
"return",
"CalleeSavedRegsV2",
";",
"case",
"HexagonSubtarget",
"::",
"V3",
":",
"case",
"HexagonSubtarget",
"::",
"V4",
":",
"return",
"CalleeSavedRegsV3",
";",
"}",
"llvm_unreachable",
"(",
"\"Callee saved registers requested for unknown architecture \"",
"\"version\"",
")",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Hexagon",
"Hexagon",
"Hexagon::R24",
"Hexagon::R25",
"Hexagon::R26",
"Hexagon::R27",
"0",
"Hexagon::R16",
"Hexagon::R17",
"Hexagon::R18",
"Hexagon::R19",
"Hexagon::R20",
"Hexagon::R21",
"Hexagon::R22",
"Hexagon::R23",
"Hexagon::R24",
"Hexagon::R25",
"Hexagon::R26",
"Hexagon::R27",
"0",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"\"Callee saved registers requested for unknown architecture \"",
"\"version\""
] | HexagonRegisterInfo36 | getCalleeSavedRegs | Hexagon | DSP | LLVM | 10,895 | 145 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"areMemAccessesTriviallyDisjoint",
"(",
"MachineInstr",
"*",
"MIa",
",",
"MachineInstr",
"*",
"MIb",
",",
"AliasAnalysis",
"*",
"AA",
")",
"const",
"{",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"&",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"BaseRegA",
"=",
"0",
",",
"BaseRegB",
"=",
"0",
";",
"int",
"OffsetA",
"=",
"0",
",",
"OffsetB",
"=",
"0",
";",
"int",
"WidthA",
"=",
"0",
",",
"WidthB",
"=",
"0",
";",
"assert",
"(",
"MIa",
"&&",
"MIa",
"->",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIa must be a load or store.\"",
")",
";",
"assert",
"(",
"MIb",
"&&",
"MIb",
"->",
"mayLoadOrStore",
"(",
")",
"&&",
"\"MIb must be a load or store.\"",
")",
";",
"if",
"(",
"MIa",
"->",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIb",
"->",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIa",
"->",
"hasOrderedMemoryRef",
"(",
")",
"||",
"MIb",
"->",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"getMemOpBaseRegImmOfsWidth",
"(",
"MIa",
",",
"BaseRegA",
",",
"OffsetA",
",",
"WidthA",
",",
"TRI",
")",
"&&",
"getMemOpBaseRegImmOfsWidth",
"(",
"MIb",
",",
"BaseRegB",
",",
"OffsetB",
",",
"WidthB",
",",
"TRI",
")",
")",
"{",
"if",
"(",
"BaseRegA",
"==",
"BaseRegB",
")",
"{",
"int",
"LowOffset",
"=",
"OffsetA",
"<",
"OffsetB",
"?",
"OffsetA",
":",
"OffsetB",
";",
"int",
"HighOffset",
"=",
"OffsetA",
"<",
"OffsetB",
"?",
"OffsetB",
":",
"OffsetA",
";",
"int",
"LowWidth",
"=",
"(",
"LowOffset",
"==",
"OffsetA",
")",
"?",
"WidthA",
":",
"WidthB",
";",
"if",
"(",
"LowOffset",
"+",
"LowWidth",
"<=",
"HighOffset",
")",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Sometimes",
",",
"it",
"is",
"possible",
"for",
"the",
"target",
"to",
"tell",
",",
"even",
"without",
"aliasing",
"information",
",",
"that",
"two",
"MIs",
"access",
"different",
"memory",
"addresses",
"."
] | [
"AArch64",
"AArch64",
"0",
"0",
"0",
"0",
"0",
"0",
"\"MIa must be a load or store.\"",
"\"MIb must be a load or store.\""
] | AArch64InstrInfo1 | areMemAccessesTriviallyDisjoint | AArch64 | CPU | LLVM | 10,896 | 199 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"X86WindowsTargetObjectFile",
"::",
"getSectionForConstant",
"(",
"SectionKind",
"Kind",
",",
"const",
"Constant",
"*",
"C",
")",
"const",
"{",
"if",
"(",
"Kind",
".",
"isMergeableConst",
"(",
")",
"&&",
"C",
")",
"{",
"const",
"unsigned",
"Characteristics",
"=",
"COFF",
"::",
"IMAGE_SCN_CNT_INITIALIZED_DATA",
"|",
"COFF",
"::",
"IMAGE_SCN_MEM_READ",
"|",
"COFF",
"::",
"IMAGE_SCN_LNK_COMDAT",
";",
"std",
"::",
"string",
"COMDATSymName",
";",
"if",
"(",
"Kind",
".",
"isMergeableConst4",
"(",
")",
"||",
"Kind",
".",
"isMergeableConst8",
"(",
")",
")",
"COMDATSymName",
"=",
"\"__real@\"",
"+",
"scalarConstantToHexString",
"(",
"C",
")",
";",
"else",
"if",
"(",
"Kind",
".",
"isMergeableConst16",
"(",
")",
")",
"COMDATSymName",
"=",
"\"__xmm@\"",
"+",
"scalarConstantToHexString",
"(",
"C",
")",
";",
"if",
"(",
"!",
"COMDATSymName",
".",
"empty",
"(",
")",
")",
"return",
"getContext",
"(",
")",
".",
"getCOFFSection",
"(",
"\".rdata\"",
",",
"Characteristics",
",",
"Kind",
",",
"COMDATSymName",
",",
"COFF",
"::",
"IMAGE_COMDAT_SELECT_ANY",
")",
";",
"}",
"return",
"TargetLoweringObjectFile",
"::",
"getSectionForConstant",
"(",
"Kind",
",",
"C",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constant",
"with",
"the",
"SectionKind",
",",
"return",
"a",
"section",
"that",
"it",
"should",
"be",
"placed",
"in",
"."
] | [
"X86",
"X86",
"\"__real@\"",
"\"__xmm@\"",
"\".rdata\""
] | X86TargetObjectFile32 | getSectionForConstant | X86 | CPU | LLVM | 10,897 | 130 | 1 | [] |
[
"<s>",
"bool",
"X86AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"1",
"]",
"!=",
"0",
")",
"return",
"true",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNo",
")",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"default",
":",
"return",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNo",
",",
"AsmVariant",
",",
"ExtraCode",
",",
"O",
")",
";",
"case",
"'a'",
":",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"default",
":",
"return",
"true",
";",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"O",
"<<",
"MO",
".",
"getImm",
"(",
")",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"llvm_unreachable",
"(",
"\"unexpected operand type!\"",
")",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"printSymbolOperand",
"(",
"*",
"this",
",",
"MO",
",",
"O",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isPICStyleRIPRel",
"(",
")",
")",
"O",
"<<",
"\"(%rip)\"",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"O",
"<<",
"'('",
";",
"printOperand",
"(",
"*",
"this",
",",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"O",
"<<",
"')'",
";",
"return",
"false",
";",
"}",
"case",
"'c'",
":",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"default",
":",
"printOperand",
"(",
"*",
"this",
",",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"O",
"<<",
"MO",
".",
"getImm",
"(",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"llvm_unreachable",
"(",
"\"unexpected operand type!\"",
")",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"printSymbolOperand",
"(",
"*",
"this",
",",
"MO",
",",
"O",
")",
";",
"break",
";",
"}",
"return",
"false",
";",
"case",
"'A'",
":",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"O",
"<<",
"'*'",
";",
"printOperand",
"(",
"*",
"this",
",",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"case",
"'b'",
":",
"case",
"'h'",
":",
"case",
"'w'",
":",
"case",
"'k'",
":",
"case",
"'q'",
":",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"printAsmMRegister",
"(",
"*",
"this",
",",
"MO",
",",
"ExtraCode",
"[",
"0",
"]",
",",
"O",
")",
";",
"printOperand",
"(",
"*",
"this",
",",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"return",
"false",
";",
"case",
"'P'",
":",
"printPCRelImm",
"(",
"*",
"this",
",",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"return",
"false",
";",
"case",
"'n'",
":",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"O",
"<<",
"-",
"MO",
".",
"getImm",
"(",
")",
";",
"return",
"false",
";",
"}",
"O",
"<<",
"'-'",
";",
"}",
"}",
"printOperand",
"(",
"*",
"this",
",",
"MI",
",",
"OpNo",
",",
"O",
",",
"0",
",",
"AsmVariant",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"X86",
"X86",
"0",
"1",
"0",
"0",
"\"unexpected operand type!\"",
"\"(%rip)\"",
"\"unexpected operand type!\"",
"0",
"0"
] | X86AsmPrinter27 | PrintAsmOperand | X86 | CPU | LLVM | 10,898 | 440 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"findDeadCallerSavedReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"const",
"X86RegisterInfo",
"*",
"TRI",
",",
"bool",
"Is64Bit",
")",
"{",
"const",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
"->",
"getFunction",
"(",
")",
";",
"if",
"(",
"!",
"F",
"||",
"MF",
"->",
"getMMI",
"(",
")",
".",
"callsEHReturn",
"(",
")",
")",
"return",
"0",
";",
"const",
"TargetRegisterClass",
"&",
"AvailableRegs",
"=",
"*",
"TRI",
"->",
"getGPRsForTailCall",
"(",
"*",
"MF",
")",
";",
"unsigned",
"Opc",
"=",
"MBBI",
"->",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"return",
"0",
";",
"case",
"X86",
"::",
"RET",
":",
"case",
"X86",
"::",
"RETL",
":",
"case",
"X86",
"::",
"RETQ",
":",
"case",
"X86",
"::",
"RETIL",
":",
"case",
"X86",
"::",
"RETIQ",
":",
"case",
"X86",
"::",
"TCRETURNdi",
":",
"case",
"X86",
"::",
"TCRETURNri",
":",
"case",
"X86",
"::",
"TCRETURNmi",
":",
"case",
"X86",
"::",
"TCRETURNdi64",
":",
"case",
"X86",
"::",
"TCRETURNri64",
":",
"case",
"X86",
"::",
"TCRETURNmi64",
":",
"case",
"X86",
"::",
"EH_RETURN",
":",
"case",
"X86",
"::",
"EH_RETURN64",
":",
"{",
"SmallSet",
"<",
"uint16_t",
",",
"8",
">",
"Uses",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"MBBI",
"->",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"MachineOperand",
"&",
"MO",
"=",
"MBBI",
"->",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
"||",
"MO",
".",
"isDef",
"(",
")",
")",
"continue",
";",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"continue",
";",
"for",
"(",
"MCRegAliasIterator",
"AI",
"(",
"Reg",
",",
"TRI",
",",
"true",
")",
";",
"AI",
".",
"isValid",
"(",
")",
";",
"++",
"AI",
")",
"Uses",
".",
"insert",
"(",
"*",
"AI",
")",
";",
"}",
"for",
"(",
"auto",
"CS",
":",
"AvailableRegs",
")",
"if",
"(",
"!",
"Uses",
".",
"count",
"(",
"CS",
")",
"&&",
"CS",
"!=",
"X86",
"::",
"RIP",
")",
"return",
"CS",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"findDeadCallerSavedReg",
"-",
"Return",
"a",
"caller-saved",
"register",
"that",
"is",
"n't",
"live",
"when",
"it",
"reaches",
"the",
"``",
"return",
"''",
"instruction",
"."
] | [
"X86",
"X86",
"0",
"0",
"X86::RET",
"X86::RETL",
"X86::RETQ",
"X86::RETIL",
"X86::RETIQ",
"X86::TCRETURNdi",
"X86::TCRETURNri",
"X86::TCRETURNmi",
"X86::TCRETURNdi64",
"X86::TCRETURNri64",
"X86::TCRETURNmi64",
"X86::EH_RETURN",
"X86::EH_RETURN64",
"8",
"0",
"X86::RIP",
"0"
] | X86FrameLowering112 | findDeadCallerSavedReg | X86 | CPU | LLVM | 10,899 | 299 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.