Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "inline", "CvtDirection", "getEmptyKey", "(", ")", "{", "return", "CvtDirection", "(", ")", ";", "}", "</s>" ]

[ "Empty", "key", ":", "no", "key", "should", "be", "generated", "that", "has", "no", "DILocalVariable", "." ]

[ "TPC" ]

[]

[ "<s>", "unsigned", "HSAILInstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "isStoreToStackSlot", "(", "MI", ",", "FrameIndex", ")", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "!", "WebAssembly", "::", "isWasmVarAddressSpace", "(", "GV", "->", "getAddressSpace", "(", ")", ")", ")", "{", "AsmPrinter", "::", "emitGlobalVariable", "(", "GV", ")", ";", "return", ";", "}", "assert", "(", "!", "GV", "->", "isThreadLocal", "(", ")", ")", ";", "MCSymbolWasm", "*", "Sym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "if", "(", "!", "Sym", "->", "getType", "(", ")", ")", "{", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "Subtarget", "->", "getTargetLowering", "(", ")", ";", "SmallVector", "<", "MVT", ",", "1", ">", "VTs", ";", "Type", "*", "GlobalVT", "=", "GV", "->", "getValueType", "(", ")", ";", "computeLegalValueVTs", "(", "TLI", ",", "GV", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ",", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GlobalVT", ",", "VTs", ")", ";", "WebAssembly", "::", "wasmSymbolSetType", "(", "Sym", ",", "GlobalVT", ",", "VTs", ")", ";", "}", "if", "(", "Sym", "->", "isTable", "(", ")", ")", "{", "getTargetStreamer", "(", ")", "->", "emitTableType", "(", "Sym", ")", ";", "return", ";", "}", "emitVisibility", "(", "Sym", ",", "GV", "->", "getVisibility", "(", ")", ",", "!", "GV", "->", "isDeclaration", "(", ")", ")", ";", "if", "(", "GV", "->", "hasInitializer", "(", ")", ")", "{", "assert", "(", "getSymbolPreferLocal", "(", "*", "GV", ")", "==", "Sym", ")", ";", "emitLinkage", "(", "GV", ",", "Sym", ")", ";", "getTargetStreamer", "(", ")", "->", "emitGlobalType", "(", "Sym", ")", ";", "OutStreamer", "->", "emitLabel", "(", "Sym", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::isWasmVarAddressSpace", "WebAssembly", "1", "WebAssembly::wasmSymbolSetType" ]

[]

[ "<s>", "EVT", "SITargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i1", ";", "}", "</s>" ]

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

[ "R600", "SI", "MVT::i1" ]

[]

[ "<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "CCFunction", ")", ";", "if", "(", "RVLocs", ".", "size", "(", ")", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "for", "(", "CCValAssign", "const", "&", "RVLoc", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLoc", ".", "getLocReg", "(", ")", ",", "RVLoc", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "GBZ80", "GB", "ISD::InputArg", "16", "1", "1", "2", "0" ]

[]

[ "<s>", "static", "bool", "c6x_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V2HImode", ":", "case", "V4QImode", ":", "case", "V2SImode", ":", "case", "V4HImode", ":", "case", "V8QImode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "c6x" ]

[]

[ "<s>", "static", "ARMOperand", "*", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "bool", "OffsetIsReg", ",", "const", "MCExpr", "*", "Offset", ",", "int", "OffsetRegNum", ",", "bool", "OffsetRegShifted", ",", "enum", "ShiftType", "ShiftType", ",", "const", "MCExpr", "*", "ShiftAmount", ",", "bool", "Preindexed", ",", "bool", "Postindexed", ",", "bool", "Negative", ",", "bool", "Writeback", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "assert", "(", "(", "OffsetRegNum", "==", "-", "1", "||", "OffsetIsReg", ")", "&&", "\"OffsetRegNum must imply OffsetIsReg!\"", ")", ";", "assert", "(", "(", "!", "OffsetRegShifted", "||", "OffsetIsReg", ")", "&&", "\"OffsetRegShifted must imply OffsetIsReg!\"", ")", ";", "assert", "(", "(", "Offset", "||", "OffsetIsReg", ")", "&&", "\"Offset must exists unless register offset is used!\"", ")", ";", "assert", "(", "(", "!", "ShiftAmount", "||", "(", "OffsetIsReg", "&&", "OffsetRegShifted", ")", ")", "&&", "\"Cannot have shift amount without shifted register offset!\"", ")", ";", "assert", "(", "(", "!", "Offset", "||", "!", "OffsetIsReg", ")", "&&", "\"Cannot have expression offset and register offset!\"", ")", ";", "ARMOperand", "*", "Op", "=", "new", "ARMOperand", "(", "Memory", ")", ";", "Op", "->", "Mem", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Op", "->", "Mem", ".", "OffsetIsReg", "=", "OffsetIsReg", ";", "if", "(", "OffsetIsReg", ")", "Op", "->", "Mem", ".", "Offset", ".", "RegNum", "=", "OffsetRegNum", ";", "else", "Op", "->", "Mem", ".", "Offset", ".", "Value", "=", "Offset", ";", "Op", "->", "Mem", ".", "OffsetRegShifted", "=", "OffsetRegShifted", ";", "Op", "->", "Mem", ".", "ShiftType", "=", "ShiftType", ";", "Op", "->", "Mem", ".", "ShiftAmount", "=", "ShiftAmount", ";", "Op", "->", "Mem", ".", "Preindexed", "=", "Preindexed", ";", "Op", "->", "Mem", ".", "Postindexed", "=", "Postindexed", ";", "Op", "->", "Mem", ".", "Negative", "=", "Negative", ";", "Op", "->", "Mem", ".", "Writeback", "=", "Writeback", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "ARM", "ARM", "1", "\"OffsetRegNum must imply OffsetIsReg!\"", "\"OffsetRegShifted must imply OffsetIsReg!\"", "\"Offset must exists unless register offset is used!\"", "\"Cannot have shift amount without shifted register offset!\"", "\"Cannot have expression offset and register offset!\"", "ARM", "ARM" ]

[]

[ "<s>", "void", "GCNIterativeScheduler", "::", "enterRegion", "(", "MachineBasicBlock", "*", "BB", ",", "MachineBasicBlock", "::", "iterator", "Begin", ",", "MachineBasicBlock", "::", "iterator", "End", ",", "unsigned", "NumRegionInstrs", ")", "{", "BaseClass", "::", "enterRegion", "(", "BB", ",", "Begin", ",", "End", ",", "NumRegionInstrs", ")", ";", "if", "(", "NumRegionInstrs", ">", "2", ")", "{", "Regions", ".", "push_back", "(", "new", "(", "Alloc", ".", "Allocate", "(", ")", ")", "Region", "{", "Begin", ",", "End", ",", "NumRegionInstrs", ",", "getRegionPressure", "(", "Begin", ",", "End", ")", ",", "nullptr", "}", ")", ";", "}", "}", "</s>" ]

[ "Implement", "the", "ScheduleDAGInstrs", "interface", "for", "handling", "the", "next", "scheduling", "region", "." ]

[ "AMDGPU", "2" ]

[]

[ "<s>", "void", "RV16KInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "RV16K", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "RV16K", "::", "LW", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "RV16K::GPRRegClass", "\"Can't load this register from stack slot\"", "RV16K::LW", "0" ]

[]

[ "<s>", "bool", "TeakTargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "Imm", ">=", "-", "32768", "&&", "Imm", "<=", "32767", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "32768", "32767" ]

[]

[ "<s>", "void", "MipsTargetELFStreamer", "::", "finish", "(", ")", "{", "MCAssembler", "&", "MCA", "=", "getStreamer", "(", ")", ".", "getAssembler", "(", ")", ";", "const", "MCObjectFileInfo", "&", "OFI", "=", "*", "MCA", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", ";", "MCSectionData", "&", "TextSectionData", "=", "MCA", ".", "getOrCreateSectionData", "(", "*", "OFI", ".", "getTextSection", "(", ")", ")", ";", "MCSectionData", "&", "DataSectionData", "=", "MCA", ".", "getOrCreateSectionData", "(", "*", "OFI", ".", "getDataSection", "(", ")", ")", ";", "MCSectionData", "&", "BSSSectionData", "=", "MCA", ".", "getOrCreateSectionData", "(", "*", "OFI", ".", "getBSSSection", "(", ")", ")", ";", "TextSectionData", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "TextSectionData", ".", "getAlignment", "(", ")", ")", ")", ";", "DataSectionData", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "DataSectionData", ".", "getAlignment", "(", ")", ")", ")", ";", "BSSSectionData", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "BSSSectionData", ".", "getAlignment", "(", ")", ")", ")", ";", "MipsELFStreamer", "&", "MEF", "=", "static_cast", "<", "MipsELFStreamer", "&", ">", "(", "Streamer", ")", ";", "MEF", ".", "EmitMipsOptionRecords", "(", ")", ";", "emitMipsAbiFlags", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "Mips", "Mips", "16u", "16u", "16u", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "SCANode", "*", "getRoot", "(", ")", "const", "{", "return", "Root", ";", "}", "</s>" ]

[ "Similar", "to", "getMemoryRoot", ",", "but", "also", "flushes", "PendingConstrainedFP", "(", "Strict", ")", "items", "." ]

[ "Patmos" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR16_loRegClassID", ":", "case", "AArch64", "::", "FPR32_with_hsub_in_FPR16_loRegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR64_loRegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32argRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64argRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64common_and_GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64noip_and_tcGPR64RegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "rtcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "MatrixIndexGPR32_12_15RegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR16_loRegClassID", "AArch64::FPR32_with_hsub_in_FPR16_loRegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR64_loRegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32argRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64argRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64noipRegClassID", "AArch64::GPR64common_and_GPR64noipRegClassID", "AArch64::GPR64noip_and_tcGPR64RegClassID", "AArch64::tcGPR64RegClassID", "AArch64::rtcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::MatrixIndexGPR32_12_15RegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "MachineOperand", "DefMO", "=", "DefMI", ".", "getOperand", "(", "DefIdx", ")", ";", "if", "(", "HRI", ".", "isPhysicalRegister", "(", "DefMO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "DefMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "DefMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "DefMI", ".", "findRegisterDefOperandIdx", "(", "*", "SR", ",", "false", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "DefIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "MachineOperand", "UseMO", "=", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ";", "if", "(", "UseMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "UseMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "UseMI", ".", "findRegisterUseOperandIdx", "(", "*", "SR", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "UseIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "}", "return", "TargetInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "1", "1" ]

[]

