Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "AMDGPU", "AMDGPU", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::FrameIndex", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::UDIVREM", "ISD::SDIVREM", "ISD::FREM", "ISD::FCEIL", "ISD::FTRUNC", "ISD::FRINT", "ISD::FNEARBYINT", "ISD::FROUND", "ISD::FFLOOR", "ISD::SINT_TO_FP", "SI", "ISD::UINT_TO_FP", "ISD::FP_TO_SINT", "SI", "ISD::FP_TO_UINT" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "int", "OffsetOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", ";", "int", "RegOpIdx", "=", "OffsetOpIdx", "+", "1", ";", "int", "ChanOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "chan", ")", ";", "if", "(", "isRegisterLoad", "(", "*", "MI", ")", ")", "{", "int", "DstOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "dst", ")", ";", "unsigned", "RegIndex", "=", "MI", "->", "getOperand", "(", "RegOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Channel", "=", "MI", "->", "getOperand", "(", "ChanOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Address", "=", "calculateIndirectAddress", "(", "RegIndex", ",", "Channel", ")", ";", "unsigned", "OffsetReg", "=", "MI", "->", "getOperand", "(", "OffsetOpIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "OffsetReg", "==", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", "{", "buildMovInstr", "(", "MBB", ",", "MI", ",", "MI", "->", "getOperand", "(", "DstOpIdx", ")", ".", "getReg", "(", ")", ",", "getIndirectAddrRegClass", "(", ")", "->", "getRegister", "(", "Address", ")", ")", ";", "}", "else", "{", "buildIndirectRead", "(", "MBB", ",", "MI", ",", "MI", "->", "getOperand", "(", "DstOpIdx", ")", ".", "getReg", "(", ")", ",", "Address", ",", "OffsetReg", ")", ";", "}", "}", "else", "if", "(", "isRegisterStore", "(", "*", "MI", ")", ")", "{", "int", "ValOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "val", ")", ";", "unsigned", "RegIndex", "=", "MI", "->", "getOperand", "(", "RegOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Channel", "=", "MI", "->", "getOperand", "(", "ChanOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Address", "=", "calculateIndirectAddress", "(", "RegIndex", ",", "Channel", ")", ";", "unsigned", "OffsetReg", "=", "MI", "->", "getOperand", "(", "OffsetOpIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "OffsetReg", "==", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", "{", "buildMovInstr", "(", "MBB", ",", "MI", ",", "getIndirectAddrRegClass", "(", ")", "->", "getRegister", "(", "Address", ")", ",", "MI", "->", "getOperand", "(", "ValOpIdx", ")", ".", "getReg", "(", ")", ")", ";", "}", "else", "{", "buildIndirectWrite", "(", "MBB", ",", "MI", ",", "MI", "->", "getOperand", "(", "ValOpIdx", ")", ".", "getReg", "(", ")", ",", "calculateIndirectAddress", "(", "RegIndex", ",", "Channel", ")", ",", "OffsetReg", ")", ";", "}", "}", "else", "{", "return", "false", ";", "}", "MBB", "->", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "R600", "1" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "TargetPassConfig", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "initialize", "(", "*", "F", ".", "getParent", "(", ")", ",", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ")", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "I", "=", "df_begin", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ",", "E", "=", "df_end", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BasicBlock", "*", "BB", "=", "*", "I", ";", "BranchInst", "*", "Term", "=", "dyn_cast", "<", "BranchInst", ">", "(", "BB", "->", "getTerminator", "(", ")", ")", ";", "if", "(", "!", "Term", "||", "Term", "->", "isUnconditional", "(", ")", ")", "{", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "1", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "if", "(", "DT", "->", "dominates", "(", "Term", "->", "getSuccessor", "(", "1", ")", ",", "BB", ")", ")", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "BB", "&&", "isElse", "(", "Phi", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";", "}", "closeControlFlow", "(", "BB", ")", ";", "}", "openIf", "(", "Term", ")", ";", "}", "if", "(", "!", "Stack", ".", "empty", "(", ")", ")", "{", "report_fatal_error", "(", "\"failed to annotate CFG\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AMDGPU", "SI", "1", "1", "\"failed to annotate CFG\"" ]

[]

[ "<s>", "void", "UPTInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ",", "ZeroReg", "=", "0", ";", "Opc", "=", "UPT", "::", "ADDR", ",", "ZeroReg", "=", "UPT", "::", "ZERO", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "UPT", "::", "ADDR", ")", ")", ";", "if", "(", "DestReg", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "ZeroReg", ")", "MIB", ".", "addReg", "(", "UPT", "::", "ZERO", ")", ";", "if", "(", "SrcReg", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "UPT", "UPT", "0", "0", "UPT::ADDR", "UPT::ZERO", "UPT::ADDR", "UPT::ZERO" ]

[]

[ "<s>", "MCSymbol", "*", "XtensaMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "quad_address_p", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "bool", "strict", ")", "{", "rtx", "op0", ",", "op1", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "16", ")", "return", "false", ";", "if", "(", "legitimate_indirect_address_p", "(", "addr", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "!", "mode_supports_vsx_dform_quad", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", "return", "false", ";", "op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", "||", "!", "INT_REG_OK_FOR_BASE_P", "(", "op0", ",", "strict", ")", ")", "return", "false", ";", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", ")", "return", "false", ";", "return", "quad_address_offset_p", "(", "INTVAL", "(", "op1", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "ADDR", "is", "an", "acceptable", "address", "for", "a", "quad", "memory", "operation", "of", "mode", "MODE", "(", "either", "LQ/STQ", "for", "general", "purpose", "registers", ",", "or", "LXV/STXV", "for", "vector", "registers", "under", "ISA", "3.0", ".", "GPR_P", "is", "true", "if", "this", "address", "is", "intended", "for", "LQ/STQ", ".", "If", "it", "is", "false", ",", "the", "address", "is", "intended", "for", "the", "ISA", "3.0", "LXV/STXV", "instruction", "." ]

[ "powerpcspe", "16", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForStrcmp", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src1", ",", "SDValue", "Src2", ",", "MachinePointerInfo", "Op1PtrInfo", ",", "MachinePointerInfo", "Op2PtrInfo", ")", "const", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Src1", ".", "getValueType", "(", ")", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "SDValue", "Unused", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "STRCMP", ",", "DL", ",", "VTs", ",", "Chain", ",", "Src1", ",", "Src2", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "Chain", "=", "Unused", ".", "getValue", "(", "1", ")", ";", "SDValue", "Glue", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "return", "std", "::", "make_pair", "(", "addIPMSequence", "(", "DL", ",", "Glue", ",", "DAG", ")", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "strcmp", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::Other", "MVT::Glue", "SystemZISD::STRCMP", "0", "MVT::i32", "1", "2" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", "&&", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "return", "false", ";", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "X86ISD", "::", "RET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "return", "HasRet", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "X86", "X86", "1", "1", "0", "ISD::CopyToReg", "ISD::FP_EXTEND", "X86ISD::RET_FLAG" ]

[]

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

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

[ "LC3", "LC3" ]

[]

[ "<s>", "static", "rtx", "safe_vector_operand", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "x", "==", "const0_rtx", ")", "x", "=", "CONST0_RTX", "(", "mode", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Errors", "in", "the", "source", "file", "can", "cause", "expand_expr", "to", "return", "const0_rtx", "where", "we", "expect", "a", "vector", ".", "To", "avoid", "crashing", ",", "use", "one", "of", "the", "vector", "clear", "instructions", "." ]

[ "i386" ]

[]

[ "<s>", "outliner", "::", "InstrType", "RISCVInstrInfo", "::", "getOutliningType", "(", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "Flags", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "{", "if", "(", "MI", ".", "isCFIInstruction", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Invisible", ";", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "&&", "!", "MBB", "->", "succ_empty", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "RISCV", "::", "X5", ",", "TRI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "RISCV", "::", "X5", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "for", "(", "const", "auto", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MO", ".", "isMBB", "(", ")", "||", "MO", ".", "isBlockAddress", "(", ")", "||", "MO", ".", "isCPI", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Invisible", ";", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "RI5CY", "RISCV", "RISCV::X5", "RISCV::X5" ]

[]

[ "<s>", "const", "unsigned", "*", "MSP430RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntr", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430", "MSP430" ]

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "AArch64TTIImpl", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "if", "(", "TyWidth", "==", "32", "||", "TyWidth", "==", "64", ")", "return", "TTI", "::", "PSK_FastHardware", ";", "return", "TTI", "::", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "AArch64", "AArch64", "\"Ty width must be power of 2\"", "32", "64" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "CompactUnwind", "=", "MF", ".", "getMMI", "(", ")", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getCompactUnwindSection", "(", ")", "!=", "nullptr", ";", "return", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "||", "hasFP", "(", "MF", ")", "||", "!", "CompactUnwind", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "HiPE", "&&", "!", "MF", ".", "shouldSplitStack", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TSM", ".", "init", "(", "&", "MF", ".", "getSubtarget", "(", ")", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "I", "->", "first", ";", "unsigned", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugInstr", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

[ "<s>", "unsigned", "MipsInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "Mips", "::", "LW", ")", "||", "(", "Opc", "==", "Mips", "::", "LW_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "LD", ")", "||", "(", "Opc", "==", "Mips", "::", "LD_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "LWC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LWC1_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC164", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC164_P8", ")", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Mips", "Mips", "Mips::LW", "Mips::LW_P8", "Mips::LD", "Mips::LD_P8", "Mips::LWC1", "Mips::LWC1_P8", "Mips::LDC1", "Mips::LDC164", "Mips::LDC164_P8", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "int", "arc_eligible_for_epilogue_delay", "(", "rtx", "trial", ",", "int", "slot", ")", "{", "gcc_assert", "(", "!", "slot", ")", ";", "if", "(", "get_attr_length", "(", "trial", ")", "==", "1", "&&", "current_frame_info", ".", "gmask", "==", "0", "&&", "!", "reg_mentioned_p", "(", "stack_pointer_rtx", ",", "PATTERN", "(", "trial", ")", ")", "&&", "!", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "PATTERN", "(", "trial", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "TRIAL", "is", "a", "valid", "insn", "for", "the", "epilogue", "delay", "slot", ".", "Any", "single", "length", "instruction", "which", "does", "n't", "reference", "the", "stack", "or", "frame", "pointer", "or", "any", "call-saved", "register", "is", "OK.", "SLOT", "will", "always", "be", "0", "." ]

[ "arc", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "riscv_print_operand_reloc", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "bool", "hi_reloc", ")", "{", "const", "char", "*", "reloc", ";", "switch", "(", "riscv_classify_symbolic_expression", "(", "op", ")", ")", "{", "case", "SYMBOL_ABSOLUTE", ":", "reloc", "=", "hi_reloc", "?", "\"%hi\"", ":", "\"%lo\"", ";", "break", ";", "case", "SYMBOL_PCREL", ":", "reloc", "=", "hi_reloc", "?", "\"%pcrel_hi\"", ":", "\"%pcrel_lo\"", ";", "break", ";", "case", "SYMBOL_TLS_LE", ":", "reloc", "=", "hi_reloc", "?", "\"%tprel_hi\"", ":", "\"%tprel_lo\"", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"invalid use of '%%%c'\"", ",", "hi_reloc", "?", "'h'", ":", "'R'", ")", ";", "return", ";", "}", "fprintf", "(", "file", ",", "\"%s(\"", ",", "reloc", ")", ";", "output_addr_const", "(", "file", ",", "riscv_strip_unspec_address", "(", "op", ")", ")", ";", "fputc", "(", "')'", ",", "file", ")", ";", "}", "</s>" ]

[ "Print", "symbolic", "operand", "OP", ",", "which", "is", "part", "of", "a", "HIGH", "or", "LO_SUM", "in", "context", "CONTEXT", ".", "HI_RELOC", "indicates", "a", "high-part", "reloc", "." ]

[ "riscv", "\"%hi\"", "\"%lo\"", "\"%pcrel_hi\"", "\"%pcrel_lo\"", "\"%tprel_hi\"", "\"%tprel_lo\"", "\"invalid use of '%%%c'\"", "\"%s(\"" ]

[]

[ "<s>", "static", "enum", "rs6000_reg_type", "register_to_reg_type", "(", "rtx", "reg", ",", "bool", "*", "is_altivec", ")", "{", "HOST_WIDE_INT", "regno", ";", "enum", "reg_class", "rclass", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "NO_REG_TYPE", ";", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "if", "(", "!", "lra_in_progress", "&&", "!", "reload_completed", ")", "return", "PSEUDO_REG_TYPE", ";", "regno", "=", "true_regnum", "(", "reg", ")", ";", "if", "(", "regno", "<", "0", "||", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "return", "PSEUDO_REG_TYPE", ";", "}", "gcc_assert", "(", "regno", ">=", "0", ")", ";", "if", "(", "is_altivec", "&&", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "*", "is_altivec", "=", "true", ";", "rclass", "=", "rs6000_regno_regclass", "[", "regno", "]", ";", "return", "reg_class_to_reg_type", "[", "(", "int", ")", "rclass", "]", ";", "}", "</s>" ]

[ "Classify", "a", "register", "type", ".", "Because", "the", "FMRGOW/FMRGEW", "instructions", "only", "work", "on", "traditional", "floating", "point", "registers", ",", "and", "the", "VMRGOW/VMRGEW", "instructions", "only", "work", "on", "the", "traditional", "altivec", "registers", ",", "note", "if", "an", "altivec", "register", "was", "chosen", "." ]

[ "rs6000", "0", "0" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "RISCVTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'a'", ":", "case", "'d'", ":", "case", "'r'", ":", "if", "(", "CallOperandVal", "->", "getType", "(", ")", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'I'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isUInt", "<", "8", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'J'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isUInt", "<", "12", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'K'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'L'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isInt", "<", "20", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'M'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0x7fffffff", ")", "weight", "=", "CW_Constant", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "RISCV", "RISCV", "8", "12", "16", "20", "0x7fffffff" ]

[]

[ "<s>", "void", "x86_order_regs_for_local_alloc", "(", "void", ")", "{", "int", "pos", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "i", ")", "&&", "call_used_or_fixed_reg_p", "(", "i", ")", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "i", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "i", ")", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "if", "(", "!", "TARGET_SSE_MATH", ")", "for", "(", "i", "=", "FIRST_STACK_REG", ";", "i", "<=", "LAST_STACK_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_SSE_REG", ";", "i", "<=", "LAST_SSE_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_REX_SSE_REG", ";", "i", "<=", "LAST_REX_SSE_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_EXT_REX_SSE_REG", ";", "i", "<=", "LAST_EXT_REX_SSE_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_MASK_REG", ";", "i", "<=", "LAST_MASK_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "if", "(", "TARGET_SSE_MATH", ")", "for", "(", "i", "=", "FIRST_STACK_REG", ";", "i", "<=", "LAST_STACK_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_MMX_REG", ";", "i", "<=", "LAST_MMX_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "while", "(", "pos", "<", "FIRST_PSEUDO_REGISTER", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "0", ";", "}", "</s>" ]

[ "Order", "the", "registers", "for", "register", "allocator", "." ]

[ "i386", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "unicosmk_file_start", "(", "void", ")", "{", "int", "i", ";", "fputs", "(", "\"\\t.ident\\t\"", ",", "asm_out_file", ")", ";", "unicosmk_output_module_name", "(", "asm_out_file", ")", ";", "fputs", "(", "\"\\n\\n\"", ",", "asm_out_file", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "++", "i", ")", "fprintf", "(", "asm_out_file", ",", "\"$%d <- r%d\\n\"", ",", "i", ",", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "++", "i", ")", "fprintf", "(", "asm_out_file", ",", "\"$f%d <- f%d\\n\"", ",", "i", ",", "i", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.macro gcc@code@align n\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"gcc@n@bytes = 1 << n\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"gcc@here = . % gcc@n@bytes\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.if ne, gcc@here, 0\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.repeat (gcc@n@bytes - gcc@here) / 4\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\tbis r31,r31,r31\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.endr\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.endif\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.endm gcc@code@align\\n\\n\"", ",", "asm_out_file", ")", ";", "unicosmk_output_default_externs", "(", "asm_out_file", ")", ";", "fputs", "(", "\"\\n\\t.psect\\t$SG00000,data\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "text", "that", "to", "appear", "at", "the", "beginning", "of", "an", "assembler", "file", "." ]

[ "alpha", "\"\\t.ident\\t\"", "\"\\n\\n\"", "0", "32", "\"$%d <- r%d\\n\"", "0", "32", "\"$f%d <- f%d\\n\"", "\"\\t.macro gcc@code@align n\\n\"", "\"gcc@n@bytes = 1 << n\\n\"", "\"gcc@here = . % gcc@n@bytes\\n\"", "\"\\t.if ne, gcc@here, 0\\n\"", "\"\\t.repeat (gcc@n@bytes - gcc@here) / 4\\n\"", "\"\\tbis r31,r31,r31\\n\"", "\"\\t.endr\\n\"", "\"\\t.endif\\n\"", "\"\\t.endm gcc@code@align\\n\\n\"", "\"\\n\\t.psect\\t$SG00000,data\\n\"" ]

[]

[ "<s>", "bool", "SystemZAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".insn\"", ")", "return", "ParseDirectiveInsn", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".machine\"", ")", "return", "ParseDirectiveMachine", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "SystemZ", "SystemZ", "\".insn\"", "\".machine\"" ]

[]

[ "<s>", "const", "char", "*", "SparcTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "SPISD", "::", "CMPICC", ":", "return", "\"SPISD::CMPICC\"", ";", "case", "SPISD", "::", "CMPFCC", ":", "return", "\"SPISD::CMPFCC\"", ";", "case", "SPISD", "::", "BRICC", ":", "return", "\"SPISD::BRICC\"", ";", "case", "SPISD", "::", "BRXCC", ":", "return", "\"SPISD::BRXCC\"", ";", "case", "SPISD", "::", "BRFCC", ":", "return", "\"SPISD::BRFCC\"", ";", "case", "SPISD", "::", "SELECT_ICC", ":", "return", "\"SPISD::SELECT_ICC\"", ";", "case", "SPISD", "::", "SELECT_XCC", ":", "return", "\"SPISD::SELECT_XCC\"", ";", "case", "SPISD", "::", "SELECT_FCC", ":", "return", "\"SPISD::SELECT_FCC\"", ";", "case", "SPISD", "::", "Hi", ":", "return", "\"SPISD::Hi\"", ";", "case", "SPISD", "::", "Lo", ":", "return", "\"SPISD::Lo\"", ";", "case", "SPISD", "::", "FTOI", ":", "return", "\"SPISD::FTOI\"", ";", "case", "SPISD", "::", "ITOF", ":", "return", "\"SPISD::ITOF\"", ";", "case", "SPISD", "::", "FTOX", ":", "return", "\"SPISD::FTOX\"", ";", "case", "SPISD", "::", "XTOF", ":", "return", "\"SPISD::XTOF\"", ";", "case", "SPISD", "::", "CALL", ":", "return", "\"SPISD::CALL\"", ";", "case", "SPISD", "::", "RET_FLAG", ":", "return", "\"SPISD::RET_FLAG\"", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "\"SPISD::GLOBAL_BASE_REG\"", ";", "case", "SPISD", "::", "FLUSHW", ":", "return", "\"SPISD::FLUSHW\"", ";", "case", "SPISD", "::", "TLS_ADD", ":", "return", "\"SPISD::TLS_ADD\"", ";", "case", "SPISD", "::", "TLS_LD", ":", "return", "\"SPISD::TLS_LD\"", ";", "case", "SPISD", "::", "TLS_CALL", ":", "return", "\"SPISD::TLS_CALL\"", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SPISD::CMPICC", "\"SPISD::CMPICC\"", "SPISD::CMPFCC", "\"SPISD::CMPFCC\"", "SPISD::BRICC", "\"SPISD::BRICC\"", "SPISD::BRXCC", "\"SPISD::BRXCC\"", "SPISD::BRFCC", "\"SPISD::BRFCC\"", "SPISD::SELECT_ICC", "\"SPISD::SELECT_ICC\"", "SPISD::SELECT_XCC", "\"SPISD::SELECT_XCC\"", "SPISD::SELECT_FCC", "\"SPISD::SELECT_FCC\"", "SPISD::Hi", "\"SPISD::Hi\"", "SPISD::Lo", "\"SPISD::Lo\"", "SPISD::FTOI", "\"SPISD::FTOI\"", "SPISD::ITOF", "\"SPISD::ITOF\"", "SPISD::FTOX", "\"SPISD::FTOX\"", "SPISD::XTOF", "\"SPISD::XTOF\"", "SPISD::CALL", "\"SPISD::CALL\"", "SPISD::RET_FLAG", "\"SPISD::RET_FLAG\"", "SPISD::GLOBAL_BASE_REG", "\"SPISD::GLOBAL_BASE_REG\"", "SPISD::FLUSHW", "\"SPISD::FLUSHW\"", "SPISD::TLS_ADD", "\"SPISD::TLS_ADD\"", "SPISD::TLS_LD", "\"SPISD::TLS_LD\"", "SPISD::TLS_CALL", "\"SPISD::TLS_CALL\"" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Advance cycle, clear state\\n\"", ")", ";", "Resources", "->", "clearResources", "(", ")", ";", "if", "(", "DotCurPNum", "!=", "-", "1", "&&", "DotCurPNum", "!=", "(", "int", ")", "PacketNum", ")", "{", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "}", "UsesLoad", "=", "false", ";", "PrefVectorStoreNew", "=", "nullptr", ";", "PacketNum", "++", ";", "RegDefs", ".", "clear", "(", ")", ";", "}", "</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", "." ]

[ "Hexagon", "Hexagon", "\"Advance cycle, clear state\\n\"", "1", "1" ]

[]

[ "<s>", "bool", "isMachineVerifierClean", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "Lanai" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "CodeGenOpt", "::", "Level", "OptLevel", "=", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "FADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "STI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "PerformSHLCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::FADD", "ISD::MUL", "ISD::SHL", "ISD::AND", "ISD::SELECT" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"rvex Assembly Printer\"", ";", "}", "</s>" ]

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

[ "rvex", "\"rvex Assembly Printer\"" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getScalarizationOverhead", "(", "Type", "*", "Ty", ",", "bool", "Insert", ",", "bool", "Extract", ")", "{", "assert", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "\"Can only scalarize vectors\"", ")", ";", "int", "Cost", "=", "0", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Ty", "->", "getVectorNumElements", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "Insert", ")", "Cost", "+=", "getVectorInstrCost", "(", "Instruction", "::", "InsertElement", ",", "Ty", ",", "i", ")", ";", "if", "(", "Extract", ")", "Cost", "+=", "getVectorInstrCost", "(", "Instruction", "::", "ExtractElement", ",", "Ty", ",", "i", ")", ";", "}", "return", "Cost", ";", "}", "</s>" ]

[ "Estimate", "the", "overhead", "of", "scalarizing", "an", "instruction", "." ]

[ "X86", "X86", "\"Can only scalarize vectors\"", "0", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "AMDGPUAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "AMDGPU", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_si_sopp_br\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_si_rodata\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_si_end_of_text\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::NumTargetFixupKinds", "\"fixup_si_sopp_br\"", "0", "16", "\"fixup_si_rodata\"", "0", "32", "0", "\"fixup_si_end_of_text\"", "0", "32" ]

[]

[ "<s>", "bool", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallingConv", "::", "ID", "CallConv", ",", "const", "MachineOperand", "&", "Callee", ",", "const", "ArgInfo", "&", "OrigRet", ",", "ArrayRef", "<", "ArgInfo", ">", "OrigArgs", ")", "const", "override", "{", "return", "lowerCall", "(", "MIRBuilder", ",", "CallConv", ",", "Callee", ",", "OrigRet", ",", "OrigArgs", ",", "0", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "AArch64", "0" ]

[]

[ "<s>", "static", "machine_mode", "aarch64_simd_container_mode", "(", "scalar_mode", "mode", ",", "poly_int64", "width", ")", "{", "if", "(", "TARGET_SVE", "&&", "known_eq", "(", "width", ",", "BITS_PER_SVE_VECTOR", ")", ")", "switch", "(", "mode", ")", "{", "case", "E_DFmode", ":", "return", "VNx2DFmode", ";", "case", "E_SFmode", ":", "return", "VNx4SFmode", ";", "case", "E_HFmode", ":", "return", "VNx8HFmode", ";", "case", "E_DImode", ":", "return", "VNx2DImode", ";", "case", "E_SImode", ":", "return", "VNx4SImode", ";", "case", "E_HImode", ":", "return", "VNx8HImode", ";", "case", "E_QImode", ":", "return", "VNx16QImode", ";", "default", ":", "return", "word_mode", ";", "}", "gcc_assert", "(", "known_eq", "(", "width", ",", "64", ")", "||", "known_eq", "(", "width", ",", "128", ")", ")", ";", "if", "(", "TARGET_SIMD", ")", "{", "if", "(", "known_eq", "(", "width", ",", "128", ")", ")", "switch", "(", "mode", ")", "{", "case", "E_DFmode", ":", "return", "V2DFmode", ";", "case", "E_SFmode", ":", "return", "V4SFmode", ";", "case", "E_HFmode", ":", "return", "V8HFmode", ";", "case", "E_SImode", ":", "return", "V4SImode", ";", "case", "E_HImode", ":", "return", "V8HImode", ";", "case", "E_QImode", ":", "return", "V16QImode", ";", "case", "E_DImode", ":", "return", "V2DImode", ";", "default", ":", "break", ";", "}", "else", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "V2SFmode", ";", "case", "E_HFmode", ":", "return", "V4HFmode", ";", "case", "E_SImode", ":", "return", "V2SImode", ";", "case", "E_HImode", ":", "return", "V4HImode", ";", "case", "E_QImode", ":", "return", "V8QImode", ";", "default", ":", "break", ";", "}", "}", "return", "word_mode", ";", "}", "</s>" ]

[ "Return", "appropriate", "SIMD", "container", "for", "MODE", "within", "a", "vector", "of", "WIDTH", "bits", "." ]

[ "aarch64", "64", "128", "128" ]

[]

[ "<s>", "int", "registers_ok_for_ldd_peep", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "if", "(", "GET_CODE", "(", "reg1", ")", "!=", "REG", "||", "GET_CODE", "(", "reg2", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "reg1", ")", "%", "2", "!=", "0", ")", "return", "0", ";", "if", "(", "TARGET_V9", "&&", "SPARC_INT_REG_P", "(", "REGNO", "(", "reg1", ")", ")", ")", "return", "0", ";", "return", "(", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", "-", "1", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "REGNO", "(", "reg1", ")", "is", "even", "and", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", "-", "1", ".", "This", "makes", "them", "candidates", "for", "using", "ldd", "and", "std", "insns", ".", "Note", "reg1", "and", "reg2", "*", "must", "*", "be", "hard", "registers", "." ]

[ "sparc", "0", "2", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "StackOffset", "Off", "=", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Done", "=", "rewriteAArch64FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AArch64", "AArch64", "0", "\"Instr doesn't have FrameIndex operand!\"", "AArch64", "AArch64", "AArch64", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "const", "MipsTargetLowering", "*", "MipsTargetLowering", "::", "create", "(", "const", "MipsTargetMachine", "&", "TM", ",", "const", "MipsSubtarget", "&", "STI", ")", "{", "if", "(", "STI", ".", "inMips16Mode", "(", ")", ")", "return", "llvm", "::", "createMips16TargetLowering", "(", "TM", ",", "STI", ")", ";", "return", "llvm", "::", "createMipsSETargetLowering", "(", "TM", ",", "STI", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "fastMaterializeFloatZero", "(", "const", "ConstantFP", "*", "CFP", ")", "{", "assert", "(", "CFP", "->", "isNullValue", "(", ")", "&&", "\"Floating-point constant is not a positive zero.\"", ")", ";", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "CFP", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "if", "(", "VT", "!=", "MVT", "::", "f32", "&&", "VT", "!=", "MVT", "::", "f64", ")", "return", "0", ";", "bool", "Is64Bit", "=", "(", "VT", "==", "MVT", "::", "f64", ")", ";", "unsigned", "ZReg", "=", "Is64Bit", "?", "AArch64", "::", "XZR", ":", "AArch64", "::", "WZR", ";", "unsigned", "Opc", "=", "Is64Bit", "?", "AArch64", "::", "FMOVXDr", ":", "AArch64", "::", "FMOVWSr", ";", "return", "fastEmitInst_r", "(", "Opc", ",", "TLI", ".", "getRegClassFor", "(", "VT", ")", ",", "ZReg", ",", "true", ")", ";", "}", "</s>" ]

[ "Emit", "the", "floating-point", "constant", "+0.0", "in", "a", "register", "using", "target-", "specific", "logic", "." ]

[ "AArch64", "AArch64", "\"Floating-point constant is not a positive zero.\"", "0", "MVT::f32", "MVT::f64", "0", "MVT::f64", "AArch64::XZR", "AArch64::WZR", "AArch64::FMOVXDr", "AArch64::FMOVWSr" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createSIInsertWaits", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "R600", "SI", "SI" ]

[]

[ "<s>", "void", "SparcTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "dl", "(", "N", ")", ";", "RTLIB", "::", "Libcall", "libCall", "=", "RTLIB", "::", "UNKNOWN_LIBCALL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f128", "||", "N", "->", "getValueType", "(", "0", ")", "!=", "MVT", "::", "i64", ")", "return", ";", "libCall", "=", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_TO_SINT", ")", "?", "RTLIB", "::", "FPTOSINT_F128_I64", ":", "RTLIB", "::", "FPTOUINT_F128_I64", ")", ";", "Results", ".", "push_back", "(", "LowerF128Op", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "getLibcallName", "(", "libCall", ")", ",", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "!=", "MVT", "::", "f128", "||", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i64", ")", "return", ";", "libCall", "=", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SINT_TO_FP", ")", "?", "RTLIB", "::", "SINTTOFP_I64_F128", ":", "RTLIB", "::", "UINTTOFP_I64_F128", ")", ";", "Results", ".", "push_back", "(", "LowerF128Op", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "getLibcallName", "(", "libCall", ")", ",", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "{", "LoadSDNode", "*", "Ld", "=", "cast", "<", "LoadSDNode", ">", "(", "N", ")", ";", "if", "(", "Ld", "->", "getValueType", "(", "0", ")", "!=", "MVT", "::", "i64", "||", "Ld", "->", "getMemoryVT", "(", ")", "!=", "MVT", "::", "i64", ")", "return", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "LoadRes", "=", "DAG", ".", "getExtLoad", "(", "Ld", "->", "getExtensionType", "(", ")", ",", "dl", ",", "MVT", "::", "v2i32", ",", "Ld", "->", "getChain", "(", ")", ",", "Ld", "->", "getBasePtr", "(", ")", ",", "Ld", "->", "getPointerInfo", "(", ")", ",", "MVT", "::", "v2i32", ",", "Ld", "->", "isVolatile", "(", ")", ",", "Ld", "->", "isNonTemporal", "(", ")", ",", "Ld", "->", "isInvariant", "(", ")", ",", "Ld", "->", "getAlignment", "(", ")", ",", "Ld", "->", "getAAInfo", "(", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "i64", ",", "LoadRes", ")", ";", "Results", ".", "push_back", "(", "Res", ")", ";", "Results", ".", "push_back", "(", "LoadRes", ".", "getValue", "(", "1", ")", ")", ";", "return", ";", "}", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Do not know how to custom type legalize this operation!\"", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "0", "MVT::f128", "0", "MVT::i64", "ISD::FP_TO_SINT", "0", "1", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "0", "MVT::f128", "0", "MVT::i64", "ISD::SINT_TO_FP", "0", "1", "ISD::LOAD", "0", "MVT::i64", "MVT::i64", "MVT::v2i32", "MVT::v2i32", "ISD::BITCAST", "MVT::i64", "1" ]

[]

[ "<s>", "void", "CAHPFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", ")", ";", "DebugLoc", "DL", ";", "determineFrameLayout", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "std", "::", "advance", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "FPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "CAHP", "CAHP", "\"Shrink-wrapping not yet supported\"", "0" ]

[]

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

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

[ "Digital" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "ARM_AM", "::", "getSOImmVal", "(", "Imm", ")", "!=", "-", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "ARM", "ARM", "ARM_AM::getSOImmVal", "1" ]

[]

[ "<s>", "AArch64Subtarget", "&", "AArch64Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "FS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "AArch64", "AArch64", "AArch64", "\"generic\"" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "combineRepeatedFPDivisors", "(", ")", "const", "{", "switch", "(", "Subtarget", ".", "getCPUDirective", "(", ")", ")", "{", "default", ":", "return", "3", ";", "case", "PPC", "::", "DIR_440", ":", "case", "PPC", "::", "DIR_A2", ":", "case", "PPC", "::", "DIR_E500", ":", "case", "PPC", "::", "DIR_E500mc", ":", "case", "PPC", "::", "DIR_E5500", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Indicate", "whether", "this", "target", "prefers", "to", "combine", "FDIVs", "with", "the", "same", "divisor", "." ]

[ "PowerPC", "PPC", "3", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500", "PPC::DIR_E500mc", "PPC::DIR_E5500", "2" ]

[]

[ "<s>", "int", "aarch64_epilogue_uses", "(", "int", "regno", ")", "{", "if", "(", "epilogue_completed", ")", "{", "if", "(", "regno", "==", "LR_REGNUM", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "register", "is", "used", "by", "the", "epilogue", ".", "We", "need", "to", "say", "the", "return", "register", "is", "used", ",", "but", "only", "after", "epilogue", "generation", "is", "complete", ".", "Note", "that", "in", "the", "case", "of", "sibcalls", ",", "the", "values", "``", "used", "by", "the", "epilogue", "''", "are", "considered", "live", "at", "the", "start", "of", "the", "called", "function", ".", "For", "SIMD", "functions", "we", "need", "to", "return", "1", "for", "FP", "registers", "that", "are", "saved", "and", "restored", "by", "a", "function", "but", "are", "not", "zero", "in", "call_used_regs", ".", "If", "we", "do", "not", "do", "this", "optimizations", "may", "remove", "the", "restore", "of", "the", "register", "." ]

[ "aarch64", "1", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "LanaiSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "LanaiSubtarget", ">", "(", ")", ";", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "MF", ".", "begin", "(", ")", ",", "FE", "=", "MF", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "const", "SNESRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "SNES", "SNES" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Mips", "::", "RetRA", ")", ";", "if", "(", "Val", "!=", "nullptr", ")", "{", "if", "(", "!", "isSupportedType", "(", "Val", "->", "getType", "(", ")", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "RetInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "ArgInfo", "ArgRetInfo", "(", "VReg", ",", "Val", "->", "getType", "(", ")", ")", ";", "setArgFlags", "(", "ArgRetInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "ArgRetInfo", ",", "0", ",", "RetInfos", ",", "OrigArgIndices", ")", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "8", ">", "Outs", ";", "subTargetRegTypeForCallingConv", "(", "MIRBuilder", ",", "RetInfos", ",", "OrigArgIndices", ",", "[", "&", "]", "(", "ISD", "::", "ArgFlagsTy", "flags", ",", "EVT", "vt", ",", "EVT", "argvt", ",", "bool", "used", ",", "unsigned", "origIdx", ",", "unsigned", "partOffs", ")", "{", "Outs", ".", "emplace_back", "(", "flags", ",", "vt", ",", "argvt", ",", "used", ",", "origIdx", ",", "partOffs", ")", ";", "}", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "TLI", ".", "CCAssignFnForReturn", "(", ")", ")", ";", "OutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "Ret", ")", ";", "if", "(", "!", "RetHandler", ".", "handle", "(", "ArgLocs", ",", "RetInfos", ")", ")", "{", "return", "false", ";", "}", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "Mips", "Mips", "Mips::RetRA", "Mips", "Mips", "8", "8", "0", "ISD::OutputArg", "8", "ISD::ArgFlagsTy", "16", "Mips" ]

[]

[ "<s>", "static", "rtx", "gen_conditional_move", "(", "rtx", "cmp", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "cmp", ")", ";", "rtx", "op0", "=", "branch_cmp", "[", "0", "]", ";", "rtx", "op1", "=", "branch_cmp", "[", "1", "]", ";", "if", "(", "branch_type", "==", "CMP_SI", ")", "{", "if", "(", "(", "code", "==", "GT", ")", "&&", "(", "op1", "==", "constm1_rtx", ")", ")", "{", "code", "=", "GE", ";", "op1", "=", "const0_rtx", ";", "}", "cmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cc0_rtx", ",", "const0_rtx", ")", ";", "if", "(", "boolean_operator", "(", "cmp", ",", "VOIDmode", ")", ")", "{", "if", "(", "op0", "==", "const0_rtx", ")", "{", "op0", "=", "op1", ";", "op1", "=", "const0_rtx", ";", "}", "if", "(", "op1", "!=", "const0_rtx", ")", "{", "op0", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op0", ",", "op1", ",", "0", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ";", "op1", "=", "const0_rtx", ";", "}", "}", "else", "if", "(", "branch_operator", "(", "cmp", ",", "VOIDmode", ")", ")", "{", "if", "(", "op0", "==", "const0_rtx", ")", "{", "op0", "=", "op1", ";", "op1", "=", "const0_rtx", ";", "switch", "(", "code", ")", "{", "case", "LT", ":", "code", "=", "GE", ";", "break", ";", "case", "GE", ":", "code", "=", "LT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "op1", "!=", "const0_rtx", ")", "return", "0", ";", "}", "else", "return", "0", ";", "return", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "op0", ",", "op1", ")", ";", "}", "if", "(", "TARGET_HARD_FLOAT", "&&", "(", "branch_type", "==", "CMP_SF", ")", ")", "return", "gen_float_relational", "(", "code", ",", "op0", ",", "op1", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Emit", "the", "common", "code", "for", "conditional", "moves", ".", "OPERANDS", "is", "the", "array", "of", "operands", "passed", "to", "the", "conditional", "move", "define_expand", "." ]

[ "xtensa", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "GBZ80PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createGBZ80ISelDag", "(", "getGBZ80TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createGBZ80PostISelPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB", "GB" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "isLSRCostLess", "(", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C1", ",", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C2", ")", "{", "if", "(", "!", "LsrNoInsnsCost", ")", "return", "std", "::", "tie", "(", "C1", ".", "Insns", ",", "C1", ".", "NumRegs", ",", "C1", ".", "AddRecCost", ",", "C1", ".", "NumIVMuls", ",", "C1", ".", "NumBaseAdds", ",", "C1", ".", "ScaleCost", ",", "C1", ".", "ImmCost", ",", "C1", ".", "SetupCost", ")", "<", "std", "::", "tie", "(", "C2", ".", "Insns", ",", "C2", ".", "NumRegs", ",", "C2", ".", "AddRecCost", ",", "C2", ".", "NumIVMuls", ",", "C2", ".", "NumBaseAdds", ",", "C2", ".", "ScaleCost", ",", "C2", ".", "ImmCost", ",", "C2", ".", "SetupCost", ")", ";", "else", "return", "TargetTransformInfoImplBase", "::", "isLSRCostLess", "(", "C1", ",", "C2", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "LSR", "cost", "of", "C1", "is", "lower", "than", "C2", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "isNonallocatableRegisterCalleeSave", "(", "MCRegister", "Reg", ")", "const", "override", "{", "return", "Reg", "==", "PPC", "::", "LR", "||", "Reg", "==", "PPC", "::", "LR8", ";", "}", "</s>" ]

[ "Some", "targets", "have", "non-allocatable", "registers", "that", "are", "n't", "technically", "part", "of", "the", "explicit", "callee", "saved", "register", "list", ",", "but", "should", "be", "handled", "as", "such", "in", "certain", "cases", "." ]

[ "PowerPC", "PPC::LR", "PPC::LR8" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Emit Clause Markers Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"R600 Emit Clause Markers Pass\"" ]

[]

[ "<s>", "static", "void", "microblaze_block_move_loop", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ")", "{", "rtx_code_label", "*", "label", ";", "rtx", "src_reg", ",", "dest_reg", ",", "final_src", ";", "HOST_WIDE_INT", "leftover", ";", "leftover", "=", "length", "%", "MAX_MOVE_BYTES", ";", "length", "-=", "leftover", ";", "microblaze_adjust_block_mem", "(", "src", ",", "MAX_MOVE_BYTES", ",", "&", "src_reg", ",", "&", "src", ")", ";", "microblaze_adjust_block_mem", "(", "dest", ",", "MAX_MOVE_BYTES", ",", "&", "dest_reg", ",", "&", "dest", ")", ";", "final_src", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "src_reg", ",", "GEN_INT", "(", "length", ")", ",", "0", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "microblaze_block_move_straight", "(", "dest", ",", "src", ",", "MAX_MOVE_BYTES", ")", ";", "emit_move_insn", "(", "src_reg", ",", "plus_constant", "(", "Pmode", ",", "src_reg", ",", "MAX_MOVE_BYTES", ")", ")", ";", "emit_move_insn", "(", "dest_reg", ",", "plus_constant", "(", "Pmode", ",", "dest_reg", ",", "MAX_MOVE_BYTES", ")", ")", ";", "emit_insn", "(", "gen_cbranchsi4", "(", "gen_rtx_NE", "(", "SImode", ",", "src_reg", ",", "final_src", ")", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "if", "(", "leftover", ")", "microblaze_block_move_straight", "(", "dest", ",", "src", ",", "leftover", ")", ";", "}", "</s>" ]

[ "Move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", "using", "a", "loop", "that", "moves", "MAX_MOVE_BYTES", "per", "iteration", ".", "LENGTH", "must", "be", "at", "least", "MAX_MOVE_BYTES", ".", "Assume", "that", "the", "memory", "regions", "do", "not", "overlap", "." ]

[ "microblaze", "0", "0" ]

[]

[ "<s>", "bool", "GBZ80AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "llvm_unreachable", "(", "\"This branch is not implemented yet\"", ")", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "(", "void", ")", "MO", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"Unexpected inline asm memory operand\"", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "GB", "::", "R31R30", ")", "{", "O", "<<", "\"Z\"", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "GB", "::", "R29R28", "&&", "\"Wrong register class for memory operand.\"", ")", ";", "O", "<<", "\"Y\"", ";", "}", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "if", "(", "NumOpRegs", "==", "2", ")", "{", "O", "<<", "'+'", "<<", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "0", "\"This branch is not implemented yet\"", "\"Unexpected inline asm memory operand\"", "GB::R31R30", "\"Z\"", "GB::R29R28", "\"Wrong register class for memory operand.\"", "\"Y\"", "1", "2", "1" ]

[]

[ "<s>", "bool", "MipsFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "const", "SHUXIInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Vector Registers Merge Pass\"", ";", "}", "</s>" ]

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

[ "R600", "\"R600 Vector Registers Merge Pass\"" ]

[]

[ "<s>", "static", "bool", "mips_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "machine_mode", "op_mode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "if", "(", "vmode", "!=", "op_mode", ")", "return", "false", ";", "struct", "expand_vec_perm_d", "d", ";", "int", "i", ",", "nelt", ",", "which", ";", "unsigned", "char", "orig_perm", "[", "MAX_VECT_LEN", "]", ";", "bool", "ok", ";", "d", ".", "target", "=", "target", ";", "if", "(", "op0", ")", "{", "rtx", "nop0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "if", "(", "op0", "==", "op1", ")", "op1", "=", "nop0", ";", "op0", "=", "nop0", ";", "}", "if", "(", "op1", ")", "op1", "=", "force_reg", "(", "vmode", ",", "op1", ")", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "vmode", "=", "vmode", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "vmode", ")", ")", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "d", ".", "testing_p", "=", "!", "target", ";", "memset", "(", "orig_perm", ",", "0", ",", "MAX_VECT_LEN", ")", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "int", "ei", "=", "sel", "[", "i", "]", "&", "(", "2", "*", "nelt", "-", "1", ")", ";", "which", "|=", "(", "ei", "<", "nelt", "?", "1", ":", "2", ")", ";", "orig_perm", "[", "i", "]", "=", "ei", ";", "}", "memcpy", "(", "d", ".", "perm", ",", "orig_perm", ",", "MAX_VECT_LEN", ")", ";", "switch", "(", "which", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "3", ":", "d", ".", "one_vector_p", "=", "false", ";", "if", "(", "d", ".", "testing_p", "||", "!", "rtx_equal_p", "(", "d", ".", "op0", ",", "d", ".", "op1", ")", ")", "break", ";", "case", "2", ":", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "&=", "nelt", "-", "1", ";", "d", ".", "op0", "=", "d", ".", "op1", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "case", "1", ":", "d", ".", "op1", "=", "d", ".", "op0", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "}", "if", "(", "d", ".", "testing_p", ")", "{", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "if", "(", "!", "d", ".", "one_vector_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "3", ")", ";", "start_sequence", "(", ")", ";", "ok", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ok", ";", "}", "ok", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "if", "(", "!", "ok", "&&", "which", "==", "3", ")", "{", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "one_vector_p", "=", "false", ";", "memcpy", "(", "d", ".", "perm", ",", "orig_perm", ",", "MAX_VECT_LEN", ")", ";", "ok", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "}", "return", "ok", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

[ "mips", "0", "0", "2", "1", "1", "2", "3", "2", "0", "1", "1", "1", "2", "3", "3" ]

[]

[ "<s>", "bool", "AMDGPUCFGStructurizer", "::", "prepare", "(", ")", "{", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AMDGPUCFGStructurizer::prepare\\n\"", ";", ")", ";", "orderBlocks", "(", "FuncRep", ")", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "DEFAULT_VEC_SLOTS", ">", "RetBlks", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "It", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineLoop", "*", "LoopRep", "=", "(", "*", "It", ")", ";", "MBBVector", "ExitingMBBs", ";", "LoopRep", "->", "getExitingBlocks", "(", "ExitingMBBs", ")", ";", "if", "(", "ExitingMBBs", ".", "size", "(", ")", "==", "0", ")", "{", "MachineBasicBlock", "*", "DummyExitBlk", "=", "normalizeInfiniteLoopExit", "(", "LoopRep", ")", ";", "if", "(", "DummyExitBlk", ")", "RetBlks", ".", "push_back", "(", "DummyExitBlk", ")", ";", "}", "}", "for", "(", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "::", "const_iterator", "It", "=", "OrderedBlks", ".", "begin", "(", ")", ",", "E", "=", "OrderedBlks", ".", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "*", "It", ";", "removeUnconditionalBranch", "(", "MBB", ")", ";", "removeRedundantConditionalBranch", "(", "MBB", ")", ";", "if", "(", "isReturnBlock", "(", "MBB", ")", ")", "{", "RetBlks", ".", "push_back", "(", "MBB", ")", ";", "}", "assert", "(", "MBB", "->", "succ_size", "(", ")", "<=", "2", ")", ";", "}", "if", "(", "RetBlks", ".", "size", "(", ")", ">=", "2", ")", "{", "addDummyExitBlock", "(", "RetBlks", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "AMDGPU", "AMDGPU", "\"AMDGPUCFGStructurizer::prepare\\n\"", "0", "2", "2" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Patmos Single-Path Bundling (machine code)\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Single-Path Bundling (machine code)\"" ]

[]

[ "<s>", "void", "ARMHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "ITBlockSize", ")", "{", "--", "ITBlockSize", ";", "}", "else", "if", "(", "Opcode", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumTZ", "=", "CountTrailingZeros_32", "(", "Mask", ")", ";", "assert", "(", "NumTZ", "<=", "3", "&&", "\"Invalid IT mask!\"", ")", ";", "ITBlockSize", "=", "4", "-", "NumTZ", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "ITBlockSize", ";", "++", "i", ")", "{", "do", "{", "++", "I", ";", "}", "while", "(", "I", "->", "isDebugValue", "(", ")", ")", ";", "ITBlockMIs", "[", "ITBlockSize", "-", "1", "-", "i", "]", "=", "&", "*", "I", ";", "}", "}", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "{", "LastMI", "=", "MI", ";", "FpMLxStalls", "=", "0", ";", "}", "ScoreboardHazardRecognizer", "::", "EmitInstruction", "(", "SU", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::t2IT", "1", "3", "\"Invalid IT mask!\"", "4", "0", "1", "0" ]

[]

[ "<s>", "const", "MipsSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "override", "{", "if", "(", "Subtarget", ")", "return", "Subtarget", ";", "return", "&", "DefaultSubtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "bool", "c6x_in_small_data_p", "(", "const_tree", "exp", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_WEAK", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "exp", ")", ")", "{", "const", "char", "*", "section", "=", "DECL_SECTION_NAME", "(", "exp", ")", ";", "if", "(", "strcmp", "(", "section", ",", "\".neardata\"", ")", "==", "0", "||", "startswith", "(", "section", ",", "\".neardata.\"", ")", "||", "startswith", "(", "section", ",", "\".gnu.linkonce.s.\"", ")", "||", "strcmp", "(", "section", ",", "\".bss\"", ")", "==", "0", "||", "startswith", "(", "section", ",", "\".bss.\"", ")", "||", "startswith", "(", "section", ",", "\".gnu.linkonce.sb.\"", ")", "||", "strcmp", "(", "section", ",", "\".rodata\"", ")", "==", "0", "||", "startswith", "(", "section", ",", "\".rodata.\"", ")", "||", "startswith", "(", "section", ",", "\".gnu.linkonce.s2.\"", ")", ")", "return", "true", ";", "}", "else", "return", "PLACE_IN_SDATA_P", "(", "exp", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "EXP", "goes", "in", "small", "data/bss", "." ]

[ "c6x", "\".neardata\"", "0", "\".neardata.\"", "\".gnu.linkonce.s.\"", "\".bss\"", "0", "\".bss.\"", "\".gnu.linkonce.sb.\"", "\".rodata\"", "0", "\".rodata.\"", "\".gnu.linkonce.s2.\"" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "Register", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "RVFI", "->", "useSaveRestoreLibCalls", "(", "MF", ")", ")", "return", "false", ";", "auto", "FII", "=", "FixedCSRFIMap", ".", "find", "(", "Reg", ")", ";", "if", "(", "FII", "==", "FixedCSRFIMap", ".", "end", "(", ")", ")", "return", "false", ";", "FrameIdx", "=", "FII", "->", "second", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "RI5CY", "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "AMDGPULateCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "AC", "=", "&", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "for", "(", "auto", "BI", "=", "BB", ".", "begin", "(", ")", ",", "BE", "=", "BB", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", ")", "{", "Instruction", "*", "I", "=", "&", "*", "BI", "++", ";", "Changed", "|=", "visit", "(", "*", "I", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "unsigned", "MipsInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "Mips", "::", "SW", ")", "||", "(", "Opc", "==", "Mips", "::", "SW_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "SD", ")", "||", "(", "Opc", "==", "Mips", "::", "SD_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "SWC1", ")", "||", "(", "Opc", "==", "Mips", "::", "SWC1_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "SDC1", ")", "||", "(", "Opc", "==", "Mips", "::", "SDC164", ")", "||", "(", "Opc", "==", "Mips", "::", "SDC164_P8", ")", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "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", "." ]

[ "Mips", "Mips", "Mips::SW", "Mips::SW_P8", "Mips::SD", "Mips::SD_P8", "Mips::SWC1", "Mips::SWC1_P8", "Mips::SDC1", "Mips::SDC164", "Mips::SDC164_P8", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "StackAlignmentOverride", ",", "is64Bit", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "ELFWriterInfo", "(", "is64Bit", ",", "true", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "void", "emit_fusion_load_store", "(", "rtx", "load_store_reg", ",", "rtx", "addis_reg", ",", "rtx", "offset", ",", "const", "char", "*", "insn_str", ")", "{", "rtx", "fuse_ops", "[", "10", "]", ";", "char", "insn_template", "[", "80", "]", ";", "fuse_ops", "[", "0", "]", "=", "load_store_reg", ";", "fuse_ops", "[", "1", "]", "=", "addis_reg", ";", "if", "(", "CONST_INT_P", "(", "offset", ")", "&&", "satisfies_constraint_I", "(", "offset", ")", ")", "{", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2(%%1)\"", ",", "insn_str", ")", ";", "fuse_ops", "[", "2", "]", "=", "offset", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "offset", ")", "==", "UNSPEC", "&&", "XINT", "(", "offset", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", "{", "if", "(", "TARGET_ELF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@toc@l(%%1)\"", ",", "insn_str", ")", ";", "else", "if", "(", "TARGET_XCOFF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@l(%%1)\"", ",", "insn_str", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "offset", ",", "0", ",", "0", ")", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "offset", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "offset", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "offset", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_TOCREL", "&&", "CONST_INT_P", "(", "XEXP", "(", "offset", ",", "1", ")", ")", ")", "{", "rtx", "tocrel_unspec", "=", "XEXP", "(", "offset", ",", "0", ")", ";", "if", "(", "TARGET_ELF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2+%%3@toc@l(%%1)\"", ",", "insn_str", ")", ";", "else", "if", "(", "TARGET_XCOFF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2+%%3@l(%%1)\"", ",", "insn_str", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "tocrel_unspec", ",", "0", ",", "0", ")", ";", "fuse_ops", "[", "3", "]", "=", "XEXP", "(", "offset", ",", "1", ")", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "TARGET_ELF", "&&", "!", "TARGET_POWERPC64", "&&", "CONSTANT_P", "(", "offset", ")", ")", "{", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@l(%%1)\"", ",", "insn_str", ")", ";", "fuse_ops", "[", "2", "]", "=", "offset", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "fatal_insn", "(", "\"Unable to generate load/store offset for fusion\"", ",", "offset", ")", ";", "return", ";", "}", "</s>" ]

[ "Emit", "a", "D-form", "load", "or", "store", "instruction", "that", "is", "the", "second", "instruction", "of", "a", "fusion", "sequence", "." ]

[ "powerpcspe", "10", "80", "0", "1", "\"%s %%0,%%2(%%1)\"", "2", "1", "\"%s %%0,%%2@toc@l(%%1)\"", "\"%s %%0,%%2@l(%%1)\"", "2", "0", "0", "0", "0", "1", "1", "0", "\"%s %%0,%%2+%%3@toc@l(%%1)\"", "\"%s %%0,%%2+%%3@l(%%1)\"", "2", "0", "0", "3", "1", "\"%s %%0,%%2@l(%%1)\"", "2", "\"Unable to generate load/store offset for fusion\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SystemZ Comparison Elimination\"", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ Comparison Elimination\"" ]

[]

[ "<s>", "void", "TLCS900InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "TLCS900", "TLCS900" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "reduceLoopCount", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "PreHeader", ",", "MachineInstr", "*", "IndVar", ",", "MachineInstr", "&", "Cmp", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "PrevInsts", ",", "unsigned", "Iter", ",", "unsigned", "MaxIter", ")", "const", "{", "assert", "(", "(", "!", "IndVar", ")", "&&", "isEndLoopN", "(", "Cmp", ".", "getOpcode", "(", ")", ")", "&&", "\"Expecting a hardware loop\"", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "Cmp", ".", "getDebugLoc", "(", ")", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "VisitedBBs", ";", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "&", "MBB", ",", "Cmp", ".", "getOpcode", "(", ")", ",", "Cmp", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ",", "VisitedBBs", ")", ";", "if", "(", "!", "Loop", ")", "return", "0", ";", "if", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0i", "||", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop1i", ")", "{", "int64_t", "Offset", "=", "Loop", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", "<=", "1", ")", "Loop", "->", "eraseFromParent", "(", ")", ";", "else", "Loop", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "Offset", "-", "1", ")", ";", "return", "Offset", "-", "1", ";", "}", "assert", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0r", "&&", "\"Unexpected instruction\"", ")", ";", "Register", "LoopCount", "=", "Loop", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "LoopEnd", "=", "createVR", "(", "MF", ",", "MVT", "::", "i1", ")", ";", "MachineInstr", "*", "NewCmp", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "C2_cmpgtui", ")", ",", "LoopEnd", ")", ".", "addReg", "(", "LoopCount", ")", ".", "addImm", "(", "1", ")", ";", "unsigned", "NewLoopCount", "=", "createVR", "(", "MF", ",", "MVT", "::", "i32", ")", ";", "MachineInstr", "*", "NewAdd", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_addi", ")", ",", "NewLoopCount", ")", ".", "addReg", "(", "LoopCount", ")", ".", "addImm", "(", "-", "1", ")", ";", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "::", "iterator", "I", "=", "PrevInsts", ".", "begin", "(", ")", ",", "E", "=", "PrevInsts", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "substituteRegister", "(", "LoopCount", ",", "NewLoopCount", ",", "0", ",", "HRI", ")", ";", "PrevInsts", ".", "clear", "(", ")", ";", "PrevInsts", ".", "push_back", "(", "NewCmp", ")", ";", "PrevInsts", ".", "push_back", "(", "NewAdd", ")", ";", "if", "(", "Iter", "==", "MaxIter", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "J2_loop0r", ")", ")", ".", "addMBB", "(", "Loop", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ".", "addReg", "(", "NewLoopCount", ")", ";", "if", "(", "Iter", "==", "0", ")", "Loop", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Hexagon", "::", "J2_jumpf", ")", ")", ";", "Cond", ".", "push_back", "(", "NewCmp", "->", "getOperand", "(", "0", ")", ")", ";", "return", "NewLoopCount", ";", "}", "</s>" ]

[ "Generate", "code", "to", "reduce", "the", "loop", "iteration", "by", "one", "and", "check", "if", "the", "loop", "is", "finished", "." ]

[ "Hexagon", "Hexagon", "\"Expecting a hardware loop\"", "8", "0", "0", "Hexagon::J2_loop0i", "Hexagon::J2_loop1i", "1", "1", "1", "1", "1", "Hexagon::J2_loop0r", "\"Unexpected instruction\"", "1", "MVT::i1", "Hexagon::C2_cmpgtui", "1", "MVT::i32", "Hexagon::A2_addi", "1", "Hexagon", "0", "Hexagon::J2_loop0r", "0", "0", "Hexagon::J2_jumpf", "0" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">>", "WebAssemblyInstrInfo", "::", "getSerializableTargetIndices", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">", "TargetIndices", "[", "]", "=", "{", "{", "WebAssembly", "::", "TI_LOCAL_START", ",", "\"wasm-local-start\"", "}", ",", "{", "WebAssembly", "::", "TI_GLOBAL_START", ",", "\"wasm-global-start\"", "}", ",", "{", "WebAssembly", "::", "TI_OPERAND_STACK_START", ",", "\"wasm-operator-stack-start\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetIndices", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "ids", "of", "the", "target", "indices", "(", "used", "for", "the", "TargetIndex", "machine", "operand", ")", "and", "their", "names", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::TI_LOCAL_START", "\"wasm-local-start\"", "WebAssembly::TI_GLOBAL_START", "\"wasm-global-start\"", "WebAssembly::TI_OPERAND_STACK_START", "\"wasm-operator-stack-start\"" ]

[]

[ "<s>", "void", "frv_expand_epilogue", "(", "bool", "emit_return", ")", "{", "frv_stack_t", "*", "info", "=", "frv_stack_info", "(", ")", ";", "rtx", "fp", "=", "frame_pointer_rtx", ";", "rtx", "sp", "=", "stack_pointer_rtx", ";", "rtx", "return_addr", ";", "int", "fp_offset", ";", "fp_offset", "=", "info", "->", "reg_offset", "[", "FRAME_POINTER_REGNUM", "]", ";", "if", "(", "!", "crtl", "->", "sp_is_unchanging", ")", "emit_insn", "(", "gen_addsi3", "(", "sp", ",", "fp", ",", "frv_frame_offset_rtx", "(", "-", "fp_offset", ")", ")", ")", ";", "frv_frame_access_standard_regs", "(", "FRV_LOAD", ",", "info", ")", ";", "if", "(", "info", "->", "save_p", "[", "LR_REGNO", "]", ")", "{", "int", "lr_offset", ";", "rtx", "mem", ";", "lr_offset", "=", "info", "->", "reg_offset", "[", "LR_REGNO", "]", ";", "if", "(", "frame_pointer_needed", ")", "mem", "=", "frv_frame_mem", "(", "Pmode", ",", "fp", ",", "lr_offset", "-", "fp_offset", ")", ";", "else", "mem", "=", "frv_frame_mem", "(", "Pmode", ",", "sp", ",", "lr_offset", ")", ";", "return_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "TEMP_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "return_addr", ",", "mem", ")", ")", ";", "}", "else", "return_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "fp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "fp", ")", ")", ")", ";", "emit_use", "(", "fp", ")", ";", "}", "if", "(", "info", "->", "total_size", "!=", "0", ")", "{", "rtx", "offset", "=", "frv_frame_offset_rtx", "(", "info", "->", "total_size", ")", ";", "emit_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "offset", ")", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "emit_return", ")", "emit_jump_insn", "(", "gen_epilogue_return", "(", "return_addr", ")", ")", ";", "else", "{", "rtx", "lr", "=", "return_addr", ";", "if", "(", "REGNO", "(", "return_addr", ")", "!=", "LR_REGNO", ")", "{", "lr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "emit_move_insn", "(", "lr", ",", "return_addr", ")", ";", "}", "emit_use", "(", "lr", ")", ";", "}", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "epilogue", ".", "Using", "an", "epilogue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "the", "TARGET_ASM_FUNCTION_PROLOGUE", "target", "hook", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", "." ]

[ "frv", "0" ]

[]

[ "<s>", "bool", "AVRAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "assert", "(", "(", "Count", "%", "2", ")", "==", "0", "&&", "\"NOP instructions must be 2 bytes\"", ")", ";", "OW", "->", "WriteZeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "2", "0", "\"NOP instructions must be 2 bytes\"" ]

[]

[ "<s>", "void", "xstormy16_expand_epilogue", "(", ")", "{", "struct", "xstormy16_stack_layout", "layout", ";", "rtx", "mem_pop_rtx", ";", "int", "regno", ";", "const", "int", "ifun", "=", "xstormy16_interrupt_function_p", "(", ")", ";", "mem_pop_rtx", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "mem_pop_rtx", "=", "gen_rtx_MEM", "(", "HImode", ",", "mem_pop_rtx", ")", ";", "layout", "=", "xstormy16_compute_stack_layout", "(", ")", ";", "if", "(", "layout", ".", "locals_size", ")", "{", "if", "(", "frame_pointer_needed", "&&", "layout", ".", "sp_minus_fp", "==", "layout", ".", "locals_size", ")", "emit_move_insn", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "else", "emit_addhi3_postreload", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "layout", ".", "locals_size", ")", ")", ";", "}", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", ">=", "0", ";", "regno", "--", ")", "if", "(", "REG_NEEDS_SAVE", "(", "regno", ",", "ifun", ")", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "HImode", ",", "regno", ")", ",", "mem_pop_rtx", ")", ";", "if", "(", "layout", ".", "stdarg_save_size", ")", "emit_addhi3_postreload", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "layout", ".", "stdarg_save_size", ")", ")", ";", "if", "(", "ifun", ")", "emit_jump_insn", "(", "gen_return_internal_interrupt", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_return_internal", "(", ")", ")", ";", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "epilogue", ".", "Using", "an", "epilogue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "the", "TARGET_ASM_FUNCTION_PROLOGUE", "macro", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", "." ]

[ "stormy16", "1", "0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "DstReg", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "Cond", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "if", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", "||", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "!", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "GPRC_NOR0RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RC_NOX0RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "false", ";", "CondCycles", "=", "1", ";", "TrueCycles", "=", "1", ";", "FalseCycles", "=", "1", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "PowerPC", "PPC", "2", "1", "PPC::CTR", "1", "PPC::CTR8", "PPC::GPRCRegClass", "PPC::GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_NOX0RegClass", "1", "1", "1" ]

[]

[ "<s>", "bool", "ix86_bd_has_dispatch", "(", "rtx_insn", "*", "insn", ",", "int", "action", ")", "{", "if", "(", "(", "TARGET_CPU_P", "(", "BDVER1", ")", "||", "TARGET_CPU_P", "(", "BDVER2", ")", "||", "TARGET_CPU_P", "(", "BDVER3", ")", "||", "TARGET_CPU_P", "(", "BDVER4", ")", ")", "&&", "flag_dispatch_scheduler", ")", "switch", "(", "action", ")", "{", "default", ":", "return", "false", ";", "case", "IS_DISPATCH_ON", ":", "return", "true", ";", "case", "IS_CMP", ":", "return", "is_cmp", "(", "insn", ")", ";", "case", "DISPATCH_VIOLATION", ":", "return", "dispatch_violation", "(", ")", ";", "case", "FITS_DISPATCH_WINDOW", ":", "return", "fits_dispatch_window", "(", "insn", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "Dispatch", "Scheduling", "is", "supported", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "expand_vselect_vconcat", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ",", "bool", "testing_p", ")", "{", "machine_mode", "v2mode", ";", "rtx", "x", ";", "bool", "ok", ";", "if", "(", "vselect_insn", "==", "NULL_RTX", ")", "init_vselect_insn", "(", ")", ";", "v2mode", "=", "GET_MODE_2XWIDER_MODE", "(", "GET_MODE", "(", "op0", ")", ")", ";", "x", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "0", ")", ";", "PUT_MODE", "(", "x", ",", "v2mode", ")", ";", "XEXP", "(", "x", ",", "0", ")", "=", "op0", ";", "XEXP", "(", "x", ",", "1", ")", "=", "op1", ";", "ok", "=", "expand_vselect", "(", "target", ",", "x", ",", "perm", ",", "nelt", ",", "testing_p", ")", ";", "XEXP", "(", "x", ",", "0", ")", "=", "const0_rtx", ";", "XEXP", "(", "x", ",", "1", ")", "=", "const0_rtx", ";", "return", "ok", ";", "}", "</s>" ]

[ "Similar", ",", "but", "generate", "a", "vec_concat", "from", "op0", "and", "op1", "as", "well", "." ]

[ "i386", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", "||", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsItaniumEnvironment", "(", ")", ")", "{", "M", ".", "getOrInsertGlobal", "(", "\"__security_cookie\"", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "FunctionCallee", "SecurityCheckCookie", "=", "M", ".", "getOrInsertFunction", "(", "\"__security_check_cookie\"", ",", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "if", "(", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "SecurityCheckCookie", ".", "getCallee", "(", ")", ")", ")", "{", "F", "->", "setCallingConv", "(", "CallingConv", "::", "X86_FastCall", ")", ";", "F", "->", "addAttribute", "(", "1", ",", "Attribute", "::", "AttrKind", "::", "InReg", ")", ";", "}", "return", ";", "}", "if", "(", "hasStackGuardSlotTLS", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ")", ")", "return", ";", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "X86", "X86", "\"__security_cookie\"", "\"__security_check_cookie\"", "X86", "1" ]

[]

[ "<s>", "bool", "MipsDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "assert", "(", "ConstraintCode", "==", "'m'", "&&", "\"unexpected asm memory constraint\"", ")", ";", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "Mips", "Mips", "\"unexpected asm memory constraint\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "getMemOperandWithOffset", "(", "const", "MachineInstr", "&", "MemOp", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MemOp", ".", "getDesc", "(", ")", ";", "int", "MemRefBegin", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemRefBegin", "<", "0", ")", "return", "false", ";", "MemRefBegin", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "BaseOp", "=", "&", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrScaleAmt", ")", ".", "getImm", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrIndexReg", ")", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", "return", "false", ";", "const", "MachineOperand", "&", "DispMO", "=", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "!", "DispMO", ".", "isImm", "(", ")", ")", "return", "false", ";", "Offset", "=", "DispMO", ".", "getImm", "(", ")", ";", "assert", "(", "BaseOp", "->", "isReg", "(", ")", "&&", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Get", "the", "base", "operand", "and", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

[ "X86", "X86", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "X86::AddrScaleAmt", "1", "X86::AddrIndexReg", "X86::NoRegister", "X86::AddrDisp", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"" ]

[]

[ "<s>", "bool", "AMDGPUPeepholeOpt", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "R600" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "STI", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "getFramePointerReg", "(", "STI", ")", ";", "return", "ARM", "::", "SP", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM::SP" ]

[]

[ "<s>", "bool", "hasBranchDivergence", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "branch", "divergence", "exists", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "visium_split_cbranch", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "label", ")", "{", "enum", "machine_mode", "cc_mode", "=", "visium_select_cc_mode", "(", "code", ",", "op0", ",", "op1", ")", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "cc_mode", ",", "FLAGS_REGNUM", ")", ";", "rtx", "x", "=", "gen_rtx_COMPARE", "(", "cc_mode", ",", "op0", ",", "op1", ")", ";", "x", "=", "gen_rtx_SET", "(", "flags", ",", "x", ")", ";", "emit_insn", "(", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "x", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ";", "emit_jump_insn", "(", "x", ")", ";", "visium_flags_exposed", "=", "true", ";", "}", "</s>" ]

[ "Split", "a", "compare-and-branch", "with", "CODE", ",", "operands", "OP0", "and", "OP1", ",", "and", "LABEL", "." ]

[ "visium" ]

[]

[ "<s>", "OperandMatchResultTy", "MCS51AsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "StartLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "RegNo", "=", "parseRegister", "(", "true", ")", ";", "EndLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "RegNo", "==", "MCS51", "::", "NoRegister", ")", "return", "MatchOperand_NoMatch", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "MCS51", "MCS51", "MCS51::NoRegister" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "INLINEASM", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "unsigned", "NumBytes", "=", "0", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "NumBytes", "=", "4", ";", "break", ";", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "NumBytes", "=", "0", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "AArch64", "::", "TLSDESC_CALLSEQ", ":", "NumBytes", "=", "16", ";", "break", ";", "}", "return", "NumBytes", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AArch64", "AArch64", "AArch64::INLINEASM", "0", "0", "4", "0", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "AArch64::TLSDESC_CALLSEQ", "16" ]

[]

[ "<s>", "static", "bool", "sparc_secondary_memory_needed", "(", "machine_mode", "mode", ",", "reg_class_t", "class1", ",", "reg_class_t", "class2", ")", "{", "return", "(", "(", "FP_REG_CLASS_P", "(", "class1", ")", "!=", "FP_REG_CLASS_P", "(", "class2", ")", ")", "&&", "(", "!", "TARGET_VIS3", "||", "GET_MODE_SIZE", "(", "mode", ")", ">", "8", "||", "GET_MODE_SIZE", "(", "mode", ")", "<", "4", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_MEMORY_NEEDED", ".", "On", "SPARC", "when", "not", "VIS3", "it", "is", "not", "possible", "to", "directly", "move", "data", "between", "GENERAL_REGS", "and", "FP_REGS", "." ]

[ "sparc", "8", "4" ]

[]

[ "<s>", "static", "void", "vms_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\".section\\t%s\"", ",", "name", ")", ";", "if", "(", "flags", "&", "SECTION_DEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\",NOWRT\"", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Switch", "to", "an", "arbitrary", "section", "NAME", "with", "attributes", "as", "specified", "by", "FLAGS", ".", "ALIGN", "specifies", "any", "known", "alignment", "requirements", "for", "the", "section", ";", "0", "if", "the", "default", "should", "be", "used", "." ]

[ "alpha", "\".section\\t%s\"", "\",NOWRT\"" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "loadImmediate", "(", "int64_t", "Imm", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "II", ",", "DebugLoc", "DL", ",", "unsigned", "*", "NewImm", ")", "const", "{", "MipsAnalyzeImmediate", "AnalyzeImm", ";", "const", "MipsSubtarget", "&", "STI", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Size", "=", "STI", ".", "isABI_N64", "(", ")", "?", "64", ":", "32", ";", "unsigned", "LUi", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "LUi64", ":", "Mips", "::", "LUi", ";", "unsigned", "ZEROReg", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "const", "TargetRegisterClass", "*", "RC", "=", "STI", ".", "isABI_N64", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "bool", "LastInstrIsADDiu", "=", "NewImm", ";", "const", "MipsAnalyzeImmediate", "::", "InstSeq", "&", "Seq", "=", "AnalyzeImm", ".", "Analyze", "(", "Imm", ",", "Size", ",", "LastInstrIsADDiu", ")", ";", "MipsAnalyzeImmediate", "::", "InstSeq", "::", "const_iterator", "Inst", "=", "Seq", ".", "begin", "(", ")", ";", "assert", "(", "Seq", ".", "size", "(", ")", "&&", "(", "!", "LastInstrIsADDiu", "||", "(", "Seq", ".", "size", "(", ")", ">", "1", ")", ")", ")", ";", "unsigned", "Reg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "if", "(", "Inst", "->", "Opc", "==", "LUi", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "LUi", ")", ",", "Reg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "ZEROReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "for", "(", "++", "Inst", ";", "Inst", "!=", "Seq", ".", "end", "(", ")", "-", "LastInstrIsADDiu", ";", "++", "Inst", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "if", "(", "LastInstrIsADDiu", ")", "*", "NewImm", "=", "Inst", "->", "ImmOpnd", ";", "return", "Reg", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "64", "32", "Mips::LUi64", "Mips::LUi", "Mips::ZERO_64", "Mips::ZERO", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "Mips", "Mips", "1", "16", "16", "16" ]

[]

[ "<s>", "int", "AArch64TargetLowering", "::", "getScalingFactorCost", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "isLegalAddressingMode", "(", "AM", ",", "Ty", ",", "AS", ")", ")", "return", "AM", ".", "Scale", "!=", "0", "&&", "AM", ".", "Scale", "!=", "1", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "the", "scaling", "factor", "used", "in", "the", "addressing", "mode", "represented", "by", "AM", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "AArch64", "AArch64", "0", "1", "1" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "MMI", "->", "AnalyzeModule", "(", "M", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", "OutContext", ",", "&", "TM", ")", ";", "emitHeader", "(", "M", ",", "OS1", ")", ";", "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", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "GlobalsEmitted", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"", "NVPTX::CUDA" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "FeatureBitset", "MissingFeatures", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MissingFeatures", ",", "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", ")", ";", "}", "if", "(", "getSTI", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", ")", "{", "auto", "Opc64", "=", "WebAssembly", "::", "getWasm64Opcode", "(", "static_cast", "<", "uint16_t", ">", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "if", "(", "Opc64", ">=", "0", ")", "{", "Inst", ".", "setOpcode", "(", "Opc64", ")", ";", "}", "}", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "CurrentState", "==", "EndFunction", ")", "{", "onEndOfFunction", "(", ")", ";", "}", "else", "{", "CurrentState", "=", "Instructions", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "{", "assert", "(", "MissingFeatures", ".", "count", "(", ")", ">", "0", "&&", "\"Expected missing features\"", ")", ";", "SmallString", "<", "128", ">", "Message", ";", "raw_svector_ostream", "OS", "(", "Message", ")", ";", "OS", "<<", "\"instruction requires:\"", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MissingFeatures", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "MissingFeatures", ".", "test", "(", "i", ")", ")", "OS", "<<", "' '", "<<", "getSubtargetFeatureName", "(", "i", ")", ";", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "Message", ")", ";", "}", "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", "WebAssembly::getWasm64Opcode", "0", "0", "\"Expected missing features\"", "128", "\"instruction requires:\"", "0", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "Builder", "(", "BasicBlock", "*", "B", ")", ":", "IRBuilder", "<", ">", "(", "B", ")", "{", "}", "</s>" ]

[ "Hold", "a", "reference", "to", "the", "IRBuilder", "used", "to", "generate", "output", "IR", "code", "." ]

[ "Hexagon" ]

[]

[ "<s>", "PreservedAnalyses", "AMDGPUUseNativeCallsPass", "::", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", "{", "if", "(", "UseNative", ".", "empty", "(", ")", ")", "return", "PreservedAnalyses", "::", "all", "(", ")", ";", "AMDGPULibCalls", "Simplifier", ";", "Simplifier", ".", "initNativeFuncs", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "!", "CI", ")", "continue", ";", "Function", "*", "Callee", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "Callee", "==", "0", ")", "continue", ";", "if", "(", "Simplifier", ".", "useNative", "(", "CI", ")", ")", "Changed", "=", "true", ";", "}", "}", "return", "Changed", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "0" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "&", "MAI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "if", "(", "MCID", ".", "getSize", "(", ")", ")", "return", "MCID", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "INLINEASM", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "MAI", ")", ";", "if", "(", "MI", ".", "isLabel", "(", ")", ")", "return", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleLength", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "PROLOG_LABEL", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "AArch64", "::", "TLSDESCCALL", ":", "return", "0", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown instruction class\"", ")", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AArch64", "AArch64", "AArch64::INLINEASM", "0", "0", "0", "AArch64::TLSDESCCALL", "0", "\"Unknown instruction class\"" ]

[]

[ "<s>", "bool", "X86PreTileConfig", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "MRI", "=", "&", "mf", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "mf", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "mf", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineInstr", "*", "MI", "=", "getTileConfigPoint", "(", ")", ";", "if", "(", "!", "MI", ")", "return", "false", ";", "unsigned", "Size", "=", "ST", "->", "getTileConfigSize", "(", ")", ";", "Align", "Alignment", "=", "ST", "->", "getTileConfigAlignment", "(", ")", ";", "int", "SS", "=", "mf", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "false", ")", ";", "Register", "CFG", "=", "buildConfigMI", "(", "MI", ",", "SS", ",", "TII", ",", "MRI", ",", "ST", ")", ";", "addTileCFGUse", "(", "mf", ",", "CFG", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "gen_push", "(", "rtx", "arg", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "stack_pointer_rtx", ")", "m", "->", "fs", ".", "cfa_offset", "+=", "UNITS_PER_WORD", ";", "m", "->", "fs", ".", "sp_offset", "+=", "UNITS_PER_WORD", ";", "if", "(", "REG_P", "(", "arg", ")", "&&", "GET_MODE", "(", "arg", ")", "!=", "word_mode", ")", "arg", "=", "gen_rtx_REG", "(", "word_mode", ",", "REGNO", "(", "arg", ")", ")", ";", "return", "gen_rtx_SET", "(", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ",", "arg", ")", ";", "}", "</s>" ]

[ "Code", "to", "generate", "prologue", "and", "epilogue", "sequences" ]

[ "i386" ]

[]

[ "<s>", "MVT", "PIC16TargetLowering", "::", "getSetCCResultType", "(", "MVT", "ValType", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "MVT::i8" ]

[]

[ "<s>", "bool", "AMDGPUPostLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "AMDGPULegalizerInfo", "*", "LI", "=", "static_cast", "<", "const", "AMDGPULegalizerInfo", "*", ">", "(", "ST", ".", "getLegalizerInfo", "(", ")", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "IsOptNone", "?", "nullptr", ":", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "AMDGPUPostLegalizerCombinerInfo", "PCInfo", "(", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "LI", ",", "KB", ",", "MDT", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "nullptr", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]