Datasets:

docz-ict

/

ComBack

like 2

[ "<s>", "void", "PPCIncomingValueHandler", "::", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "LLT", "MemTy", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "{", "auto", "BuildLoad", "=", "[", "]", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "MachinePointerInfo", "&", "MPO", ",", "LLT", "MemTy", ",", "const", "DstOp", "&", "Res", ",", "Register", "Addr", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", ",", "MemTy", ",", "inferAlignFromPtrInfo", "(", "MF", ",", "MPO", ")", ")", ";", "return", "MIRBuilder", ".", "buildLoad", "(", "Res", ",", "Addr", ",", "*", "MMO", ")", ";", "}", ";", "BuildLoad", "(", "MIRBuilder", ",", "MPO", ",", "MemTy", ",", "ValVReg", ",", "Addr", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "PowerPC", "PPC" ]

[]

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

[ "For", "targets", "which", "want", "to", "use", "big-endian", "can", "enable", "it", "with", "enableBigEndian", "(", ")", "hook", "." ]

[ "M88k" ]

[]

[ "<s>", "static", "tree", "build_const_pointer", "(", "tree", "t", ")", "{", "return", "build_pointer_type", "(", "build_qualified_type", "(", "t", ",", "TYPE_QUAL_CONST", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "representation", "of", "``", "const", "T", "*", "''", "." ]

[ "riscv" ]

[]

[ "<s>", "enum", "reg_class", "crx_regno_reg_class", "(", "int", "regno", ")", "{", "if", "(", "regno", ">=", "0", "&&", "regno", "<", "SP_REGNUM", ")", "return", "NOSP_REGS", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "GENERAL_REGS", ";", "if", "(", "regno", "==", "LO_REGNUM", ")", "return", "LO_REGS", ";", "if", "(", "regno", "==", "HI_REGNUM", ")", "return", "HI_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Return", "the", "class", "number", "of", "the", "smallest", "class", "containing", "reg", "number", "REGNO", ".", "*", "This", "could", "be", "a", "conditional", "expression", "or", "could", "index", "an", "array", "." ]

[ "crx", "0" ]

[]

[ "<s>", "static", "tree", "handle_int_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "x", "=", "*", "node", ";", "if", "(", "TREE_CODE", "(", "x", ")", "==", "FUNCTION_DECL", ")", "x", "=", "TREE_TYPE", "(", "x", ")", ";", "if", "(", "TREE_CODE", "(", "x", ")", "!=", "FUNCTION_TYPE", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "funkind", "(", "x", ")", "!=", "SUBROUTINE", ")", "error", "(", "\"multiple function type attributes specified\"", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "interrupt_handler", ",", "exception_handler", "and", "nmi_handler", "function", "attributes", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "bfin", "\"%qs attribute only applies to functions\"", "\"multiple function type attributes specified\"" ]

[]

[ "<s>", "static", "void", "constant_fp_to_128bit_vector", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "size_t", "byte_num", ",", "vec_const_128bit_type", "*", "info", ")", "{", "unsigned", "bitsize", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "unsigned", "num_words", "=", "bitsize", "/", "32", ";", "const", "REAL_VALUE_TYPE", "*", "rtype", "=", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ";", "long", "real_words", "[", "VECTOR_128BIT_WORDS", "]", ";", "gcc_assert", "(", "num_words", "<=", "VECTOR_128BIT_WORDS", "&&", "(", "bitsize", "%", "32", ")", "==", "0", ")", ";", "real_to_target", "(", "real_words", ",", "rtype", ",", "mode", ")", ";", "for", "(", "unsigned", "num", "=", "0", ";", "num", "<", "num_words", ";", "num", "++", ")", "{", "unsigned", "endian_num", "=", "(", "BYTES_BIG_ENDIAN", "?", "num", ":", "num_words", "-", "1", "-", "num", ")", ";", "unsigned", "uvalue", "=", "real_words", "[", "endian_num", "]", ";", "for", "(", "int", "shift", "=", "32", "-", "8", ";", "shift", ">=", "0", ";", "shift", "-=", "8", ")", "info", "->", "bytes", "[", "byte_num", "++", "]", "=", "(", "uvalue", ">>", "shift", ")", "&", "0xff", ";", "}", "info", "->", "fp_constant_p", "=", "true", ";", "}", "</s>" ]

[ "Copy", "a", "floating", "point", "constant", "to", "the", "vector", "constant", "structure", "." ]

[ "rs6000", "32", "32", "0", "0", "1", "32", "8", "0", "8", "0xff" ]

[]

[ "<s>", "machine_mode", "mmix_select_cc_mode", "(", "RTX_CODE", "op", ",", "rtx", "x", ",", "rtx", "y", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "if", "(", "op", "==", "ORDERED", "||", "op", "==", "UNORDERED", "||", "op", "==", "UNGE", "||", "op", "==", "UNGT", "||", "op", "==", "UNLE", "||", "op", "==", "UNLT", ")", "return", "CC_FUNmode", ";", "if", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", "return", "CC_FPEQmode", ";", "return", "CC_FPmode", ";", "}", "if", "(", "op", "==", "GTU", "||", "op", "==", "LTU", "||", "op", "==", "GEU", "||", "op", "==", "LEU", ")", "return", "CC_UNSmode", ";", "return", "CCmode", ";", "}", "</s>" ]

[ "SELECT_CC_MODE", "." ]

[ "mmix" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", ".", "estimateStackSize", "(", "MF", ")", ":", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", ".", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "1", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ";", "bool", "CanUseRedZone", "=", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", "&&", "!", "MustSaveLR", "(", "MF", ",", "LR", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ";", "bool", "FitsInRedZone", "=", "FrameSize", "<=", "Subtarget", ".", "getRedZoneSize", "(", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "CanUseRedZone", "&&", "FitsInRedZone", ")", "{", "if", "(", "UpdateMF", ")", "MFI", ".", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getLinkageSize", "(", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", ".", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "PPC", "0", "0" ]

[]

[ "<s>", "void", "rs6000_xcoff_asm_globalize_decl_name", "(", "FILE", "*", "stream", ",", "tree", "decl", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ",", "0", ")", ";", "fputs", "(", "GLOBAL_ASM_OP", ",", "stream", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fputs", "(", "rs6000_xcoff_visibility", "(", "decl", ")", ",", "stream", ")", ";", "putc", "(", "'\\n'", ",", "stream", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "language", "to", "globalize", "a", "symbol", "from", "a", "DECL", ",", "possibly", "with", "visibility", "." ]

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

[]

[ "<s>", "unsigned", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "override", "{", "const", "MCRegisterClass", "&", "MRC", "=", "MRI", "->", "getRegClass", "(", "AAP", "::", "GR8RegClassID", ")", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "Match_Success", ";", "case", "AAP", "::", "LDB_short", ":", "case", "AAP", "::", "LDW_short", ":", "case", "AAP", "::", "LDB_postinc_short", ":", "case", "AAP", "::", "LDW_postinc_short", ":", "case", "AAP", "::", "LDB_predec_short", ":", "case", "AAP", "::", "LDW_predec_short", ":", "case", "AAP", "::", "STB_short", ":", "case", "AAP", "::", "STW_short", ":", "case", "AAP", "::", "STB_postinc_short", ":", "case", "AAP", "::", "STW_postinc_short", ":", "case", "AAP", "::", "STB_predec_short", ":", "case", "AAP", "::", "STW_predec_short", ":", "break", ";", "}", "for", "(", "MCInst", "::", "iterator", "I", "=", "Inst", ".", "begin", "(", ")", ";", "I", "!=", "Inst", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReg", "(", ")", "&&", "!", "MRC", ".", "contains", "(", "I", "->", "getReg", "(", ")", ")", ")", "{", "return", "Match_InvalidOperand", ";", "}", "}", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "AAP", "AAP::GR8RegClassID", "AAP::LDB_short", "AAP::LDW_short", "AAP::LDB_postinc_short", "AAP::LDW_postinc_short", "AAP::LDB_predec_short", "AAP::LDW_predec_short", "AAP::STB_short", "AAP::STW_short", "AAP::STB_postinc_short", "AAP::STW_postinc_short", "AAP::STB_predec_short", "AAP::STW_predec_short" ]

[]

[ "<s>", "bool", "SPScheduler", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "if", "(", "!", "mf", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", "->", "isSinglePath", "(", ")", ")", "{", "return", "false", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SPScheduler on function '\"", "<<", "mf", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "auto", "reduceAnalysis", "=", "&", "getAnalysis", "<", "PatmosSPReduce", ">", "(", ")", ";", "auto", "rootScope", "=", "reduceAnalysis", "->", "RootScope", ";", "for", "(", "auto", "mbbIter", "=", "mf", ".", "begin", "(", ")", ",", "mbbEnd", "=", "mf", ".", "end", "(", ")", ";", "mbbIter", "!=", "mbbEnd", ";", "++", "mbbIter", ")", "{", "auto", "mbb", "=", "mbbIter", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"MBB: [\"", "<<", "*", "mbb", "<<", "\"]: #\"", "<<", "mbb", "->", "getNumber", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "auto", "instrIter", "=", "mbb", "->", "begin", "(", ")", ",", "instrEnd", "=", "mbb", "->", "end", "(", ")", ";", "instrIter", "!=", "instrEnd", ";", ")", "{", "SPInstructions", "++", ";", "auto", "latency", "=", "calculateLatency", "(", "instrIter", ")", ";", "for", "(", "auto", "i", "=", "0", ";", "i", "<", "latency", ";", "i", "++", ")", "{", "TM", ".", "getInstrInfo", "(", ")", "->", "insertNoop", "(", "*", "mbb", ",", "std", "::", "next", "(", "instrIter", ")", ")", ";", "}", "instrIter", "=", "std", "::", "next", "(", "instrIter", ",", "1", "+", "latency", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AFTER Single-Path Schedule\\n\"", ";", "mf", ".", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Scope tree after scheduling:\\n\"", ";", "rootScope", "->", "dump", "(", "dbgs", "(", ")", ",", "0", ",", "true", ")", ";", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"Running SPScheduler on function '\"", "\"'\\n\"", "Patmos", "\"MBB: [\"", "\"]: #\"", "\"\\n\"", "0", "1", "\"AFTER Single-Path Schedule\\n\"", "\"Scope tree after scheduling:\\n\"", "0" ]

[]

[ "<s>", "int", "AArch64TTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Store", ":", "ImmIdx", "=", "0", ";", "break", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "URem", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "ICmp", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "if", "(", "Idx", "==", "1", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Instruction", "::", "Trunc", ":", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Select", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "break", ";", "}", "if", "(", "Idx", "==", "ImmIdx", ")", "{", "int", "NumConstants", "=", "(", "BitSize", "+", "63", ")", "/", "64", ";", "int", "Cost", "=", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "return", "(", "Cost", "<=", "NumConstants", "*", "TTI", "::", "TCC_Basic", ")", "?", "static_cast", "<", "int", ">", "(", "TTI", "::", "TCC_Free", ")", ":", "Cost", ";", "}", "return", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "AArch64", "AArch64", "0", "0U", "0", "2", "0", "1", "1", "63", "64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "unsigned", "ExtraPredCycles", ",", "BranchProbability", "Probability", ")", "const", "{", "return", "NumCycles", "==", "1", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1" ]

[]

[ "<s>", "static", "void", "nds32_emit_section_tail_template", "(", "char", "symbol_name", "[", "]", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.size\\t%s, .-%s\\n\"", ",", "symbol_name", ",", "symbol_name", ")", ";", "}", "</s>" ]

[ "A", "helper", "function", "to", "emit", "section", "tail", "template", "." ]

[ "nds32", "\"\\t.size\\t%s, .-%s\\n\"" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALL", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "RISCV::PseudoCALL", "8", "RISCV", "0" ]

[]

[ "<s>", "static", "SDValue", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "const", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "RVLocs", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ",", "4", ">", "ResultMemLocs", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "ResultMemLocs", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocMemOffset", "(", ")", ",", "InVals", ".", "size", "(", ")", ")", ")", ";", "InVals", ".", "push_back", "(", "SDValue", "(", ")", ")", ";", "}", "}", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ResultMemLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "offset", "=", "ResultMemLocs", "[", "i", "]", ".", "first", ";", "unsigned", "index", "=", "ResultMemLocs", "[", "i", "]", ".", "second", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "DAG", ".", "getConstant", "(", "offset", "/", "4", ",", "dl", ",", "MVT", "::", "i32", ")", "}", ";", "SDValue", "load", "=", "DAG", ".", "getNode", "(", "XCoreISD", "::", "LDWSP", ",", "dl", ",", "VTs", ",", "Ops", ")", ";", "InVals", "[", "index", "]", "=", "load", ";", "MemOpChains", ".", "push_back", "(", "load", ".", "getValue", "(", "1", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "XCore", "4", "0", "1", "2", "0", "4", "0", "MVT::i32", "MVT::Other", "4", "MVT::i32", "XCoreISD::LDWSP", "1", "ISD::TokenFactor", "MVT::Other" ]

[]

[ "<s>", "bool", "MipsExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "const", "MipsSubtarget", "&", "STI", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "mbbi", "=", "F", ".", "begin", "(", ")", ",", "mbbe", "=", "F", ".", "end", "(", ")", ";", "mbbi", "!=", "mbbe", ";", "++", "mbbi", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "mi", "=", "mbbi", "->", "begin", "(", ")", ",", "me", "=", "mbbi", "->", "end", "(", ")", ";", "mi", "!=", "me", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "MI", "=", "mi", ";", "MachineBasicBlock", "*", "MBB", "=", "mbbi", ";", "++", "mi", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "==", "Mips", "::", "LOAD_IMM_PSEUDO", ")", "{", "expandLoadImm", "(", "*", "MBB", ",", "MI", ",", "TII", ")", ";", "MBB", "->", "erase", "(", "MI", ")", ";", "++", "ExpandPseudo", ";", "continue", ";", "}", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "==", "Mips", "::", "IJMP_PSEUDO", ")", "{", "expandIJmp", "(", "*", "MBB", ",", "MI", ",", "TII", ")", ";", "MBB", "->", "erase", "(", "MI", ")", ";", "++", "ExpandPseudo", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::LOAD_IMM_PSEUDO", "Mips::IJMP_PSEUDO" ]

[]

[ "<s>", "void", "m32c_emit_prologue", "(", "void", ")", "{", "int", "frame_size", ",", "extra_frame_size", "=", "0", ",", "reg_save_size", ";", "int", "complex_prologue", "=", "0", ";", "cfun", "->", "machine", "->", "is_leaf", "=", "m32c_leaf_function_p", "(", ")", ";", "if", "(", "interrupt_p", "(", "cfun", "->", "decl", ")", ")", "{", "cfun", "->", "machine", "->", "is_interrupt", "=", "1", ";", "complex_prologue", "=", "1", ";", "}", "reg_save_size", "=", "m32c_pushm_popm", "(", "PP_justcount", ")", ";", "if", "(", "interrupt_p", "(", "cfun", "->", "decl", ")", ")", "emit_insn", "(", "gen_pushm", "(", "GEN_INT", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", ")", ")", ";", "frame_size", "=", "m32c_initial_elimination_offset", "(", "FB_REGNO", ",", "SP_REGNO", ")", "-", "reg_save_size", ";", "if", "(", "frame_size", "==", "0", "&&", "!", "cfun", "->", "machine", "->", "is_interrupt", "&&", "!", "m32c_function_needs_enter", "(", ")", ")", "cfun", "->", "machine", "->", "use_rts", "=", "1", ";", "if", "(", "frame_size", ">", "254", ")", "{", "extra_frame_size", "=", "frame_size", "-", "254", ";", "frame_size", "=", "254", ";", "}", "if", "(", "cfun", "->", "machine", "->", "use_rts", "==", "0", ")", "F", "(", "emit_insn", "(", "m32c_all_frame_related", "(", "TARGET_A16", "?", "gen_prologue_enter_16", "(", "GEN_INT", "(", "frame_size", ")", ")", ":", "gen_prologue_enter_24", "(", "GEN_INT", "(", "frame_size", ")", ")", ")", ")", ")", ";", "if", "(", "extra_frame_size", ")", "{", "complex_prologue", "=", "1", ";", "if", "(", "TARGET_A16", ")", "F", "(", "emit_insn", "(", "gen_addhi3", "(", "gen_rtx_REG", "(", "HImode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "HImode", ",", "SP_REGNO", ")", ",", "GEN_INT", "(", "-", "extra_frame_size", ")", ")", ")", ")", ";", "else", "F", "(", "emit_insn", "(", "gen_addpsi3", "(", "gen_rtx_REG", "(", "PSImode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "PSImode", ",", "SP_REGNO", ")", ",", "GEN_INT", "(", "-", "extra_frame_size", ")", ")", ")", ")", ";", "}", "complex_prologue", "+=", "m32c_pushm_popm", "(", "PP_pushm", ")", ";", "if", "(", "complex_prologue", ")", "emit_insn", "(", "gen_prologue_end", "(", ")", ")", ";", "}", "</s>" ]

[ "Emits", "the", "prologue", ".", "See", "the", "frame", "layout", "comment", "earlier", "in", "this", "file", ".", "We", "can", "reserve", "up", "to", "256", "bytes", "with", "the", "ENTER", "opcode", ",", "beyond", "that", "we", "manually", "update", "sp", "." ]

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

[]

[ "<s>", "static", "int", "branch_dest", "(", "rtx_insn", "*", "branch", ")", "{", "rtx", "dest", ";", "int", "dest_uid", ";", "rtx", "pat", "=", "PATTERN", "(", "branch", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "dest", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "IF_THEN_ELSE", ")", "dest", "=", "XEXP", "(", "dest", ",", "1", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "return", "INSN_ADDRESSES", "(", "dest_uid", ")", ";", "}", "</s>" ]

[ "Return", "the", "destination", "address", "of", "BRANCH", ".", "We", "need", "to", "use", "this", "instead", "of", "get_attr_length", ",", "because", "the", "cbranch_with_nops", "pattern", "conservatively", "sets", "its", "length", "to", "6", ",", "and", "we", "still", "prefer", "to", "use", "shorter", "sequences", "." ]

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

[]

[ "<s>", "bool", "SystemZELFFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "SystemZ", "::", "GPRRegs", "RestoreGPRs", "=", "ZFI", "->", "getRestoreGPRRegs", "(", ")", ";", "if", "(", "RestoreGPRs", ".", "LowGPR", ")", "{", "assert", "(", "RestoreGPRs", ".", "LowGPR", "!=", "RestoreGPRs", ".", "HighGPR", "&&", "\"Should be loading %r15 and something else\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LMG", ")", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "LowGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "HighGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "HasFP", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MIB", ".", "addImm", "(", "RestoreGPRs", ".", "GPROffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "RestoreGPRs", ".", "LowGPR", "&&", "Reg", "!=", "RestoreGPRs", ".", "HighGPR", "&&", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::GPRRegs", "\"Should be loading %r15 and something else\"", "SystemZ::LMG", "SystemZ::R11D", "SystemZ::R15D", "0", "SystemZ::GR64BitRegClass" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "AArch64Operand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "RegKind", "Kind", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "MCContext", "&", "Ctx", ",", "RegConstraintEqualityTy", "EqTy", "=", "RegConstraintEqualityTy", "::", "EqualsReg", ",", "AArch64_AM", "::", "ShiftExtendType", "ExtTy", "=", "AArch64_AM", "::", "LSL", ",", "unsigned", "ShiftAmount", "=", "0", ",", "unsigned", "HasExplicitAmount", "=", "false", ")", "{", "auto", "Op", "=", "make_unique", "<", "AArch64Operand", ">", "(", "k_Register", ",", "Ctx", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "Reg", ".", "Kind", "=", "Kind", ";", "Op", "->", "Reg", ".", "ElementWidth", "=", "0", ";", "Op", "->", "Reg", ".", "EqualityTy", "=", "EqTy", ";", "Op", "->", "Reg", ".", "ShiftExtend", ".", "Type", "=", "ExtTy", ";", "Op", "->", "Reg", ".", "ShiftExtend", ".", "Amount", "=", "ShiftAmount", ";", "Op", "->", "Reg", ".", "ShiftExtend", ".", "HasExplicitAmount", "=", "HasExplicitAmount", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "AArch64", "AArch64", "AArch64_AM::ShiftExtendType", "AArch64_AM::LSL", "0", "AArch64", "0" ]

[]

[ "<s>", "rtx", "return_addr_rtx", "(", "int", "count", ",", "rtx", "frameaddr", ")", "{", "rtx", "label", ";", "rtx", "rp", ";", "rtx", "saved_rp", ";", "rtx", "ins", ";", "if", "(", "count", "!=", "0", ")", "return", "NULL_RTX", ";", "rp", "=", "get_hard_reg_initial_val", "(", "Pmode", ",", "2", ")", ";", "if", "(", "TARGET_64BIT", "||", "TARGET_NO_SPACE_REGS", ")", "return", "rp", ";", "saved_rp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "saved_rp", ",", "rp", ")", ";", "ins", "=", "copy_to_reg", "(", "gen_rtx_AND", "(", "Pmode", ",", "rp", ",", "MASK_RETURN_ADDR", ")", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_cmp_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "ins", ")", ",", "GEN_INT", "(", "0x4bc23fd1", ")", ",", "NE", ",", "NULL_RTX", ",", "SImode", ",", "1", ")", ";", "emit_jump_insn", "(", "gen_bne", "(", "label", ")", ")", ";", "emit_cmp_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "ins", ",", "4", ")", ")", ",", "GEN_INT", "(", "0x004010a1", ")", ",", "NE", ",", "NULL_RTX", ",", "SImode", ",", "1", ")", ";", "emit_jump_insn", "(", "gen_bne", "(", "label", ")", ")", ";", "emit_cmp_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "ins", ",", "8", ")", ")", ",", "GEN_INT", "(", "0x00011820", ")", ",", "NE", ",", "NULL_RTX", ",", "SImode", ",", "1", ")", ";", "emit_jump_insn", "(", "gen_bne", "(", "label", ")", ")", ";", "emit_cmp_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "ins", ",", "12", ")", ")", ",", "GEN_INT", "(", "0xe0400002", ")", ",", "NE", ",", "NULL_RTX", ",", "SImode", ",", "1", ")", ";", "emit_jump_insn", "(", "gen_bne", "(", "label", ")", ")", ";", "emit_move_insn", "(", "saved_rp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "plus_constant", "(", "frameaddr", ",", "-", "24", ")", ")", ")", ")", ";", "emit_label", "(", "label", ")", ";", "return", "saved_rp", ";", "}", "</s>" ]