[ "<s>", "bool", "NVPTXTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "{", "if", "(", "AM", ".", "BaseOffs", "||", "AM", ".", "HasBaseReg", "||", "AM", ".", "Scale", ")", "return", "false", ";", "return", "true", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "NVPTX", "NVPTX", "0", "1" ]

[]

[ "<s>", "SDValue", "M680x0TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_M680x0", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "VA", ".", "isExtInLoc", "(", ")", "&&", "VA", ".", "getValVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "M680x0", "M680x0", "ISD::InputArg", "16", "M680x0", "0", "1", "0", "MVT::i1", "ISD::TRUNCATE", "2" ]

[]

[ "<s>", "bool", "isLegalMaskedStore", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "return", "isLegalMaskedLoadStore", "(", "DataType", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "store", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isLegalRegOperand", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MCOperandInfo", "&", "OpInfo", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "false", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "DRC", "=", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ";", "if", "(", "Reg", ".", "isPhysical", "(", ")", ")", "return", "DRC", "->", "contains", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "Reg", ")", ";", "if", "(", "MO", ".", "getSubReg", "(", ")", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MO", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterClass", "*", "SuperRC", "=", "RI", ".", "getLargestLegalSuperClass", "(", "RC", ",", "*", "MF", ")", ";", "if", "(", "!", "SuperRC", ")", "return", "false", ";", "DRC", "=", "RI", ".", "getMatchingSuperRegClass", "(", "SuperRC", ",", "DRC", ",", "MO", ".", "getSubReg", "(", ")", ")", ";", "if", "(", "!", "DRC", ")", "return", "false", ";", "}", "return", "RC", "->", "hasSuperClassEq", "(", "DRC", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "(", "a", "register", "operand", ")", "is", "a", "legal", "register", "for", "the", "given", "operand", "description", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ")", "return", "false", ";", "Mod", "=", "&", "M", ";", "MDBuilder", "MDB", "(", "Mod", "->", "getContext", "(", ")", ")", ";", "MaxWorkGroupSizeRange", "=", "MDB", ".", "createRange", "(", "APInt", "(", "32", ",", "0", ")", ",", "APInt", "(", "32", ",", "2048", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "IsAMDGCN", "=", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ";", "IsAMDHSA", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "32", "0", "32", "2048" ]

[]

[ "<s>", "void", "CSKYFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "CSKYRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "if", "(", "RI", "->", "hasStackRealignment", "(", "MF", ")", ")", "{", "Align", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlign", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", ".", "value", "(", ")", "-", "StackAlign", ".", "value", "(", ")", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "CSKY", "CSKY", "CSKY" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "std", "::", "vector", "<", "SDNode", "*", ">", "*", "Created", ")", "const", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "1ULL", "<<", "Lg2", ")", "-", "1", ",", "VT", ")", ";", "SDValue", "CCVal", ";", "SDValue", "Cmp", "=", "getAArch64Cmp", "(", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ",", "CCVal", ",", "DAG", ",", "DL", ")", ";", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "CSel", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "CSEL", ",", "DL", ",", "VT", ",", "Add", ",", "N0", ",", "CCVal", ",", "Cmp", ")", ";", "if", "(", "Created", ")", "{", "Created", "->", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";", "Created", "->", "push_back", "(", "Add", ".", "getNode", "(", ")", ")", ";", "Created", "->", "push_back", "(", "CSel", ".", "getNode", "(", ")", ")", ";", "}", "SDValue", "SRA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "CSel", ",", "DAG", ".", "getConstant", "(", "Lg2", ",", "MVT", "::", "i64", ")", ")", ";", "if", "(", "Divisor", ".", "isNonNegative", "(", ")", ")", "return", "SRA", ";", "if", "(", "Created", ")", "Created", "->", "push_back", "(", "SRA", ".", "getNode", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "DAG", ".", "getConstant", "(", "0", ",", "VT", ")", ",", "SRA", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "AArch64", "AArch64", "0", "MVT::i32", "MVT::i64", "0", "0", "1ULL", "1", "AArch64", "ISD::SETLT", "ISD::ADD", "AArch64ISD::CSEL", "ISD::SRA", "MVT::i64", "ISD::SUB", "0" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "X86InstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "const", "X86RegisterInfo", "&", "RegInfo", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "StackPtr", "=", "RegInfo", ".", "getStackRegister", "(", ")", ";", "bool", "reseveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "int", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "bool", "IsLP64", "=", "STI", ".", "isTarget64BitLP64", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reseveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "CalleeAmt", "=", "isDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reseveCallFrame", ")", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "unsigned", "StackAlign", "=", "TM", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "getSUBriOpcode", "(", "IsLP64", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "{", "unsigned", "Opc", "=", "getADDriOpcode", "(", "IsLP64", ",", "Amount", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "return", ";", "}", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", "&&", "CalleeAmt", ")", "{", "unsigned", "Opc", "=", "getSUBriOpcode", "(", "IsLP64", ",", "CalleeAmt", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "llvm", "::", "prior", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "0", "0", "1", "0", "0", "1", "0", "3", "3" ]

[]

[ "<s>", "static", "void", "nios2_asm_file_end", "(", "void", ")", "{", "if", "(", "TARGET_LINUX_ABI", "&&", "trampolines_created", ")", "file_end_indicate_exec_stack", "(", ")", ";", "}", "</s>" ]

[ "Implemet", "TARGET_ASM_FILE_END", "." ]

[ "nios2" ]

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "TLCS900", "MVT::i8" ]

[]

[ "<s>", "static", "inline", "SPIRV", "::", "SpecialTypeDescriptor", "getTombstoneKey", "(", ")", "{", "return", "SPIRV", "::", "SpecialTypeDescriptor", "(", "SPIRV", "::", "SpecialTypeDescriptor", "::", "STK_Last", ")", ";", "}", "</s>" ]

[ "Difference", "in", "tombstone", "is", "that", "the", "Optional", "is", "meaningful", "." ]

[ "SPIRV", "SPIRV::SpecialTypeDescriptor", "SPIRV::SpecialTypeDescriptor", "SPIRV::SpecialTypeDescriptor" ]

[]

[ "<s>", "void", "recordRelocation", "(", "MachObjectWriter", "*", "Writer", ",", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "MCFragment", "*", "Fragment", ",", "const", "MCFixup", "&", "Fixup", ",", "MCValue", "Target", ",", "uint64_t", "&", "FixedValue", ")", "override", "{", "if", "(", "Writer", "->", "is64Bit", "(", ")", ")", "RecordX86_64Relocation", "(", "Writer", ",", "Asm", ",", "Layout", ",", "Fragment", ",", "Fixup", ",", "Target", ",", "FixedValue", ")", ";", "else", "RecordX86Relocation", "(", "Writer", ",", "Asm", ",", "Layout", ",", "Fragment", ",", "Fixup", ",", "Target", ",", "FixedValue", ")", ";", "}", "</s>" ]

[ "Record", "a", "relocation", "entry", "." ]

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

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "unsigned", "ParamOffsetBytes", "=", "36", ";", "Function", "::", "const_arg_iterator", "FuncArg", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "arg_begin", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ",", "++", "FuncArg", ")", "{", "EVT", "VT", "=", "Ins", "[", "i", "]", ".", "VT", ";", "Type", "*", "ArgType", "=", "FuncArg", "->", "getType", "(", ")", ";", "unsigned", "ArgSizeInBits", "=", "ArgType", "->", "isPointerTy", "(", ")", "?", "32", ":", "ArgType", "->", "getPrimitiveSizeInBits", "(", ")", ";", "unsigned", "ArgBytes", "=", "ArgSizeInBits", ">>", "3", ";", "EVT", "ArgVT", ";", "if", "(", "ArgSizeInBits", "<", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "assert", "(", "!", "ArgType", "->", "isFloatTy", "(", ")", "&&", "\"Extending floating point arguments not supported yet\"", ")", ";", "ArgVT", "=", "MVT", "::", "getIntegerVT", "(", "ArgSizeInBits", ")", ";", "}", "else", "{", "ArgVT", "=", "VT", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "PARAM_I_ADDRESS", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "ZEXTLOAD", ",", "DL", ",", "VT", ",", "DAG", ".", "getRoot", "(", ")", ",", "DAG", ".", "getConstant", "(", "ParamOffsetBytes", ",", "MVT", "::", "i32", ")", ",", "MachinePointerInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ")", ",", "ArgVT", ",", "false", ",", "false", ",", "ArgBytes", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "ParamOffsetBytes", "+=", "ArgBytes", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "R600", "ISD::InputArg", "36", "0", "32", "3", "\"Extending floating point arguments not supported yet\"", "MVT::getIntegerVT", "AMDGPUAS::PARAM_I_ADDRESS", "ISD::ZEXTLOAD", "MVT::i32" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getLoadStoreImmIdx", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "2", ";", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "STPXi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "LDNPXi", ":", "case", "AArch64", "::", "LDNPDi", ":", "case", "AArch64", "::", "STNPXi", ":", "case", "AArch64", "::", "STNPDi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "STPQi", ":", "case", "AArch64", "::", "LDNPQi", ":", "case", "AArch64", "::", "STNPQi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "STPWi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "LDNPWi", ":", "case", "AArch64", "::", "LDNPSi", ":", "case", "AArch64", "::", "STNPWi", ":", "case", "AArch64", "::", "STNPSi", ":", "case", "AArch64", "::", "LDG", ":", "return", "3", ";", "case", "AArch64", "::", "ADDG", ":", "case", "AArch64", "::", "STGOffset", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Returns", "the", "index", "for", "the", "immediate", "for", "a", "given", "instruction", "." ]

[ "AArch64", "AArch64", "2", "AArch64::LDPXi", "AArch64::LDPDi", "AArch64::STPXi", "AArch64::STPDi", "AArch64::LDNPXi", "AArch64::LDNPDi", "AArch64::STNPXi", "AArch64::STNPDi", "AArch64::LDPQi", "AArch64::STPQi", "AArch64::LDNPQi", "AArch64::STNPQi", "AArch64::LDPWi", "AArch64::LDPSi", "AArch64::STPWi", "AArch64::STPSi", "AArch64::LDNPWi", "AArch64::LDNPSi", "AArch64::STNPWi", "AArch64::STNPSi", "AArch64::LDG", "3", "AArch64::ADDG", "AArch64::STGOffset", "2" ]

[]

[ "<s>", "OperandMatchResultTy", "M68kAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "StartLoc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "auto", "Result", "=", "parseRegister", "(", "RegNo", ")", ";", "EndLoc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "size_t", "find_field", "(", "const", "std", "::", "string", "&", "field", ",", "const", "std", "::", "string", "&", "key", ")", "{", "size_t", "key_pos", ",", "sep_pos", ";", "key_pos", "=", "field", ".", "find", "(", "key", ")", ";", "if", "(", "key_pos", "==", "std", "::", "string", "::", "npos", ")", "return", "std", "::", "string", "::", "npos", ";", "sep_pos", "=", "field", ".", "find", "(", "\":\"", ",", "key_pos", "+", "1", ")", ";", "if", "(", "sep_pos", "==", "std", "::", "string", "::", "npos", ")", "return", "std", "::", "string", "::", "npos", ";", "return", "sep_pos", ";", "}", "</s>" ]

[ "Returns", "the", "index", "of", "the", "'", ":", "'", "inside", "the", "FIELD", "which", "must", "be", "found", "after", "the", "value", "of", "KEY", ".", "Returns", "string", ":", ":npos", "if", "line", "does", "not", "contain", "a", "field", "." ]

[ "aarch64", "\":\"", "1" ]

[]

[ "<s>", "bool", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "SHUXI" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".dwarf_addr_size\"", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "!=", "\"4\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\".dwarf_addr_size must be 4\"", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\".dwarf_addr_size\"", "\"4\"", "\".dwarf_addr_size must be 4\"" ]

[]

[ "<s>", "bool", "OR1KDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectAddr", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "static", "int", "s390_check_qrst_address", "(", "char", "c", ",", "rtx", "op", ",", "bool", "lit_pool_ok", ")", "{", "struct", "s390_address", "addr", ";", "bool", "decomposed", "=", "false", ";", "if", "(", "s390_loadrelative_operand_p", "(", "op", ",", "NULL", ",", "NULL", ")", ")", "return", "0", ";", "if", "(", "!", "lit_pool_ok", ")", "{", "if", "(", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "addr", ".", "literal_pool", ")", "return", "0", ";", "decomposed", "=", "true", ";", "}", "if", "(", "lra_in_progress", ")", "{", "if", "(", "!", "decomposed", "&&", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "decomposed", "=", "true", ";", "}", "switch", "(", "c", ")", "{", "case", "'Q'", ":", "if", "(", "!", "decomposed", "&&", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "addr", ".", "indx", ")", "return", "0", ";", "if", "(", "!", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "0", ";", "break", ";", "case", "'R'", ":", "if", "(", "TARGET_LONG_DISPLACEMENT", ")", "{", "if", "(", "!", "decomposed", "&&", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "!", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "0", ";", "}", "break", ";", "case", "'S'", ":", "if", "(", "!", "decomposed", "&&", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "addr", ".", "indx", ")", "return", "0", ";", "break", ";", "case", "'T'", ":", "break", ";", "default", ":", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "address", "in", "OP", "is", "valid", "for", "constraint", "letter", "C", "if", "wrapped", "in", "a", "MEM", "rtx", ".", "Set", "LIT_POOL_OK", "to", "true", "if", "it", "literal", "pool", "MEMs", "should", "be", "accepted", ".", "Only", "the", "Q", ",", "R", ",", "S", ",", "T", "constraint", "letters", "are", "allowed", "for", "C", "." ]

[ "s390", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "loongarch_set_return_address", "(", "rtx", "address", ",", "rtx", "scratch", ")", "{", "rtx", "slot_address", ";", "gcc_assert", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "slot_address", "=", "loongarch_add_offset", "(", "scratch", ",", "hard_frame_pointer_rtx", ",", "-", "UNITS_PER_WORD", ")", ";", "else", "slot_address", "=", "loongarch_add_offset", "(", "scratch", ",", "stack_pointer_rtx", ",", "cfun", "->", "machine", "->", "frame", ".", "gp_sp_offset", ")", ";", "loongarch_emit_move", "(", "gen_frame_mem", "(", "GET_MODE", "(", "address", ")", ",", "slot_address", ")", ",", "address", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "change", "the", "current", "function", "'s", "return", "address", "to", "ADDRESS", ".", "SCRATCH", "is", "available", "as", "a", "scratch", "register", ",", "if", "needed", ".", "ADDRESS", "and", "SCRATCH", "are", "both", "word-mode", "GPRs", "." ]

[ "loongarch" ]

[]

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

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

[ "MBlaze", "\"MBlaze DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "rtx", "gen_frame_mem_offset", "(", "machine_mode", "mode", ",", "rtx", "reg", ",", "int", "offset", ")", "{", "rtx", "int_rtx", ",", "offset_rtx", ";", "int_rtx", "=", "GEN_INT", "(", "offset", ")", ";", "if", "(", "(", "TARGET_SPE_ABI", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", "&&", "!", "SPE_CONST_OFFSET_OK", "(", "offset", ")", ")", "||", "(", "TARGET_E500_DOUBLE", "&&", "mode", "==", "DFmode", ")", ")", "{", "offset_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIXED_SCRATCH", ")", ";", "emit_move_insn", "(", "offset_rtx", ",", "int_rtx", ")", ";", "}", "else", "offset_rtx", "=", "int_rtx", ";", "return", "gen_frame_mem", "(", "mode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "offset_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "offset", "memory", "reference", "suitable", "for", "a", "frame", "store", ",", "while", "converting", "to", "a", "valid", "addressing", "mode", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "PPCDispatchGroupSBHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "unsigned", "Directive", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getMcpu", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "MCPU_PWR6", "||", "Directive", "==", "PPC", "::", "MCPU_PWR7", "||", "Directive", "==", "PPC", "::", "MCPU_PWR8", "||", "Directive", "==", "PPC", "::", "MCPU_PWR9", "||", "CurSlots", "==", "6", ")", "{", "CurGroup", ".", "clear", "(", ")", ";", "CurSlots", "=", "CurBranches", "=", "0", ";", "}", "else", "{", "CurGroup", ".", "push_back", "(", "nullptr", ")", ";", "++", "CurSlots", ";", "}", "}", "</s>" ]

[ "EmitNoop", "-", "This", "callback", "is", "invoked", "when", "a", "noop", "was", "added", "to", "the", "instruction", "stream", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::MCPU_PWR6", "PPC::MCPU_PWR7", "PPC::MCPU_PWR8", "PPC::MCPU_PWR9", "6", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "X86", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"reloc_riprel_4byte\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_movq_load\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_relax\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_relax_rex\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_signed_4byte\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_signed_4byte_relax\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_global_offset_table\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_global_offset_table8\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"reloc_branch_4byte_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "assert", "(", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ".", "Name", "&&", "\"Empty fixup name!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "X86", "X86::NumTargetFixupKinds", "\"reloc_riprel_4byte\"", "0", "32", "\"reloc_riprel_4byte_movq_load\"", "0", "32", "\"reloc_riprel_4byte_relax\"", "0", "32", "\"reloc_riprel_4byte_relax_rex\"", "0", "32", "\"reloc_signed_4byte\"", "0", "32", "0", "\"reloc_signed_4byte_relax\"", "0", "32", "0", "\"reloc_global_offset_table\"", "0", "32", "0", "\"reloc_global_offset_table8\"", "0", "64", "0", "\"reloc_branch_4byte_pcrel\"", "0", "32", "\"Invalid kind!\"", "\"Empty fixup name!\"" ]

[]

[ "<s>", "void", "emit_pic_move", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "temp", "=", "reload_in_progress", "?", "operands", "[", "0", "]", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "gcc_assert", "(", "!", "TARGET_FDPIC", "||", "!", "(", "reload_in_progress", "||", "reload_completed", ")", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "SImode", ",", "operands", "[", "1", "]", ")", ";", "else", "operands", "[", "1", "]", "=", "legitimize_pic_address", "(", "operands", "[", "1", "]", ",", "temp", ",", "TARGET_FDPIC", "?", "OUR_FDPIC_REG", ":", "pic_offset_table_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "." ]

[ "bfin", "0", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "hwloop_fail", "(", "hwloop_info", "loop", ")", "{", "rtx", "insn", "=", "loop", "->", "loop_end", ";", "if", "(", "DPREG_P", "(", "loop", "->", "iter_reg", ")", ")", "{", "rtx", "insn", ",", "test", ";", "emit_insn_before", "(", "gen_addsi3", "(", "loop", "->", "iter_reg", ",", "loop", "->", "iter_reg", ",", "constm1_rtx", ")", ",", "loop", "->", "loop_end", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "gen_cbranchsi4", "(", "test", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ",", "loop", "->", "start_label", ")", ",", "loop", "->", "loop_end", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "loop", "->", "start_label", ";", "LABEL_NUSES", "(", "loop", "->", "start_label", ")", "++", ";", "delete_insn", "(", "loop", "->", "loop_end", ")", ";", "}", "else", "{", "splitting_loops", "=", "1", ";", "try_split", "(", "PATTERN", "(", "insn", ")", ",", "safe_as_a", "<", "rtx_insn", "*", ">", "(", "insn", ")", ",", "1", ")", ";", "splitting_loops", "=", "0", ";", "}", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "Called", "when", "a", "loop", "we", "have", "discovered", "turns", "out", "not", "to", "be", "optimizable", ";", "we", "have", "to", "split", "the", "doloop_end", "pattern", "into", "a", "subtract", "and", "a", "test", "." ]

[ "bfin", "1", "1", "0" ]

[]

[ "<s>", "GCNSubtarget", "&", "GCNSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+load-store-opt,+sram-ecc,+xnack,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", ";", "if", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "FullFS", "+=", "\"+fp64-fp16-denormals,\"", ";", "}", "else", "{", "FullFS", "+=", "\"-fp32-denormals,\"", ";", "}", "FullFS", "+=", "\"+enable-prt-strict-null,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"+wavefrontsize\"", ")", "!=", "StringRef", "::", "npos", ")", "{", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize16\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize16,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize32\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize32,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize64\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize64,\"", ";", "}", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "assert", "(", "!", "hasFP64", "(", ")", "||", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", ")", "{", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "if", "(", "LDSBankCount", "==", "0", ")", "LDSBankCount", "=", "32", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "if", "(", "LocalMemorySize", "==", "0", ")", "LocalMemorySize", "=", "32768", ";", "if", "(", "!", "HasMovrel", "&&", "!", "HasVGPRIndexMode", ")", "HasMovrel", "=", "true", ";", "}", "if", "(", "WavefrontSize", "==", "0", ")", "WavefrontSize", "=", "64", ";", "HasFminFmaxLegacy", "=", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "if", "(", "!", "FS", ".", "contains", "(", "\"+xnack\"", ")", "&&", "DoesNotSupportXNACK", "&&", "EnableXNACK", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureXNACK", ")", ";", "EnableXNACK", "=", "false", ";", "}", "if", "(", "DoesNotSupportSRAMECC", "&&", "EnableSRAMECC", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureSRAMECC", ")", ";", "EnableSRAMECC", "=", "false", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,+sram-ecc,+xnack,\"", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", "AMDGPU", "\"+fp64-fp16-denormals,\"", "\"-fp32-denormals,\"", "\"+enable-prt-strict-null,\"", "\"+wavefrontsize\"", "\"wavefrontsize16\"", "\"-wavefrontsize16,\"", "\"wavefrontsize32\"", "\"-wavefrontsize32,\"", "\"wavefrontsize64\"", "\"-wavefrontsize64,\"", "AMDGPU", "\"flat-for-global\"", "0", "4", "0", "32", "0", "32768", "0", "64", "AMDGPU", "\"+xnack\"", "AMDGPU::FeatureXNACK", "AMDGPU::FeatureSRAMECC" ]

[]

[ "<s>", "bool", "s390_contiguous_bitmask_vector_p", "(", "rtx", "op", ",", "int", "*", "start", ",", "int", "*", "end", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", ";", "int", "size", ";", "rtx", "elt", ";", "bool", "b", ";", "op", "=", "gen_lowpart", "(", "related_int_vector_mode", "(", "GET_MODE", "(", "op", ")", ")", ".", "require", "(", ")", ",", "op", ")", ";", "gcc_assert", "(", "!", "!", "start", "==", "!", "!", "end", ")", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "op", ",", "&", "elt", ")", "||", "!", "CONST_INT_P", "(", "elt", ")", ")", "return", "false", ";", "size", "=", "GET_MODE_UNIT_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ";", "if", "(", "size", ">", "64", ")", "return", "false", ";", "mask", "=", "UINTVAL", "(", "elt", ")", ";", "b", "=", "s390_contiguous_bitmask_p", "(", "mask", ",", "true", ",", "size", ",", "start", ",", "end", ")", ";", "if", "(", "b", ")", "{", "if", "(", "start", ")", "{", "*", "start", "-=", "(", "HOST_BITS_PER_WIDE_INT", "-", "size", ")", ";", "*", "end", "-=", "(", "HOST_BITS_PER_WIDE_INT", "-", "size", ")", ";", "}", "return", "true", ";", "}", "else", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "contains", "the", "same", "contiguous", "bitfield", "in", "*", "all", "*", "its", "elements", ".", "START", "and", "END", "can", "be", "used", "to", "obtain", "the", "start", "and", "end", "position", "of", "the", "bitfield", ".", "START/STOP", "give", "the", "position", "of", "the", "first/last", "bit", "of", "the", "bitfield", "counting", "from", "the", "lowest", "order", "bit", "starting", "with", "zero", ".", "In", "order", "to", "use", "these", "values", "for", "S/390", "instructions", "this", "has", "to", "be", "converted", "to", "``", "bits", "big", "endian", "''", "style", "." ]

[ "s390", "64" ]

[]

[ "<s>", "bool", "HexagonSplitConst32AndConst64", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "HexagonTargetObjectFile", "&", "TLOF", "=", "*", "static_cast", "<", "const", "HexagonTargetObjectFile", "*", ">", "(", "Fn", ".", "getTarget", "(", ")", ".", "getObjFileLowering", "(", ")", ")", ";", "if", "(", "TLOF", ".", "isSmallDataEnabled", "(", ")", ")", "return", "true", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "Fn", ")", "{", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "++", "I", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "Hexagon", "::", "CONST32", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "uint64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestReg", ")", ".", "addImm", "(", "ImmValue", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "else", "if", "(", "Opc", "==", "Hexagon", "::", "CONST64", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "int64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "DestLo", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ";", "unsigned", "DestHi", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ";", "int32_t", "LowWord", "=", "(", "ImmValue", "&", "0xFFFFFFFF", ")", ";", "int32_t", "HighWord", "=", "(", "ImmValue", ">>", "32", ")", "&", "0xFFFFFFFF", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestLo", ")", ".", "addImm", "(", "LowWord", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestHi", ")", ".", "addImm", "(", "HighWord", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::CONST32", "0", "1", "Hexagon::A2_tfrsi", "Hexagon::CONST64", "0", "1", "Hexagon::subreg_loreg", "Hexagon::subreg_hireg", "0xFFFFFFFF", "32", "0xFFFFFFFF", "Hexagon::A2_tfrsi", "Hexagon::A2_tfrsi" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", "&&", "(", "Subtarget", "->", "hasNEON", "(", ")", "||", "isLegalMVEShuffleOp", "(", "PFEntry", ")", ")", ")", "return", "true", ";", "}", "bool", "ReverseVEXT", ",", "isV_UNDEF", ";", "unsigned", "Imm", ",", "WhichResult", ";", "unsigned", "EltSize", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "EltSize", ">=", "32", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "ShuffleVectorInst", "::", "isIdentityMask", "(", "M", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "16", ")", ")", "return", "true", ";", "else", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "isVEXTMask", "(", "M", ",", "VT", ",", "ReverseVEXT", ",", "Imm", ")", "||", "isVTBLMask", "(", "M", ",", "VT", ")", "||", "isNEONTwoResultShuffleMask", "(", "M", ",", "VT", ",", "WhichResult", ",", "isV_UNDEF", ")", ")", ")", "return", "true", ";", "else", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", ")", "&&", "isReverseMask", "(", "M", ",", "VT", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "ARM", "ARM", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "32", "0", "64", "32", "16", "MVT::v8i16", "MVT::v16i8" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "if", "(", "convertAddSubFlagsOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", ";", "return", "false", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tMOVr", "&&", "!", "Subtarget", ".", "hasV6Ops", "(", ")", ")", "{", "if", "(", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Non-flag-setting Thumb1 mov is v6-only\"", ";", "return", "false", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", ")", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "llvm", "::", "drop_begin", "(", "MI", ".", "operands", "(", ")", ",", "2", ")", ")", "{", "if", "(", "MO", ".", "isImplicit", "(", ")", "||", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "<", "ARM", "::", "R0", "||", "Reg", ">", "ARM", "::", "R7", ")", "{", "if", "(", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "&&", "Reg", "==", "ARM", "::", "LR", ")", "&&", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", "&&", "Reg", "==", "ARM", "::", "PC", ")", ")", "{", "ErrInfo", "=", "\"Unsupported register in Thumb1 push/pop\"", ";", "return", "false", ";", "}", "}", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MVE_VMOV_q_rr", ")", "{", "assert", "(", "MI", ".", "getOperand", "(", "4", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "5", ")", ".", "isImm", "(", ")", ")", ";", "if", "(", "(", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "!=", "2", "&&", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "!=", "3", ")", "||", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "!=", "MI", ".", "getOperand", "(", "5", ")", ".", "getImm", "(", ")", "+", "2", ")", "{", "ErrInfo", "=", "\"Incorrect array index for MVE_VMOV_q_rr\"", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "ARM", "ARM", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", "ARM::tMOVr", "ARM::hGPRRegClass", "0", "ARM::hGPRRegClass", "1", "\"Non-flag-setting Thumb1 mov is v6-only\"", "ARM::tPUSH", "ARM::tPOP", "ARM::tPOP_RET", "2", "ARM::R0", "ARM::R7", "ARM::tPUSH", "ARM::LR", "ARM::tPOP_RET", "ARM::PC", "\"Unsupported register in Thumb1 push/pop\"", "ARM::MVE_VMOV_q_rr", "4", "5", "4", "2", "4", "3", "4", "5", "2", "\"Incorrect array index for MVE_VMOV_q_rr\"" ]

[]

[ "<s>", "void", "x86_output_aligned_bss", "(", "FILE", "*", "file", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "int", "align", ")", "{", "if", "(", "(", "ix86_cmodel", "==", "CM_MEDIUM", "||", "ix86_cmodel", "==", "CM_MEDIUM_PIC", ")", "&&", "size", ">", "(", "unsigned", "int", ")", "ix86_section_threshold", ")", "named_section", "(", "decl", ",", "\".lbss\"", ",", "0", ")", ";", "else", "bss_section", "(", ")", ";", "ASM_OUTPUT_ALIGN", "(", "file", ",", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "last_assemble_variable_decl", "=", "decl", ";", "ASM_DECLARE_OBJECT_NAME", "(", "file", ",", "name", ",", "decl", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "name", ")", ";", "ASM_OUTPUT_SKIP", "(", "file", ",", "size", "?", "size", ":", "1", ")", ";", "}", "</s>" ]

[ "Utility", "function", "for", "targets", "to", "use", "in", "implementing", "ASM_OUTPUT_ALIGNED_BSS", "." ]

[ "i386", "\".lbss\"", "0", "1" ]

[]

[ "<s>", "unsigned", "M680x0TargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "return", "Subtarget", ".", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "M680x0", "M680x0" ]

[]

[ "<s>", "bool", "Mips16HardFloat", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "auto", "&", "TM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Run on Module Mips16HardFloat\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "Module", "::", "iterator", "F", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "F", "!=", "E", ";", "++", "F", ")", "{", "if", "(", "F", "->", "hasFnAttribute", "(", "\"nomips16\"", ")", "&&", "F", "->", "hasFnAttribute", "(", "\"use-soft-float\"", ")", ")", "{", "removeUseSoftFloat", "(", "*", "F", ")", ";", "continue", ";", "}", "if", "(", "F", "->", "isDeclaration", "(", ")", "||", "F", "->", "hasFnAttribute", "(", "\"mips16_fp_stub\"", ")", "||", "F", "->", "hasFnAttribute", "(", "\"nomips16\"", ")", ")", "continue", ";", "Modified", "|=", "fixupFPReturnAndCall", "(", "*", "F", ",", "&", "M", ",", "TM", ")", ";", "FPParamVariant", "V", "=", "whichFPParamVariantNeeded", "(", "*", "F", ")", ";", "if", "(", "V", "!=", "NoSig", ")", "{", "Modified", "=", "true", ";", "createFPFnStub", "(", "&", "*", "F", ",", "&", "M", ",", "V", ",", "TM", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"Run on Module Mips16HardFloat\\n\"", "\"nomips16\"", "\"use-soft-float\"", "\"mips16_fp_stub\"", "\"nomips16\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Register", ":", "OS", "<<", "\"Reg<\"", "<<", "Reg", ".", "Num", "<<", "\">\"", ";", "break", ";", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", "<<", "Imm", ".", "Val", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"Mem<Reg<\"", "<<", "Mem", ".", "BaseNum", "<<", "\">, \"", "<<", "Mem", ".", "Off", "<<", "\">\"", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "OR1K", "\"Reg<\"", "\">\"", "\"Imm<\"", "\">\"", "\"Mem<Reg<\"", "\">, \"", "\">\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v8f32", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "Enabled", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "return", "SDValue", "(", ")", ";", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "1", ";", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "FRCP", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "Op", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]

[ "X86", "X86", "MVT::f32", "MVT::v4f32", "MVT::v8f32", "MVT::f32", "1", "X86ISD::FRCP" ]

[]

[ "<s>", "static", "const", "char", "*", "m68k_get_reloc_decoration", "(", "enum", "m68k_reloc", "reloc", ")", "{", "gcc_assert", "(", "MOTOROLA", "||", "reloc", "==", "RELOC_GOT", ")", ";", "switch", "(", "reloc", ")", "{", "case", "RELOC_GOT", ":", "if", "(", "MOTOROLA", ")", "{", "if", "(", "flag_pic", "==", "1", "&&", "TARGET_68020", ")", "return", "\"@GOT.w\"", ";", "else", "return", "\"@GOT\"", ";", "}", "else", "{", "if", "(", "TARGET_68020", ")", "{", "switch", "(", "flag_pic", ")", "{", "case", "1", ":", "return", "\":w\"", ";", "case", "2", ":", "return", "\":l\"", ";", "default", ":", "return", "\"\"", ";", "}", "}", "}", "gcc_unreachable", "(", ")", ";", "case", "RELOC_TLSGD", ":", "return", "\"@TLSGD\"", ";", "case", "RELOC_TLSLDM", ":", "return", "\"@TLSLDM\"", ";", "case", "RELOC_TLSLDO", ":", "return", "\"@TLSLDO\"", ";", "case", "RELOC_TLSIE", ":", "return", "\"@TLSIE\"", ";", "case", "RELOC_TLSLE", ":", "return", "\"@TLSLE\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "string", "for", "TLS", "relocation", "RELOC", "." ]

[ "m68k", "1", "\"@GOT.w\"", "\"@GOT\"", "1", "\":w\"", "2", "\":l\"", "\"\"", "\"@TLSGD\"", "\"@TLSLDM\"", "\"@TLSLDO\"", "\"@TLSIE\"", "\"@TLSLE\"" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "getRegAllocationHints", "(", "unsigned", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Hint", "=", "MRI", ".", "getRegAllocationHint", "(", "VirtReg", ")", ";", "unsigned", "Odd", ";", "switch", "(", "Hint", ".", "first", ")", "{", "case", "ARMRI", "::", "RegPairEven", ":", "Odd", "=", "0", ";", "break", ";", "case", "ARMRI", "::", "RegPairOdd", ":", "Odd", "=", "1", ";", "break", ";", "default", ":", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "return", ";", "}", "unsigned", "Paired", "=", "Hint", ".", "second", ";", "if", "(", "Paired", "==", "0", ")", "return", ";", "unsigned", "PairedPhys", "=", "0", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "Paired", ";", "}", "else", "if", "(", "VRM", "&&", "VRM", "->", "hasPhys", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "getPairedGPR", "(", "VRM", "->", "getPhys", "(", "Paired", ")", ",", "Odd", ",", "this", ")", ";", "}", "if", "(", "PairedPhys", "&&", "std", "::", "find", "(", "Order", ".", "begin", "(", ")", ",", "Order", ".", "end", "(", ")", ",", "PairedPhys", ")", "!=", "Order", ".", "end", "(", ")", ")", "Hints", ".", "push_back", "(", "PairedPhys", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Order", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "Order", "[", "I", "]", ";", "if", "(", "Reg", "==", "PairedPhys", "||", "(", "getEncodingValue", "(", "Reg", ")", "&", "1", ")", "!=", "Odd", ")", "continue", ";", "unsigned", "Paired", "=", "getPairedGPR", "(", "Reg", ",", "!", "Odd", ",", "this", ")", ";", "if", "(", "!", "Paired", "||", "MRI", ".", "isReserved", "(", "Paired", ")", ")", "continue", ";", "Hints", ".", "push_back", "(", "Reg", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARMRI::RegPairEven", "0", "ARMRI::RegPairOdd", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "int", "avr_ret_register", "(", "void", ")", "{", "return", "24", ";", "}", "</s>" ]

[ "Returns", "register", "number", "for", "function", "return", "value", "." ]

[ "avr", "24" ]

[]

[ "<s>", "void", "rs6000_emit_swrsqrt", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "rtx", "x0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "y", "=", "gen_reg_rtx", "(", "mode", ")", ";", "int", "passes", "=", "(", "TARGET_RECIP_PRECISION", ")", "?", "1", ":", "3", ";", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "V2DFmode", ")", "passes", "++", ";", "REAL_VALUE_TYPE", "dconst3_2", ";", "int", "i", ";", "rtx", "halfthree", ";", "enum", "insn_code", "code", "=", "optab_handler", "(", "smul_optab", ",", "mode", ")", ";", "insn_gen_fn", "gen_mul", "=", "GEN_FCN", "(", "code", ")", ";", "gcc_assert", "(", "code", "!=", "CODE_FOR_nothing", ")", ";", "real_from_integer", "(", "&", "dconst3_2", ",", "VOIDmode", ",", "3", ",", "SIGNED", ")", ";", "SET_REAL_EXP", "(", "&", "dconst3_2", ",", "REAL_EXP", "(", "&", "dconst3_2", ")", "-", "1", ")", ";", "halfthree", "=", "rs6000_load_constant_and_splat", "(", "mode", ",", "dconst3_2", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x0", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "UNSPEC_RSQRT", ")", ")", ")", ";", "rs6000_emit_msub", "(", "y", ",", "src", ",", "halfthree", ",", "src", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "passes", ";", "i", "++", ")", "{", "rtx", "x1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "u", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "v", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_mul", "(", "u", ",", "x0", ",", "x0", ")", ")", ";", "rs6000_emit_nmsub", "(", "v", ",", "y", ",", "u", ",", "halfthree", ")", ";", "emit_insn", "(", "gen_mul", "(", "x1", ",", "x0", ",", "v", ")", ")", ";", "x0", "=", "x1", ";", "}", "emit_move_insn", "(", "dst", ",", "x0", ")", ";", "return", ";", "}", "</s>" ]

[ "Newton-Raphson", "approximation", "of", "single/double-precision", "floating", "point", "rsqrt", ".", "Assumes", "no", "trapping", "math", "and", "finite", "arguments", "." ]

[ "rs6000", "1", "3", "3", "1", "1", "0" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "expandMLx", "(", ")", ")", "return", "false", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->", "isSwift", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "HexagonMCInstrInfo", "::", "getMinValue", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "uint64_t", "const", "F", "=", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "MCI", ")", ".", "TSFlags", ";", "unsigned", "isSigned", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "unsigned", "bits", "=", "(", "F", ">>", "HexagonII", "::", "ExtentBitsPos", ")", "&", "HexagonII", "::", "ExtentBitsMask", ";", "if", "(", "isSigned", ")", "return", "-", "1U", "<<", "(", "bits", "-", "1", ")", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "minimal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "HexagonII::ExtentBitsPos", "HexagonII::ExtentBitsMask", "1U", "1", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "const", "IntrinsicData", "*", "IntrData", "=", "getIntrinsicWithChain", "(", "Intrinsic", ")", ";", "if", "(", "!", "IntrData", ")", "return", "false", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MONone", ";", "Info", ".", "offset", "=", "0", ";", "switch", "(", "IntrData", "->", "Type", ")", "{", "case", "TRUNCATE_TO_MEM_VI8", ":", "case", "TRUNCATE_TO_MEM_VI16", ":", "case", "TRUNCATE_TO_MEM_VI32", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "MVT", "VT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "MVT", "ScalarVT", "=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ";", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI8", ")", "ScalarVT", "=", "MVT", "::", "i8", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI16", ")", "ScalarVT", "=", "MVT", "::", "i16", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI32", ")", "ScalarVT", "=", "MVT", "::", "i32", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVectorVT", "(", "ScalarVT", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "break", ";", "}", "case", "GATHER", ":", "case", "GATHER_AVX2", ":", "{", "Info", ".", "ptrVal", "=", "nullptr", ";", "MVT", "DataVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getType", "(", ")", ")", ";", "MVT", "IndexVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "2", ")", "->", "getType", "(", ")", ")", ";", "unsigned", "NumElts", "=", "std", "::", "min", "(", "DataVT", ".", "getVectorNumElements", "(", ")", ",", "IndexVT", ".", "getVectorNumElements", "(", ")", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVectorVT", "(", "DataVT", ".", "getVectorElementType", "(", ")", ",", "NumElts", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "break", ";", "}", "case", "SCATTER", ":", "{", "Info", ".", "ptrVal", "=", "nullptr", ";", "MVT", "DataVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "3", ")", "->", "getType", "(", ")", ")", ";", "MVT", "IndexVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "2", ")", "->", "getType", "(", ")", ")", ";", "unsigned", "NumElts", "=", "std", "::", "min", "(", "DataVT", ".", "getVectorNumElements", "(", ")", ",", "IndexVT", ".", "getVectorNumElements", "(", ")", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVectorVT", "(", "DataVT", ".", "getVectorElementType", "(", ")", ",", "NumElts", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "break", ";", "}", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "X86", "X86", "ISD::INTRINSIC_W_CHAIN", "0", "0", "MVT::getVT", "1", "MVT::INVALID_SIMPLE_VALUE_TYPE", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::getVectorVT", "1", "MVT::getVT", "MVT::getVT", "2", "MVT::getVectorVT", "1", "MVT::getVT", "3", "MVT::getVT", "2", "MVT::getVectorVT", "1" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "(", "4", "-", "i", "-", "1", ")", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "PowerPC", "0", "4", "4", "1", "8", "0xff" ]

[]

[ "<s>", "static", "bool", "ia64_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", "&&", "(", "(", "mode1", "==", "XFmode", "||", "mode1", "==", "XCmode", "||", "mode1", "==", "RFmode", ")", "==", "(", "mode2", "==", "XFmode", "||", "mode2", "==", "XCmode", "||", "mode2", "==", "RFmode", ")", ")", "&&", "(", "mode1", "==", "BImode", ")", "==", "(", "mode2", "==", "BImode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", ".", "Do", "n't", "tie", "integer", "and", "FP", "modes", ",", "as", "that", "causes", "us", "to", "get", "integer", "registers", "allocated", "for", "FP", "instructions", ".", "XFmode", "only", "supported", "in", "FP", "registers", "so", "we", "ca", "n't", "tie", "it", "with", "any", "other", "modes", "." ]

[ "ia64" ]

[]

[ "<s>", "Candidate", "(", "MachineInstr", "*", "mi", ",", "unsigned", "reg", ",", "unsigned", "freebanks", ",", "unsigned", "weight", ")", ":", "MI", "(", "mi", ")", ",", "Reg", "(", "reg", ")", ",", "FreeBanks", "(", "freebanks", ")", ",", "Weight", "(", "weight", ")", "{", "}", "</s>" ]

[ "Describes", "the", "region", "of", "code", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "LowerAArch64MachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "SDNode", "*", "FISCDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\">>>>>> Selecting Node: \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "return", "SelectIndexedLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectIndexedStore", "(", "N", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "SelectFrameIndex", "(", "N", ")", ";", "case", "ISD", "::", "Constant", ":", "return", "ConstantToRegisterExpand", "(", "N", ",", "SDValue", "(", "N", ",", "0", ")", ")", ".", "getNode", "(", ")", ";", "case", "ISD", "::", "ADD", ":", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetGlobalAddress", ")", "return", "SelectTargetGlobalAddressforADD", "(", "N", ",", "N", "->", "getOperand", "(", "0", ")", ".", "getNode", "(", ")", ")", ";", "break", ";", "case", "FISCISD", "::", "CMP", ":", "return", "SelectCompare", "(", "N", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "SelectConditionalBranch", "(", "N", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "if", "(", "N", "->", "getOperand", "(", "2", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetGlobalAddress", ")", "{", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "N", "->", "getOperand", "(", "2", ")", ")", ";", "const", "GlobalValue", "*", "GV", "=", "GA", "->", "getGlobal", "(", ")", ";", "unsigned", "char", "TargetFlags", "=", "FISCII", "::", "MO_MOVRZ", ";", "if", "(", "GV", "->", "getValueID", "(", ")", "==", "Value", "::", "FunctionVal", ")", "TargetFlags", "=", "FISCII", "::", "MO_Q1", ";", "SDValue", "TargetGlobalAddr", "=", "CurDAG", "->", "getTargetGlobalAddress", "(", "GV", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i64", ",", "GA", "->", "getOffset", "(", ")", ",", "TargetFlags", ")", ";", "MachineSDNode", "*", "Move", "=", "CurDAG", "->", "getMachineNode", "(", "FISC", "::", "MOVRZ", ",", "N", ",", "MVT", "::", "i64", ",", "TargetGlobalAddr", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "N", ",", "MVT", "::", "i64", ")", ")", ";", "CurDAG", "->", "ReplaceAllUsesWith", "(", "N", "->", "getOperand", "(", "2", ")", ",", "SDValue", "(", "Move", ",", "0", ")", ")", ";", "}", "break", ";", "case", "FISCISD", "::", "CALL", ":", "{", "unsigned", "int", "operand2Opc", "=", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", ";", "if", "(", "operand2Opc", "==", "ISD", "::", "LOAD", "||", "operand2Opc", "==", "ISD", "::", "CopyFromReg", ")", "{", "return", "SelectCallFunctionPointer", "(", "N", ")", ";", "}", "break", ";", "}", "case", "ISD", "::", "SRL", ":", "return", "SelectShifts", "(", "N", ")", ";", "case", "ISD", "::", "MULHU", ":", "case", "ISD", "::", "MULHS", ":", "return", "SelectMUL", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "\">>>>>> Selecting Node: \"", "\"\\n\"", "ISD::LOAD", "ISD::STORE", "ISD::FrameIndex", "ISD::Constant", "0", "ISD::ADD", "0", "ISD::TargetGlobalAddress", "0", "FISCISD::CMP", "ISD::BR_CC", "ISD::CopyToReg", "2", "ISD::TargetGlobalAddress", "2", "FISCII::MO_MOVRZ", "FISCII::MO_Q1", "MVT::i64", "FISC::MOVRZ", "MVT::i64", "0", "MVT::i64", "2", "0", "FISCISD::CALL", "1", "ISD::LOAD", "ISD::CopyFromReg", "ISD::SRL", "ISD::MULHU", "ISD::MULHS" ]

[]

[ "<s>", "bool", "PIC16RegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "SP", "::", "I64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDXri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntPairRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "FPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "DFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "QFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDQFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::LDXri", "0", "SP::IntRegsRegClass", "SP::LDri", "0", "SP::IntPairRegClass", "SP::LDDri", "0", "SP::FPRegsRegClass", "SP::LDFri", "0", "SP::DFPRegsRegClass", "SP::LDDFri", "0", "SP::QFPRegsRegClass", "SP::LDQFri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "MachineInstr", "*", "SparcInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FI", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "unsigned", "OpNum", "=", "Ops", "[", "0", "]", ";", "bool", "isFloat", "=", "false", ";", "MachineInstr", "*", "NewMI", "=", "NULL", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "SP", "::", "ORrr", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "SP", "::", "G0", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "OpNum", "==", "0", ")", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ";", "else", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "SP", "::", "LDri", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "break", ";", "case", "SP", "::", "FMOVS", ":", "isFloat", "=", "true", ";", "case", "SP", "::", "FMOVD", ":", "if", "(", "OpNum", "==", "0", ")", "{", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isUndef", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "SP", "::", "STFri", ":", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ";", "}", "else", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isUndef", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "SP", "::", "LDFri", ":", "SP", "::", "LDDFri", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "isDead", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "break", ";", "}", "return", "NewMI", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Sparc", "Sparc", "1", "0", "SP::ORrr", "1", "1", "SP::G0", "0", "2", "0", "SP::STri", "0", "2", "SP::LDri", "0", "0", "SP::FMOVS", "SP::FMOVD", "0", "1", "1", "1", "SP::STFri", "SP::STDFri", "0", "0", "0", "0", "SP::LDFri", "SP::LDDFri", "0" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "MaxReach", "=", "(", "MFFrame", ".", "estimateStackSize", "(", "MF", ")", "+", "SystemZMC", "::", "CallFrameSize", "*", "2", ")", ";", "if", "(", "!", "isUInt", "<", "12", ">", "(", "MaxReach", ")", ")", "{", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "8", ",", "false", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "8", ",", "false", ")", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "SystemZ", "SystemZ", "SystemZMC::CallFrameSize", "2", "12", "8", "8", "8", "8" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "MachineInstr", "&", "LdSt", ",", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "LdSt", ".", "mayLoadOrStore", "(", ")", "&&", "\"Expected a memory operation.\"", ")", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", "{", "if", "(", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "||", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "}", "else", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "4", ")", "{", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "(", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "||", "!", "LdSt", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "}", "else", "return", "false", ";", "unsigned", "Scale", "=", "0", ";", "int64_t", "Dummy1", ",", "Dummy2", ";", "if", "(", "!", "getMemOpInfo", "(", "LdSt", ".", "getOpcode", "(", ")", ",", "Scale", ",", "Width", ",", "Dummy1", ",", "Dummy2", ")", ")", "return", "false", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", "{", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "1", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "*", "Scale", ";", "}", "else", "{", "assert", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "4", "&&", "\"invalid number of operands\"", ")", ";", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "2", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "*", "Scale", ";", "}", "assert", "(", "(", "BaseOp", "->", "isReg", "(", ")", "||", "BaseOp", "->", "isFI", "(", ")", ")", "&&", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register or frame index.\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "get", "the", "base", "operand", ",", "byte", "offset", "of", "an", "instruction", "and", "the", "memory", "width", "." ]

[ "AArch64", "AArch64", "\"Expected a memory operation.\"", "3", "1", "1", "2", "4", "1", "2", "2", "3", "0", "3", "1", "2", "4", "\"invalid number of operands\"", "2", "3", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register or frame index.\"" ]

[]

[ "<s>", "static", "bool", "xtensa_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_WINDOWED_ABI", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_OK_FOR_SIBCALL", "." ]

[ "xtensa" ]

[]

[ "<s>", "static", "void", "initialize_aarch64_code_model", "(", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "opts", "->", "x_flag_pic", ")", "{", "switch", "(", "opts", "->", "x_aarch64_cmodel_var", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "aarch64_cmodel", "=", "AARCH64_CMODEL_TINY_PIC", ";", "break", ";", "case", "AARCH64_CMODEL_SMALL", ":", "aarch64_cmodel", "=", "(", "flag_pic", "==", "2", "?", "AARCH64_CMODEL_SMALL_PIC", ":", "AARCH64_CMODEL_SMALL_SPIC", ")", ";", "aarch64_cmodel", "=", "AARCH64_CMODEL_SMALL_PIC", ";", "break", ";", "case", "AARCH64_CMODEL_LARGE", ":", "sorry", "(", "\"code model %qs with -f%s\"", ",", "\"large\"", ",", "opts", "->", "x_flag_pic", ">", "1", "?", "\"PIC\"", ":", "\"pic\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "aarch64_cmodel", "=", "opts", "->", "x_aarch64_cmodel_var", ";", "}", "</s>" ]

[ "A", "checking", "mechanism", "for", "the", "implementation", "of", "the", "various", "code", "models", "." ]

[ "aarch64", "2", "\"code model %qs with -f%s\"", "\"large\"", "1", "\"PIC\"", "\"pic\"" ]

[]

[ "<s>", "static", "rtx", "nios2_legitimize_constant_address", "(", "rtx", "addr", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "addr", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "nios2_tls_symbol_p", "(", "base", ")", ")", "base", "=", "nios2_legitimize_tls_address", "(", "base", ")", ";", "else", "if", "(", "flag_pic", ")", "base", "=", "nios2_load_pic_address", "(", "base", ",", "UNSPEC_PIC_SYM", ",", "NULL_RTX", ")", ";", "else", "return", "addr", ";", "if", "(", "offset", "!=", "const0_rtx", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "base", ")", ",", "(", "CONST_INT_P", "(", "offset", ")", "?", "(", "SMALL_INT", "(", "INTVAL", "(", "offset", ")", ")", "?", "offset", ":", "force_reg", "(", "Pmode", ",", "offset", ")", ")", ":", "offset", ")", ")", ";", "}", "return", "base", ";", "}", "</s>" ]

[ "Legitimize", "addresses", "that", "are", "CONSTANT_P", "expressions", "." ]

[ "nios2" ]

[]

[ "<s>", "bool", "ix86_macro_fusion_p", "(", ")", "{", "return", "TARGET_FUSE_CMP_AND_BRANCH", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "platform", "supports", "macro-fusion", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "riscv_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.option %spic\\n\"", ",", "(", "flag_pic", "?", "\"\"", ":", "\"no\"", ")", ")", ";", "if", "(", "!", "riscv_mrelax", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.option norelax\\n\"", ")", ";", "if", "(", "riscv_emit_attribute_p", ")", "riscv_emit_attribute", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", "." ]

[ "riscv", "\"\\t.option %spic\\n\"", "\"\"", "\"no\"", "\"\\t.option norelax\\n\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasHardClauses", "(", ")", ")", "return", "false", ";", "const", "SIInstrInfo", "*", "SII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "ClauseInfo", "CI", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "HardClauseType", "Type", "=", "getHardClauseType", "(", "MI", ")", ";", "int64_t", "Dummy1", ";", "bool", "Dummy2", ";", "unsigned", "Dummy3", ";", "SmallVector", "<", "const", "MachineOperand", "*", ",", "4", ">", "BaseOps", ";", "if", "(", "Type", "<=", "LAST_REAL_HARDCLAUSE_TYPE", ")", "{", "if", "(", "!", "SII", "->", "getMemOperandsWithOffsetWidth", "(", "MI", ",", "BaseOps", ",", "Dummy1", ",", "Dummy2", ",", "Dummy3", ",", "TRI", ")", ")", "{", "Type", "=", "HARDCLAUSE_ILLEGAL", ";", "}", "}", "if", "(", "CI", ".", "Length", "==", "64", "||", "(", "CI", ".", "Length", "&&", "Type", "!=", "HARDCLAUSE_INTERNAL", "&&", "Type", "!=", "HARDCLAUSE_IGNORE", "&&", "(", "Type", "!=", "CI", ".", "Type", "||", "!", "SII", "->", "shouldClusterMemOps", "(", "CI", ".", "BaseOps", ",", "BaseOps", ",", "2", ",", "2", ")", ")", ")", ")", "{", "Changed", "|=", "emitClause", "(", "CI", ",", "SII", ")", ";", "CI", "=", "ClauseInfo", "(", ")", ";", "}", "if", "(", "CI", ".", "Length", ")", "{", "if", "(", "Type", "!=", "HARDCLAUSE_IGNORE", ")", "{", "if", "(", "Type", "==", "HARDCLAUSE_INTERNAL", ")", "{", "++", "CI", ".", "TrailingInternalLength", ";", "}", "else", "{", "++", "CI", ".", "Length", ";", "CI", ".", "Length", "+=", "CI", ".", "TrailingInternalLength", ";", "CI", ".", "TrailingInternalLength", "=", "0", ";", "CI", ".", "Last", "=", "&", "MI", ";", "CI", ".", "BaseOps", "=", "std", "::", "move", "(", "BaseOps", ")", ";", "}", "}", "}", "else", "if", "(", "Type", "<=", "LAST_REAL_HARDCLAUSE_TYPE", ")", "{", "CI", "=", "ClauseInfo", "{", "Type", ",", "&", "MI", ",", "&", "MI", ",", "1", ",", "0", ",", "std", "::", "move", "(", "BaseOps", ")", "}", ";", "}", "}", "if", "(", "CI", ".", "Length", ")", "Changed", "|=", "emitClause", "(", "CI", ",", "SII", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "4", "SI", "64", "SI", "2", "2", "SI", "0", "1", "0", "SI" ]

[]

[ "<s>", "int", "is_function_label_plus_const", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "function_label_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "Pmode", ")", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "}", "</s>" ]

[ "Returns", "1", "if", "OP", "is", "a", "function", "label", "involved", "in", "a", "simple", "addition", "with", "a", "constant", ".", "Used", "to", "keep", "certain", "patterns", "from", "matching", "during", "instruction", "combination", "." ]

[ "pa", "0", "0", "1" ]

[]

[ "<s>", "bool", "Z80TargetLowering", "::", "isTypeDesirableForOp", "(", "unsigned", "Opc", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "is16Bit", "(", ")", ")", "return", "true", ";", "switch", "(", "Opc", ")", "{", "default", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "true", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "VT", "!=", "MVT", "::", "i16", ";", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "VT", "!=", "MVT", "::", "i24", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "for", "the", "given", "node", "type", "." ]

[ "Z80", "Z80", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::LOAD", "ISD::STORE", "ISD::ADD", "ISD::SUB", "MVT::i16", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SHL", "ISD::SRA", "ISD::SRL", "MVT::i24" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "inlineStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "PrologMBB", ")", "const", "{", "auto", "Where", "=", "llvm", "::", "find_if", "(", "PrologMBB", ",", "[", "]", "(", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "getOpcode", "(", ")", "==", "X86", "::", "STACKALLOC_W_PROBING", ";", "}", ")", ";", "if", "(", "Where", "!=", "PrologMBB", ".", "end", "(", ")", ")", "{", "DebugLoc", "DL", "=", "PrologMBB", ".", "findDebugLoc", "(", "Where", ")", ";", "emitStackProbeInline", "(", "MF", ",", "PrologMBB", ",", "Where", ",", "DL", ",", "true", ")", ";", "Where", "->", "eraseFromParent", "(", ")", ";", "}", "}", "</s>" ]

[ "Replace", "a", "StackProbe", "inline-stub", "with", "the", "actual", "probe", "code", "inline", "." ]

[ "X86", "X86", "X86::STACKALLOC_W_PROBING" ]

[]

[ "<s>", "int", "m32c_prepare_move", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "far_addr_space_p", "(", "operands", "[", "0", "]", ")", "&&", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ")", ";", "}", "if", "(", "TARGET_A16", "&&", "mode", "==", "PSImode", ")", "return", "m32c_split_move", "(", "operands", ",", "mode", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "rtx", "dest_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "dest_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "dest_reg", ",", "dest_mod", ")", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_MEM", "(", "mode", ",", "dest_reg", ")", ";", "}", "if", "(", "can_create_pseudo_p", "(", ")", "&&", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "operands", "[", "1", "]", "=", "copy_to_mode_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Used", "to", "emit", "move", "instructions", ".", "We", "split", "some", "moves", ",", "and", "avoid", "mem-mem", "moves", "." ]

[ "m32c", "0", "1", "1", "0", "1", "1", "0", "0", "0", "0", "0", "0", "1", "0", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "WebAssemblyFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "auto", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MFI", "->", "hasStackMap", "(", ")", "||", "MFI", "->", "hasPatchPoint", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_hard_regno_nregs", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "lowest_size", "=", "constant_lower_bound", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "switch", "(", "aarch64_regno_regclass", "(", "regno", ")", ")", "{", "case", "FP_REGS", ":", "case", "FP_LO_REGS", ":", "case", "FP_LO8_REGS", ":", "{", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "if", "(", "vec_flags", "&", "VEC_SVE_DATA", ")", "return", "exact_div", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "aarch64_vl_bytes", "(", "mode", ",", "vec_flags", ")", ")", ".", "to_constant", "(", ")", ";", "return", "CEIL", "(", "lowest_size", ",", "UNITS_PER_VREG", ")", ";", "}", "case", "PR_REGS", ":", "case", "PR_LO_REGS", ":", "case", "PR_HI_REGS", ":", "case", "FFR_REGS", ":", "case", "PR_AND_FFR_REGS", ":", "return", "1", ";", "default", ":", "return", "CEIL", "(", "lowest_size", ",", "UNITS_PER_WORD", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_NREGS", "." ]

[ "aarch64", "1" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ",", "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" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "SMRange", "Range", "=", "None", ")", "{", "return", "getParser", "(", ")", ".", "Error", "(", "L", ",", "Msg", ",", "Range", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "rtx_insn", "*", "frame_emit_load", "(", "int", "regno", ",", "rtx", "addr", ",", "rtx", "*", "cfa_restores", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ";", "if", "(", "cfa_restores", ")", "*", "cfa_restores", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "*", "cfa_restores", ")", ";", "return", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "load", "in", "the", "stack", "frame", "to", "load", "REGNO", "from", "address", "ADDR", ".", "Add", "a", "REG_CFA_RESTORE", "note", "to", "CFA_RESTORES", "if", "CFA_RESTORES", "is", "non-null", ".", "Return", "the", "emitted", "insn", "." ]

[ "tilepro" ]

[]

[ "<s>", "bool", "s390_contiguous_bitmask_p", "(", "unsigned", "HOST_WIDE_INT", "in", ",", "bool", "wrap_p", ",", "int", "size", ",", "int", "*", "start", ",", "int", "*", "end", ")", "{", "int", "bs", "=", "HOST_BITS_PER_WIDE_INT", ";", "bool", "b", ";", "gcc_assert", "(", "!", "!", "start", "==", "!", "!", "end", ")", ";", "if", "(", "(", "in", "&", "(", "(", "~", "HOST_WIDE_INT_0U", ")", ">>", "(", "bs", "-", "size", ")", ")", ")", "==", "0", ")", "return", "false", ";", "b", "=", "s390_contiguous_bitmask_nowrap_p", "(", "in", ",", "size", ",", "start", ",", "end", ")", ";", "if", "(", "b", ")", "return", "true", ";", "if", "(", "!", "wrap_p", ")", "return", "false", ";", "b", "=", "s390_contiguous_bitmask_nowrap_p", "(", "~", "in", ",", "size", ",", "start", ",", "end", ")", ";", "if", "(", "b", "&&", "start", ")", "{", "int", "s", "=", "*", "start", ";", "int", "e", "=", "*", "end", ";", "gcc_assert", "(", "s", ">=", "1", ")", ";", "*", "start", "=", "(", "(", "e", "+", "1", ")", "&", "(", "bs", "-", "1", ")", ")", ";", "*", "end", "=", "(", "(", "s", "-", "1", "+", "bs", ")", "&", "(", "bs", "-", "1", ")", ")", ";", "}", "return", "b", ";", "}", "</s>" ]

[ "Return", "true", "if", "IN", "contains", "a", "contiguous", "bitfield", "in", "the", "lower", "SIZE", "bits", "and", "no", "other", "bits", "are", "set", "in", "IN", ".", "POS", "and", "LENGTH", "can", "be", "used", "to", "obtain", "the", "start", "position", "and", "the", "length", "of", "the", "bitfield", ".", "POS", "gives", "the", "position", "of", "the", "first", "bit", "of", "the", "bitfield", "counting", "from", "the", "lowest", "order", "bit", "starting", "with", "zero", ".", "In", "order", "to", "use", "this", "value", "for", "S/390", "instructions", "this", "has", "to", "be", "converted", "to", "``", "bits", "big", "endian", "''", "style", "." ]

[ "s390", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "Lanai" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "assert", "(", "Expr", "&&", "\"Expr shouldn't be null!\"", ")", ";", "int64_t", "Imm", "=", "0", ";", "RISCVMCExpr", "::", "VariantKind", "VK", "=", "RISCVMCExpr", "::", "VK_RISCV_None", ";", "bool", "IsConstant", "=", "evaluateConstantImm", "(", "Expr", ",", "Imm", ",", "VK", ")", ";", "if", "(", "IsConstant", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "RI5CY", "\"Expr shouldn't be null!\"", "0", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "rtx", "nios2_split_large_constant_memory_operand", "(", "rtx", "op", ")", "{", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "nios2_large_constant_p", "(", "addr", ")", ")", "addr", "=", "nios2_split_large_constant", "(", "addr", ",", "gen_reg_rtx", "(", "Pmode", ")", ")", ";", "else", "if", "(", "nios2_plus_large_constant_p", "(", "addr", ")", ")", "addr", "=", "nios2_split_plus_large_constant", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "return", "replace_equiv_address", "(", "op", ",", "addr", ",", "false", ")", ";", "}", "</s>" ]

[ "Given", "a", "MEM", "OP", "with", "an", "address", "that", "includes", "a", "splittable", "symbol", "or", "other", "large", "constant", ",", "emit", "some", "instructions", "to", "do", "the", "split", "and", "return", "a", "new", "MEM", "." ]

[ "nios2", "0", "0", "1" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "X86" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "isIndirectJump", "(", "Inst", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxIndirectJump", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "unsigned", "AddrIdx", ";", "bool", "IsStore", ";", "bool", "IsMemAccess", "=", "isBasePlusOffsetMemoryAccess", "(", "Inst", ".", "getOpcode", "(", ")", ",", "&", "AddrIdx", ",", "&", "IsStore", ")", ";", "bool", "IsSPFirstOperand", "=", "isStackPointerFirstOperand", "(", "Inst", ")", ";", "if", "(", "IsMemAccess", "||", "IsSPFirstOperand", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "bool", "MaskBefore", "=", "(", "IsMemAccess", "&&", "baseRegNeedsLoadStoreMask", "(", "Inst", ".", "getOperand", "(", "AddrIdx", ")", ".", "getReg", "(", ")", ")", ")", ";", "bool", "MaskAfter", "=", "IsSPFirstOperand", "&&", "!", "IsStore", ";", "if", "(", "MaskBefore", "||", "MaskAfter", ")", "sandboxLoadStoreStackChange", "(", "Inst", ",", "AddrIdx", ",", "STI", ",", "MaskBefore", ",", "MaskAfter", ")", ";", "else", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "bool", "IsIndirectCall", ";", "if", "(", "isCall", "(", "Inst", ".", "getOpcode", "(", ")", ",", "&", "IsIndirectCall", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "EmitBundleLock", "(", "true", ")", ";", "if", "(", "IsIndirectCall", ")", "{", "unsigned", "TargetReg", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "emitMask", "(", "TargetReg", ",", "IndirectBranchMaskReg", ",", "STI", ")", ";", "}", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "PendingCall", "=", "true", ";", "return", ";", "}", "if", "(", "PendingCall", ")", "{", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "EmitBundleUnlock", "(", ")", ";", "PendingCall", "=", "false", ";", "return", ";", "}", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Mips", "\"Dangerous instruction in branch delay slot!\"", "\"Dangerous instruction in branch delay slot!\"", "Mips", "\"Dangerous instruction in branch delay slot!\"", "1", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "void", "MetadataStreamerV3", "::", "begin", "(", "const", "Module", "&", "Mod", ")", "{", "emitVersion", "(", ")", ";", "emitPrintf", "(", "Mod", ")", ";", "getRootMetadata", "(", "\"amdhsa.kernels\"", ")", ".", "reset", "(", "new", "msgpack", "::", "ArrayNode", "(", ")", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "AMDGPU", "\"amdhsa.kernels\"" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "zeroExtend", "(", "unsigned", "Reg", ",", "const", "Value", "*", "V", ",", "MVT", "::", "SimpleValueType", "From", ",", "MVT", "::", "SimpleValueType", "To", ")", "{", "if", "(", "To", "==", "MVT", "::", "i64", ")", "{", "if", "(", "From", "==", "MVT", "::", "i64", ")", "return", "copyValue", "(", "Reg", ")", ";", "Reg", "=", "zeroExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "unsigned", "Result", "=", "createResultReg", "(", "&", "WebAssembly", "::", "I64RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "WebAssembly", "::", "I64_EXTEND_U_I32", ")", ",", "Result", ")", ".", "addReg", "(", "Reg", ")", ";", "return", "Result", ";", "}", "if", "(", "To", "==", "MVT", "::", "i32", ")", "return", "zeroExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "a", "new", "range", "in", "the", "specified", "integer", "type", ",", "which", "must", "be", "strictly", "larger", "than", "the", "current", "type", "." ]

[ "WebAssembly", "WebAssembly", "MVT::SimpleValueType", "MVT::SimpleValueType", "MVT::i64", "MVT::i64", "WebAssembly::I64RegClass", "WebAssembly::I64_EXTEND_U_I32", "MVT::i32", "0" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isDarwin", "(", ")", ")", "return", "4", ";", "if", "(", "VectorType", "*", "VTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "Ty", ")", ")", "if", "(", "VTy", "->", "getBitWidth", "(", ")", ">=", "128", ")", "return", "16", ";", "if", "(", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "8", ";", "return", "4", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "PowerPC", "PPC", "PPC", "4", "128", "16", "PPC", "PPC", "8", "4" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_invalid_binary_op", "(", "int", "op", "ATTRIBUTE_UNUSED", ",", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "machine_mode", "mode1", "=", "TYPE_MODE", "(", "type1", ")", ";", "machine_mode", "mode2", "=", "TYPE_MODE", "(", "type2", ")", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode1", ")", ")", "mode1", "=", "GET_MODE_INNER", "(", "mode1", ")", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode2", ")", ")", "mode2", "=", "GET_MODE_INNER", "(", "mode2", ")", ";", "if", "(", "mode1", "==", "mode2", ")", "return", "NULL", ";", "if", "(", "!", "TARGET_FLOAT128_CVT", ")", "{", "if", "(", "(", "mode1", "==", "KFmode", "&&", "mode2", "==", "IFmode", ")", "||", "(", "mode1", "==", "IFmode", "&&", "mode2", "==", "KFmode", ")", ")", "return", "N_", "(", "\"__float128 and __ibm128 cannot be used in the same \"", "\"expression\"", ")", ";", "if", "(", "TARGET_IEEEQUAD", "&&", "(", "(", "mode1", "==", "IFmode", "&&", "mode2", "==", "TFmode", ")", "||", "(", "mode1", "==", "TFmode", "&&", "mode2", "==", "IFmode", ")", ")", ")", "return", "N_", "(", "\"__ibm128 and long double cannot be used in the same \"", "\"expression\"", ")", ";", "if", "(", "!", "TARGET_IEEEQUAD", "&&", "(", "(", "mode1", "==", "KFmode", "&&", "mode2", "==", "TFmode", ")", "||", "(", "mode1", "==", "TFmode", "&&", "mode2", "==", "KFmode", ")", ")", ")", "return", "N_", "(", "\"__float128 and long double cannot be used in the same \"", "\"expression\"", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "the", "diagnostic", "message", "string", "if", "the", "binary", "operation", "OP", "is", "not", "permitted", "on", "TYPE1", "and", "TYPE2", ",", "NULL", "otherwise", "." ]

[ "powerpcspe", "\"__float128 and __ibm128 cannot be used in the same \"", "\"expression\"", "\"__ibm128 and long double cannot be used in the same \"", "\"expression\"", "\"__float128 and long double cannot be used in the same \"", "\"expression\"" ]

[]

[ "<s>", "void", "mt_override_options", "(", "void", ")", "{", "if", "(", "mt_cpu_string", "!=", "NULL", ")", "{", "if", "(", "!", "strcmp", "(", "mt_cpu_string", ",", "\"ms1-64-001\"", ")", ")", "mt_cpu", "=", "PROCESSOR_MS1_64_001", ";", "else", "if", "(", "!", "strcmp", "(", "mt_cpu_string", ",", "\"ms1-16-002\"", ")", ")", "mt_cpu", "=", "PROCESSOR_MS1_16_002", ";", "else", "if", "(", "!", "strcmp", "(", "mt_cpu_string", ",", "\"ms1-16-003\"", ")", ")", "mt_cpu", "=", "PROCESSOR_MS1_16_003", ";", "else", "if", "(", "!", "strcmp", "(", "mt_cpu_string", ",", "\"ms2\"", ")", ")", "mt_cpu", "=", "PROCESSOR_MS2", ";", "else", "error", "(", "\"bad value (%s) for -march= switch\"", ",", "mt_cpu_string", ")", ";", "}", "else", "mt_cpu", "=", "PROCESSOR_MS1_64_001", ";", "if", "(", "flag_exceptions", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "flag_gcse", "=", "0", ";", "}", "mt_flag_delayed_branch", "=", "flag_delayed_branch", ";", "flag_delayed_branch", "=", "0", ";", "init_machine_status", "=", "mt_init_machine_status", ";", "}", "</s>" ]

[ "Implement", "OVERRIDE_OPTIONS", "." ]

[ "mt", "\"ms1-64-001\"", "\"ms1-16-002\"", "\"ms1-16-003\"", "\"ms2\"", "\"bad value (%s) for -march= switch\"", "0", "0", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "AArch64_MachoTargetObjectFile", "::", "getIndirectSymViaGOTPCRel", "(", "const", "MCSymbol", "*", "Sym", ",", "const", "MCValue", "&", "MV", ",", "int64_t", "Offset", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "assert", "(", "(", "Offset", "+", "MV", ".", "getConstant", "(", ")", "==", "0", ")", "&&", "\"Arch64 does not support GOT PC rel with extra offset\"", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOT", ",", "getContext", "(", ")", ")", ";", "MCSymbol", "*", "PCSym", "=", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "Streamer", ".", "EmitLabel", "(", "PCSym", ")", ";", "const", "MCExpr", "*", "PC", "=", "MCSymbolRefExpr", "::", "create", "(", "PCSym", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createSub", "(", "Res", ",", "PC", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "Get", "the", "target", "specific", "PC", "relative", "GOT", "entry", "relocation", "." ]

[ "AArch64", "AArch64", "0", "\"Arch64 does not support GOT PC rel with extra offset\"" ]

[]

[ "<s>", "int", "mmix_shiftable_wyde_value", "(", "uint64_t", "value", ")", "{", "int", "i", ";", "int", "has_candidate", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "if", "(", "value", "&", "65535", ")", "{", "if", "(", "has_candidate", ")", "return", "0", ";", "else", "has_candidate", "=", "1", ";", "}", "value", ">>=", "16", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "value", "is", "0", "..", "65535", "*", "2", "*", "*", "(", "16", "*", "N", ")", "for", "N=0", "..", "3.", "else", "return", "0", "." ]

[ "mmix", "0", "0", "4", "65535", "0", "1", "16", "1" ]

[]

[ "<s>", "static", "rtx", "force_offsettable", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "size", ",", "bool", "reuse", ")", "{", "rtx", "base", "=", "addr", ";", "rtx", "offs", "=", "const0_rtx", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "offs", "=", "XEXP", "(", "base", ",", "1", ")", ";", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "}", "if", "(", "!", "REG_P", "(", "base", ")", "||", "(", "REGNO", "(", "base", ")", "!=", "STACK_POINTER_REGNUM", "&&", "REGNO_PTR_FRAME_P", "(", "REGNO", "(", "addr", ")", ")", ")", "||", "!", "CONST_INT_P", "(", "offs", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", "+", "size", ")", ")", "{", "if", "(", "reuse", ")", "emit_insn", "(", "gen_add2_insn", "(", "addr", ",", "offs", ")", ")", ";", "else", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "addr", ")", ";", "}", "return", "addr", ";", "}", "</s>" ]

[ "Helper", "function", "of", "arc_expand_movmem", ".", "ADDR", "points", "to", "a", "chunk", "of", "memory", ".", "Emit", "code", "and", "return", "an", "potentially", "modified", "address", "such", "that", "offsets", "up", "to", "SIZE", "are", "can", "be", "added", "to", "yield", "a", "legitimate", "address", ".", "if", "REUSE", "is", "set", ",", "ADDR", "is", "a", "register", "that", "may", "be", "modified", "." ]

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

[]

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

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

[ "TOY", "TOY" ]

[]

[ "<s>", "void", "s390_expand_plus_operand", "(", "rtx", "target", ",", "rtx", "src", ",", "rtx", "scratch", ")", "{", "rtx", "sum1", ",", "sum2", ";", "struct", "s390_address", "ad", ";", "gcc_assert", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "src", ")", "==", "Pmode", ")", ";", "sum1", "=", "find_replacement", "(", "&", "XEXP", "(", "src", ",", "0", ")", ")", ";", "sum2", "=", "find_replacement", "(", "&", "XEXP", "(", "src", ",", "1", ")", ")", ";", "src", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "sum1", ",", "sum2", ")", ";", "if", "(", "!", "s390_decompose_address", "(", "src", ",", "&", "ad", ")", "||", "(", "ad", ".", "base", "&&", "!", "REG_OK_FOR_BASE_STRICT_P", "(", "ad", ".", "base", ")", ")", "||", "(", "ad", ".", "indx", "&&", "!", "REG_OK_FOR_INDEX_STRICT_P", "(", "ad", ".", "indx", ")", ")", ")", "{", "if", "(", "true_regnum", "(", "sum1", ")", "<", "1", "||", "true_regnum", "(", "sum1", ")", ">", "15", ")", "{", "emit_move_insn", "(", "scratch", ",", "sum1", ")", ";", "sum1", "=", "scratch", ";", "}", "if", "(", "true_regnum", "(", "sum2", ")", "<", "1", "||", "true_regnum", "(", "sum2", ")", ">", "15", ")", "{", "emit_move_insn", "(", "scratch", ",", "sum2", ")", ";", "sum2", "=", "scratch", ";", "}", "if", "(", "sum1", "==", "scratch", "&&", "sum2", "==", "scratch", ")", "{", "debug_rtx", "(", "src", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "src", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "sum1", ",", "sum2", ")", ";", "}", "s390_load_address", "(", "target", ",", "src", ")", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "SRC", ",", "which", "is", "PLUS", "that", "is", "not", "a", "legitimate", "operand", "for", "the", "LA", "instruction", ",", "into", "TARGET", ".", "SCRATCH", "may", "be", "used", "as", "scratch", "register", "." ]

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

[]