Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

[ "AArch64", "<STR_LIT>", ")", ";" ]

[ "RegisterTarget", "<", "Triple", "::", "aarch64", ">", "X", "(", "TheAArch64Target", ",", "<STR_LIT>", "aarch64", "<STR_LIT>", ",", "<STR_LIT>" ]

[ "MI", ")", "{" ]

[ "static", "bool", "IsStackMask", "(", "const", "MachineInstr", "&" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "class", "MVEVectorVTInfo", "<", "ValueType", "vec", ",", "ValueType", "dblvec", ",", "ValueType", "pred", ",", "ValueType", "dblpred", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "string", "suffixletter", ",", "bit", "unsigned", ">", "{", "ValueType", "Vec", "=", "vec", ";", "ValueType", "DblVec", "=", "dblvec", ";", "ValueType", "Pred", "=", "pred", ";", "ValueType", "DblPred", "=", "dblpred", ";", "bits", "<", "<NUM_LIT>", ">", "Size", "=", "size", ";", "bit", "Unsigned", "=", "unsigned", ";", "int", "LaneBits", "=", "!", "shl", "(", "<NUM_LIT>", ",", "Size", ")", ";", "string", "BitsSuffix", "=", "!", "if", "(", "!", "eq", "(", "suffixletter", ",", "<STR_LIT>", ")", ",", "!", "if", "(", "!", "eq", "(", "unsigned", ",", "<NUM_LIT>", ")", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ",", "!", "cast", "<", "string", ">", "(", "LaneBits", ")", ")", ";", "string", "Suffix", "=", "suffixletter", "#", "BitsSuffix", ";", "string", "SuffixLetter", "=", "suffixletter", ";" ]

[ "MIB", ".", "addReg", "(", "WaveBase", ")", ";" ]

[ "}", "}", "}", ";", "}", "int64_t", "Offset", "=", "<NUM_LIT>", ";", "Register", "BasePtr", ";", "if", "(", "mi_match", "(", "Reg", ",", "*", "MRI", ",", "m_GPtrAdd", "(", "m_Reg", "(", "BasePtr", ")", ",", "m_Copy", "(", "m_ICst", "(", "Offset", ")", ")", ")", ")", ")", "{", "if", "(", "!", "SIInstrInfo", "::", "isLegalMUBUFImmOffset", "(", "Offset", ")", ")", "return", "{", "}", ";", "const", "MachineInstr", "*", "BasePtrDef", "=", "MRI", "->", "getVRegDef", "(", "BasePtr", ")", ";", "Register", "WaveBase", "=", "getWaveAddress", "(", "BasePtrDef", ")", ";", "if", "(", "!", "WaveBase", ")", "return", "{", "}", ";", "return", "{", "{", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addReg", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{" ]

[ "<STR_LIT>", ";" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=" ]

[ "return", "Log2_32", "(", "Align", ")", ";" ]

[ "unsigned", "CPI", "=", "CPEMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "assert", "(", "CPI", "<", "MCP", "->", "getConstants", "(", ")", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid constant pool index.", "<STR_LIT>", ")", ";", "unsigned", "Align", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPI", "]", ".", "getAlignment", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "Align", ")", "&&", "<STR_LIT>", "Invalid CPE alignment", "<STR_LIT>", ")", ";" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "!", "ShiftImm", ",", "MVT", ":", ":", "i32", ")", ";" ]

[ "uint64_t", "OpCmode", "=", "N", "-", ">", "getZExtValue", "(", ")", ";", "unsigned", "ShiftImm", ";", "unsigned", "ShiftOnesIn", ";", "(", "void", ")", "A64Imms", ":", ":", "decodeNeonModShiftImm", "(", "OpCmode", ",", "ShiftImm", ",", "ShiftOnesIn", ")", ";" ]

[ "static", "rtx", "emit_adjust_base_to_offset", "(", "rtx", "base", ",", "int", "offset", ")", "{", "rtx", "new", "_", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "new", "_", "base", ",", "GEN_INT", "(", "offset", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new", "_", "base", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "new", "_", "base", ")", ")", ")", ";", "return", "new", "_", "base", ";", "}" ]

[ "Emit", "code", "to", "adjust", "BASE", "to", "OFFSET", ".", "Return", "the", "new", "base", "." ]

[ "Nand", ")", "return", "AtomicExpansionKind", "::", "LLSC", ";" ]

[ "if", "(", "AI", "->", "isFloatingPointOperation", "(", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "<NUM_LIT>", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::" ]

[ "Vt", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Xm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Xm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "}", "=", "<NUM_LIT>", ";" ]

[ "def", "A2_minp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isUnsigned", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";" ]

[ "(", ")", ")", ";" ]

[ "MachineInstr", "*", "AArch64CondBrTuning", "::", "getOperandDef", "(", "const", "MachineOperand", "&", "MO", ")", "{", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "return", "nullptr", ";", "return", "MRI", "->", "getUniqueVRegDef", "(", "MO", ".", "getReg" ]

[ "<STR_LIT>", ")", "]", ")" ]

[ "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "{", "return", "get_attr_length", "(", "insn", ")", "=", "=", "<NUM_LIT>", "?", "<STR_LIT>", ":", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>" ]

[ ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "static", "bool", "getTargetShuffleInputs", "(", "SDValue", "Op", ",", "SmallVectorImpl", "SDValue", ">", "&", "Inputs", ",", "SmallVectorImpl", "int", ">", "&", "Mask", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", "=", "<NUM_LIT>", ",", "bool", "ResolveZero", "=", "true", ")", "{", "<FIXE>", "<FIXS>", "return", "getTargetShuffleInputs", "(", "Op", ",", "DemandedElts", ",", "Inputs", ",", "Mask", ",", "DAG", ",", "Depth", ",", "ResolveZero", ")", ";", "<FIXE>" ]

[ "ResolveZero", ")", ";", "}", "<BUGS>", "static", "bool", "resolveTargetShuffleInputs", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "SmallVectorImpl", "SDValue", ">", "&", "Inputs", ",", "SmallVectorImpl", "int", ">", "&", "Mask", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ",", "bool", "ResolveZero", ")", "{", "if", "(", "!", "getTargetShuffleInputs", "(", "Op", ",", "DemandedElts", ",", "Inputs", ",", "Mask", ",", "DAG", ",", "Depth", ",", "ResolveZero", ")", ")", "return", "false", ";", "resolveTargetShuffleInputsAndMask", "(", "Inputs", ",", "Mask", ")", ";", "return", "true", ";", "}", "static", "bool", "resolveTargetShuffleInputs", "(", "SDValue", "Op", ",", "SmallVectorImpl", "SDValue", ">", "&", "Inputs", ",", "SmallVectorImpl", "int", ">", "&", "Mask", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ",", "bool", "ResolveZero", "=", "true", ")", "{", "<BUGE>", "unsigned", "NumElts", "=", "Op", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "APInt", "DemandedElts", "=", "APInt", "::", "getAllOnesValue", "(", "NumElts", ")", ";", "<BUGS>", "return", "resolveTargetShuffleInputs", "(", "Op", ",", "DemandedElts", ",", "Inputs", ",", "Mask", ",", "DAG", ",", "Depth", ",", "ResolveZero", ")", ";", "<BUGE>", "}" ]

[ "<FIXS>", "[", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "{" ]

[ "==", "Type", "::", "TypedPointerTyID", ";" ]

[ "return", "T", "&&", "T", "->", "getTypeID", "(", ")" ]

[ ")", ",", "ResVReg", ")", ";" ]

[ "if", "(", "auto", "*", "Res", "=", "checkSpecialInstr", "(", "TD", ",", "MIRBuilder", ")", ")", "return", "Res", ";", "Register", "ResVReg", "=", "createTypeVReg", "(", "MIRBuilder", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstr", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addDef", "(", "ResVReg", ")", ".", "addUse", "(", "getSPIRVTypeID", "(", "SampledType", ")", ")", ".", "addImm", "(", "Dim", ")", ".", "addImm", "(", "Depth", ")", ".", "addImm", "(", "Arrayed", ")", ".", "addImm", "(", "Multisampled", ")", ".", "addImm", "(", "Sampled", ")", ".", "addImm", "(", "ImageFormat", ")", ".", "addImm", "(", "AccessQual", ")", ";", "DT", ".", "add", "(", "TD", ",", "&", "MIRBuilder", ".", "getMF", "(" ]

[ ";" ]

[ "def", "v1i32_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "FPR32Op", ",", "FPR32Op", ",", "V128", ",", "VectorIndexS", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "i32", "FPR32Op", ":", "$", "Rd", ")", ",", "(", "OpNode", "FPR32Op", ":", "$", "Rn", ",", "(", "i32", "(", "vector_extract", "(", "v4i32", "V128", ":", "$", "Rm", ")", ",", "VectorIndexS", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "QI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";" ]

[ "Features", ")", "/", "WavesPerEU", ";" ]

[ "IsaVersion", "Version", "=", "getIsaVersion", "(", "Features", ")", ";", "unsigned", "AddressableNumSGPRs", "=", "getAddressableNumSGPRs", "(", "Features", ")", ";", "if", "(", "Version", ".", "Major", ">=", "<NUM_LIT>", "&&", "!", "Addressable", ")", "AddressableNumSGPRs", "=", "<NUM_LIT>", ";", "unsigned", "MaxNumSGPRs", "=", "getTotalNumSGPRs", "(" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "Pg", ";", "bits", "<", "<NUM_LIT>", ">", "Zd", ";", "bits", "<", "<NUM_LIT>", ">", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zd", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DestructiveInstType", "=", "Destructive", ";", "let", "ElementSize", "=", "size", ";" ]

[ "<STR_LIT>" ]

[ "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec_volatile", ":", "I48MODE", "[", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPECV_CAS", ")", ")", "]" ]

[ "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DF", "[", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VSX_CVUXWDP", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ ">", "Vdd32", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rtt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rtt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>" ]

[ "else", "if", "(", "S", "==", "<NUM_LIT>", "&&", "Signed", ")", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "A2_asrh", ")", ",", "TmpR", ")", ".", "addReg", "(", "Op1", ".", "getReg", "(", ")", ",", "RS", "&", "~", "RegState", "::", "Kill", ",", "LoSR", ")", ";" ]

[ "int64_t", "Sh64", "=", "Op2", ".", "getImm", "(", ")", ";", "assert", "(", "Sh64", ">=", "<NUM_LIT>", "&&", "Sh64", "<", "<NUM_LIT>", ")", ";", "unsigned", "S", "=", "Sh64", ";", "UUPairMap", "::", "const_iterator", "F", "=", "PairMap", ".", "find", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "assert", "(", "F", "!=", "PairMap", ".", "end", "(", ")", ")", ";", "const", "UUPair", "&", "P", "=", "F", "->", "second", ";", "unsigned", "LoR", "=", "P", ".", "first", ";", "unsigned", "HiR", "=", "P", ".", "second", ";", "using", "namespace", "Hexagon", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "bool", "Right", "=", "(", "Opc", "==", "S2_lsr_i_p", "||", "Opc", "==", "S2_asr_i_p", ")", ";", "bool", "Left", "=", "!", "Right", ";", "bool", "Signed", "=", "(", "Opc", "==", "S2_asr_i_p", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "RS", "=", "getRegState", "(", "Op1", ")", ";", "unsigned", "ShiftOpc", "=", "Left", "?", "S2_asl_i_r", ":", "(", "Signed", "?", "S2_asr_i_r", ":", "S2_lsr_i_r", ")", ";", "unsigned", "LoSR", "=", "subreg_loreg", ";", "unsigned", "HiSR", "=", "subreg_hireg", ";", "if", "(", "S", "==", "<NUM_LIT>", ")", "{", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "LoR", ")", ".", "addReg", "(", "Op1", ".", "getReg", "(", ")", ",", "RS", "&", "~", "RegState", "::", "Kill", ",", "LoSR", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "HiR", ")", ".", "addReg", "(", "Op1", ".", "getReg", "(", ")", ",", "RS", ",", "HiSR", ")", ";", "}", "else", "if", "(", "S", "<", "<NUM_LIT>", ")", "{", "const", "TargetRegisterClass", "*", "IntRC", "=", "&", "IntRegsRegClass", ";", "unsigned", "TmpR", "=", "MRI", "->", "createVirtualRegister", "(", "IntRC", ")", ";", "if", "(", "S", "==", "<NUM_LIT>", "&&", "Left", ")", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "A2_aslh", ")", ",", "LoR", ")", ".", "addReg", "(", "Op1", ".", "getReg", "(", ")", ",", "RS", "&", "~", "RegState", "::", "Kill", ",", "LoSR", ")", ";" ]

[ "let", "ElementSize", "=", "zprty", ".", "ElementSize", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zd", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DestructiveInstType", "=", "Destructive", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "return", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass", "=", "Imm0_255Operand", ";" ]

[ "<STR_LIT>", ",", "SDT_AArch64Zip", ">", ";" ]

[ "def", "AArch64trn1", ":", "SDNode", "<" ]

[ "}" ]

[ "unsigned", "Idx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "NewBldVec", "[", "i", "]", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "isUnmovable", "[", "Idx", "]", ")", "{", "std", "::", "swap", "(", "NewBldVec", "[", "Idx", "]", ",", "NewBldVec", "[", "i", "]", ")", ";", "std", "::", "swap", "(", "RemapSwizzle", "[", "RemapSwizzle", "[", "Idx", "]", "]", ",", "RemapSwizzle", "[", "RemapSwizzle", "[", "i", "]", "]", ")", ";", "}", "isUnmovable", "[", "Idx", "]", "=", "true", ";", "}", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "SDLoc", "(", "VectorEntry", ")", ",", "VectorEntry", ".", "getValueType", "(", ")", ",", "NewBldVec", ",", "<NUM_LIT>", ")", ";" ]

[ "i64", ")", ";" ]

[ "unsigned", "SplatBitSize", ";", "bool", "HasAnyUndefs", ";", "unsigned", "NElts", "=", "BVN", "->", "getNumOperands", "(", ")", ";", "if", "(", "(", "VT", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "v4i8", "||", "VT", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "v4i16", ")", "&&", "(", "BVN", "->", "isConstantSplat", "(", "APSplatBits", ",", "APSplatUndef", ",", "SplatBitSize", ",", "HasAnyUndefs", ",", "<NUM_LIT>", ",", "true", ")", "&&", "SplatBitSize", "<=", "<NUM_LIT>", ")", ")", "{", "unsigned", "SplatBits", "=", "APSplatBits", ".", "getZExtValue", "(", ")", ";", "int32_t", "SextVal", "=", "(", "(", "int32_t", ")", "(", "SplatBits", "<<", "(", "<NUM_LIT>", "-", "SplatBitSize", ")", ")", ">>", "(", "<NUM_LIT>", "-", "SplatBitSize", ")", ")", ";", "return", "createSplat", "(", "DAG", ",", "dl", ",", "VT", ",", "DAG", ".", "getConstant", "(", "SextVal", ",", "MVT", "::", "i32", ")", ")", ";", "}", "if", "(", "VT", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "v2i32", ")", "{", "SDValue", "V0", "=", "BVN", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "V1", "=", "BVN", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "V0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "V0", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "if", "(", "V1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "V1", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "ConstantSDNode", "*", "C0", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "V0", ")", ";", "ConstantSDNode", "*", "C1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "V1", ")", ";", "if", "(", "!", "C0", "||", "!", "C1", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "V1", ",", "V0", ")", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "C0", "->", "getSExtValue", "(", ")", ")", "||", "isInt", "<", "<NUM_LIT>", ">", "(", "C1", "->", "getSExtValue", "(", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "V1", ",", "V0", ")", ";", "}", "if", "(", "VT", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "v2i16", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NElts", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "BVN", "->", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "continue", ";", "ConstantSDNode", "*", "Cst", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "BVN", "->", "getOperand", "(", "i", ")", ")", ";", "if", "(", "!", "Cst", ")", "{", "SDValue", "pack", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v4i16", ",", "BVN", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "BVN", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getTargetExtractSubreg", "(", "Hexagon", "::", "subreg_loreg", ",", "dl", ",", "MVT", "::", "v2i16", ",", "pack", ")", ";", "}", "}", "}", "uint64_t", "Res", "=", "<NUM_LIT>", ";", "unsigned", "EltSize", "=", "Size", "/", "NElts", ";", "SDValue", "ConstVal", ";", "uint64_t", "Mask", "=", "~", "uint64_t", "(", "<NUM_LIT>", "ULL", ")", ">>", "(", "<NUM_LIT>", "-", "EltSize", ")", ";", "bool", "HasNonConstantElements", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NElts", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "OpIdx", "=", "NElts", "-", "i", "-", "<NUM_LIT>", ";", "SDValue", "Operand", "=", "BVN", "->", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "Operand", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "continue", ";", "int64_t", "Val", "=", "<NUM_LIT>", ";", "if", "(", "ConstantSDNode", "*", "Cst", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Operand", ")", ")", "Val", "=", "Cst", "->", "getSExtValue", "(", ")", ";", "else", "HasNonConstantElements", "=", "true", ";", "Val", "&=", "Mask", ";", "Res", "=", "(", "Res", "<<", "EltSize", ")", "|", "Val", ";", "}", "if", "(", "Size", "==", "<NUM_LIT>", ")", "ConstVal", "=", "DAG", ".", "getConstant", "(", "Res", ",", "MVT", "::", "i64", ")", ";", "else", "ConstVal", "=", "DAG", ".", "getConstant", "(", "Res", ",", "MVT", "::", "i32", ")", ";", "if", "(", "HasNonConstantElements", ")", "{", "EVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "SDValue", "Width", "=", "DAG", ".", "getConstant", "(", "EltVT", ".", "getSizeInBits", "(", ")", ",", "MVT", "::", "i64", ")", ";", "SDValue", "Shifted", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "MVT", "::", "i64", ",", "Width", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i64", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NElts", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "OpIdx", "=", "NElts", "-", "i", "-", "<NUM_LIT>", ";", "SDValue", "Operand", "=", "BVN", "->", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "Operand", ")", ")", "continue", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "Operand", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "SDValue", "C", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "Operand", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "C", ",", "Operand", ")", ";", "}", "SDValue", "Idx", "=", "DAG", ".", "getConstant", "(", "OpIdx", ",", "MVT", "::" ]

[ "<FIXS>", "def", "SDTX86cas8pair", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisPtrTy", "<NUM_LIT>", ">", "]", ">", ";", "def", "SDTX86cas16pair", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisPtrTy", "<NUM_LIT>", ">", ",", "SDTCisVT", "<NUM_LIT>", ",", "i64", ">", "]", ">", ";", "<FIXE>" ]

[ "def", "SDTX86cas", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisPtrTy", "<NUM_LIT>", ">", ",", "SDTCisInt", "<NUM_LIT>", ">", ",", "SDTCisVT", "<NUM_LIT>", ",", "i8", ">", "]", ">", ";", "<BUGS>", "def", "SDTX86caspair", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisPtrTy", "<NUM_LIT>", ">", "]", ">", ";", "def", "SDTX86caspairSaveRbx16", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVT", "<NUM_LIT>", ",", "i64", ">", ",", "SDTCisPtrTy", "<NUM_LIT>", ">", ",", "SDTCisVT", "<NUM_LIT>", ",", "i64", ">", ",", "SDTCisVT", "<NUM_LIT>", ",", "i64", ">", "]", ">", ";", "<BUGE>", "def", "SDTLockBinaryArithWithFlags", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVT", "<NUM_LIT>", ",", "i32", ">", ",", "SDTCisPtrTy", "<NUM_LIT>", ">", "," ]

[ "bool", "SIInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "*", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "uint16_t", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "int", "Src2Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "Opcode", ")", ";", "if", "(", "!", "Desc", ".", "isVariadic", "(", ")", "&&", "Desc", ".", "getNumOperands", "(", ")", "!=", "MI", "->", "getNumExplicitOperands", "(", ")", ")", "{", "ErrInfo", "=", "<STR_LIT>", "Instruction has wrong number of operands.", "<STR_LIT>", ";", "return", "false", ";", "}", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "Desc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "i", ")", ".", "isFPImm", "(", ")", ")", "{", "ErrInfo", "=", "<STR_LIT>", "FPImm Machine Operands are not supported. ISel should bitcast ", "<STR_LIT>", "<STR_LIT>", "all fp values to integers.", "<STR_LIT>", ";", "return", "false", ";", "}", "int", "RegClass", "=", "Desc", ".", "OpInfo", "[", "i", "]", ".", "RegClass", ";", "switch", "(", "Desc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", ")", "{", "case", "MCOI", "::", "OPERAND_REGISTER", ":", "if", "(", "MI", "->", "getOperand", "(", "i", ")", ".", "isImm", "(", ")", ")", "{", "ErrInfo", "=", "<STR_LIT>", "Illegal immediate value for operand.", "<STR_LIT>", ";", "return", "false", ";", "}", "break", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM32", ":", "break", ";", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C", ":", "if", "(", "isLiteralConstant", "(", "MI", "->", "getOperand", "(", "i", ")", ",", "RI", ".", "getRegClass", "(", "RegClass", ")", "->", "getSize", "(", ")", ")", ")", "{", "ErrInfo", "=", "<STR_LIT>", "Illegal immediate value for operand.", "<STR_LIT>", ";", "return", "false", ";", "}", "break", ";", "case", "MCOI", "::", "OPERAND_IMMEDIATE", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isImm", "(", ")", "&&", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "ErrInfo", "=", "<STR_LIT>", "Expected immediate, but got non-immediate", "<STR_LIT>", ";", "return", "false", ";", "}", "default", ":", "continue", ";", "}", "if", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "RegClass", "!=", "-", "<NUM_LIT>", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RegClass", ")", ";", "if", "(", "!", "RC", "->", "contains", "(", "Reg", ")", ")", "{", "ErrInfo", "=", "<STR_LIT>", "Operand has incorrect register class.", "<STR_LIT>", ";", "return", "false", ";", "}", "}", "}", "if", "(", "isVOP1", "(", "Opcode", ")", "||", "isVOP2", "(", "Opcode", ")", "||", "isVOP3", "(", "Opcode", ")", "||", "isVOPC", "(", "Opcode", ")", ")", "{", "const", "int", "OpIndices", "[", "]", "=", "{", "Src0Idx", ",", "Src1Idx", ",", "Src2Idx", "}", ";", "unsigned", "ConstantBusCount", "=", "<NUM_LIT>", ";", "unsigned", "SGPRUsed", "=", "AMDGPU", "::", "NoRegister", ";", "for", "(", "int", "OpIdx", ":", "OpIndices", ")", "{", "if", "(", "OpIdx", "==", "-", "<NUM_LIT>", ")", "break", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "usesConstantBus", "(", "MRI", ",", "MO", ",", "getOpSize", "(", "Opcode", ",", "OpIdx", ")", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "MO", ".", "getReg", "(", ")", "!=", "SGPRUsed", ")", "++", "ConstantBusCount", ";", "SGPRUsed", "=", "MO", ".", "getReg", "(", ")", ";", "}", "else", "{", "++", "ConstantBusCount", ";", "}", "}", "}", "if", "(", "ConstantBusCount", ">", "<NUM_LIT>", ")", "{", "ErrInfo", "=", "<STR_LIT>", "VOP* instruction uses the constant bus more than once", "<STR_LIT>", ";", "return", "false", ";", "}", "}", "if", "(", "Desc", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_DIV_SCALE_F32", "||", "Desc", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_DIV_SCALE_F64", ")", "{", "const", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "const", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "const", "MachineOperand", "&", "Src2", "=", "MI", "->", "getOperand", "(", "Src2Idx", ")", ";", "if", "(", "Src0", ".", "isReg", "(", ")", "&&", "Src1", ".", "isReg", "(", ")", "&&", "Src2", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "compareMachineOp", "(", "Src0", ",", "Src1", ")", "&&", "!", "compareMachineOp", "(", "Src0", ",", "Src2", ")", ")", "{", "ErrInfo", "=", "<STR_LIT>", "v_div_scale_{f32|f64} require src0 = src1 or src2", "<STR_LIT>", ";", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}" ]

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

[ ")", ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const_string", "<STR_LIT>" ]

[ ";" ]

[ "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "UncondBranch", ".", "second", ")", ")", "{", "TBB", "=", "nullptr", ";", "EraseList", ".", "push_back", "(", "*", "iter", ")", ";", "UncondBranch", "=", "{", "MBB", ".", "rend", "(", ")", ",", "nullptr", "}", ";", "}", "continue", ";", "}", "auto", "BranchCode", "=", "M68k", "::", "GetCondFromBranchOpc", "(", "Opcode", ")", ";", "if", "(", "BranchCode", "==", "M68k", "::", "COND_INVALID", ")", "return", "true", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "iter", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isMBB", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "*", "CondBranchTarget", "=", "iter", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "UncondBranch", ".", "first", "!=", "MBB", ".", "rend", "(", ")", ")", "{", "assert", "(", "std", "::", "next", "(", "UncondBranch", ".", "first", ")", "==", "iter", "&&", "<STR_LIT>", "Wrong block layout.", "<STR_LIT>", ")", ";", "if", "(", "AllowModify", "&&", "MBB", ".", "isLayoutSuccessor", "(", "CondBranchTarget", ")", ")", "{", "BranchCode", "=", "GetOppositeBranchCondition", "(", "BranchCode", ")", ";", "unsigned", "BNCC", "=", "GetCondBranchFromCond", "(", "BranchCode", ")", ";", "BuildMI", "(", "MBB", ",", "*", "UncondBranch", ".", "first", ",", "MBB", ".", "rfindDebugLoc", "(", "iter", ")", ",", "get", "(", "BNCC", ")", ")", ".", "addMBB", "(", "UncondBranch", ".", "second", ")", ";", "EraseList", ".", "push_back", "(", "*", "iter", ")", ";", "EraseList", ".", "push_back", "(", "*", "UncondBranch", ".", "first", ")", ";", "TBB", "=", "UncondBranch", ".", "second", ";", "FBB", "=", "nullptr", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "}", "else", "{", "TBB", "=", "CondBranchTarget", ";", "FBB", "=", "UncondBranch", ".", "second", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "}", "UncondBranch", "=", "{", "MBB", ".", "rend", "(", ")", ",", "nullptr", "}", ";", "continue", ";", "}", "TBB", "=", "CondBranchTarget", ";", "FBB", "=", "nullptr", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "assert", "(", "TBB", ")" ]

[ "}" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "bool", "HexagonRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "HexagonSubtarget", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "if", "(", "!", "HST", ".", "useHVXOps", "(", ")", "||", "NewRC", "->", "getID", "(", ")", "!=", "Hexagon", "::", "HvxWRRegClass", ".", "getID", "(", ")", ")", "return", "true", ";", "bool", "SmallSrc", "=", "SrcRC", "->", "getID", "(", ")", "==", "Hexagon", "::", "HvxVRRegClass", ".", "getID", "(", ")", ";", "bool", "SmallDst", "=", "DstRC", "->", "getID", "(", ")", "==", "Hexagon", "::", "HvxVRRegClass", ".", "getID", "(", ")", ";", "if", "(", "!", "SmallSrc", "&&", "!", "SmallDst", ")", "return", "true", ";", "Register", "DstReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "SlotIndexes", "&", "Indexes", "=", "*", "LIS", ".", "getSlotIndexes", "(", ")", ";", "auto", "HasCall", "=", "[", "&", "Indexes", "]", "(", "const", "LiveInterval", "::", "Segment", "&", "S", ")", "{", "for", "(", "SlotIndex", "I", "=", "S", ".", "start", ".", "getBaseIndex", "(", ")", ",", "E", "=", "S", ".", "end", ".", "getBaseIndex", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "I", ".", "getNextIndex", "(", ")", ")", "{", "if", "(", "const", "MachineInstr", "*", "MI", "=", "Indexes", ".", "getInstructionFromIndex", "(", "I", ")", ")", "if", "(", "MI", "->", "isCall", "(", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", ";", "if", "(", "SmallSrc", "==", "SmallDst", ")", "{", "return", "!", "any_of", "(", "LIS", ".", "getInterval", "(", "DstReg", ")", ",", "HasCall", ")", "&&", "!", "any_of", "(", "LIS", ".", "getInterval", "(", "SrcReg", ")", ",", "HasCall", ")", ";", "}", "unsigned", "SmallReg", "=", "SmallSrc", "?", "SrcReg", ":", "DstReg", ";", "unsigned", "LargeReg", "=", "SmallSrc", "?", "DstReg", ":", "SrcReg", ";", "return", "any_of", "(", "LIS", ".", "getInterval", "(", "LargeReg", ")", ",", "HasCall", ")", "||", "!", "any_of", "(", "LIS", ".", "getInterval", "(", "SmallReg", ")", ",", "HasCall", ")", ";", "}" ]

[ "Subtarget", "Hooks", "." ]

[ "}", "}", ";" ]

[ "unsigned", "Mods", ";", "std", "::", "tie", "(", "Src", ",", "Mods", ")", "=", "selectVOP3ModsImpl", "(", "Root", ")", ";", "return", "{", "{", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addReg", "(", "Src", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addImm", "(", "Mods", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}" ]

[ "void", "x86_order_regs_for_local_alloc", "(", "void", ")", "{", "int", "pos", "=", "<NUM_LIT>", ";", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "i", ")", "&&", "call_used_regs", "[", "i", "]", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "i", ")", "&&", "!", "call_used_regs", "[", "i", "]", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "if", "(", "!", "TARGET_SSE_MATH", ")", "for", "(", "i", "=", "FIRST_STACK_REG", ";", "i", "<=", "LAST_STACK_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_SSE_REG", ";", "i", "<=", "LAST_SSE_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_REX_SSE_REG", ";", "i", "<=", "LAST_REX_SSE_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "if", "(", "TARGET_SSE_MATH", ")", "for", "(", "i", "=", "FIRST_STACK_REG", ";", "i", "<=", "LAST_STACK_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_MMX_REG", ";", "i", "<=", "LAST_MMX_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "while", "(", "pos", "<", "FIRST_PSEUDO_REGISTER", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "<NUM_LIT>", ";", "}" ]

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

[ "(", "OpNo", ")", ";" ]

[ "assert", "(", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Expecting an immediate.", "<STR_LIT>", ")", ";", "uint64_t", "RegBits", "=", "getMachineOpValue", "(", "MI", ",", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ",", "Fixups", ",", "STI", ")", "<<", "<NUM_LIT>", ";", "if", "(", "RegBits", "!=", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "Operand must be 0", "<STR_LIT>", ")", ";", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand" ]

[ "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opcode", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "<NUM_LIT>", ",", "*", "MBB", ".", "getParent", "(", ")", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "const", "std", "::", "string", "FuncName", "=", "Func", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "ESNames", "::", "createESName", "(", "PAN", "::", "getTempdataLabel", "(", "FuncName", ")", ")", ";", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "<NUM_LIT>", ",", "*", "MBB", ".", "getParent", "(", ")", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "opcode", "=", "(", "DestReg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ ";" ]

[ "if", "(", "ca", "->", "reg_count", "&&", "ca", "->", "mem_count", ")", "return", "ca", "->", "reg_count", "*", "UNITS_PER_WORD", ";", "return", "<NUM_LIT>" ]

[ "getScalarType", "(", ")", ";" ]

[ "if", "(", "!", "isOperationLegalOrCustomOrPromote", "(", "Opc", ",", "VecVT", ")", ")", "return", "true", ";", "EVT", "ScalarVT", "=", "VecVT", "." ]

[ "<STR_LIT>", ")", ")", "]" ]

[ "(", "unspec", ":", "XF", "[", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "FRNDINT_ROUNDING", ")", ")", "(", "use", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>" ]

[ "SI", "SP_REG", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", ")", "]", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "call", "(", "mem", ":", "QI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":" ]

[ "<FIXS>", "bit", "RC", "=", "<NUM_LIT>", ";", "<FIXE>" ]

[ "let", "Pattern", "=", "pattern", ";", "<BUGS>", "bit", "RC", "=", "<NUM_LIT>", ";", "<BUGE>", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RT", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RA", ";" ]

[ "<NUM_LIT>", ";" ]

[ "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=" ]

[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "insn", "=", "gen_movsi", "(", "reg", ",", "gen_rtx_MEM", "(", "SImode", ",", "slot", ")", ")", ";" ]

[ "if", "(", "cfun", "->", "machine", "->", "save_ret", ")", "{", "temp", "-=", "<NUM_LIT>", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "RETURN_ADDRESS_REGNUM", ")", ";", "slot", "=", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "temp", ")", ")", ";", "insn", "=", "gen_movsi", "(", "reg", ",", "gen_rtx_MEM", "(", "SImode", ",", "slot", ")", ")", ";", "insn", "=", "emit", "(", "insn", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "saved_reg_size", "!=", "<NUM_LIT>", ")", "{", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", ";", "regno", "--", ">", "<NUM_LIT>", ";", ")", "{", "if", "(", "!", "fixed_regs", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "{", "temp", "-=", "<NUM_LIT>", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "slot", "=", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "temp", ")", ")", ";" ]

[ "SymToPrint", "=", "getSymbol", "(", "GV", ")", ";" ]

[ "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "MCSymbol", "*", "SymToPrint", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", "&&", "!", "GV", "->", "isStrongDefinitionForLinker", "(", ")", ")", "{", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "{", "SymToPrint", "=", "getSymbolWithGlobalValueBase", "(", "GV", ",", "<STR_LIT>", "$non_lazy_ptr", "<STR_LIT>", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ".", "getGVStubEntry", "(", "SymToPrint", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "getSymbol", "(", "GV", ")", ",", "!", "GV", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "if", "(", "GV", "->", "isDeclaration", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", "||", "GV", "->", "hasAvailableExternallyLinkage", "(", ")", ")", "{", "SymToPrint", "=", "getSymbolWithGlobalValueBase", "(", "GV", ",", "<STR_LIT>", "$non_lazy_ptr", "<STR_LIT>", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ".", "getHiddenGVStubEntry", "(", "SymToPrint", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "getSymbol", "(", "GV", ")", ",", "!", "GV", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{" ]

[ "<FIXS>", "switch", "(", "IntrinsicID", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown comparison intrinsic.", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpneb_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpneh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnew_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnezb_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnezh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnezw_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "<FIXE>", "<FIXS>", "isDot", "=", "true", ";", "<FIXE>", "<FIXS>", "case", "Intrinsic", "::", "ppc_altivec_vcmpgefp_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtfp_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsb_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsw_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "<FIXE>", "<FIXS>", "isDot", "=", "true", ";", "<FIXE>", "<FIXS>", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtub_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuw_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "true", ";", "break", ";", "<FIXE>", "<FIXS>", "isDot", "=", "true", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "case", "Intrinsic", "::", "ppc_altivec_vcmpnezh_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpnezw_p", ":", "if", "(", "Subtarget", ".", "hasP9Altivec", "(", ")", ")", "{", "<BUGS>", "switch", "(", "IntrinsicID", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown comparison intrinsic.", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpneb_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpneh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnew_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnezb_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnezh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpnezw_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "break", ";", "<BUGE>", "}", "<BUGS>", "isDot", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "elsereturn", "false", ";", "break", ";", "<BUGS>", "case", "Intrinsic", "::", "ppc_altivec_vcmpgefp_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtfp_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsb_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsw_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "<BUGE>", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsd_p", ":", "if", "(", "Subtarget", ".", "hasP8Altivec", "(", ")", ")", "{", "CompareOpc", "=", "<NUM_LIT>", ";", "<BUGS>", "isDot", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "elsereturn", "false", ";", "break", ";", "<BUGS>", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtub_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuh_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuw_p", ":", "CompareOpc", "=", "<NUM_LIT>", ";", "isDot", "=", "<NUM_LIT>", ";", "break", ";", "<BUGE>", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtud_p", ":", "if", "(", "Subtarget", ".", "hasP8Altivec", "(", ")", ")", "{", "CompareOpc", "=", "<NUM_LIT>", ";", "<BUGS>", "isDot", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "elsereturn", "false", ";", "break", ";", "<BUGS>", "<BUGE>", "case", "Intrinsic", "::", "ppc_vsx_xvcmpeqdp_p", ":", "case", "Intrinsic", "::", "ppc_vsx_xvcmpgedp_p", ":", "case", "Intrinsic", "::", "ppc_vsx_xvcmpgtdp_p", ":" ]

[ "DAG", ")", ";" ]

[ "if", "(", "SDValue", "Blend", "=", "lowerShuffleAsBlend", "(", "DL", ",", "MVT", "::", "v4f64", ",", "V1", ",", "V2", ",", "Mask", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Blend", ";", "if", "(", "SDValue", "Op", "=", "lowerShuffleWithSHUFPD", "(", "DL", ",", "MVT", "::", "v4f64", ",", "Mask", ",", "V1", ",", "V2", ",", "DAG", ")", ")", "return", "Op", ";", "if", "(", "SDValue", "V", "=", "lowerShuffleAsRepeatedMaskAndLanePermute", "(", "DL", ",", "MVT", "::", "v4f64", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "!", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "(", "isShuffleMaskInputInPlace", "(", "<NUM_LIT>", ",", "Mask", ")", "||", "isShuffleMaskInputInPlace", "(", "<NUM_LIT>", ",", "Mask", ")", ")", ")", ")", "if", "(", "SDValue", "V", "=", "lowerShuffleByMerging128BitLanes", "(", "DL", ",", "MVT", "::", "v4f64", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "Subtarget", ".", "hasVLX", "(", ")", ")", "if", "(", "SDValue", "V", "=", "lowerShuffleToEXPAND", "(", "DL", ",", "MVT", "::", "v4f64", ",", "Zeroable", ",", "Mask", ",", "V1", ",", "V2", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";", "if", "(", "Subtarget", ".", "hasAVX2", "(", ")", ")", "return", "lowerShuffleAsDecomposedShuffleBlend", "(", "DL", ",", "MVT", "::", "v4f64", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ";", "return", "lowerShuffleAsSplitOrBlend", "(", "DL", ",", "MVT", "::", "v4f64", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", "," ]

[ ")", ";" ]

[ "tree", "expr", "=", "MEM_EXPR", "(", "mem", ")", ";", "if", "(", "!", "expr", ")", "continue", ";", "if", "(", "TREE_CODE", "(", "expr", ")", "==", "MEM_REF", "&&", "TREE_CODE", "(", "TREE_OPERAND", "(", "expr", ",", "<NUM_LIT>", ")", ")", "==", "SSA_NAME", ")", "{", "gimple", "*", "def_stmt", "=", "SSA_NAME_DEF_STMT", "(", "TREE_OPERAND", "(", "expr", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "def_stmt", "&&", "is_gimple_assign", "(", "def_stmt", ")", ")", "expr", "=", "gimple_assign_rhs1", "(", "def_stmt", ")", ";", "}", "if", "(", "is_attr_preserve_access", "(", "expr", ")", ")", "{", "auto_vec", "<", "unsigned", "int", ",", "<NUM_LIT>", ">", "accessors", ";", "tree", "container", "=", "bpf_core_compute", "(", "expr", ",", "&", "accessors", ")", ";", "if", "(", "accessors", ".", "length", "(", ")", "<", "<NUM_LIT>", ")", "continue", ";", "accessors", ".", "reverse", "(" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "class", "SignAuthOneData", "<", "bits", "<", "<NUM_LIT>", ">", "opcode_prefix", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", "GPR64", ":", "$", "Rd", ")", ",", "(", "ins", "GPR64", ":", "$", "src", ",", "GPR64sp", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteI", ",", "ReadI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";" ]

[ ")", ";" ]

[ "static", "SDValue", "getZeroVector", "(", "EVT", "VT", ",", "bool", "HasSSE2", ",", "bool", "HasAVX2", ",", "SelectionDAG", "&", "DAG", ",", "DebugLoc", "dl", ")", "{", "assert", "(", "VT", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Expected a vector type", "<STR_LIT>", ")", ";", "SDValue", "Vec", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "HasSSE2", ")", "{", "SDValue", "Cst", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "MVT", "::", "v4i32", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ")", ";", "}", "else", "{", "SDValue", "Cst", "=", "DAG", ".", "getTargetConstantFP", "(", "+", "<NUM_LIT>", ",", "MVT", "::", "f32", ")", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "MVT", "::", "v4f32", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ")", ";", "}", "}", "else", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "HasAVX2", ")", "{", "SDValue", "Cst", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", "}", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "MVT", "::", "v8i32", ",", "Ops", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "SDValue", "Cst", "=", "DAG", ".", "getTargetConstantFP", "(", "+", "<NUM_LIT>", ",", "MVT", "::", "f32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", "}", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "MVT", "::", "v8f32", ",", "Ops", ",", "<NUM_LIT>", ")", ";", "}", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VT", ",", "Vec" ]

[ "ScheduleHazardRecognizer", "::", "HazardType", "PPCHazardRecognizer970", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "PPC hazards don't support scoreboard lookahead", "<STR_LIT>", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "NoHazard", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "LastWasBL8_ELF", "&&", "Opcode", "!=", "PPC", "::", "NOP", ")", "return", "Hazard", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "<STR_LIT>", "::", "<STR_LIT>", "InstrType", "=", "GetInstrType", "(", "Opcode", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "NoHazard", ";", "if", "(", "NumIssued", "!=", "<NUM_LIT>", "&&", "(", "isFirst", "||", "isSingle", ")", ")", "return", "Hazard", ";", "if", "(", "isCracked", "&&", "NumIssued", ">", "<NUM_LIT>", ")", "return", "Hazard", ";", "switch", "(", "InstrType", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown instruction type!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "NumIssued", "==", "<NUM_LIT>", ")", "return", "Hazard", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "NumIssued", ">=", "<NUM_LIT>", ")", "return", "Hazard", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "}", "if", "(", "HasCTRSet", "&&", "(", "Opcode", "==", "PPC", "::", "BCTRL_Darwin", "||", "Opcode", "==", "PPC", "::", "BCTRL_SVR4", ")", ")", "return", "NoopHazard", ";", "if", "(", "isLoad", "&&", "NumStores", "&&", "!", "MI", "->", "memoperands_empty", "(", ")", ")", "{", "MachineMemOperand", "*", "MO", "=", "*", "MI", "->", "memoperands_begin", "(", ")", ";", "if", "(", "isLoadOfStoredAddress", "(", "MO", "->", "getSize", "(", ")", ",", "MO", "->", "getOffset", "(", ")", ",", "MO", "->", "getValue", "(", ")", ")", ")", "return", "NoopHazard", ";", "}", "return", "NoHazard", ";", "}" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask16", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cmpge_epi8_mask", "(", "_", "_", "m128i", "_", "_", "X", ",", "_", "_", "m128i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_cmpb128_mask", "(", "(", "_", "_", "v16qi", ")", "_", "_", "X", ",", "(", "_", "_", "v16qi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask16", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr" ]

[ "-", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vdd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vdd32", "{", "<NUM_LIT>" ]

[ "<FIXS>", "rtx", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "old_value_lo", ",", "required_value_lo", ",", "new", "_", "value_lo", ",", "t1_lo", ";", "rtx", "old_value_hi", ",", "required_value_hi", ",", "new", "_", "value_hi", ",", "t1_hi", ";", "bool", "is_di", "=", "mode", "==", "DImode", ";", "<FIXE>" ]

[ "enum", "attr_sync_op", "sync_op", ",", "int", "early_barrier_required", ")", "{", "<BUGS>", "rtx", "operands", "[", "<NUM_LIT>", "]", ";", "<BUGE>", "gcc_assert", "(", "t1", "!=", "t2", ")", ";" ]

[ "return", "Addr", ";" ]

[ "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", "|", "<NUM_LIT>", "<<", "<NUM_LIT>", "|", "<NUM_LIT>", "<<", "<NUM_LIT>", "|", "Lo", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", "|", "<NUM_LIT>", "<<", "<NUM_LIT>", "|", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "sys", "::", "Memory", "::", "InvalidateInstructionCache", "(", "Addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "sys", "::", "Memory", "::", "setRangeExecutable", "(", "Addr", ",", "<NUM_LIT>", ")", ")", "llvm_unreachable", "(", "<STR_LIT>", "ERROR: Unable to mark stub executable.", "<STR_LIT>", ")", ";" ]

[ "O", "<<", "'", "(", "'", ";" ]

[ "const", "MachineOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "const", "MachineOperand", "&", "Disp", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ";", "if", "(", "Disp", ".", "isImm", "(", ")", "&&", "!", "Base", ".", "getReg", "(", ")", ")", "O", "<<", "'", "&", "'", ";", "printOperand", "(", "MI", ",", "OpNum", "+", "<NUM_LIT>", ",", "O", ",", "<STR_LIT>", "nohash", "<STR_LIT>", ")", ";", "if", "(", "Base", ".", "getReg", "(", ")", ")", "{" ]

[ ";" ]

[ "void", "*", "Result", "=", "SemaCallback", "->", "LookupInlineAsmIdentifier", "(", "LineBuf", ",", "Info", ",", "IsUnevaluatedOperand", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "SMLoc", "Loc", "=", "Tok", ".", "getLoc", "(", ")", ";", "const", "char", "*", "EndPtr", "=", "Tok", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "+", "LineBuf", ".", "size", "(", ")", ";", "while", "(", "true", ")", "{", "End", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "assert", "(", "End", ".", "getPointer", "(", ")", "<=", "EndPtr", "&&", "<STR_LIT>", "frontend claimed part of a token?", "<STR_LIT>", ")", ";", "if", "(", "End", ".", "getPointer", "(", ")", "==", "EndPtr", ")", "break", ";", "}", "Identifier", "=", "LineBuf", ";", "if", "(", "!", "Result", ")", "{", "StringRef", "InternalName", "=", "SemaCallback", "->", "LookupInlineAsmLabel", "(", "Identifier", ",", "getSourceManager", "(", ")", ",", "Loc", ",", "false", ")", ";", "assert", "(", "InternalName", ".", "size", "(", ")", "&&", "<STR_LIT>", "We should have an internal name here.", "<STR_LIT>", ")", ";", "InstInfo", "->", "AsmRewrites", "->", "push_back", "(", "AsmRewrite", "(", "AOK_Label", ",", "Loc", ",", "Identifier", ".", "size", "(", ")", ",", "InternalName", ")", ")", ";", "}", "MCSymbol", "*", "Sym", "=", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Identifier", ")", ";", "MCSymbolRefExpr", "::", "VariantKind", "Variant", "=", "MCSymbolRefExpr", "::", "VK_None", ";", "Val", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Variant", ",", "getParser", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "false" ]

[ "void", "ARMFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "<STR_LIT>", "This emitEpilogue does not support Thumb1!", "<STR_LIT>", ")", ";", "bool", "isARM", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", ";", "unsigned", "ArgRegsSaveSize", "=", "AFI", "->", "getArgRegsSaveSize", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", ".", "getStackSize", "(", ")", ";", "Register", "FramePtr", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasStackFrame", "(", ")", ")", "{", "if", "(", "NumBytes", "-", "ArgRegsSaveSize", "!=", "<NUM_LIT>", ")", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "NumBytes", "-", "ArgRegsSaveSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "else", "{", "if", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "do", "{", "--", "MBBI", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", ";", "if", "(", "!", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "++", "MBBI", ";", "}", "NumBytes", "-=", "(", "ArgRegsSaveSize", "+", "AFI", "->", "getFPCXTSaveAreaSize", "(", ")", "+", "AFI", "->", "getGPRCalleeSavedArea1Size", "(", ")", "+", "AFI", "->", "getGPRCalleeSavedArea2Size", "(", ")", "+", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", "+", "AFI", "->", "getDPRCalleeSavedAreaSize", "(", ")", ")", ";", "if", "(", "AFI", "->", "shouldRestoreSPFromFP", "(", ")", ")", "{", "NumBytes", "=", "AFI", "->", "getFramePtrSpillOffset", "(", ")", "-", "NumBytes", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "isARM", ")", "emitARMRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "SP", ",", "FramePtr", ",", "-", "NumBytes", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "TII", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "else", "{", "assert", "(", "!", "MFI", ".", "getPristineRegs", "(", "MF", ")", ".", "test", "(", "ARM", "::", "R4", ")", "&&", "<STR_LIT>", "No scratch register to restore SP from FP!", "<STR_LIT>", ")", ";", "emitT2RegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "R4", ",", "FramePtr", ",", "-", "NumBytes", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "TII", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "R4", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "else", "{", "if", "(", "isARM", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "MOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "condCodeOp", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "else", "if", "(", "NumBytes", "&&", "!", "tryFoldSPUpdateIntoPushPop", "(", "STI", ",", "MF", ",", "&", "*", "MBBI", ",", "NumBytes", ")", ")", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "NumBytes", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "AFI", "->", "getDPRCalleeSavedAreaSize", "(", ")", ")", "{", "MBBI", "++", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VLDMDIA_UPD", ")", "MBBI", "++", ";", "}", "if", "(", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", ")", "{", "assert", "(", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "unexpected DPR alignment gap", "<STR_LIT>", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "AFI", "->", "getGPRCalleeSavedArea2Size", "(", ")", ")", "MBBI", "++", ";", "if", "(", "AFI", "->", "getGPRCalleeSavedArea1Size", "(", ")", ")", "MBBI", "++", ";", "if", "(", "AFI", "->", "getFPCXTSaveAreaSize", "(", ")", ")", "MBBI", "++", ";", "}", "if", "(", "ArgRegsSaveSize", ")", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "ArgRegsSaveSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "trace_reg_uses_1", "(", "reg", ",", "start_insn", ",", "BLOCK_FOR_INSN", "(", "start_insn", ")", ",", "count", ",", "visited_bb", ",", "abort_at_insn", ")", ";" ]

[ "int", "count", "=", "<NUM_LIT>", ";", "std", "::", "vector", "<", "basic_block", ">", "visited_bb", ";", "visited_bb", ".", "reserve", "(", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>", "X86ISD::VZEXT_MOVL", "<STR_LIT>", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FP_TO_INT16_IN_MEM", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FP_TO_INT32_IN_MEM", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FP_TO_INT64_IN_MEM", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FLD", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FST", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::CALL", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::RDTSC_DAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::RDTSCP_DAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::RDPMC_DAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::BT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::CMP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::COMI", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::UCOMI", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::CMPM", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::CMPMU", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::SETCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::SETCC_CARRY", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FSETCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::CMOV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::BRCOND", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::RET_FLAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::REP_STOS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::REP_MOVS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::GlobalBaseReg", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::Wrapper", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::WrapperRIP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::PEXTRB", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::PEXTRW", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::INSERTPS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::PINSRB", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::PINSRW", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::PSHUFB", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::ANDNP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::PSIGN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::BLENDI", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::SHRUNKBLEND", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::SUBUS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::HADD", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::HSUB", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FHADD", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FHSUB", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::UMAX", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::UMIN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::SMAX", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::SMIN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FMAX", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FMIN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FMAXC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FMINC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FRSQRT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FRCP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::TLSADDR", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::TLSBASEADDR", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::TLSCALL", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::EH_SJLJ_SETJMP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::EH_SJLJ_LONGJMP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::EH_RETURN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::TC_RETURN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FNSTCW16m", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::FNSTSW16r", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::LCMPXCHG_DAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::LCMPXCHG8_DAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "X86ISD::LCMPXCHG16_DAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return" ]

[ "<FIXS>", "(", "match_test", "<STR_LIT>", ")", ")", ")", ")", "<FIXE>" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "and", "(", "match_code", "<STR_LIT>", ")", "<BUGS>", "(", "match_test", "<STR_LIT>", ")", ")", ")", ")", "<BUGE>" ]

[ "return", "ELF", "::", "R_MICROMIPS_TLS_DTPREL_HI16", ";" ]

[ "case", "FK_Data_8", ":", "return", "ELF", "::", "R_MIPS_64", ";", "case", "FK_GPRel_4", ":", "if", "(", "isN64", "(", ")", ")", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL32", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_64", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ",", "Type", ")", ";", "return", "Type", ";", "}", "return", "ELF", "::", "R_MIPS_GPREL32", ";", "case", "Mips", "::", "fixup_Mips_GPREL16", ":", "return", "ELF", "::", "R_MIPS_GPREL16", ";", "case", "Mips", "::", "fixup_Mips_26", ":", "return", "ELF", "::", "R_MIPS_26", ";", "case", "Mips", "::", "fixup_Mips_CALL16", ":", "return", "ELF", "::", "R_MIPS_CALL16", ";", "case", "Mips", "::", "fixup_Mips_GOT_Global", ":", "case", "Mips", "::", "fixup_Mips_GOT_Local", ":", "return", "ELF", "::", "R_MIPS_GOT16", ";", "case", "Mips", "::", "fixup_Mips_HI16", ":", "return", "ELF", "::", "R_MIPS_HI16", ";", "case", "Mips", "::", "fixup_Mips_LO16", ":", "return", "ELF", "::", "R_MIPS_LO16", ";", "case", "Mips", "::", "fixup_Mips_TLSGD", ":", "return", "ELF", "::", "R_MIPS_TLS_GD", ";", "case", "Mips", "::", "fixup_Mips_GOTTPREL", ":", "return", "ELF", "::", "R_MIPS_TLS_GOTTPREL", ";", "case", "Mips", "::", "fixup_Mips_TPREL_HI", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL_HI16", ";", "case", "Mips", "::", "fixup_Mips_TPREL_LO", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL_LO16", ";", "case", "Mips", "::", "fixup_Mips_TLSLDM", ":", "return", "ELF", "::", "R_MIPS_TLS_LDM", ";", "case", "Mips", "::", "fixup_Mips_DTPREL_HI", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL_HI16", ";", "case", "Mips", "::", "fixup_Mips_DTPREL_LO", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL_LO16", ";", "case", "Mips", "::", "fixup_Mips_GOT_PAGE", ":", "return", "ELF", "::", "R_MIPS_GOT_PAGE", ";", "case", "Mips", "::", "fixup_Mips_GOT_OFST", ":", "return", "ELF", "::", "R_MIPS_GOT_OFST", ";", "case", "Mips", "::", "fixup_Mips_GOT_DISP", ":", "return", "ELF", "::", "R_MIPS_GOT_DISP", ";", "case", "Mips", "::", "fixup_Mips_GPOFF_HI", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_HI16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_Mips_GPOFF_LO", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_LO16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_Mips_HIGHER", ":", "return", "ELF", "::", "R_MIPS_HIGHER", ";", "case", "Mips", "::", "fixup_Mips_HIGHEST", ":", "return", "ELF", "::", "R_MIPS_HIGHEST", ";", "case", "Mips", "::", "fixup_Mips_GOT_HI16", ":", "return", "ELF", "::", "R_MIPS_GOT_HI16", ";", "case", "Mips", "::", "fixup_Mips_GOT_LO16", ":", "return", "ELF", "::", "R_MIPS_GOT_LO16", ";", "case", "Mips", "::", "fixup_Mips_CALL_HI16", ":", "return", "ELF", "::", "R_MIPS_CALL_HI16", ";", "case", "Mips", "::", "fixup_Mips_CALL_LO16", ":", "return", "ELF", "::", "R_MIPS_CALL_LO16", ";", "case", "Mips", "::", "fixup_MICROMIPS_26_S1", ":", "return", "ELF", "::", "R_MICROMIPS_26_S1", ";", "case", "Mips", "::", "fixup_MICROMIPS_HI16", ":", "return", "ELF", "::", "R_MICROMIPS_HI16", ";", "case", "Mips", "::", "fixup_MICROMIPS_LO16", ":", "return", "ELF", "::", "R_MICROMIPS_LO16", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT16", ":", "return", "ELF", "::", "R_MICROMIPS_GOT16", ";", "case", "Mips", "::", "fixup_MICROMIPS_CALL16", ":", "return", "ELF", "::", "R_MICROMIPS_CALL16", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ":", "return", "ELF", "::", "R_MICROMIPS_GOT_DISP", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ":", "return", "ELF", "::", "R_MICROMIPS_GOT_PAGE", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_OFST", ":", "return", "ELF", "::", "R_MICROMIPS_GOT_OFST", ";", "case", "Mips", "::", "fixup_MICROMIPS_TLS_GD", ":", "return", "ELF", "::", "R_MICROMIPS_TLS_GD", ";", "case", "Mips", "::", "fixup_MICROMIPS_TLS_LDM", ":", "return", "ELF", "::", "R_MICROMIPS_TLS_LDM", ";", "case", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_HI16", ":" ]

[ "long", "_", "_", "B", ",", "const", "int", "_", "_", "R", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvt_roundsi64_sd", "(", "_", "_", "m128d", "_", "_", "A", ",", "long" ]

[ "<FIXS>", "def", "SKLWriteResGroup179", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort23", ",", "SKLFPDivider", "]", ">", "{", "<FIXE>", "<FIXS>", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup179", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", "SKLWriteResGroup179_1", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort23", ",", "SKLFPDivider", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "}", "def", ":", "InstRW", "[", "SKLWriteResGroup179_1", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>" ]

[ "}", "def", ":", "InstRW", "[", "SKLWriteResGroup178", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", "SKLWriteResGroup179", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort23", "]", ">", "{", "<BUGE>", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "<BUGS>", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "<BUGE>", "}", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup179", "]", ",", "(", "instregex", "<STR_LIT>", ",", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", "SKLWriteResGroup180", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort1", ",", "SKLPort5", ",", "SKLPort6", ",", "SKLPort05", ",", "SKLPort0156", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "," ]

[ "(", "ANY_PLUS", ":", "VNx4SI", "(", "vec_duplicate", ":", "VNx4SI", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_SVE_CNT_PAT", ")", ")", "(", "match_operand", ":", "VNx4SI_ONLY", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "which_alternative", "=", "=", "<NUM_LIT>", ")", "output_asm_insn", "(", "<STR_LIT>", ",", "operands", ")", "return", "aarch64_output_sve_cnt_pat_immediate", "(", "<STR_LIT>", ",", "<STR_LIT>" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "bool", "aarch64_simd_valid_immediate", "(", "rtx", "op", ",", "simd_immediate_info", "*", "info", ",", "enum", "simd_immediate_check", "which", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "if", "(", "vec_flags", "==", "<NUM_LIT>", "||", "vec_flags", "==", "(", "VEC_ADVSIMD", "|", "VEC_STRUCT", ")", ")", "return", "false", ";", "if", "(", "vec_flags", "&", "VEC_SVE_PRED", ")", "return", "aarch64_sve_pred_valid_immediate", "(", "op", ",", "info", ")", ";", "scalar_mode", "elt_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "base", ",", "step", ";", "unsigned", "int", "n_elts", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", "&&", "CONST_VECTOR_DUPLICATE_P", "(", "op", ")", ")", "n_elts", "=", "CONST_VECTOR_NPATTERNS", "(", "op", ")", ";", "else", "if", "(", "(", "vec_flags", "&", "VEC_SVE_DATA", ")", "&&", "const_vec_series_p", "(", "op", ",", "&", "base", ",", "&", "step", ")", ")", "{", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", ";", "if", "(", "!", "aarch64_sve_index_immediate_p", "(", "base", ")", "||", "!", "aarch64_sve_index_immediate_p", "(", "step", ")", ")", "return", "false", ";", "if", "(", "info", ")", "{", "elt_mode", "=", "aarch64_sve_container_int_mode", "(", "mode", ")", ";", "*", "info", "=", "simd_immediate_info", "(", "elt_mode", ",", "base", ",", "step", ")", ";", "}", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", "&&", "CONST_VECTOR_NUNITS", "(", "op", ")", ".", "is_constant", "(", "&", "n_elts", ")", ")", ";", "else", "return", "false", ";", "scalar_float_mode", "elt_float_mode", ";", "if", "(", "n_elts", "==", "<NUM_LIT>", "&&", "is_a", "<", "scalar_float_mode", ">", "(", "elt_mode", ",", "&", "elt_float_mode", ")", ")", "{", "rtx", "elt", "=", "CONST_VECTOR_ENCODED_ELT", "(", "op", ",", "<NUM_LIT>", ")", ";", "if", "(", "aarch64_float_const_zero_rtx_p", "(", "elt", ")", "||", "aarch64_float_const_representable_p", "(", "elt", ")", ")", "{", "if", "(", "info", ")", "*", "info", "=", "simd_immediate_info", "(", "elt_float_mode", ",", "elt", ")", ";", "return", "true", ";", "}", "}", "scalar_int_mode", "elt_int_mode", ";", "if", "(", "(", "vec_flags", "&", "VEC_SVE_DATA", ")", "&&", "n_elts", ">", "<NUM_LIT>", ")", "elt_int_mode", "=", "aarch64_sve_container_int_mode", "(", "mode", ")", ";", "else", "elt_int_mode", "=", "int_mode_for_mode", "(", "elt_mode", ")", ".", "require", "(", ")", ";", "unsigned", "int", "elt_size", "=", "GET_MODE_SIZE", "(", "elt_int_mode", ")", ";", "if", "(", "elt_size", ">", "<NUM_LIT>", ")", "return", "false", ";", "auto_vec", "<", "unsigned", "char", ",", "<NUM_LIT>", ">", "bytes", ";", "bytes", ".", "reserve", "(", "n_elts", "*", "elt_size", ")", ";", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "bool", "swap_p", "=", "(", "(", "vec_flags", "&", "VEC_ADVSIMD", ")", "!=", "<NUM_LIT>", "&&", "BYTES_BIG_ENDIAN", ")", ";", "rtx", "elt", "=", "CONST_VECTOR_ELT", "(", "op", ",", "swap_p", "?", "(", "n_elts", "-", "<NUM_LIT>", "-", "i", ")", ":", "i", ")", ";", "if", "(", "elt_mode", "!=", "elt_int_mode", ")", "elt", "=", "gen_lowpart", "(", "elt_int_mode", ",", "elt", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elt", ")", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "elt_val", "=", "INTVAL", "(", "elt", ")", ";", "for", "(", "unsigned", "int", "byte", "=", "<NUM_LIT>", ";", "byte", "<", "elt_size", ";", "byte", "++", ")", "{", "bytes", ".", "quick_push", "(", "elt_val", "&", "<NUM_LIT>", ")", ";", "elt_val", ">>=", "BITS_PER_UNIT", ";", "}", "}", "unsigned", "int", "nbytes", "=", "bytes", ".", "length", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "nbytes", ";", "++", "i", ")", "if", "(", "bytes", "[", "i", "]", "!=", "bytes", "[", "i", "-", "<NUM_LIT>", "]", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "val64", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "val64", "|=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "bytes", "[", "i", "%", "nbytes", "]", "<<", "(", "i", "*", "BITS_PER_UNIT", ")", ")", ";", "if", "(", "vec_flags", "&", "VEC_SVE_DATA", ")", "return", "aarch64_sve_valid_immediate", "(", "val64", ",", "info", ")", ";", "else", "return", "aarch64_advsimd_valid_immediate", "(", "val64", ",", "info", ",", "which", ")", ";", "}" ]

[ "Return", "true", "for", "valid", "and", "false", "for", "invalid", "." ]

[ "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "]", "<NUM_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "<BUGS>", "]", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=" ]

[ "(", "regno", ")", "?", "FP_LO_REGS", ":", "FP_REGS", ";" ]

[ "if", "(", "GP_REGNUM_P", "(", "regno", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "STACK_REG", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "POINTER_REGS", ";", "if", "(", "FP_REGNUM_P", "(", "regno", ")", ")", "return", "FP_LO_REGNUM_P" ]

[ "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovqb512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v16qi", ")", "_", "mm_undefined_si128", "(", ")", ",", "(", "_", "_" ]

[ ":", "$", "R2", ",", "cls", ":", "$", "R3", ")", ",", "[", "]", ">", ";" ]

[ "class", "BinaryAliasVRRf", "<", "RegisterOperand", "cls", ">", ":", "Alias", "<", "<NUM_LIT>", ",", "(", "outs", "VR128", ":", "$", "V1", ")", ",", "(", "ins", "cls" ]

[ "<STR_LIT>", ")", "]", ")" ]

[ "[", "(", "compare", ":", "CCFP", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "class", "SIMDBF16MLALIndex", "<", "bit", "Q", ",", "string", "asm", ",", "SDPatternOperator", "OpNode", ">", ":", "I", "<", "(", "outs", "V128", ":", "$", "dst", ")", ",", "(", "ins", "V128", ":", "$", "Rd", ",", "V128", ":", "$", "Rn", ",", "V128_lo", ":", "$", "Rm", ",", "VectorIndexH", ":", "$", "idx", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v4f32", "V128", ":", "$", "dst", ")", ",", "(", "v4f32", "(", "OpNode", "(", "v4f32", "V128", ":", "$", "Rd", ")", ",", "(", "v8bf16", "V128", ":", "$", "Rn", ")", ",", "(", "v8bf16", "(", "AArch64duplane16", "(", "v8bf16", "V128_lo", ":", "$", "Rm", ")", ",", "VectorIndexH", ":", "$", "idx", ")", ")", ")", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteVq", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "addRegOffset", "(", "BuildMI", "(", "stackCheckMBB", ",", "DL", ",", "TII", ".", "get", "(", "CMPop", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ",", "PReg", ",", "false", ",", "SPLimitOffset", ")", ";" ]

[ "unsigned", "MoreStackForCalls", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "continue", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "continue", ";", "const", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "!", "F", ")", "continue", ";", "if", "(", "F", "->", "getName", "(", ")", ".", "contains", "(", "<STR_LIT>", "erlang.", "<STR_LIT>", ")", "||", "F", "->", "getName", "(", ")", ".", "contains", "(", "<STR_LIT>", "bif_", "<STR_LIT>", ")", "||", "F", "->", "getName", "(", ")", ".", "find_first_of", "(", "<STR_LIT>", "._", "<STR_LIT>", ")", "==", "StringRef", "::", "npos", ")", "continue", ";", "unsigned", "CalleeStkArity", "=", "F", "->", "arg_size", "(", ")", ">", "CCRegisteredArgs", "?", "F", "->", "arg_size", "(", ")", "-", "CCRegisteredArgs", ":", "<NUM_LIT>", ";", "if", "(", "HipeLeafWords", "-", "<NUM_LIT>", ">", "CalleeStkArity", ")", "MoreStackForCalls", "=", "std", "::", "max", "(", "MoreStackForCalls", ",", "(", "HipeLeafWords", "-", "<NUM_LIT>", "-", "CalleeStkArity", ")", "*", "SlotSize", ")", ";", "}", "}", "MaxStack", "+=", "MoreStackForCalls", ";", "}", "if", "(", "MaxStack", ">", "Guaranteed", ")", "{", "MachineBasicBlock", "*", "stackCheckMBB", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "MachineBasicBlock", "*", "incStackMBB", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "for", "(", "const", "auto", "&", "LI", ":", "PrologueMBB", ".", "liveins", "(", ")", ")", "{", "stackCheckMBB", "->", "addLiveIn", "(", "LI", ")", ";", "incStackMBB", "->", "addLiveIn", "(", "LI", ")", ";", "}", "MF", ".", "push_front", "(", "incStackMBB", ")", ";", "MF", ".", "push_front", "(", "stackCheckMBB", ")", ";", "unsigned", "ScratchReg", ",", "SPReg", ",", "PReg", ",", "SPLimitOffset", ";", "unsigned", "LEAop", ",", "CMPop", ",", "CALLop", ";", "SPLimitOffset", "=", "getHiPELiteral", "(", "HiPELiteralsMD", ",", "<STR_LIT>", "P_NSP_LIMIT", "<STR_LIT>", ")", ";", "if", "(", "Is64Bit", ")", "{", "SPReg", "=", "X86", "::", "RSP", ";", "PReg", "=", "X86", "::", "RBP", ";", "LEAop", "=", "X86", "::", "LEA64r", ";", "CMPop", "=", "X86", "::", "CMP64rm", ";", "CALLop", "=", "X86", "::", "CALL64pcrel32", ";", "}", "else", "{", "SPReg", "=", "X86", "::", "ESP", ";", "PReg", "=", "X86", "::", "EBP", ";", "LEAop", "=", "X86", "::", "LEA32r", ";", "CMPop", "=", "X86", "::", "CMP32rm", ";", "CALLop", "=", "X86", "::", "CALLpcrel32", ";", "}", "ScratchReg", "=", "GetScratchRegister", "(", "Is64Bit", ",", "IsLP64", ",", "MF", ",", "true", ")", ";", "assert", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ScratchReg", ")", "&&", "<STR_LIT>", "HiPE prologue scratch register is live-in", "<STR_LIT>", ")", ";", "addRegOffset", "(", "BuildMI", "(", "stackCheckMBB", ",", "DL", ",", "TII", ".", "get", "(", "LEAop", ")", ",", "ScratchReg", ")", ",", "SPReg", ",", "false", ",", "-", "MaxStack", ")", ";" ]

[ "return", "false", ";" ]

[ "if", "(", "Offset", ".", "is", "(", "AsmToken", "::", "Integer", ")", ")", "{", "parseSingleInteger", "(", "false", ",", "Operands", ")", ";", "}", "else", "{", "Operands", ".", "push_back", "(", "make_unique", "<", "WebAssemblyOperand", ">", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "Offset", ".", "getLoc", "(", ")", ",", "Offset", ".", "getEndLoc", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "{", "<NUM_LIT>", "}", ")", ")", ";", "}", "}" ]

[ ")", ";" ]

[ "AU", ".", "addPreserved", "<", "MachineDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(" ]

[ "getSExtValue", "(", ")", ";" ]

[ "const", "DataLayout", "&", "DL", "=", "CurDAG", "->", "getDataLayout", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FrameIndex", ")", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "if", "(", "FI", "==", "<NUM_LIT>", "||", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "ScalableVector", ")", "{", "Base", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ";", "OffImm", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i64", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "if", "(", "MemVT", "==", "EVT", "(", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "return", "false", ";", "SDValue", "VScale", "=", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "VScale", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "VSCALE", ")", "return", "false", ";", "TypeSize", "TS", "=", "MemVT", ".", "getSizeInBits", "(", ")", ";", "int64_t", "MemWidthBytes", "=", "static_cast", "<", "int64_t", ">", "(", "TS", ".", "getKnownMinSize", "(", ")", ")", "/", "<NUM_LIT>", ";", "int64_t", "MulImm", "=", "cast", "<", "ConstantSDNode", ">", "(", "VScale", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->" ]

[ "uneq", "unle", "unlt", "]", ")" ]

[ "(", "define_code_iterator", "FCC", "[", "unordered", "ordered", "eq", "ne", "le", "lt" ]

[ "}" ]

[ "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "PerformDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";" ]

[ "SDValue", "XtensaTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getReturnType", "(", ")", "->", "isAggregateType", "(", ")", ")", "{", "llvm", "::", "errs", "(", ")", "<<", "<STR_LIT>", "ISelDAG: Can't return aggregate types\\n", "<STR_LIT>", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled aggregate type", "<STR_LIT>", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCAssignFnForReturn", "(", "CallConv", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", "(", "<NUM_LIT>", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Can only support return in registers", "<STR_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "<NUM_LIT>", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}" ]

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

[ ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ":", "nullptr", ";" ]

[ "return", "balanceFPOps", "(", ")", "?", "llvm", "::", "make_unique", "<", "A57ChainingConstraint", ">", "(", ")" ]

[ "i", "]", ")", ")", ";" ]

[ "unsigned", "RegLst", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "RegLst", "==", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "RegNum", "=", "RegLst", "&", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "RegNum", ";", "i", "++", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Regs", "[" ]

[ "void", "m68k_expand_epilogue", "(", "bool", "sibcall_p", ")", "{", "HOST_WIDE_INT", "fsize", ",", "fsize_with_regs", ";", "bool", "big", ",", "restore_from_sp", ";", "m68k_compute_frame_layout", "(", ")", ";", "fsize", "=", "current_frame", ".", "size", ";", "big", "=", "false", ";", "restore_from_sp", "=", "false", ";", "restore_from_sp", "=", "(", "!", "frame_pointer_needed", "||", "(", "!", "cfun", "->", "calls_alloca", "&&", "crtl", "->", "is_leaf", ")", ")", ";", "fsize_with_regs", "=", "fsize", ";", "if", "(", "TARGET_COLDFIRE", "&&", "restore_from_sp", ")", "{", "if", "(", "current_frame", ".", "reg_no", ">=", "MIN_MOVEM_REGS", ")", "fsize_with_regs", "+=", "current_frame", ".", "reg_no", "*", "GET_MODE_SIZE", "(", "SImode", ")", ";", "if", "(", "current_frame", ".", "fpu_no", ">=", "MIN_FMOVEM_REGS", ")", "fsize_with_regs", "+=", "current_frame", ".", "fpu_no", "*", "GET_MODE_SIZE", "(", "DFmode", ")", ";", "}", "if", "(", "current_frame", ".", "offset", "+", "fsize", ">=", "<NUM_LIT>", "&&", "!", "restore_from_sp", "&&", "(", "current_frame", ".", "reg_mask", "||", "current_frame", ".", "fpu_mask", ")", ")", "{", "if", "(", "TARGET_COLDFIRE", "&&", "(", "current_frame", ".", "reg_no", ">=", "MIN_MOVEM_REGS", "||", "current_frame", ".", "fpu_no", ">=", "MIN_FMOVEM_REGS", ")", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "A1_REG", ")", ",", "GEN_INT", "(", "-", "(", "current_frame", ".", "offset", "+", "fsize", ")", ")", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "A1_REG", ")", ",", "frame_pointer_rtx", ")", ")", ";", "restore_from_sp", "=", "true", ";", "}", "else", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "A1_REG", ")", ",", "GEN_INT", "(", "-", "fsize", ")", ")", ";", "fsize", "=", "<NUM_LIT>", ";", "big", "=", "true", ";", "}", "}", "if", "(", "current_frame", ".", "reg_no", "<", "MIN_MOVEM_REGS", ")", "{", "int", "i", ";", "HOST_WIDE_INT", "offset", ";", "offset", "=", "current_frame", ".", "offset", "+", "fsize", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "current_frame", ".", "reg_mask", "&", "(", "<NUM_LIT>", "<<", "i", ")", ")", "{", "rtx", "addr", ";", "if", "(", "big", ")", "{", "addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "A1_REG", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "frame_pointer_rtx", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "addr", ",", "-", "offset", ")", ";", "}", "else", "if", "(", "restore_from_sp", ")", "addr", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "else", "addr", "=", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "-", "offset", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "D0_REG", "+", "i", ")", ",", "gen_frame_mem", "(", "SImode", ",", "addr", ")", ")", ";", "offset", "-=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "}", "}", "else", "if", "(", "current_frame", ".", "reg_mask", ")", "{", "if", "(", "big", ")", "m68k_emit_movem", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "A1_REG", ")", ",", "frame_pointer_rtx", ")", ",", "-", "(", "current_frame", ".", "offset", "+", "fsize", ")", ",", "current_frame", ".", "reg_no", ",", "D0_REG", ",", "current_frame", ".", "reg_mask", ",", "false", ",", "false", ")", ";", "else", "if", "(", "restore_from_sp", ")", "m68k_emit_movem", "(", "stack_pointer_rtx", ",", "<NUM_LIT>", ",", "current_frame", ".", "reg_no", ",", "D0_REG", ",", "current_frame", ".", "reg_mask", ",", "false", ",", "!", "TARGET_COLDFIRE", ")", ";", "else", "m68k_emit_movem", "(", "frame_pointer_rtx", ",", "-", "(", "current_frame", ".", "offset", "+", "fsize", ")", ",", "current_frame", ".", "reg_no", ",", "D0_REG", ",", "current_frame", ".", "reg_mask", ",", "false", ",", "false", ")", ";", "}", "if", "(", "current_frame", ".", "fpu_no", ">", "<NUM_LIT>", ")", "{", "if", "(", "big", ")", "m68k_emit_movem", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "A1_REG", ")", ",", "frame_pointer_rtx", ")", ",", "-", "(", "current_frame", ".", "foffset", "+", "fsize", ")", ",", "current_frame", ".", "fpu_no", ",", "FP0_REG", ",", "current_frame", ".", "fpu_mask", ",", "false", ",", "false", ")", ";", "else", "if", "(", "restore_from_sp", ")", "{", "if", "(", "TARGET_COLDFIRE", ")", "{", "int", "offset", ";", "if", "(", "current_frame", ".", "reg_no", "<", "MIN_MOVEM_REGS", ")", "offset", "=", "<NUM_LIT>", ";", "else", "offset", "=", "current_frame", ".", "reg_no", "*", "GET_MODE_SIZE", "(", "SImode", ")", ";", "m68k_emit_movem", "(", "stack_pointer_rtx", ",", "offset", ",", "current_frame", ".", "fpu_no", ",", "FP0_REG", ",", "current_frame", ".", "fpu_mask", ",", "false", ",", "false", ")", ";", "}", "else", "m68k_emit_movem", "(", "stack_pointer_rtx", ",", "<NUM_LIT>", ",", "current_frame", ".", "fpu_no", ",", "FP0_REG", ",", "current_frame", ".", "fpu_mask", ",", "false", ",", "true", ")", ";", "}", "else", "m68k_emit_movem", "(", "frame_pointer_rtx", ",", "-", "(", "current_frame", ".", "foffset", "+", "fsize", ")", ",", "current_frame", ".", "fpu_no", ",", "FP0_REG", ",", "current_frame", ".", "fpu_mask", ",", "false", ",", "false", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "gen_unlink", "(", "frame_pointer_rtx", ")", ")", ";", "else", "if", "(", "fsize_with_regs", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "fsize_with_regs", ")", ")", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "!", "sibcall_p", ")", "emit_jump_insn", "(", "ret_rtx", ")", ";", "}" ]

[ "Emit", "RTL", "for", "the", "``", "epilogue", "''", "or", "``", "sibcall_epilogue", "''", "define_expand", ";", "SIBCALL_P", "says", "which", ".", "The", "function", "epilogue", "should", "not", "depend", "on", "the", "current", "stack", "pointer", "!", "It", "should", "use", "the", "frame", "pointer", "only", ",", "if", "there", "is", "a", "frame", "pointer", ".", "This", "is", "mandatory", "because", "of", "alloca", ";", "we", "also", "take", "advantage", "of", "it", "to", "omit", "stack", "adjustments", "before", "returning", "." ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_expand", "<STR_LIT>" ]

[ "(", "V16HF", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_mode_attr", "sseintvecmode2", "[", "(", "V8DF", "<STR_LIT>", ")", "(", "V4DF", "<STR_LIT>", ")", "(", "V2DF", "<STR_LIT>", ")", "(", "V8SF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")" ]

[ "EltNo", "-=", "NumElems", "/", "<NUM_LIT>", ";" ]

[ "SDLoc", "dl", "(", "V", ")", ";", "while", "(", "NumElems", ">", "<NUM_LIT>", ")", "{", "if", "(", "EltNo", "<", "NumElems", "/", "<NUM_LIT>", ")", "{", "V", "=", "getUnpackl", "(", "DAG", ",", "dl", ",", "VT", ",", "V", ",", "V", ")", ";", "}", "else", "{", "V", "=", "getUnpackh", "(", "DAG", ",", "dl", ",", "VT", ",", "V", ",", "V", ")", ";" ]

[ ":", "return", "<NUM_LIT>", ";" ]

[ "static", "unsigned", "encodeAbeOp", "(", "unsigned", "reg", ")", "{", "switch", "(", "reg", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>" ]

[ "static", "std", "::", "string", "toString", "(", "const", "APFloat", "&", "FP", ")", "{", "if", "(", "FP", ".", "isNaN", "(", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ")", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ",", "true", ")", ")", ")", "{", "APInt", "AI", "=", "FP", ".", "bitcastToAPInt", "(", ")", ";", "return", "std", "::", "string", "(", "AI", ".", "isNegative", "(", ")", "?", "<STR_LIT>", "-", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "+", "<STR_LIT>", "nan:0x", "<STR_LIT>", "+", "utohexstr", "(", "AI", ".", "getZExtValue", "(", ")", "&", "(", "AI", ".", "getBitWidth", "(", ")", "==", "<NUM_LIT>", "?", "INT64_C", "(", "<NUM_LIT>", ")", ":", "INT64_C", "(", "<NUM_LIT>", ")", ")", ",", "true", ")", ";", "}", "static", "const", "size_t", "BufBytes", "=", "<NUM_LIT>", ";", "char", "buf", "[", "BufBytes", "]", ";", "auto", "Written", "=", "FP", ".", "convertToHexString", "(", "buf", ",", "<NUM_LIT>", ",", "false", ",", "APFloat", "::", "rmNearestTiesToEven", ")", ";", "(", "void", ")", "Written", ";", "assert", "(", "Written", "!=", "<NUM_LIT>", ")", ";", "assert", "(", "Written", "<", "BufBytes", ")", ";", "return", "buf", ";", "}" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "}" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";" ]