[ "Fetch", "the", "return", "address", "for", "the", "frame", "COUNT", "steps", "up", "from", "the", "current", "frame", ",", "after", "the", "prologue", ".", "FRAMEADDR", "is", "the", "frame", "pointer", "of", "the", "COUNT", "frame", ".", "We", "want", "to", "ignore", "any", "export", "stub", "remnants", "here", ".", "To", "handle", "this", ",", "we", "examine", "the", "code", "at", "the", "return", "address", ",", "and", "if", "it", "is", "an", "export", "stub", ",", "we", "return", "a", "memory", "rtx", "for", "the", "stub", "return", "address", "stored", "at", "frame-24", ".", "The", "value", "returned", "is", "used", "in", "two", "different", "ways", ":", "1", ".", "To", "find", "a", "function", "'s", "caller", ".", "2", ".", "To", "change", "the", "return", "address", "for", "a", "function", ".", "This", "function", "handles", "most", "instances", "of", "case", "1", ";", "however", ",", "it", "will", "fail", "if", "there", "are", "two", "levels", "of", "stubs", "to", "execute", "on", "the", "return", "path", ".", "The", "only", "way", "I", "believe", "that", "can", "happen", "is", "if", "the", "return", "value", "needs", "a", "parameter", "relocation", ",", "which", "never", "happens", "for", "C", "code", ".", "This", "function", "handles", "most", "instances", "of", "case", "2", ";", "however", ",", "it", "will", "fail", "if", "we", "did", "not", "originally", "have", "stub", "code", "on", "the", "return", "path", "but", "will", "need", "stub", "code", "on", "the", "new", "return", "path", ".", "This", "can", "happen", "if", "the", "caller", "&", "callee", "are", "both", "in", "the", "main", "program", ",", "but", "the", "new", "return", "location", "is", "in", "a", "shared", "library", "." ]

[ "pa", "0", "2", "0x4bc23fd1", "1", "4", "0x004010a1", "1", "8", "0x00011820", "1", "12", "0xe0400002", "1", "24" ]

[]

[ "<s>", "int", "X86RegisterInfo", "::", "getSEHRegNum", "(", "unsigned", "i", ")", "const", "{", "return", "getEncodingValue", "(", "i", ")", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "SEH", "register", "number", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "MipsInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCopy", "(", "I", ",", "TII", ",", "MRI", ",", "TRI", ",", "RBI", ")", ";", "return", "true", ";", "}", "if", "(", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "struct", "rtx_def", "*", "function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "bytes", "=", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "GEN_INT", "(", "cum", "->", "call_cookie", ")", ";", "if", "(", "bytes", "==", "-", "1", ")", "return", "NULL_RTX", ";", "if", "(", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "mode", ",", "*", "(", "cum", "->", "arg_regs", ")", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "." ]

[ "bfin", "1" ]

[]

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

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

[ "MBlaze" ]

[]

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

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

[ "VideoCore4" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "lm32_compute_frame_size", "(", "int", "size", ")", "{", "int", "regno", ";", "HOST_WIDE_INT", "total_size", ",", "locals_size", ",", "args_size", ",", "pretend_size", ",", "callee_size", ";", "unsigned", "int", "reg_save_mask", ";", "locals_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "callee_size", "=", "0", ";", "reg_save_mask", "=", "0", ";", "for", "(", "regno", "=", "1", ";", "regno", "<", "SP_REGNUM", ";", "regno", "++", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "{", "reg_save_mask", "|=", "1", "<<", "regno", ";", "callee_size", "+=", "UNITS_PER_WORD", ";", "}", "}", "if", "(", "df_regs_ever_live_p", "(", "RA_REGNUM", ")", "||", "!", "crtl", "->", "is_leaf", "||", "!", "optimize", ")", "{", "reg_save_mask", "|=", "1", "<<", "RA_REGNUM", ";", "callee_size", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "!", "(", "reg_save_mask", "&", "(", "1", "<<", "FP_REGNUM", ")", ")", "&&", "frame_pointer_needed", ")", "{", "reg_save_mask", "|=", "1", "<<", "FP_REGNUM", ";", "callee_size", "+=", "UNITS_PER_WORD", ";", "}", "total_size", "=", "pretend_size", "+", "args_size", "+", "locals_size", "+", "callee_size", ";", "total_size", "=", "(", "total_size", "+", "3", ")", "&", "~", "3", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "callee_size", "=", "callee_size", ";", "current_frame_info", ".", "pretend_size", "=", "pretend_size", ";", "current_frame_info", ".", "locals_size", "=", "locals_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "reg_save_mask", "=", "reg_save_mask", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", "." ]

[ "lm32", "0", "0", "1", "1", "1", "1", "1", "3", "3" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_call_properties", "(", "unsigned", "int", "flags", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "(", "flags", "&", "FLAG_AUTO_FP", ")", "&&", "FLOAT_MODE_P", "(", "mode", ")", ")", "flags", "|=", "FLAG_FP", ";", "if", "(", "!", "flag_trapping_math", ")", "flags", "&=", "~", "FLAG_RAISE_FP_EXCEPTIONS", ";", "return", "flags", ";", "}", "</s>" ]

[ "Return", "a", "set", "of", "FLAG_", "*", "flags", "that", "describe", "what", "the", "function", "could", "do", ",", "taking", "the", "command-line", "flags", "into", "account", "." ]

[ "aarch64" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "if", "(", "Res", ".", "getNode", "(", ")", ")", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

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

[]

[ "<s>", "static", "bool", "isShift", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Opcode", ",", "int64_t", "Imm", ")", "{", "return", "(", "MI", "->", "getOpcode", "(", ")", "==", "Opcode", "&&", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "Imm", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "2", "3" ]

[]

[ "<s>", "static", "bool", "rs6000_secondary_reload_direct_move", "(", "enum", "rs6000_reg_type", "to_type", ",", "enum", "rs6000_reg_type", "from_type", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ",", "bool", "altivec_p", ")", "{", "bool", "ret", "=", "false", ";", "enum", "insn_code", "icode", "=", "CODE_FOR_nothing", ";", "int", "cost", "=", "0", ";", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_POWERPC64", ")", "{", "if", "(", "size", "==", "16", ")", "{", "if", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_vsx_gpr", ";", "}", "else", "if", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_gpr_vsx", ";", "}", "}", "else", "if", "(", "mode", "==", "SFmode", ")", "{", "if", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_gpr_vsx", ";", "}", "else", "if", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", "{", "cost", "=", "2", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_vsx_gpr", ";", "}", "}", "}", "if", "(", "TARGET_POWERPC64", "&&", "size", "==", "16", ")", "{", "if", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_vsx_gpr", ";", "}", "else", "if", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_gpr_vsx", ";", "}", "}", "else", "if", "(", "!", "TARGET_POWERPC64", "&&", "size", "==", "8", ")", "{", "if", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", "&&", "!", "altivec_p", ")", "{", "cost", "=", "3", ";", "icode", "=", "reg_addr", "[", "mode", "]", ".", "reload_fpr_gpr", ";", "}", "}", "if", "(", "icode", "!=", "CODE_FOR_nothing", ")", "{", "ret", "=", "true", ";", "if", "(", "sri", ")", "{", "sri", "->", "icode", "=", "icode", ";", "sri", "->", "extra_cost", "=", "cost", ";", "}", "}", "return", "ret", ";", "}", "</s>" ]

[ "Power8", "helper", "function", "for", "rs6000_secondary_reload", ",", "handle", "all", "of", "the", "special", "direct", "moves", "that", "involve", "allocating", "an", "extra", "register", ",", "return", "the", "insn", "code", "of", "the", "helper", "function", "if", "there", "is", "such", "a", "function", "or", "CODE_FOR_nothing", "if", "not", "." ]

[ "rs6000", "0", "16", "3", "3", "3", "2", "16", "3", "3", "8", "3" ]

[]

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

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

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

[]

[ "<s>", "static", "int", "iq2000_address_cost", "(", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "LO_SUM", ":", "return", "1", ";", "case", "LABEL_REF", ":", "return", "2", ";", "case", "CONST", ":", "{", "rtx", "offset", "=", "const0_rtx", ";", "addr", "=", "eliminate_constant_term", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "2", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "SYMBOL_REF", ")", "return", "4", ";", "if", "(", "!", "SMALL_INT", "(", "offset", ")", ")", "return", "2", ";", "}", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_FLAG", "(", "addr", ")", "?", "1", ":", "2", ";", "case", "PLUS", ":", "{", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "GET_CODE", "(", "plus1", ")", "==", "REG", ")", "plus0", "=", "XEXP", "(", "addr", ",", "1", ")", ",", "plus1", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "SMALL_INT", "(", "plus1", ")", "?", "1", ":", "2", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "HIGH", ":", "case", "LO_SUM", ":", "return", "iq2000_address_cost", "(", "plus1", ")", "+", "1", ";", "default", ":", "break", ";", "}", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", "." ]

[ "iq2000", "1", "2", "0", "2", "4", "2", "1", "2", "0", "1", "1", "0", "1", "2", "1", "4" ]

[]

[ "<s>", "static", "int", "bfin_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "bytes", "=", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "int", "bytes_left", "=", "cum", "->", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "bytes", "==", "-", "1", ")", "return", "0", ";", "if", "(", "bytes_left", "==", "0", ")", "return", "0", ";", "if", "(", "bytes", ">", "bytes_left", ")", "return", "bytes_left", ";", "return", "0", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "passed", "in", "registers", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "Refer", "VDSP", "C", "Compiler", "manual", ",", "our", "ABI", ".", "First", "3", "words", "are", "in", "registers", ".", "So", ",", "if", "a", "an", "argument", "is", "larger", "than", "the", "registers", "available", ",", "it", "will", "span", "the", "register", "and", "stack", "." ]

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

[]

[ "<s>", "int", "avr_starting_frame_offset", "(", "void", ")", "{", "return", "1", "+", "avr_outgoing_args_size", "(", ")", ";", "}", "</s>" ]

[ "This", "is", "the", "offset", "from", "the", "frame", "pointer", "register", "to", "the", "first", "stack", "slot", "that", "contains", "a", "variable", "living", "in", "the", "frame", "." ]

[ "avr", "1" ]

[]

[ "<s>", "bool", "RegDefsUses", "::", "update", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "Begin", ",", "unsigned", "End", ")", "{", "BitVector", "NewDefs", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ",", "NewUses", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ";", "bool", "HasHazard", "=", "false", ";", "for", "(", "unsigned", "I", "=", "Begin", ";", "I", "!=", "End", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", ")", "HasHazard", "|=", "checkRegDefsUses", "(", "NewDefs", ",", "NewUses", ",", "MO", ".", "getReg", "(", ")", ",", "MO", ".", "isDef", "(", ")", ")", ";", "}", "Defs", "|=", "NewDefs", ";", "Uses", "|=", "NewUses", ";", "return", "HasHazard", ";", "}", "</s>" ]

[ "Digest", "more", "data", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "TargetPassConfig", "::", "addPostRegAlloc", "(", ")", ";", "addPass", "(", "createWebAssemblyPEI", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "const", "MachineOperand", "&", "BaseOp1", ",", "const", "MachineOperand", "&", "BaseOp2", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "BaseOp1", ".", "getType", "(", ")", "!=", "BaseOp2", ".", "getType", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "BaseOp1", ".", "isReg", "(", ")", "||", "BaseOp1", ".", "isFI", "(", ")", ")", "&&", "\"Only base registers and frame indices are supported.\"", ")", ";", "if", "(", "BaseOp1", ".", "isReg", "(", ")", "&&", "BaseOp1", ".", "getReg", "(", ")", "!=", "BaseOp2", ".", "getReg", "(", ")", ")", "return", "false", ";", "if", "(", "NumLoads", ">", "1", ")", "return", "false", ";", "if", "(", "!", "isPairableLdStInst", "(", "FirstLdSt", ")", "||", "!", "isPairableLdStInst", "(", "SecondLdSt", ")", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", ".", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "if", "(", "BaseOp1", ".", "isFI", "(", ")", ")", "{", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", "<=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFrameInfo", "(", ")", ";", "return", "shouldClusterFI", "(", "MFI", ",", "BaseOp1", ".", "getIndex", "(", ")", ",", "Offset1", ",", "FirstOpc", ",", "BaseOp2", ".", "getIndex", "(", ")", ",", "Offset2", ",", "SecondOpc", ")", ";", "}", "assert", "(", "Offset1", "<=", "Offset2", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AArch64", "AArch64", "\"Only base registers and frame indices are supported.\"", "1", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "WebAssemblySubtarget", "::", "WebAssemblySubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "WebAssemblyGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "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", "." ]

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

[]

[ "<s>", "void", "P2InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "SrcReg", "==", "P2", "::", "QX", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "P2", "::", "GETQX", ")", ",", "DestReg", ")", ";", "}", "else", "if", "(", "SrcReg", "==", "P2", "::", "QY", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "P2", "::", "GETQY", ")", ",", "DestReg", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "P2", "::", "MOVrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "</s>" ]

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

[ "P2", "P2", "P2::QX", "P2::GETQX", "P2::QY", "P2::GETQY", "P2::MOVrr" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setParsingInlineAsm", "(", "false", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "getParser", "(", ")", ".", "setParsingInlineAsm", "(", "true", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", "==", "\".even\"", ")", "return", "parseDirectiveEven", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "\"prefix\"", "\"noprefix\"", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\"prefix\"", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", "\".even\"" ]

[]

[ "<s>", "bool", "BlackfinAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "O", "<<", "'['", ";", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "O", "<<", "']'", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Blackfin", "0" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "mergeOutliningCandidateAttributes", "(", "Function", "&", "F", ",", "std", "::", "vector", "<", "outliner", "::", "Candidate", ">", "&", "Candidates", ")", "const", "{", "outliner", "::", "Candidate", "&", "C", "=", "Candidates", ".", "front", "(", ")", ";", "const", "Function", "&", "CFn", "=", "C", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ";", "if", "(", "CFn", ".", "hasFnAttribute", "(", "\"branch-target-enforcement\"", ")", ")", "F", ".", "addFnAttr", "(", "CFn", ".", "getFnAttribute", "(", "\"branch-target-enforcement\"", ")", ")", ";", "ARMGenInstrInfo", "::", "mergeOutliningCandidateAttributes", "(", "F", ",", "Candidates", ")", ";", "}", "</s>" ]

[ "Optional", "target", "hook", "to", "create", "the", "LLVM", "IR", "attributes", "for", "the", "outlined", "function", "." ]

[ "ARM", "ARM", "\"branch-target-enforcement\"", "\"branch-target-enforcement\"", "ARM" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", ".", "isLabel", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "static", "void", "mips_process_load_label", "(", "rtx", "target", ")", "{", "rtx", "base", ",", "gp", ",", "intop", ";", "HOST_WIDE_INT", "offset", ";", "mips_multi_start", "(", ")", ";", "switch", "(", "mips_abi", ")", "{", "case", "ABI_N32", ":", "mips_multi_add_insn", "(", "\"lw\\t%@,%%got_page(%0)(%+)\"", ",", "target", ",", "0", ")", ";", "mips_multi_add_insn", "(", "\"addiu\\t%@,%@,%%got_ofst(%0)\"", ",", "target", ",", "0", ")", ";", "break", ";", "case", "ABI_64", ":", "mips_multi_add_insn", "(", "\"ld\\t%@,%%got_page(%0)(%+)\"", ",", "target", ",", "0", ")", ";", "mips_multi_add_insn", "(", "\"daddiu\\t%@,%@,%%got_ofst(%0)\"", ",", "target", ",", "0", ")", ";", "break", ";", "default", ":", "gp", "=", "pic_offset_table_rtx", ";", "if", "(", "mips_cfun_has_cprestore_slot_p", "(", ")", ")", "{", "gp", "=", "gen_rtx_REG", "(", "Pmode", ",", "AT_REGNUM", ")", ";", "mips_get_cprestore_base_and_offset", "(", "&", "base", ",", "&", "offset", ",", "true", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "offset", ")", ")", "{", "intop", "=", "GEN_INT", "(", "CONST_HIGH_PART", "(", "offset", ")", ")", ";", "mips_multi_add_insn", "(", "\"lui\\t%0,%1\"", ",", "gp", ",", "intop", ",", "0", ")", ";", "mips_multi_add_insn", "(", "\"addu\\t%0,%0,%1\"", ",", "gp", ",", "base", ",", "0", ")", ";", "base", "=", "gp", ";", "offset", "=", "CONST_LOW_PART", "(", "offset", ")", ";", "}", "intop", "=", "GEN_INT", "(", "offset", ")", ";", "if", "(", "ISA_HAS_LOAD_DELAY", ")", "mips_multi_add_insn", "(", "\"lw\\t%0,%1(%2)%#\"", ",", "gp", ",", "intop", ",", "base", ",", "0", ")", ";", "else", "mips_multi_add_insn", "(", "\"lw\\t%0,%1(%2)\"", ",", "gp", ",", "intop", ",", "base", ",", "0", ")", ";", "}", "if", "(", "ISA_HAS_LOAD_DELAY", ")", "mips_multi_add_insn", "(", "\"lw\\t%@,%%got(%0)(%1)%#\"", ",", "target", ",", "gp", ",", "0", ")", ";", "else", "mips_multi_add_insn", "(", "\"lw\\t%@,%%got(%0)(%1)\"", ",", "target", ",", "gp", ",", "0", ")", ";", "mips_multi_add_insn", "(", "\"addiu\\t%@,%@,%%lo(%0)\"", ",", "target", ",", "0", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Build", "up", "a", "multi-insn", "sequence", "that", "loads", "label", "TARGET", "into", "$", "AT", "." ]

[ "mips", "\"lw\\t%@,%%got_page(%0)(%+)\"", "0", "\"addiu\\t%@,%@,%%got_ofst(%0)\"", "0", "\"ld\\t%@,%%got_page(%0)(%+)\"", "0", "\"daddiu\\t%@,%@,%%got_ofst(%0)\"", "0", "\"lui\\t%0,%1\"", "0", "\"addu\\t%0,%0,%1\"", "0", "\"lw\\t%0,%1(%2)%#\"", "0", "\"lw\\t%0,%1(%2)\"", "0", "\"lw\\t%@,%%got(%0)(%1)%#\"", "0", "\"lw\\t%@,%%got(%0)(%1)\"", "0", "\"addiu\\t%@,%@,%%lo(%0)\"", "0" ]

[]

[ "<s>", "static", "int", "s390_function_arg_size", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "type", ")", "return", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "mode", "!=", "BLKmode", ")", "return", "GET_MODE_SIZE", "(", "mode", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "size", "in", "bytes", "of", "a", "function", "argument", "of", "type", "TYPE", "and/or", "mode", "MODE", ".", "At", "least", "one", "of", "TYPE", "or", "MODE", "must", "be", "specified", "." ]

[ "s390" ]

[]

[ "<s>", "static", "bool", "s390_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "(", "mode1", "==", "SFmode", "||", "mode1", "==", "DFmode", ")", "==", "(", "mode2", "==", "SFmode", "||", "mode2", "==", "DFmode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "s390" ]

[]

[ "<s>", "static", "void", "arc_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "(", "mode", "==", "BLKmode", "?", "int_size_in_bytes", "(", "type", ")", ":", "(", "int", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "i", ";", "if", "(", "words", ")", "*", "cum", "=", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "mode", ",", "type", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "i", "++", ")", "*", "cum", "=", "ARC_NEXT_ARG_REG", "(", "*", "cum", ")", ";", "}", "</s>" ]

[ "For", "the", "ARC", ":", "the", "cum", "set", "here", "is", "passed", "on", "to", "function_arg", "where", "we", "look", "at", "its", "value", "and", "say", "which", "reg", "to", "use", ".", "Strategy", ":", "advance", "the", "regnumber", "here", "till", "we", "run", "out", "of", "arg", "regs", ",", "then", "set", "*", "cum", "to", "last", "reg", ".", "In", "function_arg", ",", "since", "*", "cum", ">", "last", "arg", "reg", "we", "would", "return", "0", "and", "thus", "the", "arg", "will", "end", "up", "on", "the", "stack", ".", "For", "straddling", "args", "of", "course", "function_arg_partial_nregs", "will", "come", "into", "play", "." ]

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

[]

[ "<s>", "void", "SystemZXPLINKFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "auto", "&", "Regs", "=", "Subtarget", ".", "getSpecialRegisters", "<", "SystemZXPLINK64Registers", ">", "(", ")", ";", "if", "(", "HasFP", ")", "SavedRegs", ".", "set", "(", "Regs", ".", "getFramePointerRegister", "(", ")", ")", ";", "SavedRegs", ".", "set", "(", "Regs", ".", "getReturnFunctionAddressRegister", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

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

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

[ "Mips", "\"Mips Assembly Printer\"" ]

[]

[ "<s>", "const", "char", "*", "vfp_output_vstmd", "(", "rtx", "*", "operands", ")", "{", "char", "pattern", "[", "100", "]", ";", "int", "p", ";", "int", "base", ";", "int", "i", ";", "rtx", "addr_reg", "=", "REG_P", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "?", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ":", "XEXP", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "0", ")", ";", "bool", "push_p", "=", "REGNO", "(", "addr_reg", ")", "==", "SP_REGNUM", ";", "if", "(", "push_p", ")", "strcpy", "(", "pattern", ",", "\"vpush%?.64\\t{%P1\"", ")", ";", "else", "strcpy", "(", "pattern", ",", "\"vstmdb%?.64\\t%m0!, {%P1\"", ")", ";", "p", "=", "strlen", "(", "pattern", ")", ";", "gcc_assert", "(", "REG_P", "(", "operands", "[", "1", "]", ")", ")", ";", "base", "=", "(", "REGNO", "(", "operands", "[", "1", "]", ")", "-", "FIRST_VFP_REGNUM", ")", "/", "2", ";", "for", "(", "i", "=", "1", ";", "i", "<", "XVECLEN", "(", "operands", "[", "2", "]", ",", "0", ")", ";", "i", "++", ")", "{", "p", "+=", "sprintf", "(", "&", "pattern", "[", "p", "]", ",", "\", d%d\"", ",", "base", "+", "i", ")", ";", "}", "strcpy", "(", "&", "pattern", "[", "p", "]", ",", "\"}\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "for", "a", "store", "multiple", "." ]

[ "arm", "100", "0", "0", "0", "0", "0", "0", "0", "\"vpush%?.64\\t{%P1\"", "\"vstmdb%?.64\\t%m0!, {%P1\"", "1", "1", "2", "1", "2", "0", "\", d%d\"", "\"}\"", "\"\"" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "return", "0", ";", "return", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "R600", "SI", "3", "1", "2", "0" ]

[]

[ "<s>", "LiveRange", "(", "unsigned", "virtReg", ")", ":", "LiveRange", "(", ")", "{", "virtRegs", ".", "insert", "(", "virtReg", ")", ";", "}", "</s>" ]

[ "Constructs", "a", "new", "LiveRange", "object", "by", "copying", "segments", "and", "valnos", "from", "another", "LiveRange", "." ]

[ "X86" ]

[]

[ "<s>", "SDValue", "TOYTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InGlue", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "assert", "(", "!", "isVarArg", "&&", "\"Unsupported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_TOY", ")", ";", "for", "(", "auto", "&", "Loc", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Loc", ".", "getLocReg", "(", ")", ",", "Loc", ".", "getValVT", "(", ")", ",", "InGlue", ")", ".", "getValue", "(", "1", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "ISD::InputArg", "\"Unsupported\"", "16", "TOY", "1", "2", "0" ]

[]

[ "<s>", "bool", "TPCAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "!", "AsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "MBB", ")", ")", "{", "return", "false", ";", "}", "assert", "(", "MBB", "->", "pred_size", "(", ")", "<=", "1", "&&", "\"Fallthrough blocks can have only one predecessor\"", ")", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", "->", "begin", "(", ")", ",", "E", "=", "MF", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineBasicBlock", "*", "Block", "=", "&", "*", "I", ";", "for", "(", "const", "MachineInstr", "&", "MI", ":", "Block", "->", "instrs", "(", ")", ")", "{", "if", "(", "isLoop", "(", "MI", ")", ")", "{", "int", "idx", "=", "TPCII", "::", "getIsPredicated", "(", "MI", ".", "getDesc", "(", ")", ")", "?", "MI", ".", "getNumOperands", "(", ")", "-", "7", ":", "MI", ".", "getNumOperands", "(", ")", "-", "5", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "idx", ")", ";", "assert", "(", "MO", ".", "isMBB", "(", ")", "&&", "\"Last operand in a LOOP instruction should be a block\"", ")", ";", "if", "(", "MO", ".", "getMBB", "(", ")", "==", "MBB", ")", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "TPC", "TPC", "1", "\"Fallthrough blocks can have only one predecessor\"", "TPC", "7", "5", "\"Last operand in a LOOP instruction should be a block\"" ]

[]

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

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

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

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "Node", "=", "AdjustRegClass", "(", "Node", ",", "DAG", ")", ";", "if", "(", "AMDGPU", "::", "isMIMG", "(", "Node", "->", "getMachineOpcode", "(", ")", ")", "!=", "-", "1", ")", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "return", "foldOperands", "(", "Node", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

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

[]

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

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

[ "SystemZ" ]

[]

[ "<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyExternalReference", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "nullptr", ")", ")", "return", "classifyLocalReference", "(", "nullptr", ")", ";", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "return", "M680x0II", "::", "MO_GOTPCREL", ";", "}", "else", "{", "return", "M680x0II", "::", "MO_GOT", ";", "}", "}", "</s>" ]

[ "Classify", "a", "external", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "M680x0", "M680x0", "M680x0II::MO_GOTPCREL", "M680x0II::MO_GOT" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tMOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ")", ";", "assert", "(", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", "&&", "\"Thumb1 can only copy GPR registers\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::tMOVr", "ARM::GPRRegClass", "\"Thumb1 can only copy GPR registers\"" ]

[]

[ "<s>", "static", "X86Operand", "*", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "bool", "AddressOf", "=", "false", ",", "SMLoc", "OffsetOfLoc", "=", "SMLoc", "(", ")", ")", "{", "X86Operand", "*", "Res", "=", "new", "X86Operand", "(", "Register", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Res", "->", "AddressOf", "=", "AddressOf", ";", "Res", "->", "OffsetOfLoc", "=", "OffsetOfLoc", ";", "return", "Res", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "static", "bool", "arc_in_small_data_p", "(", "const_tree", "decl", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TARGET_NO_SDATA_SET", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "0", ")", "{", "const", "char", "*", "name", ";", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".sdata\"", ")", "!=", "0", "&&", "strcmp", "(", "name", ",", "\".sbss\"", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "true", ";", "}", "else", "if", "(", "1", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "(", "!", "DECL_INITIAL", "(", "decl", ")", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")", ")", ")", "return", "false", ";", "if", "(", "default_binds_local_p_1", "(", "decl", ",", "1", ")", "||", "arc_decl_anon_ns_mem_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "decl", ")", ")", "return", "false", ";", "}", "if", "(", "DECL_WEAK", "(", "decl", ")", ")", "return", "false", ";", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "return", "(", "size", ">", "0", "&&", "size", "<=", "4", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_IN_SMALL_DATA_P", ".", "Return", "true", "if", "it", "would", "be", "safe", "to", "access", "DECL", "using", "%", "gp_rel", "(", "...", ")", "(", "$", "gp", ")", "." ]

[ "arc", "0", "\".sdata\"", "0", "\".sbss\"", "0", "1", "1", "0", "4" ]

[]

[ "<s>", "bool", "nds32_n7_load_to_ii_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "if", "(", "post_update_insn_p", "(", "producer", ")", ")", "return", "false", ";", "rtx", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "return", "n7_consumed_by_ii_dep_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Guard", "functions", "for", "N7", "core", "." ]

[ "nds32" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "ARM64AppleInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "StringRef", "Layout", ",", "Mnemonic", ";", "bool", "IsTbx", ";", "if", "(", "isTblTbxInstruction", "(", "MI", "->", "getOpcode", "(", ")", ",", "Layout", ",", "IsTbx", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "(", "IsTbx", "?", "\"tbx\"", ":", "\"tbl\"", ")", "<<", "Layout", "<<", "'\\t'", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "ARM64", "::", "vreg", ")", "<<", "\", \"", ";", "unsigned", "ListOpNum", "=", "IsTbx", "?", "2", ":", "1", ";", "printVectorList", "(", "MI", ",", "ListOpNum", ",", "O", ",", "\"\"", ")", ";", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "ListOpNum", "+", "1", ")", ".", "getReg", "(", ")", ",", "ARM64", "::", "vreg", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "LdStNInstrDesc", "*", "LdStDesc", "=", "getLdStNInstrDesc", "(", "Opcode", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "LdStDesc", "->", "Mnemonic", "<<", "LdStDesc", "->", "Layout", "<<", "'\\t'", ";", "int", "OpNum", "=", "LdStDesc", "->", "ListOperand", ";", "printVectorList", "(", "MI", ",", "OpNum", "++", ",", "O", ",", "\"\"", ")", ";", "if", "(", "LdStDesc", "->", "HasLane", ")", "O", "<<", "'['", "<<", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getImm", "(", ")", "<<", "']'", ";", "unsigned", "AddrReg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "O", "<<", "\", [\"", "<<", "getRegisterName", "(", "AddrReg", ")", "<<", "']'", ";", "if", "(", "LdStDesc", "->", "NaturalOffset", "!=", "0", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "ARM64", "::", "XZR", ")", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "Reg", ")", ";", "else", "{", "assert", "(", "LdStDesc", "->", "NaturalOffset", "&&", "\"no offset on post-inc instruction?\"", ")", ";", "O", "<<", "\", #\"", "<<", "LdStDesc", "->", "NaturalOffset", ";", "}", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "ARM64InstPrinter", "::", "printInst", "(", "MI", ",", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"\\t\"", "\"tbx\"", "\"tbl\"", "0", "ARM64::vreg", "\", \"", "2", "1", "\"\"", "\", \"", "1", "ARM64::vreg", "\"\\t\"", "\"\"", "\", [\"", "0", "ARM64::XZR", "\", \"", "\"no offset on post-inc instruction?\"", "\", #\"", "ARM64" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "{", "if", "(", "SDValue", "Res", "=", "lowerINSERT_VECTOR_ELT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "{", "if", "(", "SDValue", "Res", "=", "lowerEXTRACT_VECTOR_ELT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IID", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "IID", "==", "Intrinsic", "::", "amdgcn_cvt_pkrtz", ")", "{", "SDValue", "Src0", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Src1", "=", "N", "->", "getOperand", "(", "2", ")", ";", "SDLoc", "SL", "(", "N", ")", ";", "SDValue", "Cvt", "=", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "CVT_PKRTZ_F16_F32", ",", "SL", ",", "MVT", "::", "i32", ",", "Src0", ",", "Src1", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "v2f16", ",", "Cvt", ")", ")", ";", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "SELECT", ":", "{", "SDLoc", "SL", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "EVT", "NewVT", "=", "getEquivalentMemType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", ";", "SDValue", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "NewVT", ",", "N", "->", "getOperand", "(", "1", ")", ")", ";", "SDValue", "RHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "NewVT", ",", "N", "->", "getOperand", "(", "2", ")", ")", ";", "EVT", "SelectVT", "=", "NewVT", ";", "if", "(", "NewVT", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "{", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "SL", ",", "MVT", "::", "i32", ",", "LHS", ")", ";", "RHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "SL", ",", "MVT", "::", "i32", ",", "RHS", ")", ";", "SelectVT", "=", "MVT", "::", "i32", ";", "}", "SDValue", "NewSelect", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "SL", ",", "SelectVT", ",", "N", "->", "getOperand", "(", "0", ")", ",", "LHS", ",", "RHS", ")", ";", "if", "(", "NewVT", "!=", "SelectVT", ")", "NewSelect", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "SL", ",", "NewVT", ",", "NewSelect", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "VT", ",", "NewSelect", ")", ")", ";", "return", ";", "}", "default", ":", "break", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "ISD::INSERT_VECTOR_ELT", "0", "ISD::EXTRACT_VECTOR_ELT", "0", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::amdgcn_cvt_pkrtz", "1", "2", "AMDGPUISD::CVT_PKRTZ_F16_F32", "MVT::i32", "ISD::BITCAST", "MVT::v2f16", "ISD::SELECT", "0", "ISD::BITCAST", "1", "ISD::BITCAST", "2", "MVT::i32", "ISD::ANY_EXTEND", "MVT::i32", "ISD::ANY_EXTEND", "MVT::i32", "MVT::i32", "ISD::SELECT", "0", "ISD::TRUNCATE", "ISD::BITCAST" ]

[]

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

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

[ "RISCV", "\"RISCV Assembly Printer\"" ]

[]

[ "<s>", "TargetPassConfig", "*", "LanaiTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PassManager", ")", "{", "return", "new", "LanaiPassConfig", "(", "this", ",", "&", "PassManager", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

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

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "1", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ";", "break", ";", "}", "}", "else", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_SAVE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_SAVE", ";", "break", ";", "case", "96", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_SAVE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "1", ")", "{", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "1", "8", "32", "SI", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "8", "32", "SI", "64", "SI", "96", "SI", "128", "SI", "256", "SI", "512", "SI", "1", "4", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "thumb1_emit_multi_reg_push", "(", "unsigned", "long", "mask", ",", "unsigned", "long", "real_regs", ")", "{", "unsigned", "long", "regno", ";", "rtx", "par", "[", "10", "]", ",", "tmp", ",", "reg", ";", "rtx_insn", "*", "insn", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ";", "mask", ";", "++", "i", ",", "mask", "&=", "mask", "-", "1", ")", "{", "regno", "=", "ctz_hwi", "(", "mask", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "if", "(", "i", "==", "0", ")", "tmp", "=", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ";", "else", "tmp", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "par", "[", "i", "]", "=", "tmp", ";", "}", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "i", ")", ";", "tmp", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "tmp", ")", ";", "tmp", "=", "gen_frame_mem", "(", "BLKmode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "par", "[", "0", "]", ")", ";", "par", "[", "0", "]", "=", "tmp", ";", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "i", ",", "par", ")", ")", ";", "insn", "=", "emit_insn", "(", "tmp", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "i", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "tmp", ")", ";", "par", "[", "0", "]", "=", "tmp", ";", "for", "(", "j", "=", "0", ";", "real_regs", ";", "++", "j", ",", "real_regs", "&=", "real_regs", "-", "1", ")", "{", "regno", "=", "ctz_hwi", "(", "real_regs", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "j", "*", "4", ")", ";", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "par", "[", "j", "+", "1", "]", "=", "tmp", ";", "}", "if", "(", "j", "==", "0", ")", "tmp", "=", "par", "[", "0", "]", ";", "else", "{", "RTX_FRAME_RELATED_P", "(", "par", "[", "0", "]", ")", "=", "1", ";", "tmp", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "j", "+", "1", ",", "par", ")", ")", ";", "}", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "tmp", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Like", "emit_multi_reg_push", ",", "but", "allowing", "for", "a", "different", "set", "of", "registers", "to", "be", "described", "as", "saved", ".", "MASK", "is", "the", "set", "of", "registers", "to", "be", "saved", ";", "REAL_REGS", "is", "the", "set", "of", "registers", "to", "be", "described", "as", "saved", ".", "If", "REAL_REGS", "is", "0", ",", "only", "describe", "the", "stack", "adjustment", "." ]

[ "arm", "10", "0", "1", "0", "1", "4", "0", "0", "4", "0", "0", "1", "4", "1", "1", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "uint64_t", "SystemZMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "uint64_t", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unexpected operand type!\"", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "SystemZ", "SystemZ", "\"Unexpected operand type!\"" ]

[]

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

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

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

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "AArch64TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "Info", ",", "const", "char", "*", "Constraint", ")", "const", "{", "llvm_unreachable", "(", "\"Constraint weight unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Constraint weight unimplemented\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Outs", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other", "0" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "JIT", ",", "RM", ")", ",", "getEffectiveX86CodeModel", "(", "CM", ",", "JIT", ",", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", "{", "std", "::", "cout", "<<", "\"X86TargetMachine --->> In the constructor class !! \\n\"", ";", "if", "(", "(", "TT", ".", "isOSWindows", "(", ")", "&&", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "||", "TT", ".", "isPS4", "(", ")", "||", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "TT", ".", "isOSBinFormatMachO", "(", ")", ";", "}", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "setMachineOutliner", "(", "true", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"X86TargetMachine --->> In the constructor class !! \\n\"" ]

[]

[ "<s>", "static", "void", "ix86_test_dumping_hard_regs", "(", ")", "{", "ASSERT_RTL_DUMP_EQ", "(", "\"(reg:SI ax)\"", ",", "gen_raw_REG", "(", "SImode", ",", "0", ")", ")", ";", "ASSERT_RTL_DUMP_EQ", "(", "\"(reg:SI dx)\"", ",", "gen_raw_REG", "(", "SImode", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Verify", "that", "hard", "regs", "are", "dumped", "as", "expected", "(", "in", "compact", "mode", ")", "." ]

[ "i386", "\"(reg:SI ax)\"", "0", "\"(reg:SI dx)\"", "1" ]

[]

[ "<s>", "static", "rtx", "m68k_get_m68k_read_tp", "(", "void", ")", "{", "if", "(", "m68k_read_tp", "==", "NULL_RTX", ")", "m68k_read_tp", "=", "init_one_libfunc", "(", "\"__m68k_read_tp\"", ")", ";", "return", "m68k_read_tp", ";", "}", "</s>" ]

[ "Return", "SYMBOL_REF", "for", "__m68k_read_tp", "." ]

[ "m68k", "\"__m68k_read_tp\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "optimizeCompareInstr", "(", "MachineInstr", "&", "CmpInstr", ",", "Register", "SrcReg", ",", "Register", "SrcReg2", ",", "int64_t", "CmpMask", ",", "int64_t", "CmpValue", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "assert", "(", "CmpInstr", ".", "getParent", "(", ")", ")", ";", "assert", "(", "MRI", ")", ";", "int", "DeadNZCVIdx", "=", "CmpInstr", ".", "findRegisterDefOperandIdx", "(", "AArch64", "::", "NZCV", ",", "true", ")", ";", "if", "(", "DeadNZCVIdx", "!=", "-", "1", ")", "{", "if", "(", "CmpInstr", ".", "definesRegister", "(", "AArch64", "::", "WZR", ")", "||", "CmpInstr", ".", "definesRegister", "(", "AArch64", "::", "XZR", ")", ")", "{", "CmpInstr", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "unsigned", "Opc", "=", "CmpInstr", ".", "getOpcode", "(", ")", ";", "unsigned", "NewOpc", "=", "convertToNonFlagSettingOpc", "(", "CmpInstr", ")", ";", "if", "(", "NewOpc", "==", "Opc", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "NewOpc", ")", ";", "CmpInstr", ".", "setDesc", "(", "MCID", ")", ";", "CmpInstr", ".", "RemoveOperand", "(", "DeadNZCVIdx", ")", ";", "bool", "succeeded", "=", "UpdateOperandRegClass", "(", "CmpInstr", ")", ";", "(", "void", ")", "succeeded", ";", "assert", "(", "succeeded", "&&", "\"Some operands reg class are incompatible!\"", ")", ";", "return", "true", ";", "}", "if", "(", "CmpInstr", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "PTEST_PP", ")", "return", "optimizePTestInstr", "(", "&", "CmpInstr", ",", "SrcReg", ",", "SrcReg2", ",", "MRI", ")", ";", "if", "(", "SrcReg2", "!=", "0", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "use_nodbg_empty", "(", "CmpInstr", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "if", "(", "CmpValue", "==", "0", "&&", "substituteCmpToZero", "(", "CmpInstr", ",", "SrcReg", ",", "*", "MRI", ")", ")", "return", "true", ";", "return", "(", "CmpValue", "==", "0", "||", "CmpValue", "==", "1", ")", "&&", "removeCmpToZeroOrOne", "(", "CmpInstr", ",", "SrcReg", ",", "CmpValue", ",", "*", "MRI", ")", ";", "}", "</s>" ]

[ "optimizeCompareInstr", "-", "Check", "if", "there", "exists", "an", "earlier", "instruction", "that", "operates", "on", "the", "same", "source", "operands", "and", "sets", "flags", "in", "the", "same", "way", "as", "Compare", ";", "remove", "Compare", "if", "possible", "." ]

[ "AArch64", "AArch64", "AArch64::NZCV", "1", "AArch64::WZR", "AArch64::XZR", "\"Some operands reg class are incompatible!\"", "AArch64::PTEST_PP", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasPOPCNT", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAVX", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasCLMUL", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "stackAlignment", "(", "8", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Is64Bit", "(", "is64Bit", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "CPU", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "if", "(", "HasAVX", ")", "X86SSELevel", "=", "NoMMXSSE", ";", "}", "else", "{", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "Is64Bit", "&&", "!", "HasAVX", "&&", "X86SSELevel", "<", "SSE2", ")", "X86SSELevel", "=", "SSE2", ";", "}", "if", "(", "Is64Bit", ")", "{", "HasX86_64", "=", "true", ";", "HasCMov", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "Is64Bit", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "isTargetDarwin", "(", ")", "||", "Is64Bit", ")", "stackAlignment", "=", "16", ";", "if", "(", "StackAlignment", ")", "stackAlignment", "=", "StackAlignment", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "8", "128", "X86", "X86", "X86", "X86", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "16" ]

[]

[ "<s>", "static", "bool", "mep_assign_save_slots", "(", "int", "reg_save_size", ")", "{", "bool", "really_need_stack_frame", "=", "false", ";", "int", "di_ofs", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "mep_call_saves_register", "(", "i", ")", ")", "{", "int", "regsize", "=", "mep_reg_size", "(", "i", ")", ";", "if", "(", "(", "i", "!=", "TP_REGNO", "&&", "i", "!=", "GP_REGNO", "&&", "i", "!=", "LP_REGNO", ")", "||", "mep_reg_set_in_function", "(", "i", ")", ")", "really_need_stack_frame", "=", "true", ";", "if", "(", "cfun", "->", "machine", "->", "reg_save_slot", "[", "i", "]", ")", "continue", ";", "if", "(", "regsize", "<", "8", ")", "{", "cfun", "->", "machine", "->", "reg_save_size", "+=", "regsize", ";", "cfun", "->", "machine", "->", "reg_save_slot", "[", "i", "]", "=", "cfun", "->", "machine", "->", "reg_save_size", ";", "}", "else", "{", "cfun", "->", "machine", "->", "reg_save_slot", "[", "i", "]", "=", "reg_save_size", "-", "di_ofs", ";", "di_ofs", "+=", "8", ";", "}", "}", "cfun", "->", "machine", "->", "frame_locked", "=", "1", ";", "return", "really_need_stack_frame", ";", "}", "</s>" ]

[ "Assign", "save", "slots", "for", "any", "register", "not", "already", "saved", ".", "DImode", "registers", "go", "at", "the", "end", "of", "the", "reg", "save", "area", ";", "the", "rest", "go", "at", "the", "beginning", ".", "This", "is", "for", "alignment", "purposes", ".", "Returns", "true", "if", "a", "frame", "is", "really", "needed", "." ]

[ "mep", "0", "0", "8", "8", "1" ]

[]

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

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

[ "Mips", "\"MipsPostLegalizerCombiner\"" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "Cpu0" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "LM32TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

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

[ "LM32", "LM32" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalInterleavedAccessType", "(", "VectorType", "*", "VecTy", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "unsigned", "VecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", ";", "unsigned", "ElSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", "->", "getElementType", "(", ")", ")", ";", "if", "(", "cast", "<", "FixedVectorType", ">", "(", "VecTy", ")", "->", "getNumElements", "(", ")", "<", "2", ")", "return", "false", ";", "if", "(", "ElSize", "!=", "8", "&&", "ElSize", "!=", "16", "&&", "ElSize", "!=", "32", "&&", "ElSize", "!=", "64", ")", "return", "false", ";", "return", "VecSize", "==", "64", "||", "VecSize", "%", "128", "==", "0", ";", "}", "</s>" ]

[ "Returns", "whether", "or", "not", "generating", "a", "interleaved", "load/store", "intrinsic", "for", "this", "type", "will", "be", "legal", "." ]

[ "AArch64", "AArch64", "2", "8", "16", "32", "64", "64", "128", "0" ]

[]

[ "<s>", "void", "AMDGPUFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "M680x0" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "-", "1", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ix86_emit_swsqrtsf", "(", "rtx", "res", ",", "rtx", "a", ",", "machine_mode", "mode", ",", "bool", "recip", ")", "{", "rtx", "x0", ",", "e0", ",", "e1", ",", "e2", ",", "e3", ",", "mthree", ",", "mhalf", ";", "REAL_VALUE_TYPE", "r", ";", "int", "unspec", ";", "x0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e3", "=", "gen_reg_rtx", "(", "mode", ")", ";", "real_from_integer", "(", "&", "r", ",", "VOIDmode", ",", "-", "3", ",", "SIGNED", ")", ";", "mthree", "=", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "r", ",", "SFmode", ")", ";", "real_arithmetic", "(", "&", "r", ",", "NEGATE_EXPR", ",", "&", "dconsthalf", ",", "NULL", ")", ";", "mhalf", "=", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "r", ",", "SFmode", ")", ";", "unspec", "=", "UNSPEC_RSQRT", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "mthree", "=", "ix86_build_const_vector", "(", "mode", ",", "true", ",", "mthree", ")", ";", "mhalf", "=", "ix86_build_const_vector", "(", "mode", ",", "true", ",", "mhalf", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "unspec", "=", "UNSPEC_RSQRT14", ";", "}", "a", "=", "force_reg", "(", "mode", ",", "a", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x0", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "a", ")", ",", "unspec", ")", ")", ")", ";", "if", "(", "!", "recip", ")", "{", "rtx", "zero", ",", "mask", ";", "zero", "=", "gen_reg_rtx", "(", "mode", ")", ";", "mask", "=", "gen_reg_rtx", "(", "mode", ")", ";", "zero", "=", "force_reg", "(", "mode", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "{", "mask", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_avx512f_cmpv16sf3", "(", "mask", ",", "zero", ",", "a", ",", "GEN_INT", "(", "0x4", ")", ")", ")", ";", "emit_insn", "(", "gen_avx512f_blendmv16sf", "(", "x0", ",", "zero", ",", "x0", ",", "mask", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "mask", ",", "gen_rtx_NE", "(", "mode", ",", "zero", ",", "a", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x0", ",", "gen_rtx_AND", "(", "mode", ",", "x0", ",", "mask", ")", ")", ")", ";", "}", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e0", ",", "gen_rtx_MULT", "(", "mode", ",", "x0", ",", "a", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e1", ",", "gen_rtx_MULT", "(", "mode", ",", "e0", ",", "x0", ")", ")", ")", ";", "mthree", "=", "force_reg", "(", "mode", ",", "mthree", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e2", ",", "gen_rtx_PLUS", "(", "mode", ",", "e1", ",", "mthree", ")", ")", ")", ";", "mhalf", "=", "force_reg", "(", "mode", ",", "mhalf", ")", ";", "if", "(", "recip", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e3", ",", "gen_rtx_MULT", "(", "mode", ",", "x0", ",", "mhalf", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e3", ",", "gen_rtx_MULT", "(", "mode", ",", "e0", ",", "mhalf", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "res", ",", "gen_rtx_MULT", "(", "mode", ",", "e2", ",", "e3", ")", ")", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "Newton-Rhapson", "approximation", "of", "a", "single", "precision", "floating", "point", "[", "reciprocal", "]", "square", "root", "." ]

[ "i386", "3", "64", "1", "64", "0x4" ]

[]

[ "<s>", "unsigned", "CSKYAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "CSKYOperand", "&", "Op", "=", "static_cast", "<", "CSKYOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "MCRegister", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "FPR32RegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_FPR64", "||", "Kind", "==", "MCK_sFPR64_V", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR32ToFPR64", "(", "Reg", ")", ";", "if", "(", "Kind", "==", "MCK_sFPR64_V", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F15_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "if", "(", "Kind", "==", "MCK_FPR64", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F31_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "return", "Match_Success", ";", "}", "}", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "GPRRegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_GPRPair", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "MRI", "->", "getEncodingValue", "(", "Reg", ")", "+", "CSKY", "::", "R0_R1", ";", "return", "Match_Success", ";", "}", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY::FPR32RegClassID", "CSKY::F0_64", "CSKY::F15_64", "CSKY::F0_64", "CSKY::F31_64", "CSKY", "CSKY::GPRRegClassID", "CSKY::R0_R1" ]

[]

[ "<s>", "bool", "AMDGPUAtomicOptimizer", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "{", "return", "false", ";", "}", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "DominatorTreeWrapperPass", "*", "const", "DTW", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTW", "?", "&", "DTW", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "const", "TargetPassConfig", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "HasDPP", "=", "ST", ".", "hasDPP", "(", ")", ";", "IsPixelShader", "=", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", ";", "visit", "(", "F", ")", ";", "const", "bool", "Changed", "=", "!", "ToReplace", ".", "empty", "(", ")", ";", "for", "(", "ReplacementInfo", "&", "Info", ":", "ToReplace", ")", "{", "optimizeAtomic", "(", "*", "Info", ".", "I", ",", "Info", ".", "Op", ",", "Info", ".", "ValIdx", ",", "Info", ".", "ValDivergent", ")", ";", "}", "ToReplace", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Teak", "Teak::NumTargetFixupKinds" ]

[]

[ "<s>", "Register", "PatmosRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Patmos", "::", "RFP", ":", "Patmos", "::", "RSP", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::RFP", "Patmos::RSP" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "LittleEndian", ")", "{", "initReciprocals", "(", "*", "this", ",", "Subtarget", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "VideoCore4", "VideoCore4" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "X86RegisterInfo", "*", "TRI", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "return", "hasReservedCallFrame", "(", "MF", ")", "||", "(", "hasFP", "(", "MF", ")", "&&", "!", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "||", "TRI", "->", "hasBasePointer", "(", "MF", ")", ";", "}", "</s>" ]

[ "canSimplifyCallFramePseudos", "-", "If", "there", "is", "a", "reserved", "call", "frame", ",", "the", "call", "frame", "pseudos", "can", "be", "simplified", "." ]

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

[]

[ "<s>", "void", "AArch64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_CondCode", ":", "OS", "<<", "\"<CondCode: \"", "<<", "CondCode", ".", "Code", "<<", "\">\"", ";", "break", ";", "case", "k_FPImmediate", ":", "OS", "<<", "\"<fpimm: \"", "<<", "FPImm", ".", "Val", "<<", "\">\"", ";", "break", ";", "case", "k_ImmWithLSL", ":", "OS", "<<", "\"<immwithlsl: imm=\"", "<<", "ImmWithLSL", ".", "Val", "<<", "\", shift=\"", "<<", "ImmWithLSL", ".", "ShiftAmount", "<<", "\">\"", ";", "break", ";", "case", "k_Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "'\\''", "<<", "getToken", "(", ")", "<<", "'\\''", ";", "break", ";", "case", "k_ShiftExtend", ":", "OS", "<<", "\"<shift: type=\"", "<<", "ShiftExtend", ".", "ShiftType", "<<", "\", amount=\"", "<<", "ShiftExtend", ".", "Amount", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "{", "StringRef", "Name", "(", "SysReg", ".", "Data", ",", "SysReg", ".", "Length", ")", ";", "OS", "<<", "\"<sysreg: \"", "<<", "Name", "<<", "'>'", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"No idea how to print this kind of operand\"", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"<CondCode: \"", "\">\"", "\"<fpimm: \"", "\">\"", "\"<immwithlsl: imm=\"", "\", shift=\"", "\">\"", "\"<register \"", "\"<shift: type=\"", "\", amount=\"", "\">\"", "\"<sysreg: \"", "\"No idea how to print this kind of operand\"" ]

[]