Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "supportSplitCSR", "(", "MachineFunction", "*", "MF", ")", "const", "override", "{", "return", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "that", "a", "subset", "of", "CSRs", "for", "the", "given", "machine", "function", "is", "handled", "explicitly", "via", "copies", "." ]

[ "X86" ]

[]

[ "<s>", "static", "bool", "aarch64_modifies_global_state_p", "(", "aarch64_simd_builtin_datum", "*", "d", ")", "{", "unsigned", "int", "flags", "=", "aarch64_call_properties", "(", "d", ")", ";", "if", "(", "flags", "&", "FLAG_RAISE_FP_EXCEPTIONS", ")", "return", "true", ";", "if", "(", "flags", "&", "FLAG_PREFETCH_MEMORY", ")", "return", "true", ";", "return", "flags", "&", "FLAG_WRITE_MEMORY", ";", "}", "</s>" ]

[ "Return", "true", "if", "calls", "to", "the", "function", "could", "modify", "some", "form", "of", "global", "state", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "handleD16VData", "(", "SDValue", "VData", ",", "SelectionDAG", "&", "DAG", ",", "bool", "ImageStore", ")", "const", "{", "EVT", "StoreVT", "=", "VData", ".", "getValueType", "(", ")", ";", "if", "(", "!", "StoreVT", ".", "isVector", "(", ")", ")", "return", "VData", ";", "SDLoc", "DL", "(", "VData", ")", ";", "unsigned", "NumElements", "=", "StoreVT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "Subtarget", "->", "hasUnpackedD16VMem", "(", ")", ")", "{", "EVT", "IntStoreVT", "=", "StoreVT", ".", "changeTypeToInteger", "(", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "EquivStoreVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i32", ",", "NumElements", ")", ";", "SDValue", "ZExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "EquivStoreVT", ",", "IntVData", ")", ";", "return", "DAG", ".", "UnrollVectorOp", "(", "ZExt", ".", "getNode", "(", ")", ")", ";", "}", "else", "if", "(", "NumElements", "==", "3", ")", "{", "EVT", "IntStoreVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StoreVT", ".", "getStoreSizeInBits", "(", ")", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "WidenedStoreVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StoreVT", ".", "getVectorElementType", "(", ")", ",", "NumElements", "+", "1", ")", ";", "EVT", "WidenedIntVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WidenedStoreVT", ".", "getStoreSizeInBits", "(", ")", ")", ";", "SDValue", "ZExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "WidenedIntVT", ",", "IntVData", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "WidenedStoreVT", ",", "ZExt", ")", ";", "}", "if", "(", "ImageStore", "&&", "Subtarget", "->", "hasImageStoreD16Bug", "(", ")", ")", "{", "EVT", "IntStoreVT", "=", "StoreVT", ".", "changeTypeToInteger", "(", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "Elts", ";", "DAG", ".", "ExtractVectorElements", "(", "IntVData", ",", "Elts", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "PackedElts", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "Elts", ".", "size", "(", ")", "/", "2", ";", "I", "+=", "1", ")", "{", "SDValue", "Pair", "=", "DAG", ".", "getBuildVector", "(", "MVT", "::", "v2i16", ",", "DL", ",", "{", "Elts", "[", "I", "*", "2", "]", ",", "Elts", "[", "I", "*", "2", "+", "1", "]", "}", ")", ";", "SDValue", "IntPair", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i32", ",", "Pair", ")", ";", "PackedElts", ".", "push_back", "(", "IntPair", ")", ";", "}", "PackedElts", ".", "resize", "(", "PackedElts", ".", "size", "(", ")", "*", "2", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ")", ";", "EVT", "VecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i32", ",", "PackedElts", ".", "size", "(", ")", ")", ";", "return", "DAG", ".", "getBuildVector", "(", "VecVT", ",", "DL", ",", "PackedElts", ")", ";", "}", "assert", "(", "isTypeLegal", "(", "StoreVT", ")", ")", ";", "return", "VData", ";", "}", "</s>" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "AMDGPU", "SI", "ISD::BITCAST", "MVT::i32", "ISD::ZERO_EXTEND", "3", "ISD::BITCAST", "1", "ISD::ZERO_EXTEND", "ISD::BITCAST", "ISD::BITCAST", "4", "4", "0", "2", "1", "MVT::v2i16", "2", "2", "1", "ISD::BITCAST", "MVT::i32", "2", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "void", "PPCELFStreamer", "::", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "PPCMCCodeEmitter", "*", "Emitter", "=", "static_cast", "<", "PPCMCCodeEmitter", "*", ">", "(", "getAssembler", "(", ")", ".", "getEmitterPtr", "(", ")", ")", ";", "if", "(", "!", "Emitter", "->", "isPrefixedInstruction", "(", "Inst", ")", ")", "{", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "emitPrefixedInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "void", "rl78_start_function", "(", "FILE", "*", "file", ")", "{", "int", "i", ";", "add_vector_labels", "(", "file", ",", "\"interrupt\"", ")", ";", "add_vector_labels", "(", "file", ",", "\"vector\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize", "==", "0", ")", "return", ";", "fprintf", "(", "file", ",", "\"\\t; start of function\\n\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_regs", ")", "{", "fprintf", "(", "file", ",", "\"\\t; push %d:\"", ",", "cfun", "->", "machine", "->", "framesize_regs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "cfun", "->", "machine", "->", "need_to_push", "[", "i", "]", ")", "fprintf", "(", "file", ",", "\" %s\"", ",", "word_regnames", "[", "i", "*", "2", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "fprintf", "(", "file", ",", "\"\\t; $fp points here (r22)\\n\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_locals", ")", "fprintf", "(", "file", ",", "\"\\t; locals: %d byte%s\\n\"", ",", "cfun", "->", "machine", "->", "framesize_locals", ",", "cfun", "->", "machine", "->", "framesize_locals", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "framesize_outgoing", ")", "fprintf", "(", "file", ",", "\"\\t; outgoing: %d byte%s\\n\"", ",", "cfun", "->", "machine", "->", "framesize_outgoing", ",", "cfun", "->", "machine", "->", "framesize_outgoing", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "uses_es", ")", "fprintf", "(", "file", ",", "\"\\t; uses ES register\\n\"", ")", ";", "if", "(", "MUST_SAVE_MDUC_REGISTERS", ")", "fprintf", "(", "file", ",", "\"\\t; preserves MDUC registers\\n\"", ")", ";", "}", "</s>" ]

[ "We", "do", "n't", "use", "this", "to", "actually", "emit", "the", "function", "prologue", ".", "We", "use", "this", "to", "insert", "a", "comment", "in", "the", "asm", "file", "describing", "the", "function", "." ]

[ "rl78", "\"interrupt\"", "\"vector\"", "0", "\"\\t; start of function\\n\"", "\"\\t; push %d:\"", "0", "16", "\" %s\"", "2", "\"\\n\"", "\"\\t; $fp points here (r22)\\n\"", "\"\\t; locals: %d byte%s\\n\"", "1", "\"\"", "\"s\"", "\"\\t; outgoing: %d byte%s\\n\"", "1", "\"\"", "\"s\"", "\"\\t; uses ES register\\n\"", "\"\\t; preserves MDUC registers\\n\"" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".option\"", ")", "return", "parseDirectiveOption", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".attribute\"", ")", "return", "parseDirectiveAttribute", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "\".option\"", "\".attribute\"" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", "->", "getFeatureBits", "(", ")", ";", "bool", "MatchExact", "=", "(", "CallerBits", "&", "~", "InlineFeatureWhitelist", ")", "==", "(", "CalleeBits", "&", "~", "InlineFeatureWhitelist", ")", ";", "bool", "MatchSubset", "=", "(", "(", "CallerBits", "&", "CalleeBits", ")", "&", "InlineFeatureWhitelist", ")", "==", "(", "CalleeBits", "&", "InlineFeatureWhitelist", ")", ";", "return", "MatchExact", "&&", "MatchSubset", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "LHSTy", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "GBZ80", "MVT::i8" ]

[]

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

[ "Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "." ]

[ "PowerPC" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", "PreferFalse", ")", "const", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MOVCCr", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2MOVCCr", ")", "&&", "\"Unknown select instruction\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "2", ":", "1", ")", ";", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "PreviousClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "PreviousClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "addOperand", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "ARMCC", "::", "CondCodes", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "4", ")", ")", ";", "if", "(", "NewMI", "->", "hasOptionalDef", "(", ")", ")", "AddDefaultCC", "(", "NewMI", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "addOperand", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "0", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "if", "(", "DefMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", ")", "NewMI", "->", "clearKillInfo", "(", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}", "</s>" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ "ARM", "ARM", "ARM::MOVCCr", "ARM::t2MOVCCr", "\"Unknown select instruction\"", "2", "1", "2", "1", "0", "1", "3", "ARMCC::getOppositeCondition", "ARMCC::CondCodes", "4", "0", "1" ]

[]

[ "<s>", "static", "void", "ia64_soft_fp_init_libfuncs", "(", "void", ")", "{", "}", "</s>" ]

[ "Use", "soft-fp", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "bool", "tilegx_expand_const_muldi", "(", "rtx", "op0", ",", "rtx", "op1", ",", "long", "long", "multiplier", ")", "{", "const", "struct", "tilegx_multiply_insn_seq", "*", "seq", "=", "tilegx_find_multiply_insn_seq_for_constant", "(", "multiplier", ")", ";", "if", "(", "seq", "!=", "NULL", ")", "{", "tilegx_expand_constant_multiply_given_sequence", "(", "op0", ",", "op1", ",", "seq", ")", ";", "return", "true", ";", "}", "else", "return", "false", ";", "}", "</s>" ]

[ "Try", "to", "a", "expand", "constant", "multiply", "in", "DImode", "by", "looking", "it", "up", "in", "a", "precompiled", "table", ".", "OP0", "is", "the", "result", "operand", ",", "OP1", "is", "the", "source", "operand", ",", "and", "MULTIPLIER", "is", "the", "value", "of", "the", "constant", ".", "Return", "true", "if", "it", "succeeds", "." ]

[ "tilegx" ]

[]

[ "<s>", "const", "MCSection", "*", "MipsTargetObjectFile", "::", "getSectionForConstant", "(", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ")", "const", "{", "if", "(", "IsConstantInSmallSection", "(", "C", ",", "*", "TM", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "Kind", ",", "C", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "SP", "::", "IntRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "FPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "DFPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::IntRegsRegisterClass", "SP::STri", "0", "SP::FPRegsRegisterClass", "SP::STFri", "0", "SP::DFPRegsRegisterClass", "SP::STDFri", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "bool", "NVPTXPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "auto", "BlockIter", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "BlockIter", "!=", "MBB", ".", "end", "(", ")", ")", "{", "auto", "&", "MI", "=", "*", "BlockIter", "++", ";", "if", "(", "isCVTAToLocalCombinationCandidate", "(", "MI", ")", ")", "{", "CombineCVTAToLocal", "(", "MI", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "const", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "NVPTX", "::", "VRFrame", ")", ")", "{", "if", "(", "auto", "MI", "=", "MRI", ".", "getUniqueVRegDef", "(", "NVPTX", "::", "VRFrame", ")", ")", "{", "MI", "->", "eraseFromParentAndMarkDBGValuesForRemoval", "(", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX::VRFrame", "NVPTX::VRFrame" ]

[]

[ "<s>", "bool", "SIFixVGPRCopies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "COPY", ":", "if", "(", "TII", "->", "isVGPRCopy", "(", "MI", ")", "&&", "!", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "{", "MI", ".", "addOperand", "(", "MF", ",", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "EXEC", ",", "false", ",", "true", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Add exec use to \"", "<<", "MI", ")", ";", "Changed", "=", "true", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::COPY", "AMDGPU::EXEC", "AMDGPU::EXEC", "\"Add exec use to \"" ]

[]

[ "<s>", "static", "rtx", "tilegx_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "byte_size", "=", "(", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "bool", "doubleword_aligned_p", ";", "if", "(", "cum", ">=", "TILEGX_NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "doubleword_aligned_p", "=", "tilegx_function_arg_boundary", "(", "mode", ",", "type", ")", ">", "BITS_PER_WORD", ";", "if", "(", "doubleword_aligned_p", ")", "cum", "+=", "cum", "&", "1", ";", "if", "(", "(", "cum", "+", "(", "byte_size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ">", "TILEGX_NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "mode", ",", "cum", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "tilegx", "1", "1" ]

[]

[ "<s>", "unsigned", "PTXTargetLowering", "::", "getNumRegisters", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "{", "return", "1", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "registers", "that", "this", "ValueType", "will", "eventually", "require", "." ]

[ "PTX", "PTX", "1" ]

[]

[ "<s>", "bool", "RISCVAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'z'", ":", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "OS", "<<", "RISCVInstPrinter", "::", "getRegisterName", "(", "RISCV", "::", "X0", ")", ";", "return", "false", ";", "}", "break", ";", "case", "'i'", ":", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "OS", "<<", "'i'", ";", "return", "false", ";", "}", "}", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "OS", "<<", "RISCVInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "MCSymbol", "*", "Sym", "=", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "Sym", "->", "print", "(", "OS", ",", "MAI", ")", ";", "return", "false", ";", "}", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "RISCV", "RISCV", "0", "1", "0", "0", "0", "RISCV", "RISCV::X0", "RISCV" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ForCodeSize", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", "||", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MBBInfo", "::", "isVisited", "(", ")", "const", "{", "return", "HTScope", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "node", "been", "visited", "by", "the", "DFS", "traversal", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "void", "loongarch_save_reg", "(", "rtx", "reg", ",", "rtx", "mem", ")", "{", "loongarch_emit_move", "(", "mem", ",", "reg", ")", ";", "loongarch_set_frame_expr", "(", "loongarch_frame_set", "(", "mem", ",", "reg", ")", ")", ";", "}", "</s>" ]

[ "Save", "register", "REG", "to", "MEM", ".", "Make", "the", "instruction", "frame-related", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "isIntDivCheap", "(", "EVT", "VT", ",", "AttributeList", "Attr", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "VE" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForStrcpy", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dest", ",", "SDValue", "Src", ",", "MachinePointerInfo", "DestPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ",", "bool", "isStpcpy", ")", "const", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Dest", ".", "getValueType", "(", ")", ",", "MVT", "::", "Other", ")", ";", "SDValue", "EndDest", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "STPCPY", ",", "DL", ",", "VTs", ",", "Chain", ",", "Dest", ",", "Src", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "return", "std", "::", "make_pair", "(", "isStpcpy", "?", "EndDest", ":", "Dest", ",", "EndDest", ".", "getValue", "(", "1", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "MVT::Other", "SystemZISD::STPCPY", "0", "MVT::i32", "1" ]

[]

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

[ "True", "if", "subtarget", "inserts", "the", "final", "scheduling", "pass", "on", "its", "own", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "void", "alpha_extract_integer", "(", "rtx", "x", ",", "HOST_WIDE_INT", "*", "p0", ",", "HOST_WIDE_INT", "*", "p1", ")", "{", "HOST_WIDE_INT", "i0", ",", "i1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "x", "=", "simplify_subreg", "(", "DImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "i0", "=", "INTVAL", "(", "x", ")", ";", "i1", "=", "-", "(", "i0", "<", "0", ")", ";", "}", "else", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", ")", "{", "i0", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "i1", "=", "-", "(", "i0", "<", "0", ")", ";", "}", "else", "{", "i0", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "i1", "=", "CONST_DOUBLE_HIGH", "(", "x", ")", ";", "}", "*", "p0", "=", "i0", ";", "*", "p1", "=", "i1", ";", "}", "</s>" ]

[ "Given", "an", "integral", "CONST_INT", ",", "CONST_DOUBLE", ",", "or", "CONST_VECTOR", ",", "return", "the", "low", "64", "bits", "." ]

[ "alpha", "0", "0", "64", "0" ]

[]

[ "<s>", "InstructionCost", "HexagonTTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "DataTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", ")", "{", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "DataTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "CostKind", ",", "I", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "0", "0" ]

[]

[ "<s>", "void", "fr30_setup_incoming_varargs", "(", "cumulative_args_t", "arg_regs_used_so_far_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "arg_regs_used_so_far", "=", "get_cumulative_args", "(", "arg_regs_used_so_far_v", ")", ";", "int", "size", ";", "gcc_assert", "(", "arg", ".", "mode", "!=", "BLKmode", ")", ";", "if", "(", "targetm", ".", "calls", ".", "strict_argument_naming", "(", "arg_regs_used_so_far_v", ")", ")", "arg_regs_used_so_far", "+=", "fr30_num_arg_regs", "(", "arg", ")", ";", "size", "=", "FR30_NUM_ARG_REGS", "-", "(", "*", "arg_regs_used_so_far", ")", ";", "if", "(", "size", "<=", "0", ")", "return", ";", "*", "pretend_size", "=", "(", "size", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "We", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", ",", "plus", "the", "last", "named", "argument", ",", "from", "registers", "into", "memory", ".", "*", "copying", "actually", "done", "in", "fr30_expand_prologue", "(", ")", ".", "ARG_REGS_USED_SO_FAR", "has", "*", "not", "*", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "." ]

[ "fr30", "0" ]

[]

[ "<s>", "virtual", "bool", "isReg", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "Kind", "==", "KindReg", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "Videocore" ]

[]

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

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

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

[]

[ "<s>", "static", "tree", "nvptx_goacc_adjust_private_decl", "(", "location_t", "loc", ",", "tree", "decl", ",", "int", "level", ")", "{", "gcc_checking_assert", "(", "!", "lookup_attribute", "(", "\"oacc gang-private\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", ";", "if", "(", "level", "==", "GOMP_DIM_GANG", ")", "{", "tree", "id", "=", "get_identifier", "(", "\"oacc gang-private\"", ")", ";", "tree", "loc_tree", "=", "build_empty_stmt", "(", "loc", ")", ";", "DECL_ATTRIBUTES", "(", "decl", ")", "=", "tree_cons", "(", "id", ",", "loc_tree", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "}", "return", "decl", ";", "}", "</s>" ]

[ "Implement", "TARGET_GOACC_ADJUST_PRIVATE_DECL", "." ]

[ "nvptx", "\"oacc gang-private\"", "\"oacc gang-private\"" ]

[]

[ "<s>", "void", "XtensaFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "{", "return", ";", "}", "llvm_unreachable", "(", "\"Couldn't reach here\"", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"Couldn't reach here\"" ]

[]

[ "<s>", "bool", "Z80CallFrameOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", "||", "NoZ80CFOpt", ".", "getValue", "(", ")", ")", "return", "false", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::SELECT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR" ]

[]

[ "<s>", "uint32_t", "find", "(", "T", "Val", ")", "const", "{", "auto", "F", "=", "llvm", "::", "find", "(", "Map", ",", "Val", ")", ";", "assert", "(", "F", "!=", "Map", ".", "end", "(", ")", ")", ";", "return", "F", "-", "Map", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Search", "for", "the", "first", "string", "Str", "in", "the", "string", "." ]

[ "Hexagon" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "ARMBaseInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "MultiHazardRecognizer", "*", "MHR", "=", "new", "MultiHazardRecognizer", "(", ")", ";", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", "||", "Subtarget", ".", "hasVFP2Base", "(", ")", ")", "MHR", "->", "AddHazardRecognizer", "(", "std", "::", "make_unique", "<", "ARMHazardRecognizerFPMLx", ">", "(", ")", ")", ";", "auto", "BHR", "=", "TargetInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "if", "(", "BHR", ")", "MHR", "->", "AddHazardRecognizer", "(", "std", "::", "unique_ptr", "<", "ScheduleHazardRecognizer", ">", "(", "BHR", ")", ")", ";", "return", "MHR", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

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

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "unsigned", "Directive", "=", "Subtarget", ".", "getDarwinDirective", "(", ")", ";", "unsigned", "Opcode", ";", "switch", "(", "Directive", ")", "{", "default", ":", "Opcode", "=", "PPC", "::", "NOP", ";", "break", ";", "case", "PPC", "::", "DIR_PWR6", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR6", ";", "break", ";", "case", "PPC", "::", "DIR_PWR7", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "case", "PPC", "::", "DIR_PWR8", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "}", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "PowerPC", "PPC", "PPC::NOP", "PPC::DIR_PWR6", "PPC::NOP_GT_PWR6", "PPC::DIR_PWR7", "PPC::NOP_GT_PWR7", "PPC::DIR_PWR8", "PPC::NOP_GT_PWR7" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "UP", ".", "UpperBound", "=", "true", ";", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "if", "(", "getBooleanLoopAttribute", "(", "L", ",", "\"llvm.loop.isvectorized\"", ")", ")", "return", ";", "InstructionCost", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "operand_values", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ",", "TargetTransformInfo", "::", "TCK_SizeAndLatency", ")", ";", "}", "}", "unsigned", "UnrollCount", "=", "4", ";", "if", "(", "ST", "->", "isThumb1Only", "(", ")", ")", "{", "unsigned", "ExitingValues", "=", "0", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitBlocks", ";", "L", "->", "getExitBlocks", "(", "ExitBlocks", ")", ";", "for", "(", "auto", "*", "Exit", ":", "ExitBlocks", ")", "{", "unsigned", "LiveOuts", "=", "count_if", "(", "Exit", "->", "phis", "(", ")", ",", "[", "]", "(", "auto", "&", "PH", ")", "{", "return", "PH", ".", "getNumOperands", "(", ")", "!=", "1", "||", "!", "isa", "<", "GetElementPtrInst", ">", "(", "PH", ".", "getOperand", "(", "0", ")", ")", ";", "}", ")", ";", "ExitingValues", "=", "ExitingValues", "<", "LiveOuts", "?", "LiveOuts", ":", "ExitingValues", ";", "}", "if", "(", "ExitingValues", ")", "UnrollCount", "/=", "ExitingValues", ";", "if", "(", "UnrollCount", "<=", "1", ")", "return", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Default Runtime Unroll Count: \"", "<<", "UnrollCount", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "UnrollCount", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "\"llvm.loop.isvectorized\"", "0", "4", "4", "0", "4", "1", "0", "1", "\"Cost of loop: \"", "\"\\n\"", "\"Default Runtime Unroll Count: \"", "\"\\n\"", "60", "12" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "useSoftFloat", "(", ")", "||", "!", "Subtarget", "->", "hasVFP2", "(", ")", ")", "return", "false", ";", "auto", "&", "Args", "=", "F", ".", "getArgumentList", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "1", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "ArgInfos", ",", "DL", ",", "MF", ".", "getRegInfo", "(", ")", ")", ";", "Idx", "++", ";", "}", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "return", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "8", "0", "1" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "STRrs", ":", "case", "ARM", "::", "t2STRs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "VSTRS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VST1q64", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VSTMQIA", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::STRrs", "ARM::t2STRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::STRi12", "ARM::t2STRi12", "ARM::tSTRspi", "ARM::VSTRD", "ARM::VSTRS", "1", "2", "2", "0", "1", "0", "ARM::VST1q64", "0", "2", "0", "0", "2", "ARM::VSTMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "tilegx_expand_to_rtl_hook", "(", "void", ")", "{", "crtl", "->", "uses_pic_offset_table", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_TO_RTL_HOOK", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "void", "setFunction", "(", "Function", "&", "F", ")", "{", "Func", "=", "&", "F", ";", "}", "</s>" ]

[ "Initialize", "data", "structures", "for", "specified", "new", "function", "." ]

[ "JVM" ]

[]

[ "<s>", "SDNode", "*", "X86DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "mayStore", "(", ")", "const", "{", "return", "Store", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "could", "possibly", "modify", "memory", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "rtx", "nds32_expand_unopimm_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ",", "bool", "return_p", ",", "const", "char", "*", "name", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "nds32_read_argument", "(", "exp", ",", "0", ")", ";", "int", "op0_num", "=", "return_p", "?", "1", ":", "0", ";", "if", "(", "return_p", ")", "target", "=", "nds32_legitimize_target", "(", "icode", ",", "target", ")", ";", "if", "(", "!", "nds32_check_constant_argument", "(", "icode", ",", "op0_num", ",", "op0", ",", "name", ")", ")", "return", "NULL_RTX", ";", "op0", "=", "nds32_legitimize_argument", "(", "icode", ",", "op0_num", ",", "op0", ")", ";", "if", "(", "return_p", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "one", "operands", "and", "the", "first", "is", "immediate", "." ]

[ "nds32", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "emit_move_after_reload", "(", "rtx", "to", ",", "rtx", "from", ",", "rtx", "scratch", ")", "{", "rtx", "insn", ";", "if", "(", "TARGET_M6812", "||", "H_REG_P", "(", "to", ")", "||", "H_REG_P", "(", "from", ")", ")", "{", "insn", "=", "emit_move_insn", "(", "to", ",", "from", ")", ";", "}", "else", "{", "emit_move_insn", "(", "scratch", ",", "from", ")", ";", "insn", "=", "emit_move_insn", "(", "to", ",", "scratch", ")", ";", "}", "if", "(", "IS_STACK_PUSH", "(", "to", ")", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "XEXP", "(", "XEXP", "(", "to", ",", "0", ")", ",", "0", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "else", "if", "(", "IS_STACK_POP", "(", "from", ")", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "XEXP", "(", "XEXP", "(", "from", ",", "0", ")", ",", "0", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "else", "if", "(", "TARGET_M6811", "&&", "SP_REG_P", "(", "from", ")", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "from", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "move", "after", "the", "reload", "pass", "has", "completed", ".", "This", "is", "used", "to", "emit", "the", "prologue", "and", "epilogue", "." ]

[ "m68hc11", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "LowerToCopyInstrs", ".", "clear", "(", ")", ";", "CallingConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "unsigned", "LiveMaskReg", "=", "0", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "AMDGPU", "::", "EXEC", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWWM", ")", ")", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "lowerCopyInstrs", "(", ")", ";", "return", "true", ";", "}", "}", "DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerCopyInstrs", "(", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "0", "AMDGPU::EXEC", "AMDGPU::SReg_64RegClass", "AMDGPU::COPY", "AMDGPU::EXEC", "AMDGPU::S_WQM_B64", "AMDGPU::EXEC", "AMDGPU::EXEC", "AMDGPU::SCC" ]

[]

[ "<s>", "RegisterBankInfo", "::", "InstructionMapping", "AArch64RegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "RegisterBankInfo", "::", "InstructionMapping", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "LLT", "Ty", "=", "MI", ".", "getType", "(", ")", ";", "unsigned", "BankID", ";", "if", "(", "Ty", ".", "isVector", "(", ")", ")", "BankID", "=", "AArch64", "::", "FPRRegBankID", ";", "else", "BankID", "=", "AArch64", "::", "GPRRegBankID", ";", "Mapping", "=", "InstructionMapping", "{", "1", ",", "1", ",", "MI", ".", "getNumOperands", "(", ")", "}", ";", "int", "Size", "=", "Ty", ".", "isSized", "(", ")", "?", "Ty", ".", "getSizeInBits", "(", ")", ":", "0", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MI", ".", "getNumOperands", "(", ")", ";", "++", "Idx", ")", "Mapping", ".", "setOperandMapping", "(", "Idx", ",", "Size", ",", "getRegBank", "(", "BankID", ")", ")", ";", "return", "Mapping", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "AArch64", "AArch64", "AArch64::FPRRegBankID", "AArch64::GPRRegBankID", "1", "1", "0", "0" ]

[]

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

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

[ "SIC", "\"SIC Assembly Printer\"" ]

[]

[ "<s>", "uint64_t", "ARMPLT", "::", "emit", "(", "MemoryRegion", "&", "pRegion", ")", "{", "uint64_t", "result", "=", "0x0", ";", "iterator", "it", "=", "begin", "(", ")", ";", "unsigned", "char", "*", "buffer", "=", "pRegion", ".", "begin", "(", ")", ";", "memcpy", "(", "buffer", ",", "llvm", "::", "cast", "<", "ARMPLT0", ">", "(", "(", "*", "it", ")", ")", ".", "getValue", "(", ")", ",", "ARMPLT0", "::", "EntrySize", ")", ";", "result", "+=", "ARMPLT0", "::", "EntrySize", ";", "++", "it", ";", "ARMPLT1", "*", "plt1", "=", "0", ";", "ARMPLT", "::", "iterator", "ie", "=", "end", "(", ")", ";", "while", "(", "it", "!=", "ie", ")", "{", "plt1", "=", "&", "(", "llvm", "::", "cast", "<", "ARMPLT1", ">", "(", "*", "it", ")", ")", ";", "memcpy", "(", "buffer", "+", "result", ",", "plt1", "->", "getValue", "(", ")", ",", "ARMPLT1", "::", "EntrySize", ")", ";", "result", "+=", "ARMPLT1", "::", "EntrySize", ";", "++", "it", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

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

[]

[ "<s>", "size_t", "parallel_elements", "(", "rtx", "parallel_rtx", ")", "{", "parallel_rtx", "=", "extract_pattern_from_insn", "(", "parallel_rtx", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "parallel_rtx", ")", "==", "PARALLEL", ")", ";", "return", "XVECLEN", "(", "parallel_rtx", ",", "0", ")", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "elements", "in", "a", "parallel", "rtx", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "if", "(", "classifyEHPersonality", "(", "PersonalityFn", ")", "==", "EHPersonality", "::", "CoreCLR", ")", "return", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RDX", ":", "X86", "::", "EDX", ";", "return", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "X86", "X86", "X86::RDX", "X86::EDX", "X86::RAX", "X86::EAX" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasV8_1aOps", "(", "false", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "const", "TeeRISCRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC" ]

[]

[ "<s>", "static", "inline", "void", "desc_abi", "(", "unsigned", "char", "abi", ",", "unsigned", "char", "context", ",", "struct", "unw_state_record", "*", "sr", ")", "{", "sr", "->", "unwabi", "=", "(", "abi", "<<", "8", ")", "|", "context", ";", "}", "</s>" ]

[ "Prologue", "descriptors", "." ]

[ "ia64", "8" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "XCore", "XCore", "XCore", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"" ]

[]

[ "<s>", "static", "void", "ix86_init_platform_type_builtins", "(", "void", ")", "{", "make_cpu_type_builtin", "(", "\"__builtin_cpu_init\"", ",", "IX86_BUILTIN_CPU_INIT", ",", "INT_FTYPE_VOID", ",", "false", ")", ";", "make_cpu_type_builtin", "(", "\"__builtin_cpu_is\"", ",", "IX86_BUILTIN_CPU_IS", ",", "INT_FTYPE_PCCHAR", ",", "true", ")", ";", "make_cpu_type_builtin", "(", "\"__builtin_cpu_supports\"", ",", "IX86_BUILTIN_CPU_SUPPORTS", ",", "INT_FTYPE_PCCHAR", ",", "true", ")", ";", "}", "</s>" ]

[ "Make", "builtins", "to", "get", "CPU", "type", "and", "features", "supported", ".", "The", "created", "builtins", "are", ":", "__builtin_cpu_init", "(", ")", ",", "to", "detect", "cpu", "type", "and", "features", ",", "__builtin_cpu_is", "(", "``", "<", "CPUNAME", ">", "''", ")", ",", "to", "check", "if", "cpu", "is", "of", "type", "<", "CPUNAME", ">", ",", "__builtin_cpu_supports", "(", "``", "<", "FEATURE", ">", "''", ")", ",", "to", "check", "if", "cpu", "supports", "<", "FEATURE", ">" ]

[ "i386", "\"__builtin_cpu_init\"", "\"__builtin_cpu_is\"", "\"__builtin_cpu_supports\"" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "AArch64RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AArch64", "::", "GPR64RegClass", ";", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::GPR64RegClass", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_classify_vector_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "aarch64_advsimd_struct_mode_p", "(", "mode", ")", ")", "return", "VEC_ADVSIMD", "|", "VEC_STRUCT", ";", "if", "(", "aarch64_sve_pred_mode_p", "(", "mode", ")", ")", "return", "VEC_SVE_PRED", ";", "switch", "(", "mode", ")", "{", "case", "E_VNx2QImode", ":", "case", "E_VNx4QImode", ":", "case", "E_VNx8QImode", ":", "case", "E_VNx2HImode", ":", "case", "E_VNx4HImode", ":", "case", "E_VNx2SImode", ":", "case", "E_VNx2HFmode", ":", "case", "E_VNx4HFmode", ":", "case", "E_VNx2SFmode", ":", "return", "TARGET_SVE", "?", "VEC_SVE_DATA", "|", "VEC_PARTIAL", ":", "0", ";", "case", "E_VNx16QImode", ":", "case", "E_VNx8HImode", ":", "case", "E_VNx4SImode", ":", "case", "E_VNx2DImode", ":", "case", "E_VNx8BFmode", ":", "case", "E_VNx8HFmode", ":", "case", "E_VNx4SFmode", ":", "case", "E_VNx2DFmode", ":", "return", "TARGET_SVE", "?", "VEC_SVE_DATA", ":", "0", ";", "case", "E_VNx32QImode", ":", "case", "E_VNx16HImode", ":", "case", "E_VNx8SImode", ":", "case", "E_VNx4DImode", ":", "case", "E_VNx16BFmode", ":", "case", "E_VNx16HFmode", ":", "case", "E_VNx8SFmode", ":", "case", "E_VNx4DFmode", ":", "case", "E_VNx48QImode", ":", "case", "E_VNx24HImode", ":", "case", "E_VNx12SImode", ":", "case", "E_VNx6DImode", ":", "case", "E_VNx24BFmode", ":", "case", "E_VNx24HFmode", ":", "case", "E_VNx12SFmode", ":", "case", "E_VNx6DFmode", ":", "case", "E_VNx64QImode", ":", "case", "E_VNx32HImode", ":", "case", "E_VNx16SImode", ":", "case", "E_VNx8DImode", ":", "case", "E_VNx32BFmode", ":", "case", "E_VNx32HFmode", ":", "case", "E_VNx16SFmode", ":", "case", "E_VNx8DFmode", ":", "return", "TARGET_SVE", "?", "VEC_SVE_DATA", "|", "VEC_STRUCT", ":", "0", ";", "case", "E_V8QImode", ":", "case", "E_V4HImode", ":", "case", "E_V2SImode", ":", "case", "E_V4HFmode", ":", "case", "E_V4BFmode", ":", "case", "E_V2SFmode", ":", "case", "E_V1DFmode", ":", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V8HFmode", ":", "case", "E_V8BFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2DFmode", ":", "return", "TARGET_SIMD", "?", "VEC_ADVSIMD", ":", "0", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "a", "set", "of", "flags", "describing", "the", "vector", "properties", "of", "mode", "MODE", ".", "Ignore", "modes", "that", "are", "not", "supported", "by", "the", "current", "target", "." ]

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

[]

[ "<s>", "void", "BlackfinInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "inClass", "(", "BF", "::", "DPRegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE32fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "D16RegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE16fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "AnyCCRegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE8fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "(", "std", "::", "string", "(", "\"Cannot store regclass to stack slot: \"", ")", "+", "RC", "->", "getName", "(", ")", ")", ".", "c_str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::DPRegClass", "BF::STORE32fi", "0", "BF::D16RegClass", "BF::STORE16fi", "0", "BF::AnyCCRegClass", "BF::STORE8fi", "0", "\"Cannot store regclass to stack slot: \"" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "lowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "cast", "<", "JumpTableSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKSAVE", ":", "return", "lowerSTACKSAVE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "lowerSTACKRESTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected node to lower\"", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "ISD::RETURNADDR", "ISD::SELECT_CC", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::ConstantPool", "ISD::VASTART", "ISD::VAARG", "ISD::ATOMIC_FENCE", "ISD::STACKSAVE", "ISD::STACKRESTORE", "ISD::FRAMEADDR", "\"Unexpected node to lower\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon optimize redundant zero and size extends\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon optimize redundant zero and size extends\"" ]

[]

[ "<s>", "static", "int", "get_unit_reqs", "(", "rtx_insn", "*", "insn", ",", "int", "*", "req1", ",", "int", "*", "side1", ",", "int", "*", "req2", ",", "int", "*", "side2", ")", "{", "enum", "attr_units", "units", ";", "enum", "attr_cross", "cross", ";", "int", "side", ",", "req", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "0", ";", "units", "=", "get_attr_units", "(", "insn", ")", ";", "if", "(", "units", "==", "UNITS_UNKNOWN", ")", "return", "0", ";", "side", "=", "get_insn_side", "(", "insn", ",", "units", ")", ";", "cross", "=", "get_attr_cross", "(", "insn", ")", ";", "req", "=", "(", "units", "==", "UNITS_D", "?", "UNIT_REQ_D", ":", "units", "==", "UNITS_D_ADDR", "?", "UNIT_REQ_D", ":", "units", "==", "UNITS_DL", "?", "UNIT_REQ_DL", ":", "units", "==", "UNITS_DS", "?", "UNIT_REQ_DS", ":", "units", "==", "UNITS_L", "?", "UNIT_REQ_L", ":", "units", "==", "UNITS_LS", "?", "UNIT_REQ_LS", ":", "units", "==", "UNITS_S", "?", "UNIT_REQ_S", ":", "units", "==", "UNITS_M", "?", "UNIT_REQ_M", ":", "units", "==", "UNITS_DLS", "?", "UNIT_REQ_DLS", ":", "-", "1", ")", ";", "gcc_assert", "(", "req", "!=", "-", "1", ")", ";", "*", "req1", "=", "req", ";", "*", "side1", "=", "side", ";", "if", "(", "units", "==", "UNITS_D_ADDR", ")", "{", "*", "req2", "=", "UNIT_REQ_T", ";", "*", "side2", "=", "side", "^", "(", "cross", "==", "CROSS_Y", "?", "1", ":", "0", ")", ";", "return", "2", ";", "}", "else", "if", "(", "cross", "==", "CROSS_Y", ")", "{", "*", "req2", "=", "UNIT_REQ_X", ";", "*", "side2", "=", "side", ";", "return", "2", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Examine", "INSN", ",", "and", "store", "in", "REQ1/SIDE1", "and", "REQ2/SIDE2", "the", "unit", "requirements", ".", "Returns", "zero", "if", "INSN", "ca", "n't", "be", "handled", ",", "otherwise", "either", "one", "or", "two", "to", "show", "how", "many", "of", "the", "two", "pairs", "are", "in", "use", ".", "REQ1", "is", "always", "used", ",", "it", "holds", "what", "is", "normally", "thought", "of", "as", "the", "instructions", "reservation", ",", "e.g", ".", "UNIT_REQ_DL", ".", "REQ2", "is", "used", "to", "either", "describe", "a", "cross", "path", ",", "or", "for", "loads/stores", ",", "the", "T", "unit", "." ]

[ "c6x", "0", "0", "0", "1", "1", "1", "0", "2", "2", "1" ]

[]

[ "<s>", "Function", "*", "MBlazeIntrinsicInfo", "::", "getDeclaration", "(", "Module", "*", "M", ",", "unsigned", "IntrID", ",", "Type", "*", "*", "Tys", ",", "unsigned", "numTy", ")", "const", "{", "assert", "(", "!", "isOverloaded", "(", "IntrID", ")", "&&", "\"MBlaze intrinsics are not overloaded\"", ")", ";", "AttrListPtr", "AList", "=", "getAttributes", "(", "(", "mblazeIntrinsic", "::", "ID", ")", "IntrID", ")", ";", "return", "cast", "<", "Function", ">", "(", "M", "->", "getOrInsertFunction", "(", "getName", "(", "IntrID", ")", ",", "getType", "(", "M", "->", "getContext", "(", ")", ",", "IntrID", ")", ",", "AList", ")", ")", ";", "}", "</s>" ]

[ "Create", "or", "insert", "an", "LLVM", "Function", "declaration", "for", "an", "intrinsic", ",", "and", "return", "it", "." ]

[ "MBlaze", "MBlaze", "\"MBlaze intrinsics are not overloaded\"", "mblazeIntrinsic::ID" ]

[]

[ "<s>", "bool", "TPCLutCacheCounter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "auto", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ";", "bool", "PrintlutWarn", "=", "ST", "->", "getTargetLowering", "(", ")", "->", "getTargetMachine", "(", ")", ".", "Options", ".", "LutWarn", ";", "if", "(", "!", "PrintlutWarn", ")", "{", "return", "false", ";", "}", "for", "(", "auto", "&", "BB", ":", "MF", ")", "{", "int", "deep", "=", "0", ";", "if", "(", "!", "isLookUpInADeepLoop", "(", "&", "BB", ",", "deep", ")", ")", "continue", ";", "for", "(", "auto", "&", "MI", ":", "BB", ")", "{", "if", "(", "ST", "->", "hasGoyaISA", "(", ")", ")", "{", "if", "(", "!", "processLookupDali", "(", "MI", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "if", "(", "!", "processLookupGen2Plus", "(", "MI", ")", ")", "{", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "0" ]

[]

[ "<s>", "void", "mprocAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "mprocMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "mproc", "mproc", "mproc" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "P2FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"=== eliminate call frame pseudo\\n\"", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "P2", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "if", "(", "Amount", ")", "tm", ".", "getInstrInfo", "(", ")", "->", "adjustStackPtr", "(", "P2", "::", "PTRA", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "P2", "P2", "\"=== eliminate call frame pseudo\\n\"", "0", "P2::ADJCALLSTACKDOWN", "P2::PTRA" ]

[]

[ "<s>", "static", "void", "pru_asm_function_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "flag_verbose_asm", "||", "flag_debug_asm", ")", "pru_dump_frame_layout", "(", "file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FUNCTION_PROLOGUE", "." ]

[ "pru" ]

[]

[ "<s>", "static", "void", "mcore_external_libcall", "(", "rtx", "fun", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.import\\t\"", ")", ";", "assemble_name", "(", "asm_out_file", ",", "XSTR", "(", "fun", ",", "0", ")", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\n\"", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_ASM_EXTERNAL_LIBCALL", "." ]

[ "mcore", "\"\\t.import\\t\"", "0", "\"\\n\"" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "SITargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "RMW", ")", "const", "{", "auto", "ReportUnsafeHWInst", "=", "[", "&", "]", "(", "TargetLowering", "::", "AtomicExpansionKind", "Kind", ")", "{", "OptimizationRemarkEmitter", "ORE", "(", "RMW", "->", "getFunction", "(", ")", ")", ";", "LLVMContext", "&", "Ctx", "=", "RMW", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "SmallVector", "<", "StringRef", ">", "SSNs", ";", "Ctx", ".", "getSyncScopeNames", "(", "SSNs", ")", ";", "auto", "MemScope", "=", "SSNs", "[", "RMW", "->", "getSyncScopeID", "(", ")", "]", ".", "empty", "(", ")", "?", "\"system\"", ":", "SSNs", "[", "RMW", "->", "getSyncScopeID", "(", ")", "]", ";", "ORE", ".", "emit", "(", "[", "&", "]", "(", ")", "{", "return", "OptimizationRemark", "(", "DEBUG_TYPE", ",", "\"Passed\"", ",", "RMW", ")", "<<", "\"Hardware instruction generated for atomic \"", "<<", "RMW", "->", "getOperationName", "(", "RMW", "->", "getOperation", "(", ")", ")", "<<", "\" operation at memory scope \"", "<<", "MemScope", "<<", "\" due to an unsafe request.\"", ";", "}", ")", ";", "return", "Kind", ";", "}", ";", "switch", "(", "RMW", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "FAdd", ":", "{", "Type", "*", "Ty", "=", "RMW", "->", "getType", "(", ")", ";", "if", "(", "Ty", "->", "isHalfTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "!", "Ty", "->", "isFloatTy", "(", ")", "&&", "(", "!", "Subtarget", "->", "hasGFX90AInsts", "(", ")", "||", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "AS", "=", "RMW", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "&&", "Subtarget", "->", "hasAtomicFaddInsts", "(", ")", ")", "{", "if", "(", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "!=", "\"true\"", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "if", "(", "Subtarget", "->", "hasGFX90AInsts", "(", ")", ")", "{", "if", "(", "Ty", "->", "isFloatTy", "(", ")", "&&", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "auto", "SSID", "=", "RMW", "->", "getSyncScopeID", "(", ")", ";", "if", "(", "SSID", "==", "SyncScope", "::", "System", "||", "SSID", "==", "RMW", "->", "getContext", "(", ")", ".", "getOrInsertSyncScopeID", "(", "\"one-as\"", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "RMW", "->", "use_empty", "(", ")", "?", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "Subtarget", "->", "hasLDSFPAtomics", "(", ")", ")", "{", "if", "(", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "fpModeMatchesGlobalFPAtomicMode", "(", "RMW", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", "?", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "default", ":", "break", ";", "}", "return", "AMDGPUTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "RMW", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "AMDGPU", "SI", "\"system\"", "\"Passed\"", "\"Hardware instruction generated for atomic \"", "\" operation at memory scope \"", "\" due to an unsafe request.\"", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU", "SI", "SI", "SI", "\"one-as\"", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "releaseBottomNode", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "SU", "->", "isScheduled", ")", "return", ";", "assert", "(", "SU", "->", "getInstr", "(", ")", "&&", "\"Scheduled SUnit must have instr\"", ")", ";", "for", "(", "SUnit", "::", "succ_iterator", "I", "=", "SU", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "SuccReadyCycle", "=", "I", "->", "getSUnit", "(", ")", "->", "BotReadyCycle", ";", "unsigned", "MinLatency", "=", "I", "->", "getLatency", "(", ")", ";", "Bot", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Bot", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "BotReadyCycle", "<", "SuccReadyCycle", "+", "MinLatency", ")", "SU", "->", "BotReadyCycle", "=", "SuccReadyCycle", "+", "MinLatency", ";", "}", "Bot", ".", "releaseNode", "(", "SU", ",", "SU", "->", "BotReadyCycle", ")", ";", "}", "</s>" ]

[ "Currently", "only", "scheduling", "top-down", ",", "so", "this", "method", "is", "empty", "." ]

[ "Hexagon", "\"Scheduled SUnit must have instr\"" ]

[]

[ "<s>", "static", "inline", "bool", "mode_supports_vsx_dform_quad", "(", "machine_mode", "mode", ")", "{", "return", "(", "(", "reg_addr", "[", "mode", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "&", "RELOAD_REG_QUAD_OFFSET", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "have", "D-form", "addressing", "in", "VSX", "registers", ".", "This", "addressing", "is", "more", "limited", "than", "normal", "d-form", "addressing", "in", "that", "the", "offset", "must", "be", "aligned", "on", "a", "16-byte", "boundary", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "int", "m32c_modes_tieable_p", "(", "enum", "machine_mode", "m1", ",", "enum", "machine_mode", "m2", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "m1", ")", "==", "GET_MODE_SIZE", "(", "m2", ")", ")", "return", "1", ";", "if", "(", "m1", "==", "QImode", "||", "m2", "==", "QImode", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Implements", "MODES_TIEABLE_P", ".", "In", "general", ",", "modes", "are", "n't", "tieable", "since", "registers", "are", "all", "different", "sizes", ".", "However", ",", "since", "most", "modes", "are", "bigger", "than", "our", "registers", "anyway", ",", "it", "'s", "easier", "to", "implement", "this", "function", "that", "way", ",", "leaving", "QImode", "as", "the", "only", "unique", "case", "." ]

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

[]

[ "<s>", "unsigned", "CAHPInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "&&", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "1", ";", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "CAHP", "CAHP", "0", "0", "0", "1", "1", "2" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "func_fma_steering", "::", "dfs", "(", "void", "(", "*", "process_forest", ")", "(", "fma_forest", "*", ")", ",", "void", "(", "*", "process_root", ")", "(", "fma_forest", "*", ",", "fma_root_node", "*", ")", ",", "void", "(", "*", "process_node", ")", "(", "fma_forest", "*", ",", "fma_node", "*", ")", ",", "bool", "free", ")", "{", "vec", "<", "fma_node", "*", ">", "to_process", ";", "std", "::", "list", "<", "fma_forest", "*", ">", "::", "iterator", "forest_iter", ";", "to_process", ".", "create", "(", "0", ")", ";", "for", "(", "forest_iter", "=", "this", "->", "m_fma_forests", ".", "begin", "(", ")", ";", "forest_iter", "!=", "this", "->", "m_fma_forests", ".", "end", "(", ")", ";", "forest_iter", "++", ")", "{", "std", "::", "list", "<", "fma_root_node", "*", ">", "::", "iterator", "root_iter", ";", "if", "(", "process_forest", ")", "process_forest", "(", "*", "forest_iter", ")", ";", "for", "(", "root_iter", "=", "(", "*", "forest_iter", ")", "->", "get_roots", "(", ")", "->", "begin", "(", ")", ";", "root_iter", "!=", "(", "*", "forest_iter", ")", "->", "get_roots", "(", ")", "->", "end", "(", ")", ";", "root_iter", "++", ")", "{", "if", "(", "process_root", ")", "process_root", "(", "*", "forest_iter", ",", "*", "root_iter", ")", ";", "to_process", ".", "safe_push", "(", "*", "root_iter", ")", ";", "}", "while", "(", "!", "to_process", ".", "is_empty", "(", ")", ")", "{", "fma_node", "*", "node", ";", "std", "::", "list", "<", "fma_node", "*", ">", "::", "iterator", "child_iter", ";", "node", "=", "to_process", ".", "pop", "(", ")", ";", "if", "(", "process_node", ")", "process_node", "(", "*", "forest_iter", ",", "node", ")", ";", "if", "(", "node", "->", "get_children", "(", ")", "->", "empty", "(", ")", ")", "continue", ";", "for", "(", "child_iter", "=", "node", "->", "get_children", "(", ")", "->", "begin", "(", ")", ";", "child_iter", "!=", "node", "->", "get_children", "(", ")", "->", "end", "(", ")", ";", "child_iter", "++", ")", "to_process", ".", "safe_push", "(", "*", "child_iter", ")", ";", "if", "(", "free", ")", "{", "if", "(", "node", "->", "root_p", "(", ")", ")", "delete", "static_cast", "<", "fma_root_node", "*", ">", "(", "node", ")", ";", "else", "delete", "node", ";", "}", "}", "if", "(", "free", ")", "delete", "*", "forest_iter", ";", "}", "to_process", ".", "release", "(", ")", ";", "}", "</s>" ]

[ "Perform", "a", "depth-first", "search", "of", "the", "forests", "of", "fma_node", "in", "THIS-", ">", "m_fma_forests", ",", "calling", "PROCESS_FOREST", "(", ")", "on", "each", "fma_forest", "object", "in", "THIS-", ">", "m_fma_forests", "list", ",", "PROCESS_ROOT", "(", ")", "on", "each", "tree", "root", "and", "PROCESS_NODE", "(", ")", "on", "each", "node", ".", "If", "FREE", "is", "true", ",", "free", "all", "std", ":", ":list", "in", "the", "same", "dfs", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "bool", "legitimate_small_data_address_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "return", "legitimate_small_data_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ")", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_SMALL_P", "(", "x", ")", ";", "case", "PLUS", ":", "{", "bool", "p0", "=", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "&&", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "p0", ";", "case", "2", ":", "return", "p0", "&&", "(", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "0x1", ")", "==", "0", ")", ";", "case", "4", ":", "case", "8", ":", "return", "p0", "&&", "(", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "0x3", ")", "==", "0", ")", ";", "default", ":", "return", "false", ";", "}", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "x", "is", "ok", "to", "be", "used", "as", "a", "small", "data", "address", "." ]

[ "arc", "0", "0", "0", "1", "1", "2", "1", "0x1", "0", "4", "8", "1", "0x3", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isPredicable", "(", "MachineInstr", "&", "MI", ")", "const", "{", "return", "MI", ".", "getDesc", "(", ")", ".", "isPredicable", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "AArch64CallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "MachineRegisterInfo", "&", "MRI", ",", "CallingConv", "::", "ID", "CallConv", ",", "const", "SplitArgTy", "&", "PerformArgSplit", ")", "const", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "if", "(", "OrigArg", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "return", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Reg", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "unsigned", "FirstRegIdx", "=", "SplitArgs", ".", "size", "(", ")", ";", "bool", "NeedsRegBlock", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "OrigArg", ".", "Ty", ",", "CallConv", ",", "false", ")", ";", "for", "(", "auto", "SplitVT", ":", "SplitVTs", ")", "{", "Type", "*", "SplitTy", "=", "SplitVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "SplitArgs", ".", "push_back", "(", "ArgInfo", "{", "MRI", ".", "createGenericVirtualRegister", "(", "getLLTForType", "(", "*", "SplitTy", ",", "DL", ")", ")", ",", "SplitTy", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", "}", ")", ";", "if", "(", "NeedsRegBlock", ")", "SplitArgs", ".", "back", "(", ")", ".", "Flags", ".", "setInConsecutiveRegs", "(", ")", ";", "}", "SplitArgs", ".", "back", "(", ")", ".", "Flags", ".", "setInConsecutiveRegsLast", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Offsets", ".", "size", "(", ")", ";", "++", "i", ")", "PerformArgSplit", "(", "SplitArgs", "[", "FirstRegIdx", "+", "i", "]", ".", "Reg", ",", "Offsets", "[", "i", "]", "*", "8", ")", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "4", "4", "0", "1", "0", "0", "8" ]

[]

[ "<s>", "static", "reg_class_t", "xstormy16_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "rclass", "==", "GENERAL_REGS", "&&", "MEM_P", "(", "x", ")", ")", "return", "EIGHT_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_PREFERRED_RELOAD_CLASS", "and", "TARGET_PREFERRED_OUTPUT_RELOAD_CLASS", "." ]

[ "stormy16" ]

[]

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

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

[ "rvex", "rvex", "\"\\tc0 \"" ]

[]

[ "<s>", "MVT", "M68kTargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", "DL", ",", "EVT", "Ty", ")", "const", "{", "if", "(", "Ty", ".", "isSimple", "(", ")", ")", "{", "return", "Ty", ".", "getSimpleVT", "(", ")", ";", "}", "return", "MVT", "::", "getIntegerVT", "(", "DL", ".", "getPointerSizeInBits", "(", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "M68k", "M68k", "MVT::getIntegerVT", "0" ]

[]

[ "<s>", "bool", "SIFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", "return", "false", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "{", "if", "(", "CS", ".", "getReg", "(", ")", "==", "FuncInfo", "->", "getFrameOffsetReg", "(", ")", ")", "{", "if", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", "!=", "AMDGPU", "::", "NoRegister", ")", "CS", ".", "setDstReg", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", ";", "break", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "AMDGPU::NoRegister" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "{", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "STRH", ":", "case", "ARM", "::", "STRBi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "t2STRi8", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VSTRS", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "tLDRspi", ":", "break", ";", "default", ":", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "8", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "FPOffset", "-=", "80", ";", "Offset", "+=", "MFI", "->", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "unsigned", "StackAlign", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "!", "(", "(", "MFI", "->", "getLocalFrameMaxAlign", "(", ")", ">", "StackAlign", ")", "&&", "canRealignStack", "(", "MF", ")", ")", ")", "{", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "getFrameRegister", "(", "MF", ")", ",", "FPOffset", ")", ")", "return", "false", ";", "}", "if", "(", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "ARM", "::", "SP", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARM::LDRi12", "ARM::LDRH", "ARM::LDRBi12", "ARM::STRi12", "ARM::STRH", "ARM::STRBi12", "ARM::t2LDRi12", "ARM::t2LDRi8", "ARM::t2STRi12", "ARM::t2STRi8", "ARM::VLDRS", "ARM::VLDRD", "ARM::VSTRS", "ARM::VSTRD", "ARM::tSTRspi", "ARM::tLDRspi", "ARM", "ARM", "8", "80", "128", "ARM::SP" ]

[]

[ "<s>", "static", "int", "ix86_vec_cost", "(", "machine_mode", "mode", ",", "int", "cost", ",", "bool", "parallel", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "cost", ";", "if", "(", "!", "parallel", ")", "return", "cost", "*", "GET_MODE_NUNITS", "(", "mode", ")", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "128", "&&", "TARGET_SSE_SPLIT_REGS", ")", "return", "cost", "*", "2", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "128", "&&", "TARGET_AVX128_OPTIMAL", ")", "return", "cost", "*", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "128", ";", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "vector", "operation", "in", "MODE", "given", "that", "scalar", "version", "has", "COST", ".", "If", "PARALLEL", "is", "true", "assume", "that", "CPU", "has", "more", "than", "one", "unit", "performing", "the", "operation", "." ]

[ "i386", "128", "2", "128", "128" ]

[]

[ "<s>", "bool", "MipsOs16", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "usingMask", "=", "Mips32FunctionMask", ".", "length", "(", ")", ">", "0", ";", "bool", "doneUsingMask", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Run on Module MipsOs16 \\n\"", "<<", "Mips32FunctionMask", "<<", "\"\\n\"", ")", ";", "if", "(", "usingMask", ")", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"using mask \\n\"", "<<", "Mips32FunctionMask", "<<", "\"\\n\"", ")", ";", "unsigned", "int", "functionIndex", "=", "0", ";", "bool", "modified", "=", "false", ";", "for", "(", "Module", "::", "iterator", "F", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "F", "!=", "E", ";", "++", "F", ")", "{", "if", "(", "F", "->", "isDeclaration", "(", ")", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Working on \"", "<<", "F", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "usingMask", ")", "{", "if", "(", "!", "doneUsingMask", ")", "{", "if", "(", "functionIndex", "==", "Mips32FunctionMask", ".", "length", "(", ")", ")", "functionIndex", "=", "0", ";", "switch", "(", "Mips32FunctionMask", "[", "functionIndex", "]", ")", "{", "case", "'1'", ":", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"mask forced mips32: \"", "<<", "F", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "F", "->", "addFnAttr", "(", "\"nomips16\"", ")", ";", "break", ";", "case", "'.'", ":", "doneUsingMask", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "functionIndex", "++", ";", "}", "}", "else", "{", "if", "(", "needsFP", "(", "*", "F", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"os16 forced mips32: \"", "<<", "F", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "F", "->", "addFnAttr", "(", "\"nomips16\"", ")", ";", "}", "else", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"os16 forced mips16: \"", "<<", "F", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "F", "->", "addFnAttr", "(", "\"mips16\"", ")", ";", "}", "}", "}", "return", "modified", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "0", "\"Run on Module MipsOs16 \\n\"", "Mips", "\"\\n\"", "\"using mask \\n\"", "Mips", "\"\\n\"", "0", "\"Working on \"", "\"\\n\"", "Mips", "0", "Mips", "\"mask forced mips32: \"", "\"\\n\"", "\"nomips16\"", "\"os16 forced mips32: \"", "\"\\n\"", "\"nomips16\"", "\"os16 forced mips16: \"", "\"\\n\"", "\"mips16\"" ]

[]

[ "<s>", "void", "csky_init_builtins", "(", "void", ")", "{", "static", "tree", "csky_floatHF_type_node", "=", "make_node", "(", "REAL_TYPE", ")", ";", "TYPE_PRECISION", "(", "csky_floatHF_type_node", ")", "=", "GET_MODE_PRECISION", "(", "HFmode", ")", ";", "layout_type", "(", "csky_floatHF_type_node", ")", ";", "(", "*", "lang_hooks", ".", "types", ".", "register_builtin_type", ")", "(", "csky_floatHF_type_node", ",", "\"__fp16\"", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_INIT_BUILTINS", "target", "macro", "." ]

[ "csky", "\"__fp16\"" ]

[]

[ "<s>", "void", "HexagonMCCodeEmitter", "::", "encodeInstruction", "(", "MCInst", "const", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "MCInst", "&", "HMB", "=", "const_cast", "<", "MCInst", "&", ">", "(", "MI", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "HMB", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Encoding bundle\\n\"", ";", ")", ";", "*", "Addend", "=", "0", ";", "*", "Extended", "=", "false", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "size_t", "Instruction", "=", "0", ";", "size_t", "Last", "=", "HexagonMCInstrInfo", "::", "bundleSize", "(", "HMB", ")", "-", "1", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "HMB", ")", ")", "{", "MCInst", "&", "HMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "verifyInstructionPredicates", "(", "HMI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "EncodeSingleInstruction", "(", "HMI", ",", "OS", ",", "Fixups", ",", "STI", ",", "parseBits", "(", "Instruction", ",", "Last", ",", "HMB", ",", "HMI", ")", ",", "Instruction", ")", ";", "*", "Extended", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "HMI", ")", ";", "*", "Addend", "+=", "HEXAGON_INSTR_SIZE", ";", "++", "Instruction", ";", "}", "return", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\"Encoding bundle\\n\"", "0", "0", "Hexagon", "1", "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "int", "dispatch_function_versions", "(", "tree", "dispatch_decl", ",", "void", "*", "fndecls_p", ",", "basic_block", "*", "empty_bb", ")", "{", "int", "ix", ";", "tree", "ele", ";", "vec", "<", "tree", ">", "*", "fndecls", ";", "tree", "clones", "[", "CLONE_MAX", "]", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fputs", "(", "\"dispatch_function_versions, top\\n\"", ",", "stderr", ")", ";", "gcc_assert", "(", "dispatch_decl", "!=", "NULL", "&&", "fndecls_p", "!=", "NULL", "&&", "empty_bb", "!=", "NULL", ")", ";", "fndecls", "=", "static_cast", "<", "vec", "<", "tree", ">", "*", ">", "(", "fndecls_p", ")", ";", "gcc_assert", "(", "fndecls", "->", "length", "(", ")", ">=", "2", ")", ";", "memset", "(", "(", "void", "*", ")", "clones", ",", "'\\0'", ",", "sizeof", "(", "clones", ")", ")", ";", "clones", "[", "CLONE_DEFAULT", "]", "=", "(", "*", "fndecls", ")", "[", "0", "]", ";", "for", "(", "ix", "=", "1", ";", "fndecls", "->", "iterate", "(", "ix", ",", "&", "ele", ")", ";", "++", "ix", ")", "{", "int", "priority", "=", "rs6000_clone_priority", "(", "ele", ")", ";", "if", "(", "!", "clones", "[", "priority", "]", ")", "clones", "[", "priority", "]", "=", "ele", ";", "}", "for", "(", "ix", "=", "CLONE_MAX", "-", "1", ";", "ix", ">=", "0", ";", "ix", "--", ")", "if", "(", "clones", "[", "ix", "]", ")", "{", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"dispatch_function_versions, clone %d, %s\\n\"", ",", "ix", ",", "get_decl_name", "(", "clones", "[", "ix", "]", ")", ")", ";", "*", "empty_bb", "=", "add_condition_to_bb", "(", "dispatch_decl", ",", "clones", "[", "ix", "]", ",", "ix", ",", "*", "empty_bb", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "dispatch", "function", "for", "multi-versioned", "functions", ".", "DISPATCH_DECL", "is", "the", "function", "which", "will", "contain", "the", "dispatch", "logic", ".", "FNDECLS", "are", "the", "function", "choices", "for", "dispatch", ",", "and", "is", "a", "tree", "chain", ".", "EMPTY_BB", "is", "the", "basic", "block", "pointer", "in", "DISPATCH_DECL", "in", "which", "the", "dispatch", "code", "is", "generated", "." ]

[ "rs6000", "\"dispatch_function_versions, top\\n\"", "2", "0", "1", "1", "0", "\"dispatch_function_versions, clone %d, %s\\n\"", "0" ]

[]

[ "<s>", "Register", "RISCVTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "RISCV", "::", "X11", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "RI5CY", "RISCV", "RISCV::X11" ]

[]

[ "<s>", "static", "void", "darwin_rs6000_override_options", "(", "void", ")", "{", "rs6000_altivec_abi", "=", "1", ";", "TARGET_ALTIVEC_VRSAVE", "=", "1", ";", "rs6000_current_abi", "=", "ABI_DARWIN", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "TARGET_64BIT", ")", "darwin_one_byte_bool", "=", "1", ";", "if", "(", "TARGET_64BIT", "&&", "!", "TARGET_POWERPC64", ")", "{", "rs6000_isa_flags", "|=", "OPTION_MASK_POWERPC64", ";", "warning", "(", "0", ",", "\"%qs requires PowerPC64 architecture, enabling\"", ",", "\"-m64\"", ")", ";", "}", "if", "(", "flag_mkernel", ")", "{", "rs6000_default_long_calls", "=", "1", ";", "rs6000_isa_flags", "|=", "OPTION_MASK_SOFT_FLOAT", ";", "}", "if", "(", "!", "flag_mkernel", "&&", "!", "flag_apple_kext", "&&", "TARGET_64BIT", "&&", "!", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_ALTIVEC", ")", ")", "rs6000_isa_flags", "|=", "OPTION_MASK_ALTIVEC", ";", "if", "(", "!", "flag_mkernel", "&&", "!", "flag_apple_kext", "&&", "strverscmp", "(", "darwin_macosx_version_min", ",", "\"10.5\"", ")", ">=", "0", "&&", "!", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_ALTIVEC", ")", "&&", "!", "global_options_set", ".", "x_rs6000_cpu_index", ")", "{", "rs6000_isa_flags", "|=", "OPTION_MASK_ALTIVEC", ";", "}", "}", "</s>" ]

[ "The", "Darwin", "version", "of", "SUBTARGET_OVERRIDE_OPTIONS", "." ]

[ "rs6000", "1", "1", "1", "0", "\"%qs requires PowerPC64 architecture, enabling\"", "\"-m64\"", "1", "\"10.5\"", "0" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", ")", "const", "{", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "BaseRegA", "=", "0", ",", "BaseRegB", "=", "0", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "int", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "if", "(", "getMemOpBaseRegImmOfsWidth", "(", "MIa", ",", "BaseRegA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOpBaseRegImmOfsWidth", "(", "MIb", ",", "BaseRegB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseRegA", "==", "BaseRegB", ")", "{", "int", "LowOffset", "=", "std", "::", "min", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "HighOffset", "=", "std", "::", "max", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "Lanai", "Lanai", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "parse_codes", "parse_ovld_entry", "(", "void", ")", "{", "pos", "=", "0", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "==", "'['", ")", "return", "PC_EOSTANZA", ";", "if", "(", "num_ovlds", ">=", "MAXOVLDS", "-", "1", ")", "{", "diag", "(", "pos", ",", "\"too many overloads.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "curr_ovld", "=", "num_ovlds", "++", ";", "ovlds", "[", "curr_ovld", "]", ".", "stanza", "=", "curr_ovld_stanza", ";", "if", "(", "parse_prototype", "(", "&", "ovlds", "[", "curr_ovld", "]", ".", "proto", ")", "==", "PC_PARSEFAIL", ")", "return", "PC_PARSEFAIL", ";", "if", "(", "ovlds", "[", "curr_ovld", "]", ".", "proto", ".", "nargs", ">", "max_ovld_args", ")", "max_ovld_args", "=", "ovlds", "[", "curr_ovld", "]", ".", "proto", ".", "nargs", ";", "ovlds", "[", "curr_ovld", "]", ".", "fndecl", "=", "construct_fntype_id", "(", "&", "ovlds", "[", "curr_ovld", "]", ".", "proto", ")", ";", "if", "(", "!", "advance_line", "(", "ovld_file", ")", ")", "{", "diag", "(", "0", ",", "\"unexpected EOF.\\n\"", ")", ";", "return", "PC_EOFILE", ";", "}", "pos", "=", "0", ";", "consume_whitespace", "(", ")", ";", "int", "oldpos", "=", "pos", ";", "char", "*", "id", "=", "match_identifier", "(", ")", ";", "ovlds", "[", "curr_ovld", "]", ".", "bif_id_name", "=", "id", ";", "ovlds", "[", "curr_ovld", "]", ".", "ovld_id_name", "=", "id", ";", "if", "(", "!", "id", ")", "{", "diag", "(", "pos", ",", "\"missing overload id.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "diag", "(", "pos", ",", "\"ID name is '%s'.\\n\"", ",", "id", ")", ";", "if", "(", "!", "rbt_find", "(", "&", "bif_rbt", ",", "id", ")", ")", "{", "diag", "(", "pos", ",", "\"builtin ID '%s' not found in bif file.\\n\"", ",", "id", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "'\\n'", ")", "{", "id", "=", "match_identifier", "(", ")", ";", "ovlds", "[", "curr_ovld", "]", ".", "ovld_id_name", "=", "id", ";", "consume_whitespace", "(", ")", ";", "}", "if", "(", "!", "rbt_insert", "(", "&", "ovld_rbt", ",", "id", ")", ")", "{", "diag", "(", "oldpos", ",", "\"duplicate overload ID '%s'.\\n\"", ",", "id", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "if", "(", "linebuf", "[", "pos", "]", "!=", "'\\n'", ")", "{", "diag", "(", "pos", ",", "\"garbage at end of line.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "return", "PC_OK", ";", "}", "</s>" ]

[ "Parse", "one", "two-line", "entry", "in", "the", "overload", "file", "." ]

[ "rs6000", "0", "1", "\"too many overloads.\\n\"", "0", "\"unexpected EOF.\\n\"", "0", "\"missing overload id.\\n\"", "\"ID name is '%s'.\\n\"", "\"builtin ID '%s' not found in bif file.\\n\"", "\"duplicate overload ID '%s'.\\n\"", "\"garbage at end of line.\\n\"" ]

[]

[ "<s>", "bool", "s390_decompose_addrstyle_without_index", "(", "rtx", "op", ",", "rtx", "*", "base", ",", "HOST_WIDE_INT", "*", "offset", ")", "{", "rtx", "off", "=", "NULL_RTX", ";", "if", "(", "CONST_SCALAR_INT_P", "(", "op", ")", ")", "{", "off", "=", "op", ";", "op", "=", "NULL_RTX", ";", "}", "if", "(", "op", "&&", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "CONST_SCALAR_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "off", "=", "XEXP", "(", "op", ",", "1", ")", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "}", "while", "(", "op", "&&", "GET_CODE", "(", "op", ")", "==", "SUBREG", ")", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "if", "(", "op", "&&", "GET_CODE", "(", "op", ")", "!=", "REG", ")", "return", "false", ";", "if", "(", "offset", ")", "{", "if", "(", "off", "==", "NULL_RTX", ")", "*", "offset", "=", "0", ";", "else", "if", "(", "CONST_INT_P", "(", "off", ")", ")", "*", "offset", "=", "INTVAL", "(", "off", ")", ";", "else", "if", "(", "CONST_WIDE_INT_P", "(", "off", ")", ")", "*", "offset", "=", "CONST_WIDE_INT_ELT", "(", "off", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "base", ")", "*", "base", "=", "op", ";", "return", "true", ";", "}", "</s>" ]

[ "Decompose", "a", "RTL", "expression", "OP", "for", "an", "address", "style", "operand", "into", "its", "components", ",", "and", "return", "the", "base", "register", "in", "BASE", "and", "the", "offset", "in", "OFFSET", ".", "While", "OP", "looks", "like", "an", "address", "it", "is", "never", "supposed", "to", "be", "used", "as", "such", ".", "Return", "true", "if", "OP", "is", "a", "valid", "address", "operand", ",", "false", "if", "not", "." ]

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

[]

[ "<s>", "bool", "aarch_bti_enabled", "(", "void", ")", "{", "return", "aarch_enable_bti", "!=", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "Branch", "Target", "Identification", "Mechanism", "is", "enabled", "." ]

[ "arm", "0" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "AttributeSet", "FnAttrs", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "CPUAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "Attribute", "SFAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"use-soft-float\"", ")", ";", "bool", "SoftFloat", "=", "!", "SFAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "SFAttr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ":", "Options", ".", "UseSoftFloat", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "+", "(", "SoftFloat", "?", "\"use-soft-float=true\"", ":", "\"use-soft-float=false\"", ")", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"use-soft-float=true\"", "\"use-soft-float=false\"", "X86" ]

[]

[ "<s>", "bool", "Thumb1RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "DebugLoc", "DL", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "R12", ")", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM::tMOVr", "ARM::R12", "0", "ARM::R12", "ARM::R12", "ARM::tMOVr", "ARM::R12" ]

[]

[ "<s>", "bool", "R600ClauseMergePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LatestCFAlu", "=", "E", ";", "while", "(", "I", "!=", "E", ")", "{", "MachineInstr", "*", "MI", "=", "I", "++", ";", "if", "(", "(", "!", "TII", "->", "canBeConsideredALU", "(", "MI", ")", "&&", "!", "isCFAlu", "(", "MI", ")", ")", "||", "TII", "->", "mustBeLastInClause", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "LatestCFAlu", "=", "E", ";", "if", "(", "!", "isCFAlu", "(", "MI", ")", ")", "continue", ";", "cleanPotentialDisabledCFAlu", "(", "MI", ")", ";", "if", "(", "LatestCFAlu", "!=", "E", "&&", "mergeIfPossible", "(", "LatestCFAlu", ",", "MI", ")", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", "&&", "\"CF ALU instruction disabled\"", ")", ";", "LatestCFAlu", "=", "MI", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "8", "\"CF ALU instruction disabled\"" ]

[]

[ "<s>", "TargetTransformInfo", "ARCTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "ARCTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "ARC", "ARC", "ARC" ]

[]