Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "riscv_libgcc_floating_mode_supported_p", "(", "scalar_float_mode", "mode", ")", "{", "if", "(", "mode", "==", "HFmode", ")", "return", "true", ";", "else", "return", "default_libgcc_floating_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P", "-", "return", "TRUE", "if", "MODE", "is", "HFmode", ",", "and", "punt", "to", "the", "generic", "implementation", "otherwise", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "sparc_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", ")", "{", "nextarg", "=", "expand_builtin_saveregs", "(", ")", ";", "std_expand_builtin_va_start", "(", "valist", ",", "nextarg", ")", ";", "}", "</s>" ]

[ "Implement", "`", "va_start", "'", "for", "varargs", "and", "stdarg", "." ]

[ "sparc" ]

[]

[ "<s>", "void", "emitWeakReference", "(", "MCSymbol", "*", "Alias", ",", "const", "MCSymbol", "*", "Symbol", ")", "override", "{", "}", "</s>" ]

[ "Emit", "an", "weak", "reference", "from", "Alias", "to", "Symbol", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "void", "nds32_relax_group", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "compute_bb_for_insn", "(", ")", ";", "df_chain_add_problem", "(", "DF_DU_CHAIN", "|", "DF_UD_CHAIN", ")", ";", "df_insn_rescan_all", "(", ")", ";", "df_analyze", "(", ")", ";", "df_set_flags", "(", "DF_DEFER_INSN_RESCAN", ")", ";", "calculate_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "insn", "=", "get_insns", "(", ")", ";", "gcc_assert", "(", "NOTE_P", "(", "insn", ")", ")", ";", "for", "(", "insn", "=", "next_active_insn", "(", "insn", ")", ";", "insn", ";", "insn", "=", "next_active_insn", "(", "insn", ")", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", "==", "CODE_FOR_sethi", "&&", "nds32_symbolic_operand", "(", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "0", ")", ",", "SImode", ")", ")", "nds32_group_insns", "(", "insn", ")", ";", "}", "}", "df_insn_rescan_all", "(", ")", ";", "df_finish_pass", "(", "false", ")", ";", "free_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "}", "</s>" ]

[ "Group", "the", "relax", "candidate", "instructions", "for", "linker", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitStoreConditional", "(", "IRBuilderBase", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "isReleaseOrStronger", "(", "Ord", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlexd", ":", "Intrinsic", "::", "arm_strexd", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int32Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "32", ")", ",", "Int32Ty", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Strex", ",", "{", "Lo", ",", "Hi", ",", "Addr", "}", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlex", ":", "Intrinsic", "::", "arm_strex", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "CallInst", "*", "CI", "=", "Builder", ".", "CreateCall", "(", "Strex", ",", "{", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Strex", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", "}", ")", ";", "CI", "->", "addParamAttr", "(", "1", ",", "Attribute", "::", "get", "(", "M", "->", "getContext", "(", ")", ",", "Attribute", "::", "ElementType", ",", "Val", "->", "getType", "(", ")", ")", ")", ";", "return", "CI", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_stlexd", "Intrinsic::arm_strexd", "Intrinsic::getDeclaration", "\"lo\"", "32", "\"hi\"", "Intrinsic::ID", "Intrinsic::arm_stlex", "Intrinsic::arm_strex", "Intrinsic::getDeclaration", "0", "1" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "(", "Kind", "==", "k_Register", "||", "Kind", "==", "k_Memri", ")", "&&", "\"Invalid access!\"", ")", ";", "return", "RegImm", ".", "Reg", ";", "}", "</s>" ]

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

[ "SNES", "\"Invalid access!\"" ]

[]

[ "<s>", "int", "ARM64AsmParser", "::", "tryParseRegister", "(", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "assert", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", "&&", "\"Token is not an Identifier\"", ")", ";", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "unsigned", "RegNum", "=", "MatchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "RegNum", "==", "0", ")", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"fp\"", ",", "ARM64", "::", "FP", ")", ".", "Case", "(", "\"lr\"", ",", "ARM64", "::", "LR", ")", ".", "Case", "(", "\"x31\"", ",", "ARM64", "::", "XZR", ")", ".", "Case", "(", "\"w31\"", ",", "ARM64", "::", "WZR", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "RegNum", "==", "0", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"Token is not an Identifier\"", "0", "\"fp\"", "ARM64::FP", "\"lr\"", "ARM64::LR", "\"x31\"", "ARM64::XZR", "\"w31\"", "ARM64::WZR", "0", "0", "1" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "unsigned", "int", "flags_from_code", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "LT", ":", "case", "GE", ":", "return", "CC_FLAG_S", ";", "case", "GT", ":", "case", "LE", ":", "return", "CC_FLAG_S", "|", "CC_FLAG_O", "|", "CC_FLAG_Z", ";", "case", "GEU", ":", "case", "LTU", ":", "return", "CC_FLAG_C", ";", "case", "GTU", ":", "case", "LEU", ":", "return", "CC_FLAG_C", "|", "CC_FLAG_Z", ";", "case", "EQ", ":", "case", "NE", ":", "return", "CC_FLAG_Z", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Convert", "an", "RTX_CODE", "to", "the", "set", "of", "flags", "needed", "to", "implement", "it", ".", "This", "assumes", "an", "integer", "comparison", "." ]

[ "rx" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "NumTCycles", ",", "unsigned", "ExtraTCycles", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "NumFCycles", ",", "unsigned", "ExtraFCycles", ",", "BranchProbability", "Probability", ")", "const", "{", "return", "nonDbgBBSize", "(", "&", "TMBB", ")", "<=", "3", "&&", "nonDbgBBSize", "(", "&", "FMBB", ")", "<=", "3", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "3", "3" ]

[]

[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "ReservedGPR32", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "SP", "}", ";", "static", "const", "MCPhysReg", "ReservedGPR64", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "SP_64", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "MipsSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "for", "(", "MCPhysReg", "R", ":", "ReservedGPR32", ")", "Reserved", ".", "set", "(", "R", ")", ";", "if", "(", "Subtarget", ".", "isTargetNaCl", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "T6", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "T7", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "T8", ")", ";", "}", "for", "(", "MCPhysReg", "R", ":", "ReservedGPR64", ")", "Reserved", ".", "set", "(", "R", ")", ";", "if", "(", "!", "Subtarget", ".", "isABICalls", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "GP_64", ")", ";", "}", "if", "(", "Subtarget", ".", "isFP64bit", "(", ")", ")", "{", "for", "(", "MCPhysReg", "Reg", ":", "Mips", "::", "AFGR64RegClass", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "else", "{", "for", "(", "MCPhysReg", "Reg", ":", "Mips", "::", "FGR64RegClass", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "if", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "Reserved", ".", "set", "(", "Mips", "::", "S0", ")", ";", "else", "{", "Reserved", ".", "set", "(", "Mips", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "FP_64", ")", ";", "if", "(", "hasStackRealignment", "(", "MF", ")", "&&", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "S7", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "S7_64", ")", ";", "}", "}", "}", "Reserved", ".", "set", "(", "Mips", "::", "HWR29", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPPos", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPSCount", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPCarry", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPEFI", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPOutFlag", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "Mips", "::", "MSACtrlRegClass", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "{", "const", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "RA", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "RA_64", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "T0", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "T1", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"saveS2\"", ")", "||", "MipsFI", "->", "hasSaveS2", "(", ")", ")", "Reserved", ".", "set", "(", "Mips", "::", "S2", ")", ";", "}", "if", "(", "Subtarget", ".", "useSmallSection", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "GP_64", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::ZERO", "Mips::K0", "Mips::K1", "Mips::SP", "Mips::ZERO_64", "Mips::K0_64", "Mips::K1_64", "Mips::SP_64", "Mips", "Mips", "Mips::T6", "Mips::T7", "Mips::T8", "Mips::GP", "Mips::GP_64", "Mips::AFGR64RegClass", "Mips::FGR64RegClass", "Mips", "Mips::S0", "Mips::FP", "Mips::FP_64", "Mips::S7", "Mips::S7_64", "Mips::HWR29", "Mips::DSPPos", "Mips::DSPSCount", "Mips::DSPCarry", "Mips::DSPEFI", "Mips::DSPOutFlag", "Mips::MSACtrlRegClass", "Mips", "Mips", "Mips", "Mips", "Mips::RA", "Mips::RA_64", "Mips::T0", "Mips::T1", "\"saveS2\"", "Mips", "Mips::S2", "Mips::GP", "Mips::GP_64" ]

[]

[ "<s>", "int", "arm_no_early_alu_shift_dep", "(", "rtx", "producer", ",", "rtx", "consumer", ")", "{", "rtx", "value", "=", "PATTERN", "(", "producer", ")", ";", "rtx", "op", "=", "PATTERN", "(", "consumer", ")", ";", "rtx", "early_op", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "COND_EXEC", ")", "value", "=", "COND_EXEC_CODE", "(", "value", ")", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "PARALLEL", ")", "value", "=", "XVECEXP", "(", "value", ",", "0", ",", "0", ")", ";", "value", "=", "XEXP", "(", "value", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "COND_EXEC", ")", "op", "=", "COND_EXEC_CODE", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "PARALLEL", ")", "op", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "early_op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "early_op", ")", "==", "REG", ")", "early_op", "=", "op", ";", "return", "!", "reg_overlap_mentioned_p", "(", "value", ",", "early_op", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "CONSUMER", "instruction", "(", "an", "ALU", "op", ")", "does", "not", "have", "an", "early", "register", "shift", "value", "or", "amount", "dependency", "on", "the", "result", "of", "PRODUCER", "." ]

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

[]

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

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

[ "RISCV", "1" ]

[]

[ "<s>", "void", "Thumb2RegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "t2LDRpci", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "(", "int64_t", ")", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "4", "ARM::t2LDRpci", "ARMCC::AL", "0" ]

[]

[ "<s>", "void", "HexagonSubtarget", "::", "adjustSchedDependency", "(", "SUnit", "*", "Src", ",", "int", "SrcOpIdx", ",", "SUnit", "*", "Dst", ",", "int", "DstOpIdx", ",", "SDep", "&", "Dep", ")", "const", "{", "if", "(", "!", "Src", "->", "isInstr", "(", ")", "||", "!", "Dst", "->", "isInstr", "(", ")", ")", "return", ";", "MachineInstr", "*", "SrcInst", "=", "Src", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "DstInst", "=", "Dst", "->", "getInstr", "(", ")", ";", "const", "HexagonInstrInfo", "*", "QII", "=", "getInstrInfo", "(", ")", ";", "SmallSet", "<", "SUnit", "*", ",", "4", ">", "ExclSrc", ";", "SmallSet", "<", "SUnit", "*", ",", "4", ">", "ExclDst", ";", "if", "(", "QII", "->", "canExecuteInBundle", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ",", "ExclSrc", ",", "ExclDst", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "if", "(", "!", "hasV60Ops", "(", ")", ")", "return", ";", "if", "(", "DstInst", "->", "isCopy", "(", ")", ")", "Dep", ".", "setLatency", "(", "0", ")", ";", "if", "(", "(", "DstInst", "->", "isRegSequence", "(", ")", "||", "DstInst", "->", "isCopy", "(", ")", ")", "&&", "Dst", "->", "NumSuccs", "==", "1", ")", "{", "Register", "DReg", "=", "DstInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "DDst", "=", "Dst", "->", "Succs", "[", "0", "]", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ";", "unsigned", "UseIdx", "=", "-", "1", ";", "for", "(", "unsigned", "OpNum", "=", "0", ";", "OpNum", "<", "DDst", "->", "getNumOperands", "(", ")", ";", "OpNum", "++", ")", "{", "const", "MachineOperand", "&", "MO", "=", "DDst", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "&&", "MO", ".", "isUse", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "DReg", ")", "{", "UseIdx", "=", "OpNum", ";", "break", ";", "}", "}", "int", "DLatency", "=", "(", "InstrInfo", ".", "getOperandLatency", "(", "&", "InstrItins", ",", "*", "SrcInst", ",", "0", ",", "*", "DDst", ",", "UseIdx", ")", ")", ";", "DLatency", "=", "std", "::", "max", "(", "DLatency", ",", "0", ")", ";", "Dep", ".", "setLatency", "(", "(", "unsigned", ")", "DLatency", ")", ";", "}", "ExclSrc", ".", "clear", "(", ")", ";", "ExclDst", ".", "clear", "(", ")", ";", "if", "(", "EnableDotCurSched", "&&", "QII", "->", "isToBeScheduledASAP", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ",", "ExclSrc", ",", "ExclDst", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "updateLatency", "(", "*", "SrcInst", ",", "*", "DstInst", ",", "Dep", ")", ";", "}", "</s>" ]

[ "Perform", "target", "specific", "adjustments", "to", "the", "latency", "of", "a", "schedule", "dependency", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "4", "4", "0", "0", "1", "0", "0", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "ix86_expand_xorsign", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "vdest", ",", "op0", ",", "op1", ",", "mask", ",", "x", ",", "temp", ";", "dest", "=", "operands", "[", "0", "]", ";", "op0", "=", "operands", "[", "1", "]", ";", "op1", "=", "operands", "[", "2", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "mode", "==", "HFmode", ")", "vmode", "=", "V8HFmode", ";", "else", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "else", "gcc_unreachable", "(", ")", ";", "temp", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "0", ",", "0", ")", ";", "op1", "=", "lowpart_subreg", "(", "vmode", ",", "force_reg", "(", "mode", ",", "op1", ")", ",", "mode", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "op1", ",", "mask", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "x", ")", ")", ";", "op0", "=", "lowpart_subreg", "(", "vmode", ",", "force_reg", "(", "mode", ",", "op0", ")", ",", "mode", ")", ";", "x", "=", "gen_rtx_XOR", "(", "vmode", ",", "temp", ",", "op0", ")", ";", "vdest", "=", "lowpart_subreg", "(", "vmode", ",", "dest", ",", "mode", ")", ";", "if", "(", "vdest", "==", "NULL_RTX", ")", "vdest", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "else", "dest", "=", "NULL_RTX", ";", "emit_insn", "(", "gen_rtx_SET", "(", "vdest", ",", "x", ")", ")", ";", "if", "(", "dest", ")", "emit_move_insn", "(", "dest", ",", "lowpart_subreg", "(", "mode", ",", "vdest", ",", "vmode", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "xorsign", "operation", "." ]

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

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsZeroVal", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsZeroVal", "&&", "!", "F", "->", "hasFnAttr", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "16", ")", "{", "if", "(", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "32", ")", "{", "if", "(", "Subtarget", "->", "hasAVX2", "(", ")", ")", "return", "MVT", "::", "v8i32", ";", "if", "(", "Subtarget", "->", "hasAVX", "(", ")", ")", "return", "MVT", "::", "v8f32", ";", "}", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "8", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "16", "32", "MVT::v8i32", "MVT::v8f32", "MVT::v4i32", "MVT::v4f32", "8", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "void", "x86_emit_floatuns", "(", "rtx", "operands", "[", "2", "]", ")", "{", "rtx_code_label", "*", "neglab", ",", "*", "donelab", ";", "rtx", "i0", ",", "i1", ",", "f0", ",", "in", ",", "out", ";", "machine_mode", "mode", ",", "inmode", ";", "inmode", "=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ";", "gcc_assert", "(", "inmode", "==", "SImode", "||", "inmode", "==", "DImode", ")", ";", "out", "=", "operands", "[", "0", "]", ";", "in", "=", "force_reg", "(", "inmode", ",", "operands", "[", "1", "]", ")", ";", "mode", "=", "GET_MODE", "(", "out", ")", ";", "neglab", "=", "gen_label_rtx", "(", ")", ";", "donelab", "=", "gen_label_rtx", "(", ")", ";", "f0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_cmp_and_jump_insns", "(", "in", ",", "const0_rtx", ",", "LT", ",", "const0_rtx", ",", "inmode", ",", "0", ",", "neglab", ")", ";", "expand_float", "(", "out", ",", "in", ",", "0", ")", ";", "emit_jump_insn", "(", "gen_jump", "(", "donelab", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "neglab", ")", ";", "i0", "=", "expand_simple_binop", "(", "inmode", ",", "LSHIFTRT", ",", "in", ",", "const1_rtx", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "i1", "=", "expand_simple_binop", "(", "inmode", ",", "AND", ",", "in", ",", "const1_rtx", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "i0", "=", "expand_simple_binop", "(", "inmode", ",", "IOR", ",", "i0", ",", "i1", ",", "i0", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "expand_float", "(", "f0", ",", "i0", ",", "0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "out", ",", "gen_rtx_PLUS", "(", "mode", ",", "f0", ",", "f0", ")", ")", ")", ";", "emit_label", "(", "donelab", ")", ";", "}", "</s>" ]

[ "Generate", "an", "unsigned", "DImode/SImode", "to", "FP", "conversion", ".", "This", "is", "the", "same", "code", "optabs", "would", "emit", "if", "we", "did", "n't", "have", "TFmode", "patterns", "." ]

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

[]

[ "<s>", "static", "bool", "moxie_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "const", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "2", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

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

[ "moxie", "1", "2" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "alignment", ";", "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "alignment", "<", "PARM_BOUNDARY", ")", "alignment", "=", "PARM_BOUNDARY", ";", "if", "(", "alignment", ">", "STACK_BOUNDARY", ")", "alignment", "=", "STACK_BOUNDARY", ";", "return", "alignment", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_BOUNDARY", ".", "Every", "parameter", "gets", "at", "least", "PARM_BOUNDARY", "bits", "of", "alignment", ",", "but", "will", "be", "given", "anything", "up", "to", "STACK_BOUNDARY", "bits", "if", "the", "type", "requires", "it", "." ]

[ "mips" ]

[]

[ "<s>", "void", "emitValueToAlignment", "(", "unsigned", "ByteAlignment", ",", "int64_t", "Value", "=", "0", ",", "unsigned", "ValueSize", "=", "1", ",", "unsigned", "MaxBytesToEmit", "=", "0", ")", "override", "{", "}", "</s>" ]

[ "Emit", "some", "number", "of", "copies", "of", "Value", "until", "the", "byte", "alignment", "ByteAlignment", "is", "reached", "." ]

[ "Patmos", "0", "1", "0" ]

[]

[ "<s>", "uint16_t", "getType", "(", ")", "const", "{", "return", "NodeAttrs", "::", "type", "(", "Attrs", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "ix86_in_large_data_p", "(", "tree", "exp", ")", "{", "if", "(", "ix86_cmodel", "!=", "CM_MEDIUM", "&&", "ix86_cmodel", "!=", "CM_MEDIUM_PIC", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "!", "is_global_var", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "exp", ")", ")", "{", "const", "char", "*", "section", "=", "DECL_SECTION_NAME", "(", "exp", ")", ";", "if", "(", "strcmp", "(", "section", ",", "\".ldata\"", ")", "==", "0", "||", "strcmp", "(", "section", ",", "\".lbss\"", ")", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "size", "<=", "0", "||", "size", ">", "ix86_section_threshold", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "rs6000_builtin_mask_for_load", "(", "void", ")", "{", "if", "(", "(", "TARGET_ALTIVEC", "&&", "!", "TARGET_VSX", ")", "||", "(", "TARGET_VSX", "&&", "!", "TARGET_EFFICIENT_UNALIGNED_VSX", ")", ")", "return", "altivec_builtin_mask_for_load", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_mask_for_load", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "static", "bool", "arm_const_not_ok_for_debug_p", "(", "rtx", "p", ")", "{", "tree", "decl_op0", "=", "NULL", ";", "tree", "decl_op1", "=", "NULL", ";", "if", "(", "GET_CODE", "(", "p", ")", "==", "MINUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "p", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "{", "decl_op1", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "p", ",", "1", ")", ")", ";", "if", "(", "decl_op1", "&&", "GET_CODE", "(", "XEXP", "(", "p", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "(", "decl_op0", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "p", ",", "0", ")", ")", ")", ")", "{", "if", "(", "(", "VAR_P", "(", "decl_op1", ")", "||", "TREE_CODE", "(", "decl_op1", ")", "==", "CONST_DECL", ")", "&&", "(", "VAR_P", "(", "decl_op0", ")", "||", "TREE_CODE", "(", "decl_op0", ")", "==", "CONST_DECL", ")", ")", "return", "(", "get_variable_section", "(", "decl_op1", ",", "false", ")", "!=", "get_variable_section", "(", "decl_op0", ",", "false", ")", ")", ";", "if", "(", "TREE_CODE", "(", "decl_op1", ")", "==", "LABEL_DECL", "&&", "TREE_CODE", "(", "decl_op0", ")", "==", "LABEL_DECL", ")", "return", "(", "DECL_CONTEXT", "(", "decl_op1", ")", "!=", "DECL_CONTEXT", "(", "decl_op0", ")", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "is", "a", "temporary", "fix", "for", "PR60655", ".", "Ideally", "we", "need", "to", "handle", "most", "of", "these", "cases", "in", "the", "generic", "part", "but", "currently", "we", "reject", "minus", "(", "..", ")", "(", "sym_ref", ")", ".", "We", "try", "to", "ameliorate", "the", "case", "with", "minus", "(", "sym_ref1", ")", "(", "sym_ref2", ")", "where", "they", "are", "in", "the", "same", "section", "." ]

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

[]

[ "<s>", "bool", "Mips16RegisterInfo", "::", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "bool", "alpha_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "TImode", ":", "return", "true", ";", "case", "SFmode", ":", "case", "DFmode", ":", "return", "true", ";", "case", "TFmode", ":", "return", "TARGET_HAS_XFLOATING_LIBS", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "The", "scalar", "modes", "supported", "differs", "from", "the", "default", "check-what-c-supports", "version", "in", "that", "sometimes", "TFmode", "is", "available", "even", "when", "long", "double", "indicates", "only", "DFmode", ".", "On", "unicosmk", ",", "we", "have", "the", "situation", "that", "HImode", "does", "n't", "map", "to", "any", "C", "type", ",", "but", "of", "course", "we", "still", "support", "that", "." ]

[ "alpha" ]

[]

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

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

[ "rvex", "rvex", "rvex" ]

[]

[ "<s>", "static", "void", "nvptx_record_libfunc", "(", "rtx", "callee", ",", "rtx", "retval", ",", "rtx", "pat", ")", "{", "rtx", "*", "slot", "=", "declared_libfuncs_htab", "->", "find_slot", "(", "callee", ",", "INSERT", ")", ";", "if", "(", "*", "slot", "==", "NULL", ")", "{", "*", "slot", "=", "callee", ";", "const", "char", "*", "name", "=", "XSTR", "(", "callee", ",", "0", ")", ";", "write_fn_proto_from_insn", "(", "func_decls", ",", "name", ",", "retval", ",", "pat", ")", ";", "}", "}", "</s>" ]

[ "Record", "a", "libcall", "or", "unprototyped", "external", "function", ".", "CALLEE", "is", "the", "SYMBOL_REF", ".", "Insert", "into", "the", "libfunc", "hash", "table", "and", "emit", "a", "ptx", "declaration", "for", "it", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "unsigned", "AArch64Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "if", "(", "!", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", "|", "AArch64II", "::", "MO_DLLIMPORT", ";", "if", "(", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", "|", "AArch64II", "::", "MO_COFFSTUB", ";", "return", "AArch64II", "::", "MO_GOT", ";", "}", "if", "(", "(", "useSmallAddressing", "(", ")", "||", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Tiny", ")", "&&", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "if", "(", "AllowTaggedGlobals", "&&", "!", "isa", "<", "FunctionType", ">", "(", "GV", "->", "getValueType", "(", ")", ")", ")", "return", "AArch64II", "::", "MO_NC", "|", "AArch64II", "::", "MO_TAGGED", ";", "return", "AArch64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_DLLIMPORT", "AArch64II::MO_GOT", "AArch64II::MO_COFFSTUB", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_NC", "AArch64II::MO_TAGGED", "AArch64II::MO_NO_FLAG" ]

[]

[ "<s>", "static", "bool", "ix86_expand_vec_one_operand_perm_avx512", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "d", "->", "op0", ")", ";", "machine_mode", "maskmode", "=", "mode", ";", "unsigned", "inner_size", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "rtx", "target", ",", "op0", ",", "mask", ";", "rtx", "vec", "[", "64", "]", ";", "if", "(", "!", "rtx_equal_p", "(", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512F", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512VL", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "64", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512BW", "&&", "inner_size", "==", "2", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512VBMI", "&&", "inner_size", "==", "1", ")", "return", "false", ";", "switch", "(", "mode", ")", "{", "case", "E_V16SImode", ":", "gen", "=", "gen_avx512f_permvarv16si", ";", "break", ";", "case", "E_V16SFmode", ":", "gen", "=", "gen_avx512f_permvarv16sf", ";", "maskmode", "=", "V16SImode", ";", "break", ";", "case", "E_V8DImode", ":", "gen", "=", "gen_avx512f_permvarv8di", ";", "break", ";", "case", "E_V8DFmode", ":", "gen", "=", "gen_avx512f_permvarv8df", ";", "maskmode", "=", "V8DImode", ";", "break", ";", "case", "E_V32HImode", ":", "gen", "=", "gen_avx512bw_permvarv32hi", ";", "break", ";", "case", "E_V16HImode", ":", "gen", "=", "gen_avx512vl_permvarv16hi", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_avx512vl_permvarv8hi", ";", "break", ";", "case", "E_V64QImode", ":", "gen", "=", "gen_avx512bw_permvarv64qi", ";", "break", ";", "case", "E_V32QImode", ":", "gen", "=", "gen_avx512vl_permvarv32qi", ";", "break", ";", "case", "E_V16QImode", ":", "gen", "=", "gen_avx512vl_permvarv16qi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "target", "=", "d", "->", "target", ";", "op0", "=", "d", "->", "op0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "d", "->", "nelt", ";", "++", "i", ")", "vec", "[", "i", "]", "=", "GEN_INT", "(", "d", "->", "perm", "[", "i", "]", ")", ";", "mask", "=", "gen_rtx_CONST_VECTOR", "(", "maskmode", ",", "gen_rtvec_v", "(", "d", "->", "nelt", ",", "vec", ")", ")", ";", "emit_insn", "(", "gen", "(", "target", ",", "op0", ",", "force_reg", "(", "maskmode", ",", "mask", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "expand", "one-operand", "permutation", "with", "constant", "mask", "." ]

[ "i386", "64", "64", "2", "1", "0" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnSCC", "(", "CallGraphSCC", "&", "SCC", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "CallGraphNode", "*", "I", ":", "SCC", ")", "{", "Function", "*", "F", "=", "I", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "F", "->", "isDeclaration", "(", ")", "||", "AMDGPU", "::", "isGraphics", "(", "F", "->", "getCallingConv", "(", ")", ")", ")", "continue", ";", "Changed", "|=", "addFeatureAttributes", "(", "*", "F", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnSCC", "-", "This", "method", "should", "be", "implemented", "by", "the", "subclass", "to", "perform", "whatever", "action", "is", "necessary", "for", "the", "specified", "SCC", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isGraphics" ]

[]

[ "<s>", "bool", "M680x0RegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "M680x0", "M680x0" ]

[]

[ "<s>", "void", "AArch64AsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "FulleSizeInBytes", "-", "1", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid fixup offset!\"", "0", "0", "8", "0xff", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "NonScalarIntSafe", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "NonScalarIntSafe", "&&", "!", "F", "->", "hasFnAttr", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "16", ")", "{", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "8", "&&", "Subtarget", "->", "hasXMMInt", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "16", "MVT::v4i32", "MVT::v4f32", "8", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsReadPortLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "IG", ",", "const", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "PV", ",", "std", "::", "vector", "<", "BankSwizzle", ">", "&", "ValidSwizzle", ",", "bool", "isLastAluTrans", ")", "const", "{", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", ">", "IGSrcs", ";", "ValidSwizzle", ".", "clear", "(", ")", ";", "unsigned", "ConstCount", ";", "BankSwizzle", "TransBS", "=", "ALU_VEC_012_SCL_210", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "IG", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "IGSrcs", ".", "push_back", "(", "ExtractSrcs", "(", "IG", "[", "i", "]", ",", "PV", ",", "ConstCount", ")", ")", ";", "unsigned", "Op", "=", "getOperandIdx", "(", "IG", "[", "i", "]", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "bank_swizzle", ")", ";", "ValidSwizzle", ".", "push_back", "(", "(", "R600InstrInfo", "::", "BankSwizzle", ")", "IG", "[", "i", "]", "->", "getOperand", "(", "Op", ")", ".", "getImm", "(", ")", ")", ";", "}", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", "TransOps", ";", "if", "(", "!", "isLastAluTrans", ")", "return", "FindSwizzleForVectorSlot", "(", "IGSrcs", ",", "ValidSwizzle", ",", "TransOps", ",", "TransBS", ")", ";", "TransOps", "=", "IGSrcs", ".", "back", "(", ")", ";", "IGSrcs", ".", "pop_back", "(", ")", ";", "ValidSwizzle", ".", "pop_back", "(", ")", ";", "static", "const", "R600InstrInfo", "::", "BankSwizzle", "TransSwz", "[", "]", "=", "{", "ALU_VEC_012_SCL_210", ",", "ALU_VEC_021_SCL_122", ",", "ALU_VEC_120_SCL_212", ",", "ALU_VEC_102_SCL_221", "}", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "TransBS", "=", "TransSwz", "[", "i", "]", ";", "if", "(", "!", "isConstCompatible", "(", "TransBS", ",", "TransOps", ",", "ConstCount", ")", ")", "continue", ";", "bool", "Result", "=", "FindSwizzleForVectorSlot", "(", "IGSrcs", ",", "ValidSwizzle", ",", "TransOps", ",", "TransBS", ")", ";", "if", "(", "Result", ")", "{", "ValidSwizzle", ".", "push_back", "(", "TransBS", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "the", "order", "VEC_012", "<", "VEC_021", "<", "VEC_120", "<", "VEC_102", "<", "VEC_201", "<", "VEC_210", "returns", "true", "and", "the", "first", "(", "in", "lexical", "order", ")", "BankSwizzle", "affectation", "starting", "from", "the", "one", "already", "provided", "in", "the", "Instruction", "Group", "MIs", "that", "fits", "Read", "Port", "limitations", "in", "BS", "if", "available", "." ]

[ "R600", "0", "0", "4" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFNegFree", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", ";", "return", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", "||", "(", "Subtarget", "->", "has16BitInsts", "(", ")", "&&", "VT", "==", "MVT", "::", "f16", ")", "||", "(", "Subtarget", "->", "hasVOP3PInsts", "(", ")", "&&", "VT", "==", "MVT", "::", "v2f16", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fneg", "operation", "is", "free", "to", "the", "point", "where", "it", "is", "never", "worthwhile", "to", "replace", "it", "with", "a", "bitwise", "operation", "." ]

[ "AMDGPU", "AMDGPU", "MVT::f32", "MVT::f64", "MVT::f16", "MVT::v2f16" ]

[]

[ "<s>", "int", "is_called_in_ARM_mode", "(", "tree", "func", ")", "{", "gcc_assert", "(", "TREE_CODE", "(", "func", ")", "==", "FUNCTION_DECL", ")", ";", "if", "(", "TARGET_CALLEE_INTERWORKING", "&&", "TREE_PUBLIC", "(", "func", ")", ")", "return", "TRUE", ";", "return", "lookup_attribute", "(", "\"interfacearm\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", "!=", "NULL_TREE", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "FUNC", "must", "be", "entered", "in", "ARM", "mode", "." ]

[ "arm", "\"interfacearm\"" ]

[]

[ "<s>", "void", "BTFDebug", "::", "endModule", "(", ")", "{", "if", "(", "MapDefNotCollected", ")", "{", "processGlobals", "(", "true", ")", ";", "MapDefNotCollected", "=", "false", ";", "}", "processGlobals", "(", "false", ")", ";", "for", "(", "auto", "&", "DataSec", ":", "DataSecEntries", ")", "addType", "(", "std", "::", "move", "(", "DataSec", ".", "second", ")", ")", ";", "for", "(", "auto", "&", "Fixup", ":", "FixupDerivedTypes", ")", "{", "const", "DICompositeType", "*", "CTy", "=", "Fixup", ".", "first", ";", "StringRef", "TypeName", "=", "CTy", "->", "getName", "(", ")", ";", "bool", "IsUnion", "=", "CTy", "->", "getTag", "(", ")", "==", "dwarf", "::", "DW_TAG_union_type", ";", "uint32_t", "StructTypeId", "=", "0", ";", "for", "(", "const", "auto", "&", "StructType", ":", "StructTypes", ")", "{", "if", "(", "StructType", "->", "getName", "(", ")", "==", "TypeName", ")", "{", "StructTypeId", "=", "StructType", "->", "getId", "(", ")", ";", "break", ";", "}", "}", "if", "(", "StructTypeId", "==", "0", ")", "{", "auto", "FwdTypeEntry", "=", "std", "::", "make_unique", "<", "BTFTypeFwd", ">", "(", "TypeName", ",", "IsUnion", ")", ";", "StructTypeId", "=", "addType", "(", "std", "::", "move", "(", "FwdTypeEntry", ")", ")", ";", "}", "for", "(", "auto", "&", "TypeInfo", ":", "Fixup", ".", "second", ")", "{", "const", "DIDerivedType", "*", "DTy", "=", "TypeInfo", ".", "first", ";", "BTFTypeDerived", "*", "BDType", "=", "TypeInfo", ".", "second", ";", "int", "TmpTypeId", "=", "genBTFTypeTags", "(", "DTy", ",", "StructTypeId", ")", ";", "if", "(", "TmpTypeId", ">=", "0", ")", "BDType", "->", "setPointeeType", "(", "TmpTypeId", ")", ";", "else", "BDType", "->", "setPointeeType", "(", "StructTypeId", ")", ";", "}", "}", "for", "(", "const", "auto", "&", "TypeEntry", ":", "TypeEntries", ")", "TypeEntry", "->", "completeType", "(", "*", "this", ")", ";", "emitBTFSection", "(", ")", ";", "emitBTFExtSection", "(", ")", ";", "}", "</s>" ]

[ "Emit", "all", "exception", "information", "that", "should", "come", "after", "the", "content", "." ]

[ "BPF", "0", "0", "0" ]

[]

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

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

[ "NVPTX" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "ix86_expand_vec_shift_qihi_constant", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "machine_mode", "qimode", ",", "himode", ";", "HOST_WIDE_INT", "and_constant", ",", "xor_constant", ";", "HOST_WIDE_INT", "shift_amount", ";", "rtx", "vec_const_and", ",", "vec_const_xor", ";", "rtx", "tmp", ",", "op1_subreg", ";", "rtx", "(", "*", "gen_shift", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_and", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_xor", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_sub", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op2", ")", ")", "return", "false", ";", "qimode", "=", "GET_MODE", "(", "dest", ")", ";", "shift_amount", "=", "INTVAL", "(", "op2", ")", ";", "if", "(", "shift_amount", ">", "7", ")", "return", "false", ";", "gcc_assert", "(", "code", "==", "ASHIFT", "||", "code", "==", "ASHIFTRT", "||", "code", "==", "LSHIFTRT", ")", ";", "xor_constant", "=", "1", "<<", "(", "8", "-", "shift_amount", "-", "1", ")", ";", "and_constant", "=", "(", "code", "==", "ASHIFT", "?", "256", "-", "(", "1", "<<", "shift_amount", ")", ":", "(", "1", "<<", "(", "8", "-", "shift_amount", ")", ")", "-", "1", ")", ";", "switch", "(", "qimode", ")", "{", "case", "V16QImode", ":", "himode", "=", "V8HImode", ";", "gen_shift", "=", "(", "(", "code", "==", "ASHIFT", ")", "?", "gen_ashlv8hi3", ":", "(", "code", "==", "ASHIFTRT", ")", "?", "gen_ashrv8hi3", ":", "gen_lshrv8hi3", ")", ";", "gen_and", "=", "gen_andv16qi3", ";", "gen_xor", "=", "gen_xorv16qi3", ";", "gen_sub", "=", "gen_subv16qi3", ";", "break", ";", "case", "V32QImode", ":", "himode", "=", "V16HImode", ";", "gen_shift", "=", "(", "(", "code", "==", "ASHIFT", ")", "?", "gen_ashlv16hi3", ":", "(", "code", "==", "ASHIFTRT", ")", "?", "gen_ashrv16hi3", ":", "gen_lshrv16hi3", ")", ";", "gen_and", "=", "gen_andv32qi3", ";", "gen_xor", "=", "gen_xorv32qi3", ";", "gen_sub", "=", "gen_subv32qi3", ";", "break", ";", "case", "V64QImode", ":", "himode", "=", "V32HImode", ";", "gen_shift", "=", "(", "(", "code", "==", "ASHIFT", ")", "?", "gen_ashlv32hi3", ":", "(", "code", "==", "ASHIFTRT", ")", "?", "gen_ashrv32hi3", ":", "gen_lshrv32hi3", ")", ";", "gen_and", "=", "gen_andv64qi3", ";", "gen_xor", "=", "gen_xorv64qi3", ";", "gen_sub", "=", "gen_subv64qi3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "=", "gen_reg_rtx", "(", "himode", ")", ";", "vec_const_and", "=", "gen_reg_rtx", "(", "qimode", ")", ";", "op1_subreg", "=", "lowpart_subreg", "(", "himode", ",", "op1", ",", "qimode", ")", ";", "emit_insn", "(", "gen_shift", "(", "tmp", ",", "op1_subreg", ",", "op2", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "simplify_gen_subreg", "(", "qimode", ",", "tmp", ",", "himode", ",", "0", ")", ")", ";", "emit_move_insn", "(", "vec_const_and", ",", "ix86_build_const_vector", "(", "qimode", ",", "true", ",", "gen_int_mode", "(", "and_constant", ",", "QImode", ")", ")", ")", ";", "emit_insn", "(", "gen_and", "(", "dest", ",", "dest", ",", "vec_const_and", ")", ")", ";", "if", "(", "code", "==", "ASHIFTRT", ")", "{", "vec_const_xor", "=", "gen_reg_rtx", "(", "qimode", ")", ";", "emit_move_insn", "(", "vec_const_xor", ",", "ix86_build_const_vector", "(", "qimode", ",", "true", ",", "gen_int_mode", "(", "xor_constant", ",", "QImode", ")", ")", ")", ";", "emit_insn", "(", "gen_xor", "(", "dest", ",", "dest", ",", "vec_const_xor", ")", ")", ";", "emit_insn", "(", "gen_sub", "(", "dest", ",", "dest", ",", "vec_const_xor", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "operation", "shift", "by", "constant", "for", "a", "V", "*", "QImode", "in", "terms", "of", "the", "same", "operation", "on", "V", "*", "HImode", ".", "Return", "true", "if", "success", "." ]

[ "i386", "7", "1", "8", "1", "256", "1", "1", "8", "1", "0" ]

[]

[ "<s>", "static", "void", "alpha_pad_function_end", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "CALL_P", "(", "insn", ")", "||", "!", "(", "SIBLING_CALL_P", "(", "insn", ")", "||", "find_reg_note", "(", "insn", ",", "REG_NORETURN", ",", "NULL_RTX", ")", ")", ")", "continue", ";", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "next", "==", "NULL", ")", "continue", ";", "if", "(", "NOTE_P", "(", "next", ")", "&&", "NOTE_KIND", "(", "next", ")", "==", "NOTE_INSN_CALL_ARG_LOCATION", ")", "insn", "=", "next", ";", "next", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "next", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", "==", "UNSPECV_LDGP1", ")", "emit_insn_after", "(", "gen_unop", "(", ")", ",", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "an", "unop", "between", "sibcall", "or", "noreturn", "function", "call", "and", "GP", "load", "." ]

[ "alpha", "1" ]

[]

[ "<s>", "bool", "NVPTXProxyRegErasure", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SmallVector", "<", "MachineInstr", "*", ",", "16", ">", "RemoveList", ";", "for", "(", "auto", "&", "BB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "BB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "NVPTX", "::", "ProxyRegI1", ":", "case", "NVPTX", "::", "ProxyRegI16", ":", "case", "NVPTX", "::", "ProxyRegI32", ":", "case", "NVPTX", "::", "ProxyRegI64", ":", "case", "NVPTX", "::", "ProxyRegF16", ":", "case", "NVPTX", "::", "ProxyRegF16x2", ":", "case", "NVPTX", "::", "ProxyRegF32", ":", "case", "NVPTX", "::", "ProxyRegF64", ":", "replaceMachineInstructionUsage", "(", "MF", ",", "MI", ")", ";", "RemoveList", ".", "push_back", "(", "&", "MI", ")", ";", "break", ";", "}", "}", "}", "for", "(", "auto", "*", "MI", ":", "RemoveList", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "return", "!", "RemoveList", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "16", "NVPTX::ProxyRegI1", "NVPTX::ProxyRegI16", "NVPTX::ProxyRegI32", "NVPTX::ProxyRegI64", "NVPTX::ProxyRegF16", "NVPTX::ProxyRegF16x2", "NVPTX::ProxyRegF32", "NVPTX::ProxyRegF64" ]

[]

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

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMADD64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMNAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSUB64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMXOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSWAP64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMCMPXCHG64_DAG", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::ATOMIC_LOAD_ADD", "ARMISD::ATOMADD64_DAG", "ISD::ATOMIC_LOAD_AND", "ARMISD::ATOMAND64_DAG", "ISD::ATOMIC_LOAD_NAND", "ARMISD::ATOMNAND64_DAG", "ISD::ATOMIC_LOAD_OR", "ARMISD::ATOMOR64_DAG", "ISD::ATOMIC_LOAD_SUB", "ARMISD::ATOMSUB64_DAG", "ISD::ATOMIC_LOAD_XOR", "ARMISD::ATOMXOR64_DAG", "ISD::ATOMIC_SWAP", "ARMISD::ATOMSWAP64_DAG", "ISD::ATOMIC_CMP_SWAP", "ARMISD::ATOMCMPXCHG64_DAG" ]

[]

[ "<s>", "bool", "LinuxAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "F", ",", "Mang", ",", "TM", ")", ")", ";", "EmitAlignment", "(", "MF", ".", "getAlignment", "(", ")", ",", "F", ")", ";", "switch", "(", "F", "->", "getLinkage", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown linkage type!\"", ")", ";", "case", "Function", "::", "PrivateLinkage", ":", "case", "Function", "::", "LinkerPrivateLinkage", ":", "case", "Function", "::", "InternalLinkage", ":", "break", ";", "case", "Function", "::", "ExternalLinkage", ":", "O", "<<", "\"\\t.global\\t\"", "<<", "CurrentFnName", "<<", "\"\\n\"", "<<", "\"\\t.type\\t\"", "<<", "CurrentFnName", "<<", "\", @function\\n\"", ";", "break", ";", "case", "Function", "::", "WeakAnyLinkage", ":", "case", "Function", "::", "WeakODRLinkage", ":", "case", "Function", "::", "LinkOnceAnyLinkage", ":", "case", "Function", "::", "LinkOnceODRLinkage", ":", "O", "<<", "\"\\t.global\\t\"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "O", "<<", "\"\\t.weak_definition\\t\"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "break", ";", "}", "O", "<<", "CurrentFnName", "<<", "\":\\n\"", ";", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "O", "<<", "\"\\t.size\\t\"", "<<", "CurrentFnName", "<<", "\",.-\"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "\"\\n\\n\"", "\"Unknown linkage type!\"", "\"\\t.global\\t\"", "\"\\n\"", "\"\\t.type\\t\"", "\", @function\\n\"", "\"\\t.global\\t\"", "\"\\n\"", "\"\\t.weak_definition\\t\"", "\"\\n\"", "\":\\n\"", "\"\\t.size\\t\"", "\",.-\"", "\"\\n\"" ]

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "WRYrr", ",", "dl", ",", "MVT", "::", "Glue", ",", "TopPart", ",", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "}", "case", "ISD", "::", "MULHU", ":", "case", "ISD", "::", "MULHS", ":", "{", "SDValue", "MulLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "MulRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "MULHU", "?", "SP", "::", "UMULrr", ":", "SP", "::", "SMULrr", ";", "SDNode", "*", "Mul", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Glue", ",", "MulLHS", ",", "MulRHS", ")", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "SP", "::", "RDY", ",", "MVT", "::", "i32", ",", "SDValue", "(", "Mul", ",", "1", ")", ")", ";", "}", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::WRYrr", "MVT::Glue", "SP::G0", "MVT::i32", "0", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "MVT::i32", "ISD::MULHU", "ISD::MULHS", "0", "1", "ISD::MULHU", "SP::UMULrr", "SP::SMULrr", "MVT::i32", "MVT::Glue", "SP::RDY", "MVT::i32", "1" ]

[]

[ "<s>", "static", "rtx", "rs6000_mixed_function_arg", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "align_words", ")", "{", "int", "n_units", ";", "int", "i", ",", "k", ";", "rtx", "rvec", "[", "GP_ARG_NUM_REG", "+", "1", "]", ";", "if", "(", "align_words", ">=", "GP_ARG_NUM_REG", ")", "return", "NULL_RTX", ";", "n_units", "=", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "n_units", "==", "0", "||", "(", "n_units", "==", "1", "&&", "mode", "!=", "BLKmode", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "k", "=", "0", ";", "if", "(", "align_words", "+", "n_units", ">", "GP_ARG_NUM_REG", ")", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "i", "=", "0", ";", "do", "{", "rtx", "r", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "rtx", "off", "=", "GEN_INT", "(", "i", "++", "*", "4", ")", ";", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "r", ",", "off", ")", ";", "}", "while", "(", "++", "align_words", "<", "GP_ARG_NUM_REG", "&&", "--", "n_units", "!=", "0", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "k", ",", "rvec", ")", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "place", "an", "argument", "in", "64-bit", "mode", "with", "32-bit", "ABI", "." ]

[ "rs6000", "1", "0", "1", "0", "0", "4", "0" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "!", "TM", ".", "getFunctionSections", "(", ")", ")", "PPCAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "llvm", "::", "for_each", "(", "GOAliasMap", "[", "&", "MF", "->", "getFunction", "(", ")", "]", ",", "[", "this", "]", "(", "const", "GlobalAlias", "*", "Alias", ")", "{", "OutStreamer", "->", "emitLabel", "(", "getObjFileLowering", "(", ")", ".", "getFunctionEntryPointSymbol", "(", "Alias", ",", "TM", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

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

[]

[ "<s>", "int", "tilegx_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "insn", ")", ";", "if", "(", "mode", "==", "SImode", ")", "return", "0", ";", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "INSN", ".", "LENGTH", "is", "the", "initial", "length", "computed", "by", "attributes", "in", "the", "machine-description", "file", ".", "This", "is", "where", "we", "account", "for", "bundles", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "const", "MCSection", "*", "XCoreTargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalValue", "*", "GV", ",", "SectionKind", "Kind", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "StringRef", "SectionName", "=", "GV", "->", "getSection", "(", ")", ";", "bool", "IsCPRel", "=", "SectionName", ".", "startswith", "(", "\".cp.\"", ")", ";", "if", "(", "IsCPRel", "&&", "!", "Kind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "\"Using .cp. section for writeable object.\"", ")", ";", "return", "getContext", "(", ")", ".", "getELFSection", "(", "SectionName", ",", "getXCoreSectionType", "(", "Kind", ")", ",", "getXCoreSectionFlags", "(", "Kind", ",", "IsCPRel", ")", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "XCore", "XCore", "\".cp.\"", "\"Using .cp. section for writeable object.\"", "XCore", "XCore" ]

[]

[ "<s>", "MCSection", "*", "HexagonTargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "Kind", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "TRACE", "(", "\"[getExplicitSectionGlobal] GO(\"", "<<", "GO", "->", "getName", "(", ")", "<<", "\") from(\"", "<<", "GO", "->", "getSection", "(", ")", "<<", "\") \"", ")", ";", "TRACE", "(", "(", "GO", "->", "hasPrivateLinkage", "(", ")", "?", "\"private_linkage \"", ":", "\"\"", ")", "<<", "(", "GO", "->", "hasLocalLinkage", "(", ")", "?", "\"local_linkage \"", ":", "\"\"", ")", "<<", "(", "GO", "->", "hasInternalLinkage", "(", ")", "?", "\"internal \"", ":", "\"\"", ")", "<<", "(", "GO", "->", "hasExternalLinkage", "(", ")", "?", "\"external \"", ":", "\"\"", ")", "<<", "(", "GO", "->", "hasCommonLinkage", "(", ")", "?", "\"common_linkage \"", ":", "\"\"", ")", "<<", "(", "GO", "->", "hasCommonLinkage", "(", ")", "?", "\"common \"", ":", "\"\"", ")", "<<", "(", "Kind", ".", "isCommon", "(", ")", "?", "\"kind_common \"", ":", "\"\"", ")", "<<", "(", "Kind", ".", "isBSS", "(", ")", "?", "\"kind_bss \"", ":", "\"\"", ")", "<<", "(", "Kind", ".", "isBSSLocal", "(", ")", "?", "\"kind_bss_local \"", ":", "\"\"", ")", ")", ";", "if", "(", "GO", "->", "hasSection", "(", ")", ")", "{", "StringRef", "Section", "=", "GO", "->", "getSection", "(", ")", ";", "if", "(", "Section", ".", "find", "(", "\".access.text.group\"", ")", "!=", "StringRef", "::", "npos", ")", "return", "getContext", "(", ")", ".", "getELFSection", "(", "GO", "->", "getSection", "(", ")", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_EXECINSTR", ")", ";", "if", "(", "Section", ".", "find", "(", "\".access.data.group\"", ")", "!=", "StringRef", "::", "npos", ")", "return", "getContext", "(", ")", ".", "getELFSection", "(", "GO", "->", "getSection", "(", ")", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "if", "(", "isGlobalInSmallSection", "(", "GO", ",", "TM", ")", ")", "return", "selectSmallSectionForGlobal", "(", "GO", ",", "Kind", ",", "TM", ")", ";", "TRACE", "(", "\"default_ELF_section\\n\"", ")", ";", "return", "TargetLoweringObjectFileELF", "::", "getExplicitSectionGlobal", "(", "GO", ",", "Kind", ",", "TM", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "Hexagon", "Hexagon", "\"[getExplicitSectionGlobal] GO(\"", "\") from(\"", "\") \"", "\"private_linkage \"", "\"\"", "\"local_linkage \"", "\"\"", "\"internal \"", "\"\"", "\"external \"", "\"\"", "\"common_linkage \"", "\"\"", "\"common \"", "\"\"", "\"kind_common \"", "\"\"", "\"kind_bss \"", "\"\"", "\"kind_bss_local \"", "\"\"", "\".access.text.group\"", "\".access.data.group\"", "\"default_ELF_section\\n\"" ]

[]

[ "<s>", "virtual", "unsigned", "getISAEncoding", "(", ")", "LLVM_OVERRIDE", "{", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "0", ";", "return", "Subtarget", "->", "isThumb", "(", ")", "?", "ARM", "::", "DW_ISA_ARM_thumb", ":", "ARM", "::", "DW_ISA_ARM_arm", ";", "}", "</s>" ]

[ "Get", "the", "value", "for", "DW_AT_APPLE_isa", ".", "Zero", "if", "no", "isa", "encoding", "specified", "." ]

[ "ARM", "0", "ARM::DW_ISA_ARM_thumb", "ARM::DW_ISA_ARM_arm" ]

[]

[ "<s>", "static", "int", "msp430_costs", "(", "rtx", "src", ",", "rtx", "dst", ",", "bool", "speed", ",", "rtx", "outer_rtx", ")", "{", "enum", "rtx_code", "src_code", "=", "GET_CODE", "(", "src", ")", ";", "enum", "rtx_code", "dst_code", "=", "GET_CODE", "(", "dst", ")", ";", "enum", "rtx_code", "outer_code", "=", "GET_CODE", "(", "outer_rtx", ")", ";", "machine_mode", "outer_mode", "=", "GET_MODE", "(", "outer_rtx", ")", ";", "const", "struct", "double_op_cost", "*", "cost_p", ";", "cost_p", "=", "(", "speed", "?", "&", "cycle_cost_double_op", ":", "&", "size_cost_double_op", ")", ";", "if", "(", "outer_code", "==", "TRUNCATE", "&&", "(", "outer_mode", "==", "QImode", "||", "outer_mode", "==", "HImode", "||", "outer_mode", "==", "PSImode", ")", ")", "return", "0", ";", "if", "(", "dst_code", "==", "SYMBOL_REF", "||", "dst_code", "==", "LABEL_REF", "||", "dst_code", "==", "CONST_INT", ")", "return", "0", ";", "switch", "(", "src_code", ")", "{", "case", "REG", ":", "return", "(", "dst_code", "==", "REG", "?", "cost_p", "->", "r2r", ":", "(", "dst_code", "==", "PC", "?", "cost_p", "->", "r2pc", ":", "cost_p", "->", "r2m", ")", ")", ";", "case", "CONST_INT", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "(", "dst_code", "==", "REG", "?", "cost_p", "->", "imm2r", ":", "(", "dst_code", "==", "PC", "?", "cost_p", "->", "imm2pc", ":", "cost_p", "->", "imm2m", ")", ")", ";", "case", "MEM", ":", "if", "(", "msp430_is_mem_indirect", "(", "src", ")", ")", "return", "(", "dst_code", "==", "REG", "?", "cost_p", "->", "ind2r", ":", "(", "dst_code", "==", "PC", "?", "cost_p", "->", "ind2pc", ":", "cost_p", "->", "ind2m", ")", ")", ";", "else", "return", "(", "dst_code", "==", "REG", "?", "cost_p", "->", "mem2r", ":", "(", "dst_code", "==", "PC", "?", "cost_p", "->", "mem2pc", ":", "cost_p", "->", "mem2m", ")", ")", ";", "default", ":", "return", "cost_p", "->", "mem2m", ";", "}", "}", "</s>" ]

[ "Costs", "of", "MSP430", "instructions", "are", "generally", "based", "on", "the", "addressing", "mode", "combination", "of", "the", "source", "and", "destination", "operands", ".", "Given", "source", "operand", "SRC", "(", "which", "may", "be", "NULL", "to", "indicate", "a", "single-operand", "instruction", ")", "and", "destination", "operand", "DST", "return", "the", "cost", "of", "this", "expression", "." ]

[ "msp430", "0", "0" ]

[]

[ "<s>", "SDValue", "AlphaTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Alpha", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "RetValue", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "RetValue", ")", ";", "InVals", ".", "push_back", "(", "RetValue", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "ISD::InputArg", "16", "Alpha", "0", "1", "0", "2", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE" ]

[]

[ "<s>", "void", "rs6000_scale_v2df", "(", "rtx", "tgt", ",", "rtx", "src", ",", "int", "scale", ")", "{", "HOST_WIDE_INT", "hwi_scale", "(", "scale", ")", ";", "REAL_VALUE_TYPE", "r_pow", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "2", ")", ";", "rtx", "elt", ";", "rtx", "scale_vec", "=", "gen_reg_rtx", "(", "V2DFmode", ")", ";", "(", "void", ")", "real_powi", "(", "&", "r_pow", ",", "DFmode", ",", "&", "dconst2", ",", "hwi_scale", ")", ";", "elt", "=", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "r_pow", ",", "DFmode", ")", ";", "RTVEC_ELT", "(", "v", ",", "0", ")", "=", "elt", ";", "RTVEC_ELT", "(", "v", ",", "1", ")", "=", "elt", ";", "rs6000_expand_vector_init", "(", "scale_vec", ",", "gen_rtx_PARALLEL", "(", "V2DFmode", ",", "v", ")", ")", ";", "emit_insn", "(", "gen_mulv2df3", "(", "tgt", ",", "src", ",", "scale_vec", ")", ")", ";", "}", "</s>" ]

[ "Scale", "a", "V2DF", "vector", "SRC", "by", "two", "to", "the", "SCALE", "and", "place", "in", "TGT", "." ]

[ "rs6000", "2", "0", "1" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "loongarch_starting_frame_offset", "(", "void", ")", "{", "if", "(", "FRAME_GROWS_DOWNWARD", ")", "return", "0", ";", "return", "crtl", "->", "outgoing_args_size", ";", "}", "</s>" ]

[ "Implement", "TARGET_STARTING_FRAME_OFFSET", ".", "See", "loongarch_compute_frame_info", "for", "details", "about", "the", "frame", "layout", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"VE DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "AArch64InstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "AArch64II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_COFFSTUB", ",", "\"aarch64-coffstub\"", "}", ",", "{", "MO_GOT", ",", "\"aarch64-got\"", "}", ",", "{", "MO_NC", ",", "\"aarch64-nc\"", "}", ",", "{", "MO_S", ",", "\"aarch64-s\"", "}", ",", "{", "MO_TLS", ",", "\"aarch64-tls\"", "}", ",", "{", "MO_DLLIMPORT", ",", "\"aarch64-dllimport\"", "}", ",", "{", "MO_PREL", ",", "\"aarch64-prel\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "AArch64", "AArch64", "AArch64", "\"aarch64-coffstub\"", "\"aarch64-got\"", "\"aarch64-nc\"", "\"aarch64-s\"", "\"aarch64-tls\"", "\"aarch64-dllimport\"", "\"aarch64-prel\"" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "is64bit", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "SparcELFTargetObjectFile", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "is64bit", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "static", "tree", "xtensa_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_stk", ",", "f_reg", ",", "f_ndx", ",", "record", ",", "type_decl", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_stk", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_stk\"", ")", ",", "ptr_type_node", ")", ";", "f_reg", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_reg\"", ")", ",", "ptr_type_node", ")", ";", "f_ndx", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_ndx\"", ")", ",", "integer_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_stk", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_reg", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ndx", ")", "=", "record", ";", "TYPE_STUB_DECL", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_stk", ";", "DECL_CHAIN", "(", "f_stk", ")", "=", "f_reg", ";", "DECL_CHAIN", "(", "f_reg", ")", "=", "f_ndx", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", ".", "This", "structure", "is", "set", "up", "by", "__builtin_saveregs", ".", "The", "__va_reg", "field", "points", "to", "a", "stack-allocated", "region", "holding", "the", "contents", "of", "the", "incoming", "argument", "registers", ".", "The", "__va_ndx", "field", "is", "an", "index", "initialized", "to", "the", "position", "of", "the", "first", "unnamed", "(", "variable", ")", "argument", ".", "This", "same", "index", "is", "also", "used", "to", "address", "the", "arguments", "passed", "in", "memory", ".", "Thus", ",", "the", "__va_stk", "field", "is", "initialized", "to", "point", "to", "the", "position", "of", "the", "first", "argument", "in", "memory", "offset", "to", "account", "for", "the", "arguments", "passed", "in", "registers", "and", "to", "account", "for", "the", "size", "of", "the", "argument", "registers", "not", "being", "16-byte", "aligned", ".", "E.G.", ",", "there", "are", "6", "argument", "registers", "of", "4", "bytes", "each", ",", "but", "we", "want", "the", "__va_ndx", "for", "the", "first", "stack", "argument", "to", "have", "the", "maximal", "alignment", "of", "16", "bytes", ",", "so", "we", "offset", "the", "__va_stk", "address", "by", "32", "bytes", "so", "that", "__va_stk", "[", "32", "]", "references", "the", "first", "argument", "on", "the", "stack", "." ]

[ "xtensa", "\"__va_list_tag\"", "\"__va_stk\"", "\"__va_reg\"", "\"__va_ndx\"" ]

[]

[ "<s>", "static", "int", "aarch64_reassociation_width", "(", "unsigned", "opc", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "aarch64_tune_params", "->", "vec_reassoc_width", ";", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", ")", "return", "aarch64_tune_params", "->", "int_reassoc_width", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "aarch64_tune_params", "->", "fp_reassoc_width", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "the", "reassociation", "width", "of", "treeop", "OPC", "with", "mode", "MODE", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "uint64_t", "getStackSize", "(", ")", "{", "return", "StackSize", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "that", "must", "be", "allocated", "to", "hold", "all", "of", "the", "fixed", "size", "frame", "objects", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "isTarget64BitLP64", "(", ")", "const", "{", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "GNUX32", "&&", "!", "TargetTriple", ".", "isOSNaCl", "(", ")", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "LP64", "programming", "model", "(", "standard", "AMD64", ",", "no", "x32", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "enum", "reg_class", "mcore_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "if", "(", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "rclass", "]", ",", "15", ")", "&&", "!", "mcore_r15_operand_p", "(", "x", ")", ")", "return", "LRW_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "SECONDARY_RELOAD_CLASS", ".", "If", "CLASS", "contains", "r15", ",", "and", "we", "ca", "n't", "directly", "move", "X", "into", "it", ",", "use", "r1-r14", "as", "a", "temporary", "." ]

[ "mcore", "15" ]

[]

[ "<s>", "static", "bool", "Check", "(", "DecodeStatus", "&", "Out", ",", "DecodeStatus", "In", ")", "{", "switch", "(", "In", ")", "{", "case", "MCDisassembler", "::", "Success", ":", "return", "true", ";", "case", "MCDisassembler", "::", "SoftFail", ":", "Out", "=", "In", ";", "return", "true", ";", "case", "MCDisassembler", "::", "Fail", ":", "Out", "=", "In", ";", "return", "false", ";", "}", "llvm_unreachable", "(", "\"Invalid DecodeStatus!\"", ")", ";", "}", "</s>" ]

[ "Matches", "check", "string", "and", "its", "``", "not", "strings", "''", "and/or", "``", "dag", "strings", "''", "." ]

[ "AArch64", "\"Invalid DecodeStatus!\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Lower Kernel Calls\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Lower Kernel Calls\"" ]

[]

[ "<s>", "int", "valid_parallel_load_store", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "op0", "=", "operands", "[", "0", "]", ";", "rtx", "op1", "=", "operands", "[", "1", "]", ";", "rtx", "op2", "=", "operands", "[", "2", "]", ";", "rtx", "op3", "=", "operands", "[", "3", "]", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "SUBREG", ")", "op0", "=", "SUBREG_REG", "(", "op0", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "SUBREG", ")", "op1", "=", "SUBREG_REG", "(", "op1", ")", ";", "if", "(", "GET_CODE", "(", "op2", ")", "==", "SUBREG", ")", "op2", "=", "SUBREG_REG", "(", "op2", ")", ";", "if", "(", "GET_CODE", "(", "op3", ")", "==", "SUBREG", ")", "op3", "=", "SUBREG_REG", "(", "op3", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "&&", "(", "(", "GET_CODE", "(", "op2", ")", "==", "MEM", "&&", "reg_mentioned_p", "(", "op0", ",", "XEXP", "(", "op2", ",", "0", ")", ")", ")", "||", "(", "GET_CODE", "(", "op3", ")", "==", "MEM", "&&", "reg_mentioned_p", "(", "op0", ",", "XEXP", "(", "op3", ",", "0", ")", ")", ")", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "&&", "GET_CODE", "(", "op2", ")", "==", "REG", ")", "return", "(", "REGNO", "(", "op0", ")", "!=", "REGNO", "(", "op2", ")", ")", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", "&&", "GET_CODE", "(", "op3", ")", "==", "MEM", "&&", "!", "c4x_address_conflict", "(", "op1", ",", "op3", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "REG", "&&", "GET_CODE", "(", "op3", ")", "==", "REG", ")", "return", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op2", ")", "==", "MEM", "&&", "!", "c4x_address_conflict", "(", "op0", ",", "op2", ",", "1", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "&&", "GET_CODE", "(", "op3", ")", "==", "REG", ")", "return", "GET_CODE", "(", "op1", ")", "==", "MEM", "&&", "GET_CODE", "(", "op2", ")", "==", "MEM", "&&", "!", "c4x_address_conflict", "(", "op1", ",", "op2", ",", "0", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "REG", "&&", "GET_CODE", "(", "op2", ")", "==", "REG", ")", "return", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op3", ")", "==", "MEM", "&&", "!", "c4x_address_conflict", "(", "op0", ",", "op3", ",", "1", ",", "0", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Validate", "combination", "of", "operands", "for", "parallel", "load/store", "instructions", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "*", "ARM64TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "MI", "->", "dump", "(", ")", ";", "assert", "(", "0", "&&", "\"Unexpected instruction for custom inserter!\"", ")", ";", "break", ";", "case", "ARM64", "::", "F128CSEL", ":", "return", "EmitF128CSEL", "(", "MI", ",", "BB", ")", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "emitPatchPoint", "(", "MI", ",", "BB", ")", ";", "}", "llvm_unreachable", "(", "\"Unexpected instruction for custom inserter!\"", ")", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "ARM64", "ARM64", "0", "\"Unexpected instruction for custom inserter!\"", "ARM64::F128CSEL", "\"Unexpected instruction for custom inserter!\"" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_advance_flush", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "HOST_WIDE_INT", "bitpos", ",", "int", "final", ")", "{", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "intregs", ",", "intoffset", ";", "if", "(", "cum", "->", "floats_in_gpr", "==", "1", "&&", "(", "cum", "->", "intoffset", "%", "64", "==", "0", "||", "(", "cum", "->", "intoffset", "==", "-", "1", "&&", "final", ")", ")", ")", "{", "cum", "->", "words", "++", ";", "cum", "->", "floats_in_gpr", "=", "0", ";", "}", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "return", ";", "intoffset", "=", "cum", "->", "intoffset", ";", "cum", "->", "intoffset", "=", "-", "1", ";", "cum", "->", "floats_in_gpr", "=", "0", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "{", "unsigned", "int", "bits", "=", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ";", "if", "(", "!", "int_mode_for_size", "(", "bits", ",", "0", ")", ".", "exists", "(", ")", ")", "{", "intoffset", "=", "ROUND_DOWN", "(", "intoffset", ",", "BITS_PER_WORD", ")", ";", "}", "}", "startbit", "=", "ROUND_DOWN", "(", "intoffset", ",", "BITS_PER_WORD", ")", ";", "endbit", "=", "ROUND_UP", "(", "bitpos", ",", "BITS_PER_WORD", ")", ";", "intregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "cum", "->", "words", "+=", "intregs", ";", "if", "(", "(", "unsigned", ")", "cum", "->", "words", "<", "(", "endbit", "/", "BITS_PER_WORD", ")", ")", "{", "int", "pad", "=", "(", "endbit", "/", "BITS_PER_WORD", ")", "-", "cum", "->", "words", ";", "cum", "->", "words", "+=", "pad", ";", "}", "}", "</s>" ]

[ "Use", "this", "to", "flush", "pending", "int", "fields", "." ]

[ "rs6000", "1", "64", "0", "1", "0", "1", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_zip", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "high", ";", "poly_uint64", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "rtx", "out", ",", "in0", ",", "in1", ",", "x", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "vmode", ")", ">", "8", ")", "return", "false", ";", "poly_uint64", "first", "=", "d", "->", "perm", "[", "0", "]", ";", "if", "(", "(", "maybe_ne", "(", "first", ",", "0U", ")", "&&", "maybe_ne", "(", "first", "*", "2", ",", "nelt", ")", ")", "||", "!", "d", "->", "perm", ".", "series_p", "(", "0", ",", "2", ",", "first", ",", "1", ")", "||", "!", "d", "->", "perm", ".", "series_p", "(", "1", ",", "2", ",", "first", "+", "nelt", ",", "1", ")", ")", "return", "false", ";", "high", "=", "maybe_ne", "(", "first", ",", "0U", ")", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "d", "->", "vec_flags", "==", "VEC_ADVSIMD", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "high", "=", "!", "high", ";", "}", "out", "=", "d", "->", "target", ";", "emit_set_insn", "(", "out", ",", "gen_rtx_UNSPEC", "(", "vmode", ",", "gen_rtvec", "(", "2", ",", "in0", ",", "in1", ")", ",", "high", "?", "UNSPEC_ZIP2", ":", "UNSPEC_ZIP1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "suitable", "for", "the", "ZIP", "instructions", "." ]

[ "aarch64", "8", "0", "0U", "2", "0", "2", "1", "1", "2", "1", "0U", "2" ]

[]

[ "<s>", "void", "X86WinCOFFStreamer", "::", "emitCVFPOData", "(", "const", "MCSymbol", "*", "ProcSym", ",", "SMLoc", "Loc", ")", "{", "X86TargetStreamer", "*", "XTS", "=", "static_cast", "<", "X86TargetStreamer", "*", ">", "(", "getTargetStreamer", "(", ")", ")", ";", "XTS", "->", "emitFPOData", "(", "ProcSym", ",", "Loc", ")", ";", "}", "</s>" ]

[ "This", "implements", "the", "CodeView", "'.cv_fpo_data", "'", "assembler", "directive", "." ]

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

[]

[ "<s>", "void", "cris_asm_output_case_end", "(", "FILE", "*", "stream", ",", "int", "num", ",", "rtx_insn", "*", "table", ")", "{", "rtx_insn", "*", "whole_jump_insn", "=", "prev_nonnote_nondebug_insn", "(", "table", ")", ";", "gcc_assert", "(", "whole_jump_insn", "!=", "NULL_RTX", "&&", "LABEL_P", "(", "whole_jump_insn", ")", ")", ";", "whole_jump_insn", "=", "prev_nonnote_nondebug_insn", "(", "whole_jump_insn", ")", ";", "gcc_assert", "(", "whole_jump_insn", "!=", "NULL_RTX", "&&", "JUMP_P", "(", "whole_jump_insn", ")", ")", ";", "rtx", "whole_jump_pat", "=", "PATTERN", "(", "whole_jump_insn", ")", ";", "asm_fprintf", "(", "stream", ",", "\"\\t.word %LL%d-%LL%d%s\\n\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "XVECEXP", "(", "whole_jump_pat", ",", "0", ",", "0", ")", ",", "1", ")", ",", "2", ")", ",", "0", ")", ")", ",", "num", ",", "(", "TARGET_PDEBUG", "?", "\"; default\"", ":", "\"\"", ")", ")", ";", "}", "</s>" ]

[ "The", "ASM_OUTPUT_CASE_END", "worker", "." ]

[ "cris", "\"\\t.word %LL%d-%LL%d%s\\n\"", "0", "0", "1", "2", "0", "\"; default\"", "\"\"" ]

[]

[ "<s>", "const", "SpillSlot", "*", "getCalleeSavedSpillSlots", "(", "unsigned", "&", "NumEntries", ")", "const", "override", "{", "static", "const", "SpillSlot", "Offsets", "[", "]", "=", "{", "{", "VE", "::", "SX17", ",", "40", "}", ",", "{", "VE", "::", "SX18", ",", "48", "}", ",", "{", "VE", "::", "SX19", ",", "56", "}", ",", "{", "VE", "::", "SX20", ",", "64", "}", ",", "{", "VE", "::", "SX21", ",", "72", "}", ",", "{", "VE", "::", "SX22", ",", "80", "}", ",", "{", "VE", "::", "SX23", ",", "88", "}", ",", "{", "VE", "::", "SX24", ",", "96", "}", ",", "{", "VE", "::", "SX25", ",", "104", "}", ",", "{", "VE", "::", "SX26", ",", "112", "}", ",", "{", "VE", "::", "SX27", ",", "120", "}", ",", "{", "VE", "::", "SX28", ",", "128", "}", ",", "{", "VE", "::", "SX29", ",", "136", "}", ",", "{", "VE", "::", "SX30", ",", "144", "}", ",", "{", "VE", "::", "SX31", ",", "152", "}", ",", "{", "VE", "::", "SX32", ",", "160", "}", ",", "{", "VE", "::", "SX33", ",", "168", "}", "}", ";", "NumEntries", "=", "array_lengthof", "(", "Offsets", ")", ";", "return", "Offsets", ";", "}", "</s>" ]

[ "getCalleeSavedSpillSlots", "-", "This", "method", "returns", "a", "pointer", "to", "an", "array", "of", "pairs", ",", "that", "contains", "an", "entry", "for", "each", "callee", "saved", "register", "that", "must", "be", "spilled", "to", "a", "particular", "stack", "location", "if", "it", "is", "spilled", "." ]

[ "VE", "VE::SX17", "40", "VE::SX18", "48", "VE::SX19", "56", "VE::SX20", "64", "VE::SX21", "72", "VE::SX22", "80", "VE::SX23", "88", "VE::SX24", "96", "VE::SX25", "104", "VE::SX26", "112", "VE::SX27", "120", "VE::SX28", "128", "VE::SX29", "136", "VE::SX30", "144", "VE::SX31", "152", "VE::SX32", "160", "VE::SX33", "168" ]

[]

[ "<s>", "bool", "Thumb2ITBlockPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "return", "false", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "++", "MFI", ";", "Modified", "|=", "InsertITInstructions", "(", "MBB", ")", ";", "}", "if", "(", "Modified", ")", "AFI", "->", "setHasITBlocks", "(", "true", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "SIDebuggerInsertNops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "debuggerInsertNops", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", ")", "return", "false", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DenseSet", "<", "unsigned", ">", "NopInserted", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "MI", "->", "isDebugInstr", "(", ")", "||", "!", "MI", "->", "getDebugLoc", "(", ")", ")", "continue", ";", "auto", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NopInserted", ".", "find", "(", "DL", ".", "getLine", "(", ")", ")", "==", "NopInserted", ".", "end", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "*", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_NOP", ")", ")", ".", "addImm", "(", "0", ")", ";", "NopInserted", ".", "insert", "(", "DL", ".", "getLine", "(", ")", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::S_NOP", "0" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableExpandCondsets", ")", "insertPass", "(", "&", "RegisterCoalescerID", ",", "&", "HexagonExpandCondsetsID", ")", ";", "if", "(", "!", "DisableStoreWidening", ")", "addPass", "(", "createHexagonStoreWidening", "(", ")", ",", "false", ")", ";", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonHardwareLoops", "(", ")", ",", "false", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", ")", "addPass", "(", "&", "MachinePipelinerID", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasVFP3Base", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", "return", "ARM_AM", "::", "getFP16Imm", "(", "Imm", ")", "!=", "-", "1", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "ARM_AM", "::", "getFP32Imm", "(", "Imm", ")", "!=", "-", "1", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "Subtarget", "->", "hasFP64", "(", ")", ")", "return", "ARM_AM", "::", "getFP64Imm", "(", "Imm", ")", "!=", "-", "1", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "ARM", "ARM", "MVT::f16", "ARM_AM::getFP16Imm", "1", "MVT::f32", "ARM_AM::getFP32Imm", "1", "MVT::f64", "ARM_AM::getFP64Imm", "1" ]

[]

[ "<s>", "static", "bool", "has_memory_op", "(", "rtx_insn", "*", "mem_insn", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "mem_insn", ")", ",", "ALL", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "rtx_insn", "contains", "a", "MEM", "RTX", "somewhere", "in", "it", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "TL45DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "MVT", "XLenVT", "=", "MVT", "::", "i32", ";", "SDLoc", "DL", "(", "Node", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "{", "auto", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "if", "(", "VT", "==", "XLenVT", "&&", "ConstNode", "->", "isNullValue", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "TL45", "::", "r0", ",", "XLenVT", ")", ";", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "return", ";", "}", "int64_t", "Imm", "=", "ConstNode", "->", "getSExtValue", "(", ")", ";", "if", "(", "XLenVT", "==", "MVT", "::", "i32", ")", "{", "ReplaceNode", "(", "Node", ",", "selectImm", "(", "CurDAG", ",", "SDLoc", "(", "Node", ")", ",", "Imm", ",", "XLenVT", ")", ")", ";", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "Imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "DL", ",", "XLenVT", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "TL45", "::", "ADDI", ",", "DL", ",", "VT", ",", "TFI", ",", "Imm", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "1", "MVT::i32", "0", "ISD::Constant", "TL45::r0", "MVT::i32", "ISD::FrameIndex", "0", "TL45::ADDI" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "nullptr", ";", "}", "</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", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "s390_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "cfun", "->", "machine", "->", "base_reg", ")", "if", "(", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "old_reg", "||", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "new_reg", ")", "return", "false", ";", "if", "(", "GENERAL_REGNO_P", "(", "new_reg", ")", "&&", "!", "call_used_regs", "[", "new_reg", "]", "&&", "cfun_gpr_save_slot", "(", "new_reg", ")", "==", "SAVE_SLOT_NONE", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "." ]

[ "s390" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "SPILL_CR", ":", "case", "PPC", "::", "SPILL_CRBIT", ":", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "STXVD2X", ":", "case", "PPC", "::", "QVSTFDX", ":", "case", "PPC", "::", "QVSTFSXs", ":", "case", "PPC", "::", "QVSTFDXb", ":", "case", "PPC", "::", "SPILL_VRSAVE", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "MMIXMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "SubtargetInfo", ")", "const", "{", "const", "MCOperand", "&", "MCOp", "=", "Inst", ".", "getOperand", "(", "OpNo", ")", ";", "MCFixupKind", "Kind", "=", "static_cast", "<", "MCFixupKind", ">", "(", "MMIX", "::", "fixup_mmix_rel_16", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MCOp", ".", "getExpr", "(", ")", ",", "Kind", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "MMIX", "MMIX", "MMIX::fixup_mmix_rel_16", "0", "0" ]

[]

[ "<s>", "static", "bool", "nds32_expand_cpymemsi_loop_unknown_size", "(", "rtx", "dstmem", ",", "rtx", "srcmem", ",", "rtx", "size", ",", "rtx", "alignment", ")", "{", "rtx", "dst_base_reg", ",", "src_base_reg", ";", "rtx", "dst_itr", ",", "src_itr", ";", "rtx", "dstmem_m", ",", "srcmem_m", ",", "dst_itr_m", ",", "src_itr_m", ";", "rtx", "dst_end", ";", "rtx", "size_least_3_bit", ";", "rtx", "double_word_end", ";", "rtx", "double_word_mode_loop", ",", "byte_mode_entry", ",", "byte_mode_loop", ",", "end_label", ";", "rtx", "tmp", ";", "rtx", "mask_least_3_bit", ";", "int", "start_regno", ";", "bool", "align_to_4_bytes", "=", "(", "INTVAL", "(", "alignment", ")", "&", "3", ")", "==", "0", ";", "if", "(", "TARGET_ISA_V3M", "&&", "!", "align_to_4_bytes", ")", "return", "0", ";", "if", "(", "TARGET_REDUCED_REGS", ")", "start_regno", "=", "2", ";", "else", "start_regno", "=", "16", ";", "dst_itr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "src_itr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "dst_end", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "mask_least_3_bit", "=", "GEN_INT", "(", "~", "7", ")", ";", "double_word_mode_loop", "=", "gen_label_rtx", "(", ")", ";", "byte_mode_entry", "=", "gen_label_rtx", "(", ")", ";", "byte_mode_loop", "=", "gen_label_rtx", "(", ")", ";", "end_label", "=", "gen_label_rtx", "(", ")", ";", "dst_base_reg", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "dstmem", ",", "0", ")", ")", ";", "src_base_reg", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "srcmem", ",", "0", ")", ")", ";", "size_least_3_bit", "=", "expand_binop", "(", "SImode", ",", "and_optab", ",", "size", ",", "mask_least_3_bit", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "dst_end", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "dst_base_reg", ",", "size", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "dst_itr", ",", "dst_base_reg", ")", ";", "emit_move_insn", "(", "src_itr", ",", "src_base_reg", ")", ";", "emit_cmp_and_jump_insns", "(", "size_least_3_bit", ",", "const0_rtx", ",", "EQ", ",", "NULL", ",", "SImode", ",", "1", ",", "byte_mode_entry", ")", ";", "double_word_end", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "dst_base_reg", ",", "size_least_3_bit", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "emit_label", "(", "double_word_mode_loop", ")", ";", "src_itr_m", "=", "src_itr", ";", "dst_itr_m", "=", "dst_itr", ";", "srcmem_m", "=", "srcmem", ";", "dstmem_m", "=", "dstmem", ";", "nds32_emit_mem_move_block", "(", "start_regno", ",", "2", ",", "&", "dst_itr_m", ",", "&", "dstmem_m", ",", "&", "src_itr_m", ",", "&", "srcmem_m", ",", "true", ")", ";", "emit_move_insn", "(", "dst_itr", ",", "dst_itr_m", ")", ";", "emit_move_insn", "(", "src_itr", ",", "src_itr_m", ")", ";", "emit_cmp_and_jump_insns", "(", "double_word_end", ",", "dst_itr", ",", "NE", ",", "NULL", ",", "Pmode", ",", "1", ",", "double_word_mode_loop", ")", ";", "emit_label", "(", "byte_mode_entry", ")", ";", "emit_cmp_and_jump_insns", "(", "dst_itr", ",", "dst_end", ",", "EQ", ",", "NULL", ",", "Pmode", ",", "1", ",", "end_label", ")", ";", "emit_label", "(", "byte_mode_loop", ")", ";", "nds32_emit_post_inc_load_store", "(", "tmp", ",", "src_itr", ",", "QImode", ",", "true", ")", ";", "nds32_emit_post_inc_load_store", "(", "tmp", ",", "dst_itr", ",", "QImode", ",", "false", ")", ";", "emit_cmp_and_jump_insns", "(", "dst_itr", ",", "dst_end", ",", "NE", ",", "NULL", ",", "SImode", ",", "1", ",", "byte_mode_loop", ")", ";", "emit_label", "(", "end_label", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Auxiliary", "function", "for", "expand", "cpymem", "pattern", "." ]

[ "nds32", "3", "0", "0", "2", "16", "7", "0", "0", "0", "0", "1", "0", "2", "1", "1", "1" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "RoundUpToAlignment", "(", "maxCallFrameSize", ",", "TargetAlign", ")", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "RoundUpToAlignment", "(", "FrameSize", ",", "TargetAlign", ")", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "int", "compute_a_shift_cc", "(", "rtx", "operands", "[", "3", "]", ",", "rtx_code", "code", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "shift_type", "shift_type", ";", "enum", "shift_mode", "shift_mode", ";", "struct", "shift_info", "info", ";", "int", "n", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "shift_mode", "=", "QIshift", ";", "break", ";", "case", "E_HImode", ":", "shift_mode", "=", "HIshift", ";", "break", ";", "case", "E_SImode", ":", "shift_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ASHIFTRT", ":", "shift_type", "=", "SHIFT_ASHIFTRT", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "case", "ASHIFT", ":", "shift_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", ";", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "<", "0", ")", "n", "=", "0", ";", "else", "if", "(", "(", "unsigned", "int", ")", "n", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "n", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "n", ",", "&", "info", ")", ";", "switch", "(", "info", ".", "alg", ")", "{", "case", "SHIFT_SPECIAL", ":", "if", "(", "info", ".", "remainder", "==", "0", ")", "return", "(", "info", ".", "cc_special", "==", "OLD_CC_SET_ZN", "||", "info", ".", "cc_special", "==", "OLD_CC_SET_ZNV", ")", ";", "case", "SHIFT_INLINE", ":", "return", "(", "info", ".", "cc_inline", "==", "OLD_CC_SET_ZN", "||", "info", ".", "cc_inline", "==", "OLD_CC_SET_ZNV", ")", ";", "case", "SHIFT_ROT_AND", ":", "return", "true", ";", "case", "SHIFT_LOOP", ":", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "if", "(", "n", "%", "2", ")", "return", "(", "info", ".", "cc_inline", "==", "OLD_CC_SET_ZN", "||", "info", ".", "cc_inline", "==", "OLD_CC_SET_ZNV", ")", ";", "}", "return", "false", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "a", "shift", "insn", "." ]

[ "h8300", "3", "0", "2", "2", "0", "0", "0", "2" ]

[]

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

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "arc_check_ior_const", "(", "HOST_WIDE_INT", "ival", ")", "{", "unsigned", "int", "mask", "=", "(", "unsigned", "int", ")", "(", "ival", "&", "0xffffffff", ")", ";", "if", "(", "UNSIGNED_INT6", "(", "ival", ")", "||", "IS_POWEROF2_P", "(", "mask", ")", ")", "return", "false", ";", "if", "(", "__builtin_popcount", "(", "mask", ")", "<=", "3", ")", "return", "true", ";", "if", "(", "__builtin_popcount", "(", "mask", "&", "~", "0x3f", ")", "<=", "1", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "to", "check", "C0x", "constraint", "." ]

[ "arc", "0xffffffff", "3", "0x3f", "1" ]

[]

[ "<s>", "unsigned", "getMaxInlineSizeThreshold", "(", ")", "const", "{", "return", "isThumb1Only", "(", ")", "?", "0", ":", "64", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "memset", "/", "memcpy", "size", "that", "still", "makes", "it", "profitable", "to", "inline", "the", "call", "." ]

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

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ")", "{", "Triple", "TheTriple", "(", "TT", ")", ";", "switch", "(", "TheTriple", ".", "getOS", "(", ")", ")", "{", "case", "Triple", "::", "Darwin", ":", "return", "new", "X86MCAsmInfoDarwin", "(", "TheTriple", ")", ";", "case", "Triple", "::", "MinGW32", ":", "case", "Triple", "::", "Cygwin", ":", "case", "Triple", "::", "Win32", ":", "if", "(", "TheTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MachO", ")", "return", "new", "X86MCAsmInfoDarwin", "(", "TheTriple", ")", ";", "else", "return", "new", "X86MCAsmInfoCOFF", "(", "TheTriple", ")", ";", "default", ":", "return", "new", "X86ELFMCAsmInfo", "(", "TheTriple", ")", ";", "}", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

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

[]

[ "<s>", "bool", "ARM64PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCCMP", ")", "addPass", "(", "createARM64ConditionalCompares", "(", ")", ")", ";", "if", "(", "EnableEarlyIfConvert", ")", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createARM64StorePairSuppressPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

[ "ARM64", "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBoolRetToIntPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", "&", "getPPCTargetMachine", "(", ")", ")", ")", ";", "bool", "UsePrefetching", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getVendor", "(", ")", "==", "Triple", "::", "BGQ", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ";", "if", "(", "EnablePrefetch", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "UsePrefetching", "=", "EnablePrefetch", ";", "if", "(", "UsePrefetching", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "TM", ",", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "mayLoad", "(", ")", ")", "{", "if", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "s390_asm_trampoline_template", "(", "FILE", "*", "file", ")", "{", "rtx", "op", "[", "2", "]", ";", "op", "[", "0", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "op", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "output_asm_insn", "(", "\"basr\\t%1,0\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"lmg\\t%0,%1,14(%1)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"br\\t%1\"", ",", "op", ")", ";", "ASM_OUTPUT_SKIP", "(", "file", ",", "(", "HOST_WIDE_INT", ")", "(", "TRAMPOLINE_SIZE", "-", "10", ")", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"basr\\t%1,0\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"lm\\t%0,%1,6(%1)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"br\\t%1\"", ",", "op", ")", ";", "ASM_OUTPUT_SKIP", "(", "file", ",", "(", "HOST_WIDE_INT", ")", "(", "TRAMPOLINE_SIZE", "-", "8", ")", ")", ";", "}", "}", "</s>" ]

[ "Output", "assembly", "code", "for", "the", "trampoline", "template", "to", "stdio", "stream", "FILE", ".", "On", "S/390", ",", "we", "use", "gpr", "1", "internally", "in", "the", "trampoline", "code", ";", "gpr", "0", "is", "used", "to", "hold", "the", "static", "chain", "." ]

[ "s390", "2", "0", "0", "1", "1", "\"basr\\t%1,0\"", "\"lmg\\t%0,%1,14(%1)\"", "\"br\\t%1\"", "10", "\"basr\\t%1,0\"", "\"lm\\t%0,%1,6(%1)\"", "\"br\\t%1\"", "8" ]

[]

[ "<s>", "void", "aarch64_split_simd_combine", "(", "rtx", "dst", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "machine_mode", "src_mode", "=", "GET_MODE", "(", "src1", ")", ";", "machine_mode", "dst_mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "dst_mode", ")", ")", ";", "gcc_assert", "(", "register_operand", "(", "dst", ",", "dst_mode", ")", "&&", "register_operand", "(", "src1", ",", "src_mode", ")", "&&", "register_operand", "(", "src2", ",", "src_mode", ")", ")", ";", "emit_insn", "(", "gen_aarch64_simd_combine", "(", "src_mode", ",", "dst", ",", "src1", ",", "src2", ")", ")", ";", "return", ";", "}", "</s>" ]

[ "Split", "a", "complex", "SIMD", "combine", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "mips_expand_vpc_loongson_even_odd", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "odd", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "t0", ",", "t1", ",", "t2", ",", "t3", ";", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_MMI", ")", ")", "return", "false", ";", "if", "(", "nelt", "<", "4", ")", "return", "false", ";", "odd", "=", "d", "->", "perm", "[", "0", "]", ";", "if", "(", "odd", ">", "1", ")", "return", "false", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nelt", ";", "++", "i", ")", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "i", "*", "2", "+", "odd", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "t0", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "t1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V4HImode", ":", "emit_insn", "(", "gen_loongson_punpckhhw", "(", "t0", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpcklhw", "(", "t1", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "if", "(", "odd", ")", "emit_insn", "(", "gen_loongson_punpckhhw", "(", "d", "->", "target", ",", "t1", ",", "t0", ")", ")", ";", "else", "emit_insn", "(", "gen_loongson_punpcklhw", "(", "d", "->", "target", ",", "t1", ",", "t0", ")", ")", ";", "break", ";", "case", "E_V8QImode", ":", "t2", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "t3", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "emit_insn", "(", "gen_loongson_punpckhbh", "(", "t0", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpcklbh", "(", "t1", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpckhbh", "(", "t2", ",", "t1", ",", "t0", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpcklbh", "(", "t3", ",", "t1", ",", "t0", ")", ")", ";", "if", "(", "odd", ")", "emit_insn", "(", "gen_loongson_punpckhbh", "(", "d", "->", "target", ",", "t3", ",", "t2", ")", ")", ";", "else", "emit_insn", "(", "gen_loongson_punpcklbh", "(", "d", "->", "target", ",", "t3", ",", "t2", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "even-odd", "extraction", "." ]

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

[]