Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "CellSPU" ]

[]

[ "<s>", "static", "void", "avr_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "ptrreg_to_str", "(", "REGNO", "(", "addr", ")", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "text_segment_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "2", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "AVR_3_BYTE_PC", ")", "if", "(", "warning", "(", "0", ",", "\"pointer offset from symbol maybe incorrect\"", ")", ")", "{", "output_addr_const", "(", "stderr", ",", "addr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "}", "}", "else", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>" ]

[ "Output", "ADDR", "to", "FILE", "as", "address", "." ]

[ "avr", "\"-%s\"", "0", "\"%s+\"", "0", "0", "1", "\"gs(\"", "0", "\"+\"", "\")\"", "2", "1", "0", "\"pointer offset from symbol maybe incorrect\"", "\"\\n\"", "\"gs(\"", "\")\"" ]

[]

[ "<s>", "bool", "MemSelOpt", "::", "processInstruction", "(", "MachineInstr", "*", "MI", ")", "{", "bool", "Changed", "=", "false", ";", "unsigned", "NumOperands", "=", "MI", "->", "getNumOperands", "(", ")", ";", "if", "(", "NumOperands", "==", "0", ")", "return", "false", ";", "const", "TargetInstrDesc", "&", "TID", "=", "TII", "->", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "!", "(", "TID", ".", "isBranch", "(", ")", "||", "TID", ".", "isCall", "(", ")", "||", "TID", ".", "mayLoad", "(", ")", "||", "TID", ".", "mayStore", "(", ")", ")", ")", "return", "false", ";", "if", "(", "TID", ".", "isCall", "(", ")", ")", "{", "PageChanged", "=", "1", ";", "CurBank", "=", "\"\"", ";", "}", "int", "MemOpPos", "=", "-", "1", ";", "int", "BBOpPos", "=", "-", "1", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumOperands", ";", "i", "++", ")", "{", "MachineOperand", "Op", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_GlobalAddress", "||", "Op", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_ExternalSymbol", ")", "{", "MemOpPos", "=", "i", ";", "}", "if", "(", "Op", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_MachineBasicBlock", ")", "{", "BBOpPos", "=", "i", ";", "}", "}", "if", "(", "(", "MemOpPos", "==", "-", "1", ")", "&&", "(", "BBOpPos", "==", "-", "1", ")", ")", "return", "false", ";", "assert", "(", "(", "BBOpPos", "!=", "MemOpPos", ")", "&&", "\"operand can only be of one type\"", ")", ";", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "PIC16", "::", "CALL", ")", ")", "{", "MachineOperand", "&", "MemOp", "=", "MI", "->", "getOperand", "(", "MemOpPos", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "dl", ",", "TII", "->", "get", "(", "PIC16", "::", "pagesel", ")", ")", ".", "addOperand", "(", "MemOp", ")", ";", "return", "true", ";", "}", "if", "(", "MemOpPos", "==", "-", "1", ")", "return", "Changed", ";", "MachineOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "MemOpPos", ")", ";", "std", "::", "string", "NewBank", "=", "CurBank", ";", "bool", "hasExternalLinkage", "=", "false", ";", "if", "(", "Op", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_GlobalAddress", "&&", "Op", ".", "getGlobal", "(", ")", "->", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "==", "PIC16ISD", "::", "RAM_SPACE", ")", "{", "if", "(", "Op", ".", "getGlobal", "(", ")", "->", "hasExternalLinkage", "(", ")", ")", "hasExternalLinkage", "=", "true", ";", "NewBank", "=", "Op", ".", "getGlobal", "(", ")", "->", "getSection", "(", ")", ";", "}", "else", "if", "(", "Op", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_ExternalSymbol", ")", "{", "std", "::", "string", "Sym", "=", "Op", ".", "getSymbolName", "(", ")", ";", "NewBank", "=", "PAN", "::", "getSectionNameForSym", "(", "Sym", ")", ";", "}", "if", "(", "NewBank", "==", "PAN", "::", "getSharedUDataSectionName", "(", ")", ")", "return", "Changed", ";", "if", "(", "NewBank", ".", "compare", "(", "CurBank", ")", "!=", "0", "||", "hasExternalLinkage", ")", "{", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "dl", ",", "TII", "->", "get", "(", "PIC16", "::", "banksel", ")", ")", ".", "addOperand", "(", "Op", ")", ";", "Changed", "=", "true", ";", "CurBank", "=", "NewBank", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "PIC16", "0", "1", "\"\"", "1", "1", "0", "1", "1", "\"operand can only be of one type\"", "PIC16::CALL", "PIC16::pagesel", "1", "PIC16ISD::RAM_SPACE", "0", "PIC16::banksel" ]

[]

[ "<s>", "BitVector", "MCS51RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "R1R0", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "SPL", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "SPH", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "R28", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "MCS51", "::", "R29R28", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "MCS51", "MCS51", "MCS51::R0", "MCS51::R1", "MCS51::R1R0", "MCS51::SPL", "MCS51::SPH", "MCS51::SP", "MCS51::R28", "MCS51::R29", "MCS51::R29R28" ]

[]

[ "<s>", "bool", "rs6000_overloaded_builtin_p", "(", "enum", "rs6000_builtins", "fncode", ")", "{", "return", "(", "rs6000_builtin_info", "[", "(", "int", ")", "fncode", "]", ".", "attr", "&", "RS6000_BTC_OVERLOADED", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "builtin", "function", "is", "overloaded", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "leaveMBB", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Leaving MBB#\"", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "advanceTo", "(", "MBB", "->", "getFirstTerminator", "(", ")", ")", ";", "}", "</s>" ]

[ "Tell", "the", "strategy", "that", "current", "MBB", "is", "done", "." ]

[ "SystemZ", "SystemZ", "\"+++ Leaving MBB#\"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "LM32RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "LM32", "::", "RFP", ":", "LM32", "::", "RSP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "LM32", "LM32", "LM32::RFP", "LM32::RSP" ]

[]

[ "<s>", "static", "void", "s390_register_info_set_ranges", "(", ")", "{", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", "&&", "cfun_gpr_save_slot", "(", "i", ")", "!=", "SAVE_SLOT_STACK", ";", "i", "++", ")", ";", "for", "(", "j", "=", "15", ";", "j", ">", "i", "&&", "cfun_gpr_save_slot", "(", "j", ")", "!=", "SAVE_SLOT_STACK", ";", "j", "--", ")", ";", "cfun_frame_layout", ".", "first_restore_gpr", "=", "(", "i", "==", "16", ")", "?", "-", "1", ":", "i", ";", "cfun_frame_layout", ".", "last_restore_gpr", "=", "(", "i", "==", "16", ")", "?", "-", "1", ":", "j", ";", "cfun_frame_layout", ".", "first_save_gpr", "=", "(", "i", "==", "16", ")", "?", "-", "1", ":", "i", ";", "cfun_frame_layout", ".", "last_save_gpr", "=", "(", "i", "==", "16", ")", "?", "-", "1", ":", "j", ";", "}", "</s>" ]

[ "Calculate", "the", "save", "and", "restore", "ranges", "for", "stm", "(", "g", ")", "and", "lm", "(", "g", ")", "in", "the", "prologue", "and", "epilogue", "." ]

[ "s390", "0", "16", "15", "16", "1", "16", "1", "16", "1", "16", "1" ]

[]

[ "<s>", "int", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isInt", "<", "21", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "if", "(", "(", "Imm", ".", "getSExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Basic", ";", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "}", "return", "4", "*", "TTI", "::", "TCC_Basic", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "Lanai", "0", "16", "21", "32", "0xFFFF", "0", "2", "4" ]

[]

[ "<s>", "unsigned", "TL45MCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "MCInstrDesc", "const", "&", "Desc", "=", "InstrInfo", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getImmOpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "TL45", "::", "Fixups", "FixupKind", "=", "TL45", "::", "fixup_tl45_invalid", ";", "bool", "RelaxCandidate", "=", "false", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Target", ")", "{", "Expr", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"todo, support MCExpr::Target\"", ")", ";", "}", "else", "if", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", "&&", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_None", ")", "{", "FixupKind", "=", "TL45", "::", "fixup_tl45_lo16_i", ";", "}", "assert", "(", "FixupKind", "!=", "TL45", "::", "fixup_tl45_invalid", "&&", "\"Unhandled expression!\"", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "FixupKind", ")", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "return", "0", ";", "}", "</s>" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ "TL45", "TL45", "\"getImmOpValue expects only expressions or immediates\"", "TL45::Fixups", "TL45::fixup_tl45_invalid", "\"todo, support MCExpr::Target\"", "TL45::fixup_tl45_lo16_i", "TL45::fixup_tl45_invalid", "\"Unhandled expression!\"", "0", "0" ]

[]

[ "<s>", "static", "int", "rs6000_debug_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "int", "ret", "=", "rs6000_adjust_cost", "(", "insn", ",", "link", ",", "dep_insn", ",", "cost", ")", ";", "if", "(", "ret", "!=", "cost", ")", "{", "const", "char", "*", "dep", ";", "switch", "(", "REG_NOTE_KIND", "(", "link", ")", ")", "{", "default", ":", "dep", "=", "\"unknown depencency\"", ";", "break", ";", "case", "REG_DEP_TRUE", ":", "dep", "=", "\"data dependency\"", ";", "break", ";", "case", "REG_DEP_OUTPUT", ":", "dep", "=", "\"output dependency\"", ";", "break", ";", "case", "REG_DEP_ANTI", ":", "dep", "=", "\"anti depencency\"", ";", "break", ";", "}", "fprintf", "(", "stderr", ",", "\"\\nrs6000_adjust_cost, final cost = %d, orig cost = %d, \"", "\"%s, insn:\\n\"", ",", "ret", ",", "cost", ",", "dep", ")", ";", "debug_rtx", "(", "insn", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_adjust_cost", "." ]

[ "rs6000", "\"unknown depencency\"", "\"data dependency\"", "\"output dependency\"", "\"anti depencency\"", "\"\\nrs6000_adjust_cost, final cost = %d, orig cost = %d, \"", "\"%s, insn:\\n\"" ]

[]

[ "<s>", "MCSection", "*", "XCoreTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "unsigned", "&", "Align", ")", "const", "{", "if", "(", "Kind", ".", "isMergeableConst4", "(", ")", ")", "return", "MergeableConst4Section", ";", "if", "(", "Kind", ".", "isMergeableConst8", "(", ")", ")", "return", "MergeableConst8Section", ";", "if", "(", "Kind", ".", "isMergeableConst16", "(", ")", ")", "return", "MergeableConst16Section", ";", "assert", "(", "(", "Kind", ".", "isReadOnly", "(", ")", "||", "Kind", ".", "isReadOnlyWithRel", "(", ")", ")", "&&", "\"Unknown section kind\"", ")", ";", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "XCore", "XCore", "\"Unknown section kind\"" ]

[]

[ "<s>", "void", "X86AsmParser", "::", "EmitInstruction", "(", "MCInst", "&", "Inst", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "Instrumentation", "->", "InstrumentAndEmitInstruction", "(", "Inst", ",", "Operands", ",", "getContext", "(", ")", ",", "MII", ",", "Out", ",", "getParser", "(", ")", ".", "shouldPrintSchedInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "char", "*", "function_builder", "::", "finish_name", "(", ")", "{", "obstack_1grow", "(", "&", "m_string_obstack", ",", "0", ")", ";", "return", "(", "char", "*", ")", "obstack_finish", "(", "&", "m_string_obstack", ")", ";", "}", "</s>" ]

[ "Zero-terminate", "and", "complete", "the", "function", "name", "being", "built", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isCortexA57", "(", ")", "&&", "!", "Subtarget", ".", "isCortexA53", "(", ")", "&&", "!", "Subtarget", ".", "isKryo", "(", ")", ")", "return", "MI", "->", "isAsCheapAsAMove", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "return", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "case", "AArch64", "::", "ANDWri", ":", "case", "AArch64", "::", "ANDXri", ":", "case", "AArch64", "::", "EORWri", ":", "case", "AArch64", "::", "EORXri", ":", "case", "AArch64", "::", "ORRWri", ":", "case", "AArch64", "::", "ORRXri", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrr", ":", "case", "AArch64", "::", "ANDXrr", ":", "case", "AArch64", "::", "BICWrr", ":", "case", "AArch64", "::", "BICXrr", ":", "case", "AArch64", "::", "EONWrr", ":", "case", "AArch64", "::", "EONXrr", ":", "case", "AArch64", "::", "EORWrr", ":", "case", "AArch64", "::", "EORXrr", ":", "case", "AArch64", "::", "ORNWrr", ":", "case", "AArch64", "::", "ORNXrr", ":", "case", "AArch64", "::", "ORRWrr", ":", "case", "AArch64", "::", "ORRXrr", ":", "return", "true", ";", "case", "AArch64", "::", "MOVi32imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "32", ")", ";", "case", "AArch64", "::", "MOVi64imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "64", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode to check as cheap as a move!\"", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "AArch64", "AArch64", "AArch64::ADDWri", "AArch64::ADDXri", "AArch64::SUBWri", "AArch64::SUBXri", "3", "0", "AArch64::ANDWri", "AArch64::ANDXri", "AArch64::EORWri", "AArch64::EORXri", "AArch64::ORRWri", "AArch64::ORRXri", "AArch64::ANDWrr", "AArch64::ANDXrr", "AArch64::BICWrr", "AArch64::BICXrr", "AArch64::EONWrr", "AArch64::EONXrr", "AArch64::EORWrr", "AArch64::EORXrr", "AArch64::ORNWrr", "AArch64::ORNXrr", "AArch64::ORRWrr", "AArch64::ORRXrr", "AArch64::MOVi32imm", "32", "AArch64::MOVi64imm", "64", "\"Unknown opcode to check as cheap as a move!\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Recognize Hexagon-specific loop idioms\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "Hexagon", "\"Recognize Hexagon-specific loop idioms\"" ]

[]

[ "<s>", "bool", "AMDGPULowerKernelAttributes", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "StringRef", "DispatchPtrName", "=", "Intrinsic", "::", "getName", "(", "Intrinsic", "::", "amdgcn_dispatch_ptr", ")", ";", "Function", "*", "DispatchPtr", "=", "Mod", "->", "getFunction", "(", "DispatchPtrName", ")", ";", "if", "(", "!", "DispatchPtr", ")", "return", "false", ";", "bool", "MadeChange", "=", "false", ";", "SmallPtrSet", "<", "Instruction", "*", ",", "4", ">", "HandledUses", ";", "for", "(", "auto", "*", "U", ":", "DispatchPtr", "->", "users", "(", ")", ")", "{", "CallInst", "*", "CI", "=", "cast", "<", "CallInst", ">", "(", "U", ")", ";", "if", "(", "HandledUses", ".", "insert", "(", "CI", ")", ".", "second", ")", "{", "if", "(", "processUse", "(", "CI", ")", ")", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU", "Intrinsic::getName", "Intrinsic::amdgcn_dispatch_ptr", "4" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "M68kFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "ReserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "ReserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "IsDestroy", "&&", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "ReserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "auto", "&", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "DwarfCFI", "=", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", ".", "needsUnwindTableEntry", "(", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "IsDestroy", "&&", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "{", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "}", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "IsDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "IsDestroy", "?", "Amount", ":", "-", "Amount", ";", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "IsDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "M68k", "M68k", "0", "0", "1", "0", "M68k", "0" ]

[]

[ "<s>", "void", "LC3RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "LC3", "::", "LDR", ":", "case", "LC3", "::", "STR", ":", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "break", ";", "}", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", "+", "MFI", "->", "getStackSize", "(", ")", "+", "ImmOp", ".", "getImm", "(", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "LC3", "::", "SP", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "LC3", "LC3", "0", "LC3::LDR", "LC3::STR", "1", "LC3::SP" ]

[]

[ "<s>", "static", "rtx", "create_temp_reg_if_possible", "(", "machine_mode", "mode", ",", "rtx", "default_reg", ")", "{", "return", "can_create_pseudo_p", "(", ")", "?", "gen_reg_rtx", "(", "mode", ")", ":", "default_reg", ";", "}", "</s>" ]

[ "Create", "a", "temporary", "variable", "to", "hold", "a", "partial", "result", ",", "to", "enable", "CSE", "." ]

[ "tilepro" ]

[]

[ "<s>", "virtual", "bool", "addInstSelector", "(", ")", "{", "addPass", "(", "createPatmosISelDag", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "static", "void", "recombine_lvx_pattern", "(", "rtx_insn", "*", "insn", ",", "del_info", "*", "to_delete", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "==", "MEM", ")", ";", "rtx", "mem", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "rtx", "and_operation", "=", "find_alignment_op", "(", "insn", ",", "base_reg", ")", ";", "if", "(", "and_operation", "!=", "0", ")", "{", "df_ref", "def", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "FOR_EACH_INSN_INFO_DEF", "(", "def", ",", "insn_info", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "XEXP", "(", "mem", ",", "0", ")", "=", "and_operation", ";", "SET_SRC", "(", "body", ")", "=", "mem", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"lvx opportunity found at %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "INSN", "is", "the", "load", "for", "an", "lvx", "pattern", ",", "put", "it", "in", "canonical", "form", "." ]

[ "powerpcspe", "0", "0", "0", "0", "0", "1", "\"lvx opportunity found at %d\\n\"" ]

[]

[ "<s>", "int", "size", "(", ")", "const", "{", "return", "Chain", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Hexagon" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "isRegBase", "(", ")", "&&", "\"Invalid base register access!\"", ")", ";", "return", "Base", ".", "Reg", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "Mips", "\"Invalid base register access!\"" ]

[]

[ "<s>", "static", "int", "rs6000_loop_align_max_skip", "(", "rtx_insn", "*", "label", ")", "{", "return", "(", "1", "<<", "rs6000_loop_align", "(", "label", ")", ")", "-", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_LOOP_ALIGN_MAX_SKIP", "." ]

[ "powerpcspe", "1", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "override", "{", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "RV16K" ]

[]

[ "<s>", "bool", "XCoreInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineInstr", "*", "LastInst", "=", "&", "*", "I", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "if", "(", "IsBRU", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "XCore", "::", "CondCode", "BranchCode", "=", "GetCondFromBranchOpc", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "BranchCode", "==", "XCore", "::", "COND_INVALID", ")", "return", "true", ";", "TBB", "=", "LastInst", "->", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "Cond", ".", "push_back", "(", "LastInst", "->", "getOperand", "(", "0", ")", ")", ";", "return", "false", ";", "}", "MachineInstr", "*", "SecondLastInst", "=", "&", "*", "I", ";", "if", "(", "SecondLastInst", "&&", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "return", "true", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "XCore", "::", "CondCode", "BranchCode", "=", "GetCondFromBranchOpc", "(", "SecondLastOpc", ")", ";", "if", "(", "BranchCode", "!=", "XCore", "::", "COND_INVALID", "&&", "IsBRU", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "Cond", ".", "push_back", "(", "SecondLastInst", "->", "getOperand", "(", "0", ")", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IsBRU", "(", "SecondLastInst", "->", "getOpcode", "(", ")", ")", "&&", "IsBRU", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "I", "=", "LastInst", ";", "if", "(", "AllowModify", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IsBR_JT", "(", "SecondLastInst", "->", "getOpcode", "(", ")", ")", "&&", "IsBRU", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ")", "{", "I", "=", "LastInst", ";", "if", "(", "AllowModify", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "XCore", "XCore", "0", "XCore::CondCode", "XCore::COND_INVALID", "1", "0", "XCore::CondCode", "XCore::COND_INVALID", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "aarch_macro_fusion_pair_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "curr", ")", "{", "rtx", "set_dest", ";", "rtx", "prev_set", "=", "single_set", "(", "prev", ")", ";", "rtx", "curr_set", "=", "single_set", "(", "curr", ")", ";", "if", "(", "!", "prev_set", "||", "!", "curr_set", ")", "return", "false", ";", "if", "(", "any_condjump_p", "(", "curr", ")", ")", "return", "false", ";", "if", "(", "!", "arm_macro_fusion_p", "(", ")", ")", "return", "false", ";", "if", "(", "current_tune", "->", "fuseable_ops", "&", "ARM_FUSE_MOVW_MOVT", ")", "{", "set_dest", "=", "SET_DEST", "(", "curr_set", ")", ";", "if", "(", "GET_MODE", "(", "set_dest", ")", "!=", "SImode", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "set_dest", ")", "==", "ZERO_EXTRACT", ")", "{", "if", "(", "CONST_INT_P", "(", "SET_SRC", "(", "curr_set", ")", ")", "&&", "CONST_INT_P", "(", "SET_SRC", "(", "prev_set", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "set_dest", ",", "0", ")", ")", "&&", "REG_P", "(", "SET_DEST", "(", "prev_set", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "set_dest", ",", "0", ")", ")", "==", "REGNO", "(", "SET_DEST", "(", "prev_set", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "curr_set", ")", ")", "==", "LO_SUM", "&&", "REG_P", "(", "SET_DEST", "(", "curr_set", ")", ")", "&&", "REG_P", "(", "SET_DEST", "(", "prev_set", ")", ")", "&&", "GET_CODE", "(", "SET_SRC", "(", "prev_set", ")", ")", "==", "HIGH", "&&", "REGNO", "(", "SET_DEST", "(", "curr_set", ")", ")", "==", "REGNO", "(", "SET_DEST", "(", "prev_set", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_MACRO_FUSION_PAIR_P", ".", "Return", "true", "if", "PREV", "and", "CURR", "should", "be", "kept", "together", "during", "scheduling", "." ]

[ "arm", "0", "0" ]

[]

[ "<s>", "unsigned", "char", "AArch64Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "bool", "isDef", "=", "GV", "->", "isStrongDefinitionForLinker", "(", ")", ";", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "&&", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "return", "AArch64II", "::", "MO_CONSTPOOL", ";", "else", "return", "AArch64II", "::", "MO_GOT", ";", "}", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", "&&", "GV", "->", "hasDefaultVisibility", "(", ")", ")", "{", "if", "(", "isTargetMachO", "(", ")", ")", "return", "isDef", "?", "AArch64II", "::", "MO_NO_FLAG", ":", "AArch64II", "::", "MO_GOT", ";", "else", "return", "GV", "->", "hasLocalLinkage", "(", ")", "?", "AArch64II", "::", "MO_NO_FLAG", ":", "AArch64II", "::", "MO_GOT", ";", "}", "return", "AArch64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "AArch64", "AArch64", "AArch64II::MO_GOT", "AArch64II::MO_CONSTPOOL", "AArch64II::MO_GOT", "AArch64II::MO_NO_FLAG", "AArch64II::MO_GOT", "AArch64II::MO_NO_FLAG", "AArch64II::MO_GOT", "AArch64II::MO_NO_FLAG" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "!", "FBB", "&&", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "ST", ".", "hasOffset3fBug", "(", ")", "?", "8", ":", "4", ";", "return", "1", ";", "}", "if", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "Cond", "[", "0", "]", ".", "isReg", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "SI_NON_UNIFORM_BRCOND_PSEUDO", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "TBB", "&&", "Cond", "[", "0", "]", ".", "isImm", "(", ")", ")", ";", "unsigned", "Opcode", "=", "getBranchOpcode", "(", "static_cast", "<", "BranchPredicate", ">", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "if", "(", "!", "FBB", ")", "{", "Cond", "[", "1", "]", ".", "isUndef", "(", ")", ";", "MachineInstr", "*", "CondBr", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "preserveCondRegFlags", "(", "CondBr", "->", "getOperand", "(", "1", ")", ",", "Cond", "[", "1", "]", ")", ";", "fixImplicitOperands", "(", "*", "CondBr", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "ST", ".", "hasOffset3fBug", "(", ")", "?", "8", ":", "4", ";", "return", "1", ";", "}", "assert", "(", "TBB", "&&", "FBB", ")", ";", "MachineInstr", "*", "CondBr", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "MachineOperand", "&", "CondReg", "=", "CondBr", "->", "getOperand", "(", "1", ")", ";", "CondReg", ".", "setIsUndef", "(", "Cond", "[", "1", "]", ".", "isUndef", "(", ")", ")", ";", "CondReg", ".", "setIsKill", "(", "Cond", "[", "1", "]", ".", "isKill", "(", ")", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "ST", ".", "hasOffset3fBug", "(", ")", "?", "16", ":", "8", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_BRANCH", "8", "4", "1", "1", "0", "AMDGPU::SI_NON_UNIFORM_BRCOND_PSEUDO", "0", "1", "0", "0", "1", "1", "1", "8", "4", "1", "AMDGPU::S_BRANCH", "1", "1", "1", "16", "8", "2" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"0($\"", "<<", "MipsInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "Mips", "Mips", "0", "\"unexpected inline asm memory operand\"", "\"0($\"", "Mips", "\")\"" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "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", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "output_indirect_thunk", "(", "unsigned", "int", "regno", ")", "{", "char", "indirectlabel1", "[", "32", "]", ";", "char", "indirectlabel2", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel1", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel2", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "fputs", "(", "\"\\tcall\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tpause\\n\\tlfence\\n\"", ")", ";", "fputs", "(", "\"\\tjmp\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "if", "(", "flag_asynchronous_unwind_tables", "&&", "dwarf2out_do_frame", "(", ")", ")", "{", "if", "(", "!", "dwarf2out_do_cfi_asm", "(", ")", ")", "{", "dw_cfi_ref", "xcfi", "=", "ggc_cleared_alloc", "<", "dw_cfi_node", ">", "(", ")", ";", "xcfi", "->", "dw_cfi_opc", "=", "DW_CFA_advance_loc4", ";", "xcfi", "->", "dw_cfi_oprnd1", ".", "dw_cfi_addr", "=", "ggc_strdup", "(", "indirectlabel2", ")", ";", "vec_safe_push", "(", "cfun", "->", "fde", "->", "dw_fde_cfi", ",", "xcfi", ")", ";", "}", "dw_cfi_ref", "xcfi", "=", "ggc_cleared_alloc", "<", "dw_cfi_node", ">", "(", ")", ";", "xcfi", "->", "dw_cfi_opc", "=", "DW_CFA_def_cfa_offset", ";", "xcfi", "->", "dw_cfi_oprnd1", ".", "dw_cfi_offset", "=", "2", "*", "UNITS_PER_WORD", ";", "vec_safe_push", "(", "cfun", "->", "fde", "->", "dw_fde_cfi", ",", "xcfi", ")", ";", "dwarf2out_emit_cfi", "(", "xcfi", ")", ";", "}", "if", "(", "regno", "!=", "INVALID_REGNUM", ")", "{", "rtx", "xops", "[", "2", "]", ";", "xops", "[", "0", "]", "=", "gen_rtx_MEM", "(", "word_mode", ",", "stack_pointer_rtx", ")", ";", "xops", "[", "1", "]", "=", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ";", "output_asm_insn", "(", "\"mov\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "}", "else", "{", "rtx", "xops", "[", "2", "]", ";", "xops", "[", "0", "]", "=", "stack_pointer_rtx", ";", "xops", "[", "1", "]", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ";", "output_asm_insn", "(", "\"lea\\t{%E1, %0|%0, %E1}\"", ",", "xops", ")", ";", "}", "fputs", "(", "\"\\tret\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "(", "ix86_harden_sls", "&", "harden_sls_return", ")", ")", "fputs", "(", "\"\\tint3\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "a", "call", "and", "return", "thunk", "for", "indirect", "branch", ".", "If", "BND_P", "is", "true", ",", "the", "BND", "prefix", "is", "needed", ".", "If", "REGNO", "!", "=", "-1", ",", "the", "function", "address", "is", "in", "REGNO", "and", "the", "call", "and", "return", "thunk", "looks", "like", ":", "call", "L2", "L1", ":", "pause", "lfence", "jmp", "L1", "L2", ":", "mov", "%", "REG", ",", "(", "%", "sp", ")", "ret", "Otherwise", ",", "the", "function", "address", "is", "on", "the", "top", "of", "stack", "and", "the", "call", "and", "return", "thunk", "looks", "like", ":", "call", "L2", "L1", ":", "pause", "lfence", "jmp", "L1", "L2", ":", "lea", "WORD_SIZE", "(", "%", "sp", ")", ",", "%", "sp", "ret" ]

[ "i386", "32", "32", "\"\\tcall\\t\"", "\"\\tpause\\n\\tlfence\\n\"", "\"\\tjmp\\t\"", "2", "2", "0", "1", "\"mov\\t{%1, %0|%0, %1}\"", "2", "0", "1", "\"lea\\t{%E1, %0|%0, %E1}\"", "\"\\tret\\n\"", "\"\\tint3\\n\"" ]

[]

[ "<s>", "void", "P2TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "P2", "P2" ]

[]

[ "<s>", "int", "xs_hi_general_operand", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "&&", "(", "(", "INTVAL", "(", "x", ")", ">=", "32768", ")", "||", "(", "INTVAL", "(", "x", ")", "<", "-", "32768", ")", ")", ")", "error", "(", "\"constant halfword load operand out of range\"", ")", ";", "return", "general_operand", "(", "x", ",", "mode", ")", ";", "}", "</s>" ]

[ "Detect", "and", "error", "out", "on", "out-of-range", "constants", "for", "movhi", "." ]

[ "stormy16", "32768", "32768", "\"constant halfword load operand out of range\"" ]

[]

[ "<s>", "static", "bool", "aarch64_rtx_costs_wrapper", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer", ",", "int", "param", ",", "int", "*", "cost", ",", "bool", "speed", ")", "{", "bool", "result", "=", "aarch64_rtx_costs", "(", "x", ",", "code", ",", "outer", ",", "param", ",", "cost", ",", "speed", ")", ";", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "{", "print_rtl_single", "(", "dump_file", ",", "x", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n%s cost: %d (%s)\\n\"", ",", "speed", "?", "\"Hot\"", ":", "\"Cold\"", ",", "*", "cost", ",", "result", "?", "\"final\"", ":", "\"partial\"", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Wrapper", "around", "aarch64_rtx_costs", ",", "dumps", "the", "partial", ",", "or", "total", "cost", "calculated", "for", "X", ".", "This", "cost", "is", "stored", "in", "*", "COST", ".", "Returns", "true", "if", "the", "total", "cost", "of", "X", "was", "calculated", "." ]

[ "aarch64", "\"\\n%s cost: %d (%s)\\n\"", "\"Hot\"", "\"Cold\"", "\"final\"", "\"partial\"" ]

[]

[ "<s>", "void", "ARMHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "if", "(", "FpMLxStalls", "&&", "--", "FpMLxStalls", "==", "0", ")", "LastMI", "=", "0", ";", "ScoreboardHazardRecognizer", "::", "AdvanceCycle", "(", ")", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "ARM", "ARM", "0", "0" ]

[]

[ "<s>", "StackOffset", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "IsFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CSSize", "=", "X86FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "bool", "IsWin64Prologue", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "int64_t", "FPDelta", "=", "0", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_INTR", "&&", "Offset", ">=", "0", ")", "{", "Offset", "+=", "getOffsetOfLocalArea", "(", ")", ";", "}", "if", "(", "IsWin64Prologue", ")", "{", "assert", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "StackSize", "%", "16", ")", "==", "8", ")", ";", "uint64_t", "FrameSize", "=", "StackSize", "-", "SlotSize", ";", "if", "(", "X86FI", "->", "getRestoreBasePointer", "(", ")", ")", "FrameSize", "+=", "SlotSize", ";", "uint64_t", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "uint64_t", "SEHFrameOffset", "=", "calculateSetFPREG", "(", "NumBytes", ")", ";", "if", "(", "FI", "&&", "FI", "==", "X86FI", "->", "getFAIndex", "(", ")", ")", "return", "StackOffset", "::", "getFixed", "(", "-", "SEHFrameOffset", ")", ";", "FPDelta", "=", "FrameSize", "-", "SEHFrameOffset", ";", "assert", "(", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "FPDelta", "%", "16", ")", "==", "0", ")", "&&", "\"FPDelta isn't aligned per the Win64 ABI!\"", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "assert", "(", "HasFP", "&&", "\"VLAs and dynamic stack realign, but no FP?!\"", ")", ";", "if", "(", "FI", "<", "0", ")", "{", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "SlotSize", "+", "FPDelta", ")", ";", "}", "else", "{", "assert", "(", "isAligned", "(", "MFI", ".", "getObjectAlign", "(", "FI", ")", ",", "-", "(", "Offset", "+", "StackSize", ")", ")", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "StackSize", ")", ";", "}", "}", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "if", "(", "FI", "<", "0", ")", "{", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "SlotSize", "+", "FPDelta", ")", ";", "}", "else", "{", "assert", "(", "isAligned", "(", "MFI", ".", "getObjectAlign", "(", "FI", ")", ",", "-", "(", "Offset", "+", "StackSize", ")", ")", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "StackSize", ")", ";", "}", "}", "else", "{", "if", "(", "!", "HasFP", ")", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "StackSize", ")", ";", "Offset", "+=", "SlotSize", ";", "int", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "Offset", "-=", "TailCallReturnAddrDelta", ";", "}", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "FPDelta", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "16", "8", "X86", "X86", "16", "0", "\"FPDelta isn't aligned per the Win64 ABI!\"", "\"VLAs and dynamic stack realign, but no FP?!\"", "0", "0", "X86", "0" ]

[]

[ "<s>", "static", "void", "expand_small_movmem_or_setmem", "(", "rtx", "destmem", ",", "rtx", "srcmem", ",", "rtx", "destptr", ",", "rtx", "srcptr", ",", "rtx", "value", ",", "rtx", "vec_value", ",", "rtx", "count", ",", "int", "size", ",", "rtx", "done_label", ",", "bool", "issetmem", ")", "{", "rtx_code_label", "*", "label", "=", "ix86_expand_aligntest", "(", "count", ",", "size", ",", "false", ")", ";", "machine_mode", "mode", "=", "mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "1", ")", ";", "rtx", "modesize", ";", "int", "n", ";", "if", "(", "issetmem", ")", "{", "if", "(", "!", "vec_value", ")", "{", "if", "(", "GET_MODE", "(", "value", ")", "==", "VOIDmode", "&&", "size", ">", "8", ")", "mode", "=", "Pmode", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "value", ")", ")", ")", "mode", "=", "GET_MODE", "(", "value", ")", ";", "}", "else", "mode", "=", "GET_MODE", "(", "vec_value", ")", ",", "value", "=", "vec_value", ";", "}", "else", "{", "if", "(", "size", ">=", "32", ")", "mode", "=", "TARGET_AVX", "?", "V32QImode", ":", "TARGET_SSE", "?", "V16QImode", ":", "DImode", ";", "else", "if", "(", "size", ">=", "16", ")", "mode", "=", "TARGET_SSE", "?", "V16QImode", ":", "DImode", ";", "srcmem", "=", "change_address", "(", "srcmem", ",", "mode", ",", "srcptr", ")", ";", "}", "destmem", "=", "change_address", "(", "destmem", ",", "mode", ",", "destptr", ")", ";", "modesize", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "size", ")", ";", "for", "(", "n", "=", "0", ";", "n", "*", "GET_MODE_SIZE", "(", "mode", ")", "<", "size", ";", "n", "++", ")", "{", "if", "(", "issetmem", ")", "emit_move_insn", "(", "destmem", ",", "gen_lowpart", "(", "mode", ",", "value", ")", ")", ";", "else", "{", "emit_move_insn", "(", "destmem", ",", "srcmem", ")", ";", "srcmem", "=", "offset_address", "(", "srcmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "destmem", "=", "offset_address", "(", "destmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "destmem", "=", "offset_address", "(", "destmem", ",", "count", ",", "1", ")", ";", "destmem", "=", "offset_address", "(", "destmem", ",", "GEN_INT", "(", "-", "2", "*", "size", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "!", "issetmem", ")", "{", "srcmem", "=", "offset_address", "(", "srcmem", ",", "count", ",", "1", ")", ";", "srcmem", "=", "offset_address", "(", "srcmem", ",", "GEN_INT", "(", "-", "2", "*", "size", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "for", "(", "n", "=", "0", ";", "n", "*", "GET_MODE_SIZE", "(", "mode", ")", "<", "size", ";", "n", "++", ")", "{", "if", "(", "issetmem", ")", "emit_move_insn", "(", "destmem", ",", "gen_lowpart", "(", "mode", ",", "value", ")", ")", ";", "else", "{", "emit_move_insn", "(", "destmem", ",", "srcmem", ")", ";", "srcmem", "=", "offset_address", "(", "srcmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "destmem", "=", "offset_address", "(", "destmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "emit_jump_insn", "(", "gen_jump", "(", "done_label", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "}", "</s>" ]

[ "Test", "if", "COUNT", "&", "SIZE", "is", "nonzero", "and", "if", "so", ",", "expand", "movme", "or", "setmem", "sequence", "that", "is", "valid", "for", "SIZE", "..", "2", "*", "SIZE-1", "bytes", "and", "jump", "to", "DONE_LABEL", "." ]

[ "i386", "1", "8", "32", "16", "0", "1", "2", "1", "2", "0", "1" ]

[]

[ "<s>", "bool", "MINA32AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "MINA32", "MINA32" ]

[]

[ "<s>", "static", "bool", "sh_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", ";", "if", "(", "!", "reload_completed", "||", "!", "flag_pic", ")", "return", "false", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "return", "false", ";", "if", "(", "asm_noperands", "(", "insn", ")", ">=", "0", ")", "return", "false", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "pat", ")", "==", "USE", ")", "return", "false", ";", "if", "(", "TARGET_FDPIC", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "rtx", "t", "=", "XVECEXP", "(", "pat", ",", "0", ",", "XVECLEN", "(", "pat", ",", "0", ")", "-", "1", ")", ";", "if", "(", "GET_CODE", "(", "t", ")", "==", "USE", "&&", "unspec_caller_rtx_p", "(", "XEXP", "(", "t", ",", "0", ")", ")", ")", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "false", ";", "pat", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "unspec_caller_rtx_p", "(", "pat", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "true", "for", "insn", "that", "generates", "a", "unique", "label", "." ]

[ "sh", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "const", "char", "*", "AlphaTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "AlphaISD", "::", "CVTQT_", ":", "return", "\"Alpha::CVTQT_\"", ";", "case", "AlphaISD", "::", "CVTQS_", ":", "return", "\"Alpha::CVTQS_\"", ";", "case", "AlphaISD", "::", "CVTTQ_", ":", "return", "\"Alpha::CVTTQ_\"", ";", "case", "AlphaISD", "::", "GPRelHi", ":", "return", "\"Alpha::GPRelHi\"", ";", "case", "AlphaISD", "::", "GPRelLo", ":", "return", "\"Alpha::GPRelLo\"", ";", "case", "AlphaISD", "::", "RelLit", ":", "return", "\"Alpha::RelLit\"", ";", "case", "AlphaISD", "::", "GlobalRetAddr", ":", "return", "\"Alpha::GlobalRetAddr\"", ";", "case", "AlphaISD", "::", "CALL", ":", "return", "\"Alpha::CALL\"", ";", "case", "AlphaISD", "::", "DivCall", ":", "return", "\"Alpha::DivCall\"", ";", "case", "AlphaISD", "::", "RET_FLAG", ":", "return", "\"Alpha::RET_FLAG\"", ";", "case", "AlphaISD", "::", "COND_BRANCH_I", ":", "return", "\"Alpha::COND_BRANCH_I\"", ";", "case", "AlphaISD", "::", "COND_BRANCH_F", ":", "return", "\"Alpha::COND_BRANCH_F\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "Alpha", "Alpha", "0", "AlphaISD::CVTQT_", "\"Alpha::CVTQT_\"", "AlphaISD::CVTQS_", "\"Alpha::CVTQS_\"", "AlphaISD::CVTTQ_", "\"Alpha::CVTTQ_\"", "AlphaISD::GPRelHi", "\"Alpha::GPRelHi\"", "AlphaISD::GPRelLo", "\"Alpha::GPRelLo\"", "AlphaISD::RelLit", "\"Alpha::RelLit\"", "AlphaISD::GlobalRetAddr", "\"Alpha::GlobalRetAddr\"", "AlphaISD::CALL", "\"Alpha::CALL\"", "AlphaISD::DivCall", "\"Alpha::DivCall\"", "AlphaISD::RET_FLAG", "\"Alpha::RET_FLAG\"", "AlphaISD::COND_BRANCH_I", "\"Alpha::COND_BRANCH_I\"", "AlphaISD::COND_BRANCH_F", "\"Alpha::COND_BRANCH_F\"" ]

[]

[ "<s>", "unsigned", "X86TTI", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TCC_Free", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "smul_with_overflow", ":", "case", "Intrinsic", "::", "umul_with_overflow", ":", "if", "(", "(", "Idx", "==", "1", ")", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_stackmap", ":", "if", "(", "(", "Idx", "<", "2", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_patchpoint_void", ":", "case", "Intrinsic", "::", "experimental_patchpoint_i64", ":", "if", "(", "(", "Idx", "<", "4", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TCC_Free", ";", "break", ";", "}", "return", "X86TTI", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "X86", "X86", "Intrinsic::ID", "0", "0U", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::smul_with_overflow", "Intrinsic::umul_with_overflow", "1", "64", "32", "Intrinsic::experimental_stackmap", "2", "64", "64", "Intrinsic::experimental_patchpoint_void", "Intrinsic::experimental_patchpoint_i64", "4", "64", "64", "X86" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "TPC" ]

[]

[ "<s>", "bool", "X86CallFrameOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "isLegal", "(", "MF", ")", ")", "return", "false", ";", "unsigned", "FrameSetupOpcode", "=", "TII", "->", "getCallFrameSetupOpcode", "(", ")", ";", "bool", "Changed", "=", "false", ";", "ContextMap", "CallSeqMap", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "FrameSetupOpcode", ")", "{", "CallContext", "&", "Context", "=", "CallSeqMap", "[", "I", "]", ";", "collectCallInfo", "(", "MF", ",", "*", "BB", ",", "I", ",", "Context", ")", ";", "}", "if", "(", "!", "isProfitable", "(", "MF", ",", "CallSeqMap", ")", ")", "return", "false", ";", "for", "(", "auto", "CC", ":", "CallSeqMap", ")", "if", "(", "CC", ".", "second", ".", "UsePush", ")", "Changed", "|=", "adjustCallSequence", "(", "MF", ",", "CC", ".", "first", ",", "CC", ".", "second", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "nds32_constant_alignment", "(", "const_tree", "constant", ",", "HOST_WIDE_INT", "basic_align", ")", "{", "if", "(", "(", "(", "TREE_CODE", "(", "constant", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "constant", ")", "==", "CONSTRUCTOR", "||", "TREE_CODE", "(", "constant", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "constant", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "constant", ")", "==", "ARRAY_TYPE", ")", "&&", "basic_align", "<", "BITS_PER_WORD", ")", ")", "return", "BITS_PER_WORD", ";", "else", "return", "basic_align", ";", "}", "</s>" ]

[ "Return", "alignment", "for", "constant", "value", "." ]

[ "nds32" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "SPILL_CR", ":", "case", "PPC", "::", "SPILL_CRBIT", ":", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "SPILL_VRSAVE", ":", "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>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "PowerPC", "PPC", "PPC::STD", "PPC::STW", "PPC::STFS", "PPC::STFD", "PPC::SPILL_CR", "PPC::SPILL_CRBIT", "PPC::STVX", "PPC::SPILL_VRSAVE", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableSVEPostVec", ")", "addPass", "(", "createSVEPostVectorizePass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetFeatureString", "(", ")", ".", "count", "(", "\"sve\"", ")", ")", "addPass", "(", "createSVEExpandLibCallPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableLoopDataPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", "TM", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "LowerGatherScatterToInterleaved", ")", "{", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createInterleavedGatherScatterPass", "(", "TM", ")", ")", ";", "addPass", "(", "createInstructionCombiningPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "TM", ",", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "AArch64", "AArch64", "\"sve\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "Thumb1RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "ARM", "::", "tGPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "&", "ARM", "::", "tGPRRegClass", ";", "return", "ARMBaseRegisterInfo", "::", "getLargestLegalSuperClass", "(", "RC", ")", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "ARM", "ARM::tGPRRegClass", "ARM::tGPRRegClass", "ARM" ]

[]

[ "<s>", "const", "char", "*", "msp430x_extendhisi", "(", "rtx", "*", "operands", ")", "{", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "operands", "[", "1", "]", ")", ")", "return", "\"BIT.W\\t#0x8000, %L0 { SUBC.W\\t%H0, %H0 { INV.W\\t%H0, %H0\"", ";", "if", "(", "!", "msp430x", ")", "return", "\"MOV.W\\t%1, %L0 { BIT.W\\t#0x8000, %L0 { SUBC.W\\t%H0, %H0 { INV.W\\t%H0, %H0\"", ";", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", "==", "REGNO", "(", "operands", "[", "1", "]", ")", ")", "return", "\"MOV.W\\t%1, %L0 { RPT\\t#15 { RRAX.W\\t%H0\"", ";", "return", "\"MOV.W\\t%1, %L0 { MOV.W\\t%1, %H0 { RPT\\t#15 { RRAX.W\\t%H0\"", ";", "}", "</s>" ]

[ "Generate", "a", "sequence", "of", "instructions", "to", "sign-extend", "an", "HI", "value", "into", "an", "SI", "value", ".", "Handles", "the", "tricky", "case", "where", "we", "are", "overwriting", "the", "destination", ".", "Return", "the", "number", "of", "bytes", "used", "by", "the", "emitted", "instructions", ".", "If", "RETURN_LENGTH", "is", "true", "then", "do", "not", "emit", "the", "assembly", "instruction", "sequence", "." ]

[ "msp430", "0", "1", "\"BIT.W\\t#0x8000, %L0 { SUBC.W\\t%H0, %H0 { INV.W\\t%H0, %H0\"", "\"MOV.W\\t%1, %L0 { BIT.W\\t#0x8000, %L0 { SUBC.W\\t%H0, %H0 { INV.W\\t%H0, %H0\"", "0", "1", "1", "\"MOV.W\\t%1, %L0 { RPT\\t#15 { RRAX.W\\t%H0\"", "\"MOV.W\\t%1, %L0 { MOV.W\\t%1, %H0 { RPT\\t#15 { RRAX.W\\t%H0\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM64 Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "ARM64", "\"ARM64 Instruction Selection\"" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAMDGPUISelDag", "(", "getAMDGPUTargetMachine", "(", ")", ")", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "device", "(", ")", "->", "getGeneration", "(", ")", "<=", "AMDGPUDeviceInfo", "::", "HD6XXX", ")", "{", "addPass", "(", "createAMDGPUIndirectAddressingPass", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "R600", "AMDGPUDeviceInfo::HD6XXX" ]

[]

[ "<s>", "const", "Cpu0InstrInfo", "*", "getInstrInfo", "(", ")", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "EVT", "SparcTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Sparc", "Sparc", "MVT::i32" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX512", ")", "return", "CSR_64_RT_AllRegs_512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_RegMask", ":", "CSR_Win64_RegCall_NoSSE_RegMask", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_RegMask", ":", "CSR_SysV64_RegCall_NoSSE_RegMask", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_RegMask", ":", "CSR_32_RegCall_NoSSE_RegMask", ")", ";", "}", "case", "CallingConv", "::", "CFGuard_Check", ":", "assert", "(", "!", "Is64Bit", "&&", "\"CFGuard check mechanism only used on 32-bit X86\"", ")", ";", "return", "(", "HasSSE", "?", "CSR_Win32_CFGuard_Check_RegMask", ":", "CSR_Win32_CFGuard_Check_NoSSE_RegMask", ")", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "SwiftTail", ":", "if", "(", "!", "Is64Bit", ")", "return", "CSR_32_RegMask", ";", "return", "IsWin64", "?", "CSR_Win64_SwiftTail_RegMask", ":", "CSR_64_SwiftTail_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_64_AllRegs_RegMask", ";", "return", "CSR_64_AllRegs_NoSSE_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "IsSwiftCC", "=", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ";", "if", "(", "IsSwiftCC", ")", "return", "IsWin64", "?", "CSR_Win64_SwiftError_RegMask", ":", "CSR_64_SwiftError_RegMask", ";", "return", "IsWin64", "?", "CSR_Win64_RegMask", ":", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "X86", "X86", "X86", "X86", "X86", "\"CFGuard check mechanism only used on 32-bit X86\"", "X86", "X86" ]

[]

[ "<s>", "void", "frv_optimization_options", "(", "int", "level", ",", "int", "size", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "level", ">=", "2", ")", "{", "flag_schedule_insns_after_reload", "=", "0", ";", "flag_rcsp", "=", "1", ";", "}", "}", "</s>" ]

[ "On", "the", "FRV", ",", "possibly", "disable", "VLIW", "packing", "which", "is", "done", "by", "the", "2nd", "scheduling", "pass", "at", "the", "current", "time", "." ]

[ "frv", "2", "0", "1" ]

[]

[ "<s>", "bool", "WebAssemblyCallIndirectFixup", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Fixing up CALL_INDIRECTs **********\\n\"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Changed", "=", "false", ";", "const", "WebAssemblyInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "IsPseudoCallIndirect", "(", "MI", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found call_indirect: \"", "<<", "MI", "<<", "'\\n'", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "TII", "->", "get", "(", "GetNonPseudoCallIndirectOpcode", "(", "MI", ")", ")", ";", "MI", ".", "setDesc", "(", "Desc", ")", ";", "SmallVector", "<", "MachineOperand", ",", "8", ">", "Ops", ";", "Ops", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "make_range", "(", "MI", ".", "operands_begin", "(", ")", "+", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "+", "1", ",", "MI", ".", "operands_begin", "(", ")", "+", "MI", ".", "getNumExplicitOperands", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "MO", ")", ";", "Ops", ".", "push_back", "(", "MI", ".", "getOperand", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", ")", ")", ";", "while", "(", "MI", ".", "getNumOperands", "(", ")", ">", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", ")", "MI", ".", "RemoveOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "Ops", ")", "MI", ".", "addOperand", "(", "MO", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" After transform: \"", "<<", "MI", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nDone fixing up CALL_INDIRECTs\\n\\n\"", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Fixing up CALL_INDIRECTs **********\\n\"", "WebAssembly", "WebAssembly", "\"Found call_indirect: \"", "8", "0", "0", "1", "1", "\" After transform: \"", "\"\\nDone fixing up CALL_INDIRECTs\\n\\n\"" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "ensureLocals", "(", "Out", ")", ";", "auto", "Align", "=", "WebAssembly", "::", "GetDefaultP2AlignAny", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Align", "!=", "-", "1U", ")", "{", "auto", "&", "Op0", "=", "Inst", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getImm", "(", ")", "==", "-", "1", ")", "Op0", ".", "setImm", "(", "Align", ")", ";", "}", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "CurrentState", "==", "EndFunction", ")", "{", "onEndOfFunction", "(", ")", ";", "}", "else", "{", "CurrentState", "=", "Instructions", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"instruction requires a WASM feature not currently enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "WebAssembly", "WebAssembly::GetDefaultP2AlignAny", "1U", "0", "1", "\"instruction requires a WASM feature not currently enabled\"", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "sh_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", ",", "signed", "int", "n_named_args", ",", "enum", "machine_mode", "mode", ")", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "=", "0", ";", "pcum", "->", "free_single_fp_reg", "=", "0", ";", "pcum", "->", "stack_regs", "=", "0", ";", "pcum", "->", "byref_regs", "=", "0", ";", "pcum", "->", "byref", "=", "0", ";", "pcum", "->", "outgoing", "=", "(", "n_named_args", "==", "-", "1", ")", "?", "0", ":", "1", ";", "pcum", "->", "renesas_abi", "=", "sh_attr_renesas_p", "(", "fntype", ")", "?", "1", ":", "0", ";", "if", "(", "fntype", ")", "{", "pcum", "->", "force_mem", "=", "(", "(", "TARGET_HITACHI", "||", "pcum", "->", "renesas_abi", ")", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fndecl", ")", ")", ";", "pcum", "->", "prototype_p", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", "?", "TRUE", ":", "FALSE", ";", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "TARGET_SH5", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fndecl", ")", ";", "pcum", "->", "call_cookie", "=", "CALL_COOKIE_RET_TRAMP", "(", "TARGET_SHCOMPACT", "&&", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "==", "0", "&&", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", "==", "BLKmode", "?", "int_size_in_bytes", "(", "TREE_TYPE", "(", "fntype", ")", ")", ":", "GET_MODE_SIZE", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", ")", ")", ">", "4", "&&", "(", "BASE_RETURN_VALUE_REG", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", ")", "==", "FIRST_RET_REG", ")", ")", ";", "}", "else", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "0", ";", "pcum", "->", "prototype_p", "=", "FALSE", ";", "if", "(", "mode", "!=", "VOIDmode", ")", "{", "pcum", "->", "call_cookie", "=", "CALL_COOKIE_RET_TRAMP", "(", "TARGET_SHCOMPACT", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "BASE_RETURN_VALUE_REG", "(", "mode", ")", "==", "FIRST_RET_REG", ")", ";", "pcum", "->", "force_mem", "=", "(", "TARGET_DEFAULT", "&", "MASK_HITACHI", ")", "&&", "(", "mode", "==", "BLKmode", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "!", "(", "mode", "==", "DFmode", "&&", "TARGET_FPU_DOUBLE", ")", ")", ")", ";", "}", "else", "{", "pcum", "->", "call_cookie", "=", "0", ";", "pcum", "->", "force_mem", "=", "FALSE", ";", "}", "}", "}", "</s>" ]

[ "Initialize", "the", "CUMULATIVE_ARGS", "structure", "." ]

[ "sh", "0", "0", "0", "0", "0", "1", "0", "1", "1", "0", "0", "4", "0", "4", "4", "0" ]

[]

[ "<s>", "int", "legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "flag_pic", "&&", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "arm", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "getRegAllocationHints", "(", "Register", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "BaseImplRetVal", "=", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ",", "Matrix", ")", ";", "for", "(", "MachineInstr", "&", "Use", ":", "MRI", "->", "reg_nodbg_instructions", "(", "VirtReg", ")", ")", "{", "const", "MachineOperand", "*", "ResultOp", "=", "nullptr", ";", "Register", "ResultReg", ";", "switch", "(", "Use", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "COPY", ":", "{", "ResultOp", "=", "&", "Use", ".", "getOperand", "(", "0", ")", ";", "ResultReg", "=", "ResultOp", "->", "getReg", "(", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "ResultReg", ")", "&&", "MRI", "->", "getRegClass", "(", "ResultReg", ")", "->", "contains", "(", "PPC", "::", "UACC0", ")", "&&", "VRM", "->", "hasPhys", "(", "ResultReg", ")", ")", "{", "Register", "UACCPhys", "=", "VRM", "->", "getPhys", "(", "ResultReg", ")", ";", "Register", "HintReg", "=", "getSubReg", "(", "UACCPhys", ",", "ResultOp", "->", "getSubReg", "(", ")", ")", ";", "Hints", ".", "push_back", "(", "HintReg", ")", ";", "}", "break", ";", "}", "case", "PPC", "::", "BUILD_UACC", ":", "{", "ResultOp", "=", "&", "Use", ".", "getOperand", "(", "0", ")", ";", "ResultReg", "=", "ResultOp", "->", "getReg", "(", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "ResultReg", ")", "->", "contains", "(", "PPC", "::", "ACC0", ")", "&&", "VRM", "->", "hasPhys", "(", "ResultReg", ")", ")", "{", "Register", "ACCPhys", "=", "VRM", "->", "getPhys", "(", "ResultReg", ")", ";", "assert", "(", "(", "ACCPhys", ">=", "PPC", "::", "ACC0", "&&", "ACCPhys", "<=", "PPC", "::", "ACC7", ")", "&&", "\"Expecting an ACC register for BUILD_UACC.\"", ")", ";", "Register", "HintReg", "=", "PPC", "::", "UACC0", "+", "(", "ACCPhys", "-", "PPC", "::", "ACC0", ")", ";", "Hints", ".", "push_back", "(", "HintReg", ")", ";", "}", "break", ";", "}", "}", "}", "return", "BaseImplRetVal", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "PowerPC", "PPC", "0", "PPC::UACC0", "PPC::BUILD_UACC", "0", "PPC::ACC0", "PPC::ACC0", "PPC::ACC7", "\"Expecting an ACC register for BUILD_UACC.\"", "PPC::UACC0", "PPC::ACC0" ]

[]

[ "<s>", "void", "BPFDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIV", ":", "{", "DebugLoc", "Empty", ";", "const", "DebugLoc", "&", "DL", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "if", "(", "DL", "!=", "Empty", ")", "errs", "(", ")", "<<", "\"Error at line \"", "<<", "DL", ".", "getLine", "(", ")", "<<", "\": \"", ";", "else", "errs", "(", ")", "<<", "\"Error: \"", ";", "errs", "(", ")", "<<", "\"Unsupport signed division for DAG: \"", ";", "Node", "->", "print", "(", "errs", "(", ")", ",", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"Please convert to unsigned div/mod.\\n\"", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "bpf_load_byte", ":", "case", "Intrinsic", "::", "bpf_load_half", ":", "case", "Intrinsic", "::", "bpf_load_word", ":", "{", "SDLoc", "DL", "(", "Node", ")", ";", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Skb", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "SDValue", "N3", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "R6Reg", "=", "CurDAG", "->", "getRegister", "(", "BPF", "::", "R6", ",", "MVT", "::", "i64", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "DL", ",", "R6Reg", ",", "Skb", ",", "SDValue", "(", ")", ")", ";", "Node", "=", "CurDAG", "->", "UpdateNodeOperands", "(", "Node", ",", "Chain", ",", "N1", ",", "R6Reg", ",", "N3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "BPF", "::", "MOV_rr", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VT", ",", "TFI", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "BPF", "BPF", "\"Selecting: \"", "\"== \"", "ISD::SDIV", "\"Error at line \"", "\": \"", "\"Error: \"", "\"Unsupport signed division for DAG: \"", "\"Please convert to unsigned div/mod.\\n\"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::bpf_load_byte", "Intrinsic::bpf_load_half", "Intrinsic::bpf_load_word", "0", "1", "2", "3", "BPF::R6", "MVT::i64", "ISD::FrameIndex", "0", "BPF::MOV_rr" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "scalarizeVectorLoad", "(", "Load", ",", "DAG", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "BaseAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getObjectPtrOffset", "(", "SL", ",", "BasePtr", ",", "Size", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "HiAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "ISD::CONCAT_VECTORS", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "bool", "MipsBranchExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "IsPIC", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "ABI", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "IsPIC", "&&", "ABI", ".", "IsO32", "(", ")", "&&", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "MF", ",", "TII", ")", ";", "MFp", "=", "&", "MF", ";", "ForceLongBranchFirstPass", "=", "ForceLongBranch", ";", "bool", "longBranchChanged", "=", "handlePossibleLongBranch", "(", ")", ";", "bool", "forbiddenSlotChanged", "=", "handleForbiddenSlot", "(", ")", ";", "bool", "Changed", "=", "longBranchChanged", "||", "forbiddenSlotChanged", ";", "while", "(", "forbiddenSlotChanged", ")", "{", "longBranchChanged", "=", "handlePossibleLongBranch", "(", ")", ";", "if", "(", "!", "longBranchChanged", ")", "break", ";", "forbiddenSlotChanged", "=", "handleForbiddenSlot", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "ARM", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "ARM", "ARM::NumTargetFixupKinds" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCyles", ",", "unsigned", "ExtraPredCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "R600TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "AMDGPUTargetLowering", "::", "ReplaceNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "lowerFP_TO_UINT", "(", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "lowerFP_TO_SINT", "(", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "SDValue", "Result", ";", "if", "(", "expandFP_TO_SINT", "(", "N", ",", "Result", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "case", "ISD", "::", "SDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "1", ")", ";", "SDValue", "RES", "=", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "RES", ")", ";", "Results", ".", "push_back", "(", "RES", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "UDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "0", ")", ";", "LowerUDIVREM64", "(", "Op", ",", "DAG", ",", "Results", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "AMDGPU", "R600", "AMDGPU", "ISD::FP_TO_UINT", "0", "MVT::i1", "0", "ISD::FP_TO_SINT", "0", "MVT::i1", "SI", "0", "SI", "ISD::SDIVREM", "1", "1", "ISD::UDIVREM", "0" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSoftFloat", "(", "false", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", "*", "TM", ".", "getDataLayout", "(", ")", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "MMIXRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_SaveList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "MMIX", "MMIX" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "StringRef", "CPU", "=", "TM", ".", "getTargetCPU", "(", ")", ";", "StringRef", "FS", "=", "TM", ".", "getTargetFeatureString", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "const", "NVPTXSubtarget", "STI", "(", "TT", ",", "CPU", ",", "FS", ",", "NTM", ")", ";", "if", "(", "M", ".", "alias_size", "(", ")", ")", "{", "report_fatal_error", "(", "\"Module has aliases, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "if", "(", "!", "isEmptyXXStructor", "(", "M", ".", "getNamedGlobal", "(", "\"llvm.global_ctors\"", ")", ")", ")", "{", "report_fatal_error", "(", "\"Module has a nontrivial global ctor, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "if", "(", "!", "isEmptyXXStructor", "(", "M", ".", "getNamedGlobal", "(", "\"llvm.global_dtors\"", ")", ")", ")", "{", "report_fatal_error", "(", "\"Module has a nontrivial global dtor, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "emitHeader", "(", "M", ",", "OS1", ",", "STI", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "!", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"Start of file scope inline assembly\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "StringRef", "(", "M", ".", "getModuleInlineAsm", "(", ")", ")", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"End of file scope inline assembly\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "NVCL", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "GlobalsEmitted", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "\"Module has aliases, which NVPTX does not support.\"", "\"llvm.global_ctors\"", "\"Module has a nontrivial global ctor, which NVPTX does not support.\"", "\"llvm.global_dtors\"", "\"Module has a nontrivial global dtor, which NVPTX does not support.\"", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"" ]

[]

[ "<s>", "bool", "SystemZElimCompare", "::", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "LivePhysRegs", "LiveRegs", "(", "*", "TRI", ")", ";", "LiveRegs", ".", "addLiveOuts", "(", "MBB", ")", ";", "bool", "CompleteCCUsers", "=", "!", "LiveRegs", ".", "contains", "(", "SystemZ", "::", "CC", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "CCUsers", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "--", "MBBI", ";", "if", "(", "CompleteCCUsers", "&&", "(", "MI", ".", "isCompare", "(", ")", "||", "isLoadAndTestAsCmp", "(", "MI", ")", ")", "&&", "(", "optimizeCompareZero", "(", "MI", ",", "CCUsers", ")", "||", "fuseCompareOperations", "(", "MI", ",", "CCUsers", ")", ")", ")", "{", "++", "MBBI", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "CCUsers", ".", "clear", "(", ")", ";", "continue", ";", "}", "if", "(", "MI", ".", "definesRegister", "(", "SystemZ", "::", "CC", ")", ")", "{", "CCUsers", ".", "clear", "(", ")", ";", "CompleteCCUsers", "=", "true", ";", "}", "if", "(", "MI", ".", "readsRegister", "(", "SystemZ", "::", "CC", ")", "&&", "CompleteCCUsers", ")", "CCUsers", ".", "push_back", "(", "&", "MI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "SystemZ", "SystemZ", "SystemZ::CC", "4", "SystemZ::CC", "SystemZ::CC" ]

[]

[ "<s>", "bool", "TeakPassConfig", "::", "addPreISel", "(", ")", "{", "addPass", "(", "createHardwareLoopsPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "Teak", "Teak" ]

[]

[ "<s>", "bool", "RISCVMergeBaseOffsetOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "MadeChange", "=", "false", ";", "DeadInstrs", ".", "clear", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineInstr", "&", "HiLUI", ":", "MBB", ")", "{", "MachineInstr", "*", "LoADDI", "=", "nullptr", ";", "if", "(", "!", "detectLuiAddiGlobal", "(", "HiLUI", ",", "LoADDI", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Found lowered global address with one use: \"", "<<", "*", "LoADDI", "->", "getOperand", "(", "2", ")", ".", "getGlobal", "(", ")", "<<", "\"\\n\"", ")", ";", "MadeChange", "|=", "detectAndFoldOffset", "(", "HiLUI", ",", "*", "LoADDI", ")", ";", "}", "}", "for", "(", "auto", "*", "MI", ":", "DeadInstrs", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "RISCV", "RISCV", "\"MBB: \"", "\"\\n\"", "\" Found lowered global address with one use: \"", "2", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "getCSRFirstUseCost", "(", ")", "const", "{", "return", "5", ";", "}", "</s>" ]

[ "Allow", "the", "target", "to", "override", "the", "cost", "of", "using", "a", "callee-saved", "register", "for", "the", "first", "time", "." ]

[ "ARM64", "5" ]

[]

[ "<s>", "BitVector", "RV16KRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RV16K", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RV16K", "::", "X1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RV16K", "::", "X2", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "RV16K", "RV16K", "RV16K::X0", "RV16K::X1", "RV16K::X2" ]

[]

[ "<s>", "size_t", "addString", "(", "StringRef", "S", ")", "{", "return", "StringTable", ".", "addString", "(", "S", ")", ";", "}", "</s>" ]

[ "Adds", "path", "Path", "to", "the", "line", "string", "." ]

[ "BPF" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "0", ")", "return", "false", ";", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "0", "]", ".", "OperandType", "==", "MCOI", "::", "OPERAND_PCREL", ")", "{", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Size", "+", "Imm", ";", "return", "true", ";", "}", "else", "{", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "false", ";", "Target", "=", "Imm", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "DLX", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "machine_mode", "spu_addr_space_pointer_mode", "(", "addr_space_t", "addrspace", ")", "{", "switch", "(", "addrspace", ")", "{", "case", "ADDR_SPACE_GENERIC", ":", "return", "ptr_mode", ";", "case", "ADDR_SPACE_EA", ":", "return", "EAmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "appropriate", "mode", "for", "a", "named", "address", "pointer", "." ]

[ "spu" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "SetVector", "<", "Function", "*", ">", "Functions", ";", "AnalysisGetter", "AG", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "Functions", ".", "insert", "(", "&", "F", ")", ";", "}", "CallGraphUpdater", "CGUpdater", ";", "BumpPtrAllocator", "Allocator", ";", "AMDGPUInformationCache", "InfoCache", "(", "M", ",", "AG", ",", "Allocator", ",", "nullptr", ",", "*", "TM", ")", ";", "Attributor", "A", "(", "Functions", ",", "InfoCache", ",", "CGUpdater", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDAttributes", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "A", ".", "getOrCreateAAFor", "<", "AAAMDWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "}", "}", "ChangeStatus", "Change", "=", "A", ".", "run", "(", ")", ";", "return", "Change", "==", "ChangeStatus", "::", "CHANGED", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "tilepro_expand_epilogue", "(", "bool", "sibcall_p", ")", "{", "rtx", "reg_save_addr", "[", "ROUND_ROBIN_SIZE", "]", "=", "{", "NULL_RTX", ",", "NULL_RTX", ",", "NULL_RTX", ",", "NULL_RTX", "}", ";", "rtx_insn", "*", "last_insn", ",", "*", "insn", ";", "unsigned", "int", "which_scratch", ";", "int", "offset", ",", "start_offset", ",", "regno", ";", "rtx", "cfa_restores", "=", "NULL_RTX", ";", "int", "fp_copy_regno", "=", "-", "1", ";", "int", "next_scratch_regno", "=", "29", ";", "int", "total_size", "=", "compute_total_frame_size", "(", ")", ";", "last_insn", "=", "get_last_insn", "(", ")", ";", "insn", "=", "NULL", ";", "if", "(", "df_regs_ever_live_p", "(", "TILEPRO_LINK_REGNUM", ")", ")", "{", "insn", "=", "frame_emit_load", "(", "TILEPRO_LINK_REGNUM", ",", "compute_frame_addr", "(", "0", ",", "&", "next_scratch_regno", ")", ",", "&", "cfa_restores", ")", ";", "}", "if", "(", "total_size", "==", "0", ")", "{", "if", "(", "insn", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "cfa_restores", ";", "}", "goto", "done", ";", "}", "start_offset", "=", "-", "crtl", "->", "args", ".", "pretend_args_size", "-", "UNITS_PER_WORD", ";", "offset", "=", "start_offset", ";", "if", "(", "frame_pointer_needed", ")", "fp_copy_regno", "=", "next_scratch_regno", "--", ";", "which_scratch", "=", "0", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", ">=", "0", ";", "regno", "--", ")", "if", "(", "need_to_save_reg", "(", "regno", ")", ")", "{", "rtx", "r", "=", "reg_save_addr", "[", "which_scratch", "]", ";", "if", "(", "r", "==", "NULL_RTX", ")", "{", "r", "=", "compute_frame_addr", "(", "offset", ",", "&", "next_scratch_regno", ")", ";", "reg_save_addr", "[", "which_scratch", "]", "=", "r", ";", "}", "else", "{", "int", "stride", "=", "ROUND_ROBIN_SIZE", "*", "-", "UNITS_PER_WORD", ";", "rtx", "p", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "r", ",", "GEN_INT", "(", "stride", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "r", ",", "p", ")", ")", ";", "}", "if", "(", "fp_copy_regno", ">=", "0", "&&", "regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", "frame_emit_load", "(", "fp_copy_regno", ",", "r", ",", "NULL", ")", ";", "else", "frame_emit_load", "(", "regno", ",", "r", ",", "&", "cfa_restores", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "which_scratch", "=", "(", "which_scratch", "+", "1", ")", "%", "ROUND_ROBIN_SIZE", ";", "}", "if", "(", "!", "tilepro_current_function_is_leaf", "(", ")", ")", "cfa_restores", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "stack_pointer_rtx", ",", "cfa_restores", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_insn", "(", "gen_sp_restore", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "cfa_restores", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "stack_pointer_rtx", ")", ";", "}", "else", "{", "insn", "=", "emit_sp_adjust", "(", "total_size", ",", "&", "next_scratch_regno", ",", "true", ",", "cfa_restores", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_sp_adjust", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "fp_copy_regno", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "hard_frame_pointer_rtx", ")", ";", "}", "if", "(", "flag_pic", ")", "{", "emit_use", "(", "cfun", "->", "machine", "->", "text_label_rtx", ")", ";", "emit_use", "(", "cfun", "->", "machine", "->", "got_rtx", ")", ";", "}", "done", ":", "if", "(", "!", "sibcall_p", ")", "{", "emit_jump_insn", "(", "gen__return", "(", ")", ")", ";", "}", "else", "{", "emit_use", "(", "gen_rtx_REG", "(", "Pmode", ",", "TILEPRO_LINK_REGNUM", ")", ")", ";", "}", "for", "(", ";", "last_insn", "!=", "NULL_RTX", ";", "last_insn", "=", "next_insn", "(", "last_insn", ")", ")", "RTX_FRAME_RELATED_P", "(", "last_insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Implement", "the", "epilogue", "and", "sibcall_epilogue", "patterns", ".", "SIBCALL_P", "is", "true", "for", "a", "sibcall_epilogue", "pattern", ",", "and", "false", "for", "an", "epilogue", "pattern", "." ]

[ "tilepro", "1", "29", "0", "0", "1", "0", "1", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "bool", "MipsLegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "using", "namespace", "TargetOpcode", ";", "MIRBuilder", ".", "setInstr", "(", "MI", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "emit_push_byte", "(", "unsigned", "regno", ",", "bool", "frame_related_p", ")", "{", "rtx", "mem", ",", "reg", ";", "rtx_insn", "*", "insn", ";", "mem", "=", "gen_rtx_POST_DEC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "cfun", "->", "machine", "->", "stack_usage", "++", ";", "}", "</s>" ]

[ "Helper", "for", "expand_prologue", ".", "Emit", "a", "push", "of", "a", "byte", "register", "." ]

[ "avr", "1" ]

[]

[ "<s>", "static", "int", "crx_address_cost", "(", "rtx", "addr", ")", "{", "enum", "crx_addrtype", "addrtype", ";", "struct", "crx_address", "address", ";", "int", "cost", "=", "2", ";", "addrtype", "=", "crx_decompose_address", "(", "addr", ",", "&", "address", ")", ";", "gcc_assert", "(", "addrtype", "!=", "CRX_INVALID", ")", ";", "if", "(", "addrtype", "==", "CRX_ABSOLUTE", ")", "cost", "+=", "2", ";", "if", "(", "addrtype", "==", "CRX_POST_INC", ")", "cost", "-=", "2", ";", "if", "(", "address", ".", "base", ")", "cost", "++", ";", "if", "(", "address", ".", "index", "&&", "address", ".", "scale", "==", "1", ")", "cost", "+=", "5", ";", "if", "(", "address", ".", "disp", "&&", "!", "INT_CST4", "(", "INTVAL", "(", "address", ".", "disp", ")", ")", ")", "cost", "+=", "2", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n======\\nTARGET_ADDRESS_COST = %d\\n\"", ",", "cost", ")", ";", "debug_rtx", "(", "addr", ")", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "the", "memory", "address", "x", "." ]

[ "crx", "2", "2", "2", "1", "5", "2", "\"\\n======\\nTARGET_ADDRESS_COST = %d\\n\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "GlobalBaseReg", ",", "DebugLoc", "::", "getUnknownLoc", "(", ")", ",", "getPointerTy", "(", ")", ")", ";", "return", "Table", ";", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "X86", "X86", "X86ISD::GlobalBaseReg" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_SaveList", ":", "CSR_Darwin64_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_SaveList", ":", "CSR_Darwin32_SaveList", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", "&&", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", ")", "return", "CSR_SRV464_TLS_PE_SaveList", ";", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", ";", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "(", "SaveR2", "?", "CSR_SVR464_R2_Altivec_SaveList", ":", "CSR_SVR464_Altivec_SaveList", ")", ":", "(", "SaveR2", "?", "CSR_SVR464_R2_SaveList", ":", "CSR_SVR464_SaveList", ")", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_SaveList", ":", "CSR_SVR432_SaveList", ")", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC::X2", "PPC" ]

[]

[ "<s>", "bool", "isShift", "(", ")", "const", "{", "if", "(", "!", "isShiftOrExtend", "(", ")", ")", "return", "false", ";", "if", "(", "ShiftExtend", ".", "ShiftType", "!=", "SHKind", ")", "return", "false", ";", "return", "is64Bit", "?", "ShiftExtend", ".", "Amount", "<=", "63", ":", "ShiftExtend", ".", "Amount", "<=", "31", ";", "}", "</s>" ]

[ "Determine", "if", "the", "Opcode", "is", "one", "of", "the", "shift", "instructions", "." ]

[ "AArch64", "63", "31" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "{", "for", "(", "auto", "I", ":", "MBB", "->", "successors", "(", ")", ")", "if", "(", "I", "->", "isEHPad", "(", ")", ")", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "CALLv3nr", ")", "return", "true", ";", "if", "(", "MI", ".", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", "true", ";", "if", "(", "MI", ".", "isInlineAsm", "(", ")", "&&", "!", "ScheduleInlineAsm", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "Hexagon", "Hexagon", "Hexagon::CALLv3nr" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", ")", "PM", ".", "add", "(", "createGlobalMergePass", "(", "TM", "->", "getTargetLowering", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "has_immediate", "(", "rtx", "insn", ")", "{", "int", "num_imm_operand", ";", "int", "num_imm32_operand", ";", "int", "num_imm64_operand", ";", "if", "(", "insn", ")", "return", "get_num_immediates", "(", "insn", ",", "&", "num_imm_operand", ",", "&", "num_imm32_operand", ",", "&", "num_imm64_operand", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "indicates", "if", "an", "operand", "of", "an", "instruction", "is", "an", "immediate", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "avr_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "(", "frame_pointer_needed", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "||", "!", "frame_pointer_needed", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "FROM", "can", "be", "eliminated", "via", "register", "TO", "." ]

[ "avr" ]

[]

[ "<s>", "static", "void", "ATTRIBUTE_UNUSED", "x86_64_elf_unique_section", "(", "tree", "decl", ",", "int", "reloc", ")", "{", "if", "(", "ix86_in_large_data_p", "(", "decl", ")", ")", "{", "const", "char", "*", "prefix", "=", "NULL", ";", "bool", "one_only", "=", "DECL_COMDAT_GROUP", "(", "decl", ")", "&&", "!", "HAVE_COMDAT_GROUP", ";", "switch", "(", "categorize_decl_for_section", "(", "decl", ",", "reloc", ")", ")", "{", "case", "SECCAT_DATA", ":", "case", "SECCAT_DATA_REL", ":", "case", "SECCAT_DATA_REL_LOCAL", ":", "case", "SECCAT_DATA_REL_RO", ":", "case", "SECCAT_DATA_REL_RO_LOCAL", ":", "prefix", "=", "one_only", "?", "\".ld\"", ":", "\".ldata\"", ";", "break", ";", "case", "SECCAT_BSS", ":", "prefix", "=", "one_only", "?", "\".lb\"", ":", "\".lbss\"", ";", "break", ";", "case", "SECCAT_RODATA", ":", "case", "SECCAT_RODATA_MERGE_STR", ":", "case", "SECCAT_RODATA_MERGE_STR_INIT", ":", "case", "SECCAT_RODATA_MERGE_CONST", ":", "prefix", "=", "one_only", "?", "\".lr\"", ":", "\".lrodata\"", ";", "break", ";", "case", "SECCAT_SRODATA", ":", "case", "SECCAT_SDATA", ":", "case", "SECCAT_SBSS", ":", "gcc_unreachable", "(", ")", ";", "case", "SECCAT_TEXT", ":", "case", "SECCAT_TDATA", ":", "case", "SECCAT_TBSS", ":", "break", ";", "}", "if", "(", "prefix", ")", "{", "const", "char", "*", "name", ",", "*", "linkonce", ";", "char", "*", "string", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "targetm", ".", "strip_name_encoding", "(", "name", ")", ";", "linkonce", "=", "one_only", "?", "\".gnu.linkonce\"", ":", "\"\"", ";", "string", "=", "ACONCAT", "(", "(", "linkonce", ",", "prefix", ",", "\".\"", ",", "name", ",", "NULL", ")", ")", ";", "set_decl_section_name", "(", "decl", ",", "string", ")", ";", "return", ";", "}", "}", "default_unique_section", "(", "decl", ",", "reloc", ")", ";", "}", "</s>" ]

[ "Build", "up", "a", "unique", "section", "name", ",", "expressed", "as", "a", "STRING_CST", "node", ",", "and", "assign", "it", "to", "DECL_SECTION_NAME", "(", "decl", ")", ".", "RELOC", "indicates", "whether", "the", "initial", "value", "of", "EXP", "requires", "link-time", "relocations", "." ]

[ "i386", "\".ld\"", "\".ldata\"", "\".lb\"", "\".lbss\"", "\".lr\"", "\".lrodata\"", "\".gnu.linkonce\"", "\"\"", "\".\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isComplex", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "!", "isTC1", "(", "MI", ")", "&&", "!", "isTC2Early", "(", "MI", ")", "&&", "!", "MI", ".", "getDesc", "(", ")", ".", "mayLoad", "(", ")", "&&", "!", "MI", ".", "getDesc", "(", ")", ".", "mayStore", "(", ")", "&&", "MI", ".", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "!=", "Hexagon", "::", "S2_allocframe", "&&", "MI", ".", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "!=", "Hexagon", "::", "L2_deallocframe", "&&", "!", "isMemOp", "(", "MI", ")", "&&", "!", "MI", ".", "isBranch", "(", ")", "&&", "!", "MI", ".", "isReturn", "(", ")", "&&", "!", "MI", ".", "isCall", "(", ")", ";", "}", "</s>" ]

[ "Return", "whether", "the", "location", "is", "computed", "on", "the", "expression", "stack", ",", "meaning", "it", "can", "not", "be", "a", "simple", "register", "location", "." ]

[ "Hexagon", "Hexagon", "Hexagon::S2_allocframe", "Hexagon::L2_deallocframe" ]

[]

[ "<s>", "virtual", "SMLoc", "getEndLoc", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "SystemZ" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", "<<", "\"alignment : \"", "<<", "DebugStr", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", "<<", "\"\\n\"", ")", ";", "eliminateFI", "(", "MI", ",", "FIOperandNum", ",", "FrameIndex", ",", "stackSize", ",", "spOffset", ",", "RS", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "Mips", "Mips", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "\"alignment : \"", "\"\\n\"" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "new", "X86ExecutionDomainFix", "(", ")", ")", ";", "addPass", "(", "createBreakFalseDeps", "(", ")", ")", ";", "}", "addPass", "(", "createX86IndirectBranchTrackingPass", "(", ")", ")", ";", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86FixupBWInsts", "(", ")", ")", ";", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "}", "addPass", "(", "createX86EvexToVexInsts", "(", ")", ")", ";", "addPass", "(", "createX86DiscriminateMemOpsPass", "(", ")", ")", ";", "addPass", "(", "createX86InsertPrefetchPass", "(", ")", ")", ";", "addPass", "(", "createX86InsertX87waitPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "bool", "SHUXIFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SHUXIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SHUXIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "SHUXI", "::", "PUSH", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "SHUXI", "SHUXI", "SHUXI", "SHUXI", "2", "0", "1", "SHUXI::PUSH" ]

[]

[ "<s>", "SDValue", "PTXTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "isVarArg", ")", "llvm_unreachable", "(", "\"PTX does not support varargs\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "lower_argument_func", "lower_argument", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "break", ";", "case", "CallingConv", "::", "PTX_Kernel", ":", "MFI", "->", "setKernel", "(", ")", ";", "lower_argument", "=", "lower_kernel_argument", ";", "break", ";", "case", "CallingConv", "::", "PTX_Device", ":", "MFI", "->", "setKernel", "(", "false", ")", ";", "lower_argument", "=", "lower_device_argument", ";", "break", ";", "}", "for", "(", "struct", "argmap_entry", "*", "i", "=", "argmap", ",", "*", "e", "=", "argmap", "+", "array_lengthof", "(", "argmap", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "i", "->", "reset", "(", ")", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MVT", "::", "SimpleValueType", "VT", "=", "Ins", "[", "i", "]", ".", "VT", ".", "SimpleTy", ";", "struct", "argmap_entry", "*", "entry", "=", "std", "::", "find", "(", "argmap", ",", "argmap", "+", "array_lengthof", "(", "argmap", ")", ",", "VT", ")", ";", "if", "(", "entry", "==", "argmap", "+", "array_lengthof", "(", "argmap", ")", ")", "llvm_unreachable", "(", "\"Type of argument is not supported\"", ")", ";", "unsigned", "reg", ";", "SDValue", "arg", "=", "lower_argument", "(", "i", ",", "Chain", ",", "dl", ",", "VT", ",", "entry", ",", "DAG", ",", "&", "reg", ")", ";", "InVals", ".", "push_back", "(", "arg", ")", ";", "if", "(", "!", "MFI", "->", "isDoneAddArg", "(", ")", ")", "MFI", "->", "addArgReg", "(", "reg", ")", ";", "}", "if", "(", "!", "MFI", "->", "isDoneAddArg", "(", ")", ")", "MFI", "->", "doneAddArg", "(", ")", ";", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PTX", "PTX", "ISD::InputArg", "\"PTX does not support varargs\"", "PTX", "PTX", "\"Unsupported calling convention\"", "PTX", "PTX", "0", "MVT::SimpleValueType", "\"Type of argument is not supported\"" ]

[]

[ "<s>", "void", "AlphaInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Alpha", "::", "F4RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDS", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "F8RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDT", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "GPRCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDQ", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "abort", "(", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Alpha", "Alpha", "Alpha::F4RCRegisterClass", "Alpha::LDS", "Alpha::F31", "Alpha::F8RCRegisterClass", "Alpha::LDT", "Alpha::F31", "Alpha::GPRCRegisterClass", "Alpha::LDQ", "Alpha::F31" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "createPPCPostMachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "PowerPC", "PPC" ]

[]