Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "if", "(", "!", "Node", "->", "isConstantSplat", "(", "SplatValue", ",", "SplatUndef", ",", "SplatBitSize", ",", "HasAnyUndefs", ",", "MinSizeInBits", ",", "!", "Subtarget", "->", "isLittle", "(", ")", ")", ")", "<FIXE>" ]

[ "unsigned", "SplatBitSize", ";", "bool", "HasAnyUndefs", ";", "<BUGS>", "if", "(", "!", "Node", "->", "isConstantSplat", "(", "SplatValue", ",", "SplatUndef", ",", "SplatBitSize", ",", "HasAnyUndefs", ",", "<NUM_LIT>", ",", "!", "Subtarget", "->", "isLittle", "(", ")", ")", ")", "<BUGE>", "return", "false", ";", "Imm", "=", "SplatValue", ";" ]

[ "Register", "Copy", "=", "B", ".", "buildCopy", "(", "MRI", ".", "getType", "(", "Reg", ")", ",", "Reg", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";" ]

[ "static", "Register", "constrainRegToBank", "(", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ",", "Register", "&", "Reg", ",", "const", "RegisterBank", "&", "Bank", ")", "{", "const", "RegisterBank", "*", "CurrBank", "=", "MRI", ".", "getRegBankOrNull", "(", "Reg", ")", ";", "if", "(", "CurrBank", "&&", "*", "CurrBank", "!=", "Bank", ")", "{" ]

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

[ "(", "compare", ":", "CCXNZ", "(", "neg", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

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

[ "class", "BaseLoadStorePostIdx", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "V", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "dag", "oops", ",", "dag", "iops", ",", "string", "asm", ",", "string", "cstr", ">", ":", "I", "<", "oops", ",", "iops", ",", "asm", ",", "<STR_LIT>", ",", "cstr", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "base", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";" ]

[ "]", ")", ",", "mems", "[", "j", "]", ")", ";" ]

[ "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "(", "wback_offset", "!=", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "wback_offset", "!=", "<NUM_LIT>", ")", "{", "XVECEXP", "(", "result", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "gen_rtx_SET", "(", "basereg", ",", "plus_constant", "(", "Pmode", ",", "basereg", ",", "wback_offset", ")", ")", ";", "i", "=", "<NUM_LIT>", ";", "count", "++", ";", "}", "for", "(", "j", "=", "<NUM_LIT>", ";", "i", "<", "count", ";", "i", "++", ",", "j", "++", ")", "XVECEXP", "(", "result", ",", "<NUM_LIT>", ",", "i", ")", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "SImode", ",", "regs", "[", "j" ]

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

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Is64Bit", "?", "X86", "::", "MOV64rr", ":", "X86", "::", "MOV32rr", ")", ",", "StackPtr", ")", ".", "addReg", "(", "DestAddr", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "RetOpcode", "==", "X86", "::", "TCRETURNri", "||", "RetOpcode", "==", "X86", "::", "TCRETURNdi", "||", "RetOpcode", "==", "X86", "::", "TCRETURNri64", "||", "RetOpcode", "==", "X86", "::", "TCRETURNdi64", ")", "{", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineOperand", "&", "JumpTarget", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "StackAdjust", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "StackAdjust", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Expecting immediate value.", "<STR_LIT>", ")", ";", "int", "StackAdj", "=", "StackAdjust", ".", "getImm", "(", ")", ";", "int", "MaxTCDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "int", "Offset", "=", "<NUM_LIT>", ";", "assert", "(", "MaxTCDelta", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "MaxTCDelta should never be positive", "<STR_LIT>", ")", ";", "Offset", "=", "StackAdj", "-", "MaxTCDelta", ";", "assert", "(", "Offset", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Offset should never be negative", "<STR_LIT>", ")", ";", "if", "(", "Offset", ")", "{", "Offset", "+=", "mergeSPUpdates", "(", "MBB", ",", "MBBI", ",", "StackPtr", ",", "true", ")", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "StackPtr", ",", "Offset", ",", "Is64Bit", ",", "TII", ")", ";", "}", "if", "(", "RetOpcode", "==", "X86", "::", "TCRETURNdi", "||", "RetOpcode", "==", "X86", "::", "TCRETURNdi64", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "TAILJMPd", ")", ")", ".", "addGlobalAddress", "(", "JumpTarget", ".", "getGlobal", "(", ")", ",", "JumpTarget", ".", "getOffset", "(", ")", ")", ";", "else", "if", "(", "RetOpcode", "==", "X86", "::", "TCRETURNri64", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "TAILJMPr64", ")", ",", "JumpTarget", ".", "getReg", "(", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "TAILJMPr", ")", ",", "JumpTarget", ".", "getReg", "(", ")", ")", ";", "MBB", ".", "erase" ]

[ "<FIXS>", "SDPatternOperator", "opnode", "=", "FPNoUnop", ">", "{", "<FIXE>" ]

[ "multiclass", "A64I_fpdp1sizes", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "asmstr", ",", "<BUGS>", "SDPatternOperator", "opnode", "=", "FPNoUnop", ">", "{", "<BUGE>", "def", "ss", ":", "A64I_fpdp1", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opcode", ",", "(", "outs", "FPR32", ":", "$", "Rd", ")", ",", "(", "ins", "FPR32", ":", "$", "Rn", ")", ",", "!", "strconcat", "(", "asmstr", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "(", "f32", "FPR32", ":", "$", "Rd", ")", ",", "(", "opnode", "FPR32", ":", "$", "Rn", ")", ")", "]", "," ]

[ "(", ")", ")", "{" ]

[ "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "!=", "(", "int", ")", "NumElts", ";", "++", "i", ")", "ShufMask", "[", "i", "]", "=", "(", "i", "/", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "(", "(", "i", "%", "<NUM_LIT>", ")", "*", "NumElts", ")", "+", "<NUM_LIT>", ";", "SDValue", "Res", "=", "DAG", ".", "getVectorShuffle", "(", "VT", ",", "dl", ",", "Mul1", ",", "Mul2", ",", "ShufMask", ")", ";", "if", "(", "IsSigned", "&&", "!", "Subtarget", ".", "hasSSE41", "(", ")", ")", "{", "SDValue", "ShAmt", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ";", "SDValue", "T1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "dl", ",", "VT", ",", "A", ",", "ShAmt", ")", ",", "B", ")", ";", "SDValue", "T2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "dl", ",", "VT", ",", "B", ",", "ShAmt", ")", ",", "A", ")", ";", "SDValue", "Fixup", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "VT", ",", "T1", ",", "T2", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "dl", ",", "VT", ",", "Res", ",", "Fixup", ")", ";", "}", "return", "Res", ";", "}", "assert", "(", "(", "VT", "==", "MVT", "::", "v16i8", "||", "(", "VT", "==", "MVT", "::", "v32i8", "&&", "Subtarget", ".", "hasInt256", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v64i8", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", "&&", "<STR_LIT>", "Unsupported vector type", "<STR_LIT>", ")", ";", "unsigned", "ExShift", "=", "IsSigned", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "ExAVX", "=", "IsSigned", "?", "ISD", "::", "SIGN_EXTEND", ":", "ISD", "::", "ZERO_EXTEND", ";", "if", "(", "VT", "==", "MVT", "::", "v64i8", ")", "return", "split512IntArith", "(", "Op", ",", "DAG", ")", ";", "if", "(", "Subtarget", ".", "hasInt256", "(", ")", ")", "{", "SDValue", "Lo", "=", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getIntPtrConstant", "(", "NumElts", "/", "<NUM_LIT>", ",", "dl", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v32i8", ")", "{", "if", "(", "Subtarget", ".", "canExtendTo512BW", "(", ")", ")", "{", "MVT", "ExVT", "=", "MVT", "::", "v32i16", ";", "SDValue", "ExA", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "ExVT", ",", "A", ")", ";", "SDValue", "ExB", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "ExVT", ",", "B", ")", ";", "SDValue", "Mul", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "ExVT", ",", "ExA", ",", "ExB", ")", ";", "Mul", "=", "getTargetVShiftByConstNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ExVT", ",", "Mul", ",", "<NUM_LIT>", ",", "DAG", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VT", ",", "Mul", ")", ";", "}", "MVT", "ExVT", "=", "MVT", "::", "v16i16", ";", "SDValue", "ALo", "=", "extract128BitVector", "(", "A", ",", "<NUM_LIT>", ",", "DAG", ",", "dl", ")", ";", "SDValue", "BLo", "=", "extract128BitVector", "(", "B", ",", "<NUM_LIT>", ",", "DAG", ",", "dl", ")", ";", "SDValue", "AHi", "=", "extract128BitVector", "(", "A", ",", "NumElts", "/", "<NUM_LIT>", ",", "DAG", ",", "dl", ")", ";", "SDValue", "BHi", "=", "extract128BitVector", "(", "B", ",", "NumElts", "/", "<NUM_LIT>", ",", "DAG", ",", "dl", ")", ";", "ALo", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "ExVT", ",", "ALo", ")", ";", "BLo", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "ExVT", ",", "BLo", ")", ";", "AHi", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "ExVT", ",", "AHi", ")", ";", "BHi", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "ExVT", ",", "BHi", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "ExVT", ",", "ALo", ",", "BLo", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "ExVT", ",", "AHi", ",", "BHi", ")", ";", "Lo", "=", "getTargetVShiftByConstNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ExVT", ",", "Lo", ",", "<NUM_LIT>", ",", "DAG", ")", ";", "Hi", "=", "getTargetVShiftByConstNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ExVT", ",", "Hi", ",", "<NUM_LIT>", ",", "DAG", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Lo", ",", "Hi", ")", ";", "Res", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v4i64", ",", "Res", ")", ";", "Res", "=", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v4i64", ",", "dl", ",", "Res", ",", "Res", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "Res", ")", ";", "}", "assert", "(", "VT", "==", "MVT", "::", "v16i8", "&&", "<STR_LIT>", "Unexpected VT", "<STR_LIT>", ")", ";", "SDValue", "ExA", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "MVT", "::", "v16i16", ",", "A", ")", ";", "SDValue", "ExB", "=", "DAG", ".", "getNode", "(", "ExAVX", ",", "dl", ",", "MVT", "::", "v16i16", ",", "B", ")", ";", "SDValue", "Mul", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "MVT", "::", "v16i16", ",", "ExA", ",", "ExB", ")", ";", "Mul", "=", "getTargetVShiftByConstNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v16i16", ",", "Mul", ",", "<NUM_LIT>", ",", "DAG", ")", ";", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VT", ",", "Mul", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "MVT", "::", "v8i16", ",", "Mul", ",", "Lo", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "MVT", "::", "v8i16", ",", "Mul", ",", "Hi", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Lo", ",", "Hi", ")", ";", "}", "assert", "(", "VT", "==", "MVT", "::", "v16i8", "&&", "<STR_LIT>", "Pre-AVX2 support only supports v16i8 multiplication", "<STR_LIT>", ")", ";", "MVT", "ExVT", "=", "MVT", "::", "v8i16", ";", "unsigned", "ExSSE41", "=", "IsSigned", "?", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ":", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", ";", "SDValue", "ALo", ",", "BLo", ";", "if", "(", "Subtarget", ".", "hasSSE41" ]

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

[ "[", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_LSQ", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "LastEMS", "=", "EMS_Data", ";" ]

[ "if", "(", "LastEMS", "==", "EMS_Data", ")", "return", ";", "EmitMappingSymbol", "(", "<STR_LIT>", "$d", "<STR_LIT>", ")", ";" ]

[ "SDValue", "BT", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "LHS", ",", "RHS", ")", ";" ]

[ "unsigned", "AndBitWidth", "=", "And", ".", "getValueSizeInBits", "(", ")", ";", "if", "(", "BitWidth", ">", "AndBitWidth", ")", "{", "APInt", "Zeros", ",", "Ones", ";", "DAG", ".", "computeKnownBits", "(", "Op0", ",", "Zeros", ",", "Ones", ")", ";", "if", "(", "Zeros", ".", "countLeadingOnes", "(", ")", "<", "BitWidth", "-", "AndBitWidth", ")", "return", "SDValue", "(", ")", ";", "}", "LHS", "=", "Op1", ";", "RHS", "=", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "}", "else", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "{", "ConstantSDNode", "*", "AndRHS", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op1", ")", ";", "uint64_t", "AndRHSVal", "=", "AndRHS", "->", "getZExtValue", "(", ")", ";", "SDValue", "AndLHS", "=", "Op0", ";", "if", "(", "AndRHSVal", "==", "<NUM_LIT>", "&&", "AndLHS", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", ")", "{", "LHS", "=", "AndLHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "RHS", "=", "AndLHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "AndRHSVal", ")", "&&", "isPowerOf2_64", "(", "AndRHSVal", ")", ")", "{", "LHS", "=", "AndLHS", ";", "RHS", "=", "DAG", ".", "getConstant", "(", "Log2_64_Ceil", "(", "AndRHSVal", ")", ",", "LHS", ".", "getValueType", "(", ")", ")", ";", "}", "}", "if", "(", "LHS", ".", "getNode", "(", ")", ")", "{", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "i8", "||", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "i16", ")", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "LHS", ")", ";", "if", "(", "LHS", ".", "getValueType", "(", ")", "!=", "RHS", ".", "getValueType", "(", ")", ")", "RHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "LHS", ".", "getValueType", "(", ")", ",", "RHS", ")", ";" ]

[ ",", "_", "_", "A", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "_", "_", "builtin_ia32_vcvttph2qq512_mask_round", "(", "_", "_", "B", ",", "_", "mm512_setzero_si512", "(", ")" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isTak", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "r13_2", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "r13_2", "{" ]

[ "(", "mem", ":", "BLK", "(", "scratch", ")", ")" ]

[ "(", "match_operator", ":", "<", "ssescalarmode", ">", "<NUM_LIT>", "<STR_LIT>", "[", "(", "unspec", ":", "P", "[", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "<", "VEC_GATHER_IDXDI", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VSIBADDR", ")", "]", ")" ]

[ "<FIXS>", "bool", "isVmovf", "=", "TyOp", "->", "isToken", "(", ")", "&&", "(", "TyOp", "->", "getToken", "(", ")", "==", "<STR_LIT>", ".f32", "<STR_LIT>", "||", "TyOp", "->", "getToken", "(", ")", "==", "<STR_LIT>", ".f64", "<STR_LIT>", ")", ";", "ARMOperand", "*", "Mnemonic", "=", "static_cast", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", ";", "bool", "isFconst", "=", "Mnemonic", "->", "isToken", "(", ")", "&&", "(", "Mnemonic", "->", "getToken", "(", ")", "==", "<STR_LIT>", "fconstd", "<STR_LIT>", "||", "Mnemonic", "->", "getToken", "(", ")", "==", "<STR_LIT>", "fconsts", "<STR_LIT>", ")", ";", "if", "(", "!", "(", "isVmovf", "||", "isFconst", ")", ")", "<FIXE>" ]

[ "ARMOperand", "*", "TyOp", "=", "static_cast", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", ";", "<BUGS>", "if", "(", "!", "TyOp", "->", "isToken", "(", ")", "||", "(", "TyOp", "->", "getToken", "(", ")", "!=", "<STR_LIT>", ".f32", "<STR_LIT>", "&&", "TyOp", "->", "getToken", "(", ")", "!=", "<STR_LIT>", ".f64", "<STR_LIT>", ")", ")", "<BUGE>", "return", "MatchOperand_NoMatch", ";", "Parser", ".", "Lex", "(", ")", ";" ]

[ "HSADebugProps", ".", "mDebuggerABIVersion", ".", "push_back", "(", "<NUM_LIT>", ")", ";" ]

[ "HSAMD", "::", "Kernel", "::", "DebugProps", "::", "Metadata", "HSADebugProps", ";", "if", "(", "!", "STM", ".", "debuggerSupported", "(", ")", ")", "return", "HSADebugProps", ";", "HSADebugProps", ".", "mDebuggerABIVersion", ".", "push_back", "(", "<NUM_LIT>", ")", ";" ]

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

[ "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineOperand", "&", "DestLo", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "DestHi", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "StatusReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "StatusDead", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ";", "assert", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isUndef", "(", ")", "&&", "<STR_LIT>", "cannot handle undef", "<STR_LIT>", ")", ";", "unsigned", "AddrReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "DesiredLoReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "DesiredHiReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "NewLoReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "NewHiReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "auto", "LoadCmpBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "MBB", ".", "getBasicBlock", "(", ")", ")", ";", "auto", "StoreBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "MBB", ".", "getBasicBlock", "(", ")", ")", ";", "auto", "DoneBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "MBB", ".", "getBasicBlock", "(", ")", ")", ";", "MF", "->", "insert", "(", "++", "MBB", ".", "getIterator", "(", ")", ",", "LoadCmpBB", ")", ";", "MF", "->", "insert", "(", "++", "LoadCmpBB", "->", "getIterator", "(", ")", ",", "StoreBB", ")", ";", "MF", "->", "insert", "(", "++", "StoreBB", "->", "getIterator", "(", ")", ",", "DoneBB", ")", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "DestLo", ".", "getReg", "(", ")", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "DestHi", ".", "getReg", "(", ")", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AddrReg", ")", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DestLo", ".", "getReg", "(", ")", ",", "getKillRegState", "(", "DestLo", ".", "isDead", "(", ")", ")", ")", ".", "addReg", "(", "DesiredLoReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "StatusReg", ")", ".", "addUse", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addUse", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DestHi", ".", "getReg", "(", ")", ",", "getKillRegState", "(", "DestHi", ".", "isDead", "(", ")", ")", ")", ".", "addReg", "(", "DesiredHiReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "StatusReg", ")", ".", "addUse", "(", "StatusReg", ",", "RegState", "::", "Kill", ")", ".", "addUse", "(", "StatusReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addUse", "(", "StatusReg", ",", "getKillRegState", "(", "StatusDead", ")", ")", ".", "addMBB", "(", "DoneBB", ")", ";", "LoadCmpBB", "->", "addSuccessor", "(", "DoneBB", ")", ";", "LoadCmpBB", "->", "addSuccessor", "(", "StoreBB", ")", ";", "BuildMI", "(", "StoreBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "StatusReg", ")", ".", "addReg", "(", "NewLoReg", ")", ".", "addReg", "(", "NewHiReg", ")", ".", "addReg", "(", "AddrReg", ")", ";", "BuildMI", "(", "StoreBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "StatusReg", ",", "getKillRegState", "(", "StatusDead", ")", ")", ".", "addMBB", "(", "LoadCmpBB", ")", ";", "StoreBB", "->", "addSuccessor", "(", "LoadCmpBB", ")", ";", "StoreBB", "->", "addSuccessor", "(", "DoneBB", ")", ";", "DoneBB", "->", "splice", "(", "DoneBB", "->", "end", "(", ")", ",", "&", "MBB", ",", "MI", ",", "MBB", ".", "end", "(", ")", ")", ";", "DoneBB", "->", "transferSuccessors", "(", "&", "MBB", ")", ";", "MBB", ".", "addSuccessor", "(", "LoadCmpBB", ")", ";", "NextMBBI", "=", "MBB", ".", "end" ]

[ "(", ")", "const", "{" ]

[ "bool", "SPIRVSubtarget", "::", "canDirectlyComparePointers" ]

[ "return", "true", ";" ]

[ "case", "ARM", "::", "fixup_t2_uncondbranch", ":", "case", "ARM", "::", "fixup_arm_thumb_bl", ":", "case", "ARM", "::", "fixup_arm_thumb_blx", ":", "RelocType", "=", "unsigned", "(", "MachO", "::", "ARM_THUMB_RELOC_BR22", ")", ";", "Log2Size", "=", "llvm", "::", "Log2_32", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "ARM", "::", "fixup_arm_movt_hi16", ":", "RelocType", "=", "unsigned", "(", "MachO", "::", "ARM_RELOC_HALF", ")", ";", "Log2Size", "=", "<NUM_LIT>", ";", "return", "true", ";", "case", "ARM", "::", "fixup_t2_movt_hi16", ":", "RelocType", "=", "unsigned", "(", "MachO", "::", "ARM_RELOC_HALF", ")", ";", "Log2Size", "=", "<NUM_LIT>", ";", "return", "true", ";", "case", "ARM", "::", "fixup_arm_movw_lo16", ":", "RelocType", "=", "unsigned", "(", "MachO", "::", "ARM_RELOC_HALF", ")", ";", "Log2Size", "=", "<NUM_LIT>", ";" ]

[ ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "PSI", "SP_REGNO", ")", "(", "plus", ":", "PSI", "(", "reg", ":", "PSI", "FB_REGNO", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "PSI", "FB_REGNO", ")", "(", "mem", ":", "PSI", "(", "reg", ":", "PSI", "FB_REGNO", ")", ")", ")", "(", "return", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ ")", "]" ]

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

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "OperandType", "{", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "HasImm", "=", "hasImm", ";", "let", "immOpNum", "=", "!", "if", "(", "hasImm", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "DLLExportedFns", ".", "insert", "(", "Mang", "->", "getMangledName", "(", "F", ")", ")", ";", "<FIXE>" ]

[ "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "if", "(", "F", "->", "hasDLLExportLinkage", "(", ")", ")", "<BUGS>", "DLLExportedFns", ".", "insert", "(", "Mang", "->", "getValueName", "(", "F", ")", ")", ";", "<BUGE>", "emitFunctionHeader", "(", "MF", ")", ";" ]

[ "true", ";" ]

[ "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "AddrReg", "=", "constrainOperandRegClass", "(", "II", ",", "AddrReg", ",", "II", ".", "getNumDefs", "(", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "AddrReg", ")", ";", "for", "(", "auto", "*", "Succ", ":", "BI", "->", "successors", "(", ")", ")", "FuncInfo", ".", "MBB", "->", "addSuccessor", "(", "FuncInfo", ".", "MBBMap", "[", "Succ", "]", ")", ";", "return" ]

[ "}", ")" ]

[ "{", "gcc_assert", "(", "mode", "=", "=", "SFmode", ")", "return", "fp_high_losum_p", "(", "op", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "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>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "(", "BCRLir", "(", "icond2cc", "$", "cond", ")", ",", "<NUM_LIT>", ",", "(", "CMPULrr", "$", "r", ",", "$", "l", ")", ",", "bb", ":", "$", "addr", ")", ">", ";", "<FIXE>" ]

[ "def", ":", "Pat", "(", "brcc", "CCSIOp", ":", "$", "cond", ",", "i64", ":", "$", "l", ",", "i64", ":", "$", "r", ",", "bb", ":", "$", "addr", ")", ",", "(", "BCRLrr", "(", "icond2cc", "$", "cond", ")", ",", "$", "l", ",", "$", "r", ",", "bb", ":", "$", "addr", ")", ">", ";", "def", ":", "Pat", "(", "brcc", "CCUIOp", ":", "$", "cond", ",", "i64", ":", "$", "l", ",", "i64", ":", "$", "r", ",", "bb", ":", "$", "addr", ")", ",", "<BUGS>", "(", "BCRLir", "(", "icond2cc", "$", "cond", ")", ",", "<NUM_LIT>", ",", "(", "CMPrr", "$", "r", ",", "$", "l", ")", ",", "bb", ":", "$", "addr", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "brcc", "cond", ":", "$", "cond", ",", "f32", ":", "$", "l", ",", "f32", ":", "$", "r", ",", "bb", ":", "$", "addr", ")", ",", "(", "BCRSrr", "(", "fcond2cc", "$", "cond", ")", ",", "$", "l", ",", "$", "r", ",", "bb", ":", "$", "addr", ")", ">", ";", "def", ":", "Pat", "(", "brcc", "cond", ":", "$", "cond", ",", "f64", ":", "$", "l", ",", "f64", ":", "$", "r", ",", "bb", ":", "$", "addr", ")", "," ]

[ "void", "MipsTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "Size", ",", "Align", "Alignment", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFL", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "assert", "(", "Size", "&&", "<STR_LIT>", "Byval argument's size shouldn't be 0.", "<STR_LIT>", ")", ";", "Alignment", "=", "std", "::", "min", "(", "Alignment", ",", "TFL", "->", "getStackAlign", "(", ")", ")", ";", "unsigned", "FirstReg", "=", "<NUM_LIT>", ";", "unsigned", "NumRegs", "=", "<NUM_LIT>", ";", "if", "(", "State", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "Fast", ")", "{", "unsigned", "RegSizeInBytes", "=", "Subtarget", ".", "getGPRSizeInBytes", "(", ")", ";", "ArrayRef", "<", "MCPhysReg", ">", "IntArgRegs", "=", "ABI", ".", "GetByValArgRegs", "(", ")", ";", "const", "MCPhysReg", "*", "ShadowRegs", "=", "ABI", ".", "IsO32", "(", ")", "?", "IntArgRegs", ".", "data", "(", ")", ":", "Mips64DPRegs", ";", "assert", "(", "Alignment", ">=", "Align", "(", "RegSizeInBytes", ")", "&&", "<STR_LIT>", "Byval argument's alignment should be a multiple of RegSizeInBytes.", "<STR_LIT>", ")", ";", "FirstReg", "=", "State", "->", "getFirstUnallocated", "(", "IntArgRegs", ")", ";", "if", "(", "(", "Alignment", ">", "RegSizeInBytes", ")", "&&", "(", "FirstReg", "%", "<NUM_LIT>", ")", ")", "{", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "FirstReg", "]", ",", "ShadowRegs", "[", "FirstReg", "]", ")", ";", "++", "FirstReg", ";", "}", "Size", "=", "alignTo", "(", "Size", ",", "RegSizeInBytes", ")", ";", "for", "(", "unsigned", "I", "=", "FirstReg", ";", "Size", ">", "<NUM_LIT>", "&&", "(", "I", "<", "IntArgRegs", ".", "size", "(", ")", ")", ";", "Size", "-=", "RegSizeInBytes", ",", "++", "I", ",", "++", "NumRegs", ")", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "I", "]", ",", "ShadowRegs", "[", "I", "]", ")", ";", "}", "State", "->", "addInRegsParamInfo", "(", "FirstReg", ",", "FirstReg", "+", "NumRegs", ")", ";", "}" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

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

[ "def", "_D", ":", "NeonI_LDN_Lane", "<", "r", ",", "<NUM_LIT>", ",", "op0", ",", "!", "cast", "<", "RegisterOperand", ">", "(", "List", "#", "<STR_LIT>", ")", ",", "neon_uimm1_bare", ",", "asmop", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ",", "i32", ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "i32", ">", "]", ">", ";" ]

[ "def", "SDT_AArch64Brcond", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVT", "<", "<NUM_LIT>", ",", "OtherVT", ">", ",", "SDTCisVT", "<", "<NUM_LIT>" ]

[ "}", ")" ]

[ "s390_expand_tbegin", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "NULL_RTX", ",", "true", ")", "DONE" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_unpackhi_ps", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_unpckhps128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_", "v4sf", ")", "_", "mm_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

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

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

[ "X86Mem64AsmOperand", "]", ";" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "SuperClasses", "=", "[" ]

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

[ "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "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>", ";" ]

[ "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "ARMTargetLowering", "::", "findRepresentativeClass", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "nullptr", ";", "uint8_t", "Cost", "=", "<NUM_LIT>", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "TRI", ",", "VT", ")", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v8i8", ":", "case", "MVT", "::", "v4i16", ":", "case", "MVT", "::", "v2i32", ":", "case", "MVT", "::", "v1i64", ":", "case", "MVT", "::", "v2f32", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "if", "(", "Subtarget", "->", "useNEONForSinglePrecisionFP", "(", ")", ")", "Cost", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v4i64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v8i64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "<NUM_LIT>", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "}" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "CN", "->", "getAlignment", "(", ")", ",", "MVT", "::", "i32", ")", ")", ";", "case", "CodeModel", "::", "Large", ":", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Only small and large code models supported now", "<STR_LIT>", ")", ";", "}" ]

[ "}" ]

[ "SHUXIMCInstLower", "(", "MCContext", "&", "Ctx", ",", "AsmPrinter", "&", "Printer", ")", ":", "Ctx", "(", "Ctx", ")", ",", "Printer", "(", "Printer", ")", "{", "}", "void", "Lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", ";", "MCOperand", "LowerSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCSymbol", "*", "Sym", ")", "const", ";", "MCSymbol", "*", "GetGlobalAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";" ]

[ "<FIXS>", "def", ":", "WriteRes", "WriteVecMove", ",", "[", "AtomPort0", "]", ">", ";", "<FIXE>" ]

[ "def", ":", "WriteRes", "WriteVecMaskedStore", ",", "[", "AtomPort0", "]", ">", ";", "def", ":", "WriteRes", "WriteVecMaskedStoreY", ",", "[", "AtomPort0", "]", ">", ";", "<BUGS>", "def", ":", "WriteRes", "WriteVecMove", ",", "[", "AtomPort01", "]", ">", ";", "<BUGE>", "def", ":", "WriteRes", "WriteVecMoveX", ",", "[", "AtomPort01", "]", ">", ";", "def", ":", "WriteRes", "WriteVecMoveY", ",", "[", "AtomPort01", "]", ">", ";", "defm", ":", "AtomWriteResPair", "WriteVecALU", ",", "[", "AtomPort01", "]", ",", "[", "AtomPort0", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "defm", ":", "AtomWriteResPair", "WriteVecALUX", ",", "[", "AtomPort01", "]", ",", "[", "AtomPort0", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";" ]

[ ">", ";" ]

[ "class", "AVE_S_B_ENC", ":", "MSA_3R_FMT", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

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

[ "const", "BasicBlock", "*", "BB", "=", "FuncInfo", "->", "MBB", "->", "getBasicBlock", "(", ")", ";", "const", "Instruction", "*", "BBTerm", "=", "BB", "->", "getTerminator", "(", ")", ";", "if", "(", "BBTerm", "->", "getNumSuccessors", "(", ")", "!=", "<NUM_LIT>", ")", "return", "PPC", "::", "BR_NO_HINT", ";", "const", "BasicBlock", "*", "TBB", "=", "BBTerm", "->", "getSuccessor", "(", "<NUM_LIT>", ")", ";", "const", "BasicBlock", "*", "FBB", "=", "BBTerm", "->", "getSuccessor", "(", "<NUM_LIT>", ")", ";", "auto", "TProb", "=", "FuncInfo", "->", "BPI", "->", "getEdgeProbability", "(", "BB", ",", "TBB", ")", ";", "auto", "FProb", "=", "FuncInfo", "->", "BPI", "->", "getEdgeProbability", "(", "BB", ",", "FBB", ")", ";", "const", "uint32_t", "Threshold" ]

[ "<FIXS>", "tmp", "=", "<STR_LIT>", "ssesuffix", "=", "<STR_LIT>", "<FIXE>" ]

[ "case", "MODE_V8SF", ":", "gcc_assert", "(", "TARGET_AVX", ")", "case", "MODE_V4SF", ":", "gcc_assert", "(", "TARGET_SSE", ")", "<BUGS>", "tmp", "=", "<STR_LIT>", "ssesuffix", "=", "<STR_LIT>", "<BUGE>", "breakdefault", ":" ]

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

[ "(", "define_cpu_unit" ]

[ "}" ]

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

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=" ]

[ "}" ]

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

[ "DotSym", ",", "OutContext", ")", ";" ]

[ "}", "else", "if", "(", "NumBytes", "<", "<NUM_LIT>", ")", "{", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "STI", ")", ";", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "NumBytes", "<", "<NUM_LIT>", ")", "{", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ",", "STI", ")", ";", "return", "<NUM_LIT>", ";", "}", "else", "{", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "createTempSymbol", "(", ")", ";", "const", "MCSymbolRefExpr", "*", "Dot", "=", "MCSymbolRefExpr", "::", "create", "(" ]

[ "false", ";" ]

[ "ModuleDirectiveAllowed", "=" ]

[ "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";" ]

[ "case", "ISD", "::", "ADD", ":", "return", "combineAdd", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "combineSub", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineX86AddSub", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineSBB", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineADC", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "combineMul", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "combineShiftLeft", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "return", "combineShiftRightArithmetic", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "combineShiftRightLogical", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "combineAnd", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "combineOr", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "combineXor", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineBEXTR", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "combineLoad", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MLOAD", ":", "return", "combineMaskedLoad", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "combineStore", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MSTORE", ":", "return", "combineMaskedStore", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVEXTRACT_STORE", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "STRICT_SINT_TO_FP", ":", "return", "combineSIntToFP", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "case", "ISD", "::", "STRICT_UINT_TO_FP", ":", "return", "combineUIntToFP", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "FSUB", ":", "return", "combineFaddFsub", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FNEG", ":", "return", "combineFneg", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "combineTruncate", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVTRUNC", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineAndnp", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineFAnd", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineFAndn", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineFOr", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineFMinFMax", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "return", "combineFMinNumFMaxNum", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineX86INT_TO_FP", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "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>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineCVTP2I_CVTTP2I", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineCVTPH2PS", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineBT", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZext", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSext", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "combineSignExtendInReg", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ANY_EXTEND_VECTOR_INREG", ":", "case", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ":", "case", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", ":", "return", "combineEXTEND_VECTOR_INREG", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "combineSetCC", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineX86SetCC", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineBrCond", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVectorPack", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVectorHADDSUB", "(" ]

[ "bool", "ARMTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "const", "Type", "*", "Ty", ")", "const", "{", "if", "(", "!", "isLegalAddressImmediate", "(", "AM", ".", "BaseOffs", ",", "getValueType", "(", "Ty", ",", "true", ")", ",", "Subtarget", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "<NUM_LIT>", ":", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "false", ";", "default", ":", "if", "(", "AM", ".", "BaseOffs", ")", "return", "false", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "switch", "(", "getValueType", "(", "Ty", ")", ".", "getSimpleVT", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "if", "(", "Scale", "<", "<NUM_LIT>", ")", "Scale", "=", "-", "Scale", ";", "if", "(", "Scale", "==", "<NUM_LIT>", ")", "return", "true", ";", "return", "isPowerOf2_32", "(", "Scale", "&", "~", "<NUM_LIT>", ")", ";", "case", "MVT", "::", "i16", ":", "if", "(", "(", "(", "unsigned", ")", "AM", ".", "HasBaseReg", "+", "Scale", ")", "<=", "<NUM_LIT>", ")", "return", "true", ";", "return", "false", ";", "case", "MVT", "::", "isVoid", ":", "if", "(", "AM", ".", "Scale", "&", "<NUM_LIT>", ")", "return", "false", ";", "return", "isPowerOf2_32", "(", "AM", ".", "Scale", ")", ";", "}", "break", ";", "}", "return", "true", ";", "}" ]

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

[ "<FIXS>", "enum", "insn_code", "icode", "=", "(", "enum", "insn_code", ")", "d", "->", "icode", ";", "<FIXE>" ]

[ "expand_builtin_args", "(", "struct", "spu_builtin_description", "*", "d", ",", "tree", "exp", ",", "rtx", "target", ",", "rtx", "ops", "[", "]", ")", "{", "<BUGS>", "enum", "insn_code", "icode", "=", "d", "->", "icode", ";", "<BUGE>", "int", "i", "=", "<NUM_LIT>", ",", "a", ";" ]

[ "}" ]

[ "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "M0", "&&", "<STR_LIT>", "m0 should not be spilled", "<STR_LIT>", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC", "&&", "<STR_LIT>", "exec should not be spilled", "<STR_LIT>", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ",", "NeedsCFI", ")", ")", ";", "if", "(", "SrcReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "<NUM_LIT>", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillSaveOpcode", "(", "SpillSize", ",", "NeedsCFI", ")", ":", "getVGPRSpillSaveOpcode", "(", "SpillSize", ",", "NeedsCFI", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "SI", "DI", "]", ")" ]

[ "(", "define_mode_iterator", "GPI", "[" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Unexpected operand", "<STR_LIT>", ")", ";" ]

[ "switch", "(", "e", ")", "{", "CASE", "(", "SamplerFilterMode", ",", "Nearest", ")", "CASE", "(", "SamplerFilterMode", ",", "Linear", ")", "break", ";", "}" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sign_extend", ":", "GPR", "(", "match_operand", ":", "SHORT", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "BNE", ")", ")", ".", "addReg", "(", "MaskedOldVal0", ")", ".", "addReg", "(", "ShiftedCmpVal", ")", ".", "addMBB", "(", "sinkMBB", ")", ";" ]

[ "}", "else", "{", "unsigned", "Off", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "XORi", ")", ",", "Off", ")", ".", "addReg", "(", "PtrLSB2", ")", ".", "addImm", "(", "(", "Size", "==", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SLL", ")", ",", "ShiftAmt", ")", ".", "addReg", "(", "Off", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ORi", ")", ",", "MaskUpper", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "MaskImm", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SLLV", ")", ",", "Mask", ")", ".", "addReg", "(", "MaskUpper", ")", ".", "addReg", "(", "ShiftAmt", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "NOR", ")", ",", "Mask2", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addReg", "(", "Mask", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ANDi", ")", ",", "MaskedCmpVal", ")", ".", "addReg", "(", "CmpVal", ")", ".", "addImm", "(", "MaskImm", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SLLV", ")", ",", "ShiftedCmpVal", ")", ".", "addReg", "(", "MaskedCmpVal", ")", ".", "addReg", "(", "ShiftAmt", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ANDi", ")", ",", "MaskedNewVal", ")", ".", "addReg", "(", "NewVal", ")", ".", "addImm", "(", "MaskImm", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SLLV", ")", ",", "ShiftedNewVal", ")", ".", "addReg", "(", "MaskedNewVal", ")", ".", "addReg", "(", "ShiftAmt", ")", ";", "BB", "=", "loop1MBB", ";", "unsigned", "LL", "=", "isMicroMips", "?", "Mips", "::", "LL_MM", ":", "Mips", "::", "LL", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "LL", ")", ",", "OldVal", ")", ".", "addReg", "(", "AlignedAddr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "AND", ")", ",", "MaskedOldVal0", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "Mask", ")", ";" ]

[ "count", "(", "MI", ")", ";", "}" ]

[ "bool", "wasVisited", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "return", "Types", ".", "count", "(", "MI", ")", ";", "}", "bool", "wasVisited", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "return", "Types", "." ]

[ "ix86_expand_vec_extract_even_odd", "(", "operands", "[", "<NUM_LIT>", "]", ",", "op1", ",", "op2", ",", "<NUM_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "<", "mmxpackmode", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MMXMODE24", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MMXMODE24", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "op1", "=", "gen_lowpart", "(", "<", "mmxpackmode", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "rtx", "op2", "=", "gen_lowpart", "(", "<", "mmxpackmode", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

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

[ "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "SI", "(", "sign_extend", ":", "SI", "(", "vec_select", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "zero_extend", ":", "SI", "(", "vec_select", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

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

[ "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", ")", "(", "define_insn", "<STR_LIT>" ]

[ ")", "]" ]

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

[ "}" ]

[ "const", "MCRegisterInfo", "*", "getRegInfo", "(", ")", "const", "{", "return", "RegInfo", ";" ]

[ "<FIXS>", "const", "static", "MCFixupKindInfo", "LittleEndianInfos", "[", "]", "=", "{", "<FIXE>" ]

[ "const", "MCFixupKindInfo", "&", "MipsAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "<BUGS>", "const", "static", "MCFixupKindInfo", "LittleEndianInfos", "[", "Mips", "::", "NumTargetFixupKinds", "]", "=", "{", "<BUGE>" ]

[ "||", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "arm_mve_vctp16", "||", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "arm_mve_vctp32", "||", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "arm_mve_vctp64", ";" ]

[ "}", "const", "SCEV", "*", "TripCountSCEV", "=", "SE", ".", "getAddExpr", "(", "BackedgeTakenCount", ",", "SE", ".", "getOne", "(", "BackedgeTakenCount", "->", "getType", "(", ")", ")", ")", ";", "if", "(", "SE", ".", "getUnsignedRangeMax", "(", "TripCountSCEV", ")", ".", "getBitWidth", "(", ")", ">", "<NUM_LIT>", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARMHWLoops: Trip count does not fit into 32bits\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "auto", "IsHardwareLoopIntrinsic", "=", "[", "]", "(", "Instruction", "&", "I", ")", "{", "if", "(", "auto", "*", "Call", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ")", "{", "switch", "(", "Call", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "start_loop_iterations", ":", "case", "Intrinsic", "::", "test_start_loop_iterations", ":", "case", "Intrinsic", "::", "loop_decrement", ":", "case", "Intrinsic", "::", "loop_decrement_reg", ":", "return", "true", ";", "}", "}", "return", "false", ";", "}", ";", "bool", "IsTailPredLoop", "=", "false", ";", "auto", "ScanLoop", "=", "[", "&", "]", "(", "Loop", "*", "L", ")", "{", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "maybeLoweredToCall", "(", "I", ")", "||", "IsHardwareLoopIntrinsic", "(", "I", ")", "||", "isa", "<", "InlineAsm", ">", "(", "I", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARMHWLoops: Bad instruction: ", "<STR_LIT>", "<<", "I", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "auto", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ")", "IsTailPredLoop", "|=", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "get_active_lane_mask", "||", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "arm_mve_vctp8" ]

[ "SwitchToLine", "(", "DL", ".", "getLine", "(", ")", ",", "IsInBeginFunction", ")", ";" ]

[ "assert", "(", "!", "DL", ".", "isUnknown", "(", ")", "&&", "<STR_LIT>", "can't change to invalid debug loc", "<STR_LIT>", ")", ";", "SwitchToCU", "(", "DL", ".", "getScope", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ")", ";" ]

[ "}" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "if", "(", "M", "[", "i", "]", ">=", "<NUM_LIT>", "&&", "M", "[", "i", "]", "!=", "(", "int", ")", "(", "NumElts", "-", "<NUM_LIT>", "-", "i", ")", ")", "return", "false", ";", "return", "true", ";" ]

[ "<FIXS>", "static", "void", "cr16_print_operand_address", "(", "FILE", "*", ",", "machine_mode", ",", "rtx", ")", ";", "<FIXE>" ]

[ "static", "void", "cr16_print_operand", "(", "FILE", "*", ",", "rtx", ",", "int", ")", ";", "<BUGS>", "static", "void", "cr16_print_operand_address", "(", "FILE", "*", ",", "rtx", ")", ";", "<BUGE>", "#", "undef", "TARGET_STRUCT_VALUE_RTX" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd32", ";" ]

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CCU", "CC_REGNUM", ")", "(", "compare", ":", "CCU", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "match_operand" ]

[ ",", "simm32", ">", ";" ]

[ "def", "AFI", ":", "BinaryRIL", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "add", ",", "GR32" ]

[ ",", "EndIndex", ")", ";" ]

[ "if", "(", "AntiDepBreak", "!=", "NULL", ")", "AntiDepBreak", "->", "Observe", "(", "MI", ",", "Count" ]

[ ";" ]

[ "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>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>" ]

[ "<FIXS>", "aarch64_vfp_is_call_candidate", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "<FIXE>" ]

[ "}", "static", "bool", "<BUGS>", "aarch64_vfp_is_call_candidate", "(", "cumulative_args_t", "pcum_v", ",", "enum", "machine_mode", "mode", ",", "<BUGE>", "const_tree", "type", ",", "int", "*", "nregs", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";" ]

[ "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "N", ")", ";" ]

[ "case", "ISD", "::", "SMUL_LOHI", ":", "return", "selectMultiplication", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "select", "<", "ISD", "::", "STORE", ">", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "select", "<", "ISD", "::", "LOAD", ">", "(", "N", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "select", "<" ]

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

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

[ "}" ]

[ "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "unsigned", "NumLoBits", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "Known", ".", "Zero", ".", "setBitsFrom", "(", "NumLoBits", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "if", "(", "auto", "*", "ShiftImm", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "ShiftImm", "->", "getAPIntValue", "(", ")", ".", "uge", "(", "VT", ".", "getScalarSizeInBits", "(", ")", ")", ")", "{", "Known", ".", "setAllZero", "(", ")", ";", "break", ";", "}", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Known", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "unsigned", "ShAmt", "=", "ShiftImm", "->", "getZExtValue", "(", ")", ";", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "Known", ".", "Zero", "<<=", "ShAmt", ";", "Known", ".", "One", "<<=", "ShAmt", ";", "Known", ".", "Zero", ".", "setLowBits", "(", "ShAmt", ")", ";", "}", "else", "{", "Known", ".", "Zero", ".", "lshrInPlace", "(", "ShAmt", ")", ";", "Known", ".", "One", ".", "lshrInPlace", "(", "ShAmt", ")", ";", "Known", ".", "Zero", ".", "setHighBits", "(", "ShAmt", ")", ";", "}" ]

[ "<FIXS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "imm", "*", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "int", "imm", "=", "Val", "&", "<NUM_LIT>", ";", "if", "(", "!", "(", "Val", "&", "<NUM_LIT>", ")", ")", "imm", "*=", "-", "<NUM_LIT>", ";", "<BUGS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "imm", "<<", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}", "return", "MCDisassembler", "::", "Success", ";" ]

[ "if", "(", "reg", "<", "CSKY_NPARM_REGS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "CSKY_FIRST_PARM_REGNUM", "+", "reg", ")", ";" ]

[ "int", "reg", "=", "pcum", "->", "reg", ";", "machine_mode", "mode", "=", "arg", ".", "mode", ";", "if", "(", "FUNCTION_VARG_MODE_P", "(", "mode", ")", "&&", "!", "pcum", "->", "is_stdarg", ")", "{", "reg", "=", "pcum", "->", "freg", ";", "if", "(", "reg", "<", "CSKY_NPARM_FREGS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "CSKY_FIRST_VFP_REGNUM", "+", "reg", ")", ";", "else", "return", "NULL_RTX", ";", "}" ]

[ "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "bool", "NeedFence", "=", "true", ";", "bool", "Is64Bit", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR32", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR32", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKDOWN", ")", "NeedFence", "=", "false", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "NeedFence", "=", "true", ";", "++", "I", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "TLS Dynamic Call Fixup:\\n ", "<STR_LIT>", "<<", "MI", ")", ";", "unsigned", "OutReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "InReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "GPR3", "=", "Is64Bit", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "unsigned", "Opc1", ",", "Opc2", ";", "const", "unsigned", "OrigRegs", "[", "]", "=", "{", "OutReg", ",", "InReg", ",", "GPR3", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Opcode inconsistency error", "<STR_LIT>", ")", ";", "case", "PPC", "::", "ADDItlsgdLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsgdLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL32", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR32", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL32", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR32", ";", "break", ";", "}", "if", "(", "NeedFence", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKDOWN", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MachineInstr", "*", "Addi", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc1", ")", ",", "GPR3", ")", ".", "addReg", "(", "InReg", ")", ";", "Addi", "->", "addOperand", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "First", "=", "I", ";", "--", "First", ";", "MachineInstr", "*", "Call", "=", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc2", ")", ",", "GPR3", ")", ".", "addReg", "(", "GPR3", ")", ")", ";", "Call", "->", "addOperand", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "NeedFence", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKUP", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "OutReg", ")", ".", "addReg", "(", "GPR3", ")", ";", "MachineBasicBlock", "::", "iterator", "Last", "=", "I", ";", "--", "Last", ";", "++", "I", ";", "MI", ".", "removeFromParent", "(", ")", ";", "LIS", "->", "repairIntervalsInRange", "(", "&", "MBB", ",", "First", ",", "Last", ",", "OrigRegs", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ ";" ]

[ "static", "SDValue", "LowerBuildVectorv4x32", "(", "SDValue", "Op", ",", "unsigned", "NumElems", ",", "unsigned", "NonZeros", ",", "unsigned", "NumNonZero", ",", "unsigned", "NumZero", ",", "SelectionDAG", "&", "DAG", ",", "const", "X86Subtarget", "*", "Subtarget", ",", "const", "TargetLowering", "&", "TLI", ")", "{", "unsigned", "FirstNonZeroIdx", "=", "<NUM_LIT>", ";", "SDValue", "FirstNonZero", "=", "Op", "->", "getOperand", "(", "FirstNonZeroIdx", ")", ";", "while", "(", "FirstNonZero", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", "||", "X86", "::", "isZeroNode", "(", "FirstNonZero", ")", ")", "{", "++", "FirstNonZeroIdx", ";", "FirstNonZero", "=", "Op", "->", "getOperand", "(", "FirstNonZeroIdx", ")", ";", "}", "if", "(", "FirstNonZero", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", "||", "!", "isa", "<", "ConstantSDNode", ">", "(", "FirstNonZero", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "V", "=", "FirstNonZero", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MVT", "VVT", "=", "V", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "hasSSE41", "(", ")", "||", "(", "VVT", "!=", "MVT", "::", "v4f32", "&&", "VVT", "!=", "MVT", "::", "v4i32", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "FirstNonZeroDst", "=", "cast", "<", "ConstantSDNode", ">", "(", "FirstNonZero", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "CorrectIdx", "=", "FirstNonZeroDst", "==", "FirstNonZeroIdx", ";", "unsigned", "IncorrectIdx", "=", "CorrectIdx", "?", "-", "<NUM_LIT>", "U", ":", "FirstNonZeroIdx", ";", "unsigned", "IncorrectDst", "=", "CorrectIdx", "?", "-", "<NUM_LIT>", "U", ":", "FirstNonZeroDst", ";", "for", "(", "unsigned", "Idx", "=", "FirstNonZeroIdx", "+", "<NUM_LIT>", ";", "Idx", "<", "NumElems", ";", "++", "Idx", ")", "{", "SDValue", "Elem", "=", "Op", ".", "getOperand", "(", "Idx", ")", ";", "if", "(", "Elem", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", "||", "X86", "::", "isZeroNode", "(", "Elem", ")", ")", "continue", ";", "if", "(", "Elem", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "return", "SDValue", "(", ")", ";", "if", "(", "Elem", ".", "getOperand", "(", "<NUM_LIT>", ")", "!=", "V", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Dst", "=", "cast", "<", "ConstantSDNode", ">", "(", "Elem", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "Dst", "==", "Idx", ")", "++", "CorrectIdx", ";", "else", "if", "(", "IncorrectIdx", "==", "-", "<NUM_LIT>", "U", ")", "{", "IncorrectIdx", "=", "Idx" ]

[ ";" ]

[ "if", "(", "TYPE_PACKED", "(", "type", ")", "||", "align", ">=", "<NUM_LIT>", ")", "return", "align", ";", "do", "{", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", "||", "DECL_FIELD_ABI_IGNORED", "(", "field", ")", ")", ")", "field", "=", "DECL_CHAIN", "(", "field", ")", ";", "if", "(", "!", "field", ")", "break", ";", "if", "(", "DECL_PACKED", "(", "field", ")", ")", "return", "align", ";", "type", "=", "TREE_TYPE", "(", "field", ")", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "}", "while", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "type", "!=", "error_mark_node", "&&", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "||", "TYPE_MODE", "(", "type", ")", "==", "DCmode", ")", ")", "align", "=", "MAX", "(", "align", ",", "<NUM_LIT>", ")", ";", "return", "align" ]

[ "::", "Small", ":", "CodeModel", "::", "Medium", ";" ]

[ "switch", "(", "CM", ")", "{", "default", ":", "break", ";", "case", "CodeModel", "::", "Default", ":", "CM", "=", "RM", "==", "Reloc", "::", "PIC_", "?", "CodeModel" ]

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

[ "print_rtl_with_bb", "(", "dump_file", ",", "get_insns", "(", ")", ",", "TDF_NONE", ")", ";", "fprintf", "(", "dump_file", ",", "<STR_LIT>", "\\n======================================================================\\n", "<STR_LIT>", ")", ";", "}", "rl78_remove_unused_sets", "(", ")", ";", "df_finish_pass", "(", "true", ")", ";", "if", "(", "optimize", ">", "<NUM_LIT>", ")", "df_live_add_problem" ]

[ "if", "(", "Tok1", ".", "is", "(", "AsmToken", "::", "Dollar", ")", ")", "{" ]

[ "NMXOperand", "&", "Mnemonic", "=", "static_cast", "<", "NMXOperand", "&", ">", "(", "*", "Operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "Mnemonic", ".", "getToken", "(", ")", "==", "<STR_LIT>", "la", "<STR_LIT>", ")", "{", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "NMXOperand", "::", "CreateImm", "(", "IdVal", ",", "S", ",", "E", ")", ")", ";", "return", "MatchOperand_Success", ";", "}", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "'(' expected", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "const", "AsmToken", "&", "Tok1", "=", "Parser", ".", "getTok", "(", ")", ";" ]

[ "AArch64 Address Type Promotion", "<STR_LIT>", ";" ]

[ "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>" ]

[ "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vplzcntq_128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "<NUM_LIT>", ")", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup" ]

[ "}" ]

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

[ "SD", ".", "setExternal", "(", "false", ")", ";" ]

[ "EmitLabel", "(", "Start", ")", ";", "MCSymbol", "*", "Symbol", "=", "getContext", "(", ")", ".", "GetOrCreateSymbol", "(", "Name", "+", "<STR_LIT>", ".", "<STR_LIT>", "+", "Twine", "(", "MappingSymbolCounter", "++", ")", ")", ";", "MCSymbolData", "&", "SD", "=", "getAssembler", "(", ")", ".", "getOrCreateSymbolData", "(", "*", "Symbol", ")", ";", "MCELF", "::", "SetType", "(", "SD", ",", "ELF", "::", "STT_NOTYPE", ")", ";", "MCELF", "::", "SetBinding", "(", "SD", ",", "ELF", "::", "STB_LOCAL", ")", ";" ]

[ "SImode", ")" ]

[ "{", "rtx", "system_reg", "rtx", "temp_reg", "=", "gen_reg_rtx", "(" ]

[ "<FIXS>", "for", "(", "MVT", "InnerVT", ":", "MVT", "::", "fixedlen_vector_valuetypes", "(", ")", ")", "{", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "ROTL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "VT", ",", "Expand", ")", ";", "<BUGS>", "for", "(", "MVT", "InnerVT", ":", "MVT", "::", "vector_valuetypes", "(", ")", ")", "{", "<BUGE>", "setTruncStoreAction", "(", "VT", ",", "InnerVT", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "VT", ",", "InnerVT", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "VT", ",", "InnerVT", ",", "Expand", ")", ";" ]

[ "CRm", ")", ";" ]

[ "_", "_", "arm_mcrr2", "(", "const", "unsigned", "int", "_", "_", "coproc", ",", "const", "unsigned", "int", "_", "_", "opc1", ",", "uint64_t", "_", "_", "value", ",", "const", "unsigned", "int", "_", "_", "CRm", ")", "{", "_", "_", "builtin_arm_mcrr2", "(", "_", "_", "coproc", ",", "_", "_", "opc1", ",", "_", "_", "value", ",", "_", "_" ]

[ "<STR_LIT>" ]

[ "(", "define_memory_constraint" ]

[ "if", "(", "matchShuffleWithUNPCK", "(", "MaskVT", ",", "V1", ",", "V2", ",", "Shuffle", ",", "IsUnary", ",", "Mask", ",", "DL", ",", "DAG", ",", "Subtarget", ")", ")", "{" ]

[ "if", "(", "isTargetShuffleEquivalent", "(", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", "&&", "AllowFloatDomain", ")", "{", "V2", "=", "V1", ";", "V1", "=", "(", "SM_SentinelUndef", "==", "Mask", "[", "<NUM_LIT>", "]", "?", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v4f32", ")", ":", "V1", ")", ";", "Shuffle", "=", "Subtarget", ".", "hasSSE2", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "SrcVT", "=", "DstVT", "=", "Subtarget", ".", "hasSSE2", "(", ")", "?", "MVT", "::", "v2f64", ":", "MVT", "::", "v4f32", ";", "return", "true", ";", "}", "if", "(", "isTargetShuffleEquivalent", "(", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", "&&", "AllowFloatDomain", ")", "{", "V2", "=", "V1", ";", "Shuffle", "=", "Subtarget", ".", "hasSSE2", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "SrcVT", "=", "DstVT", "=", "Subtarget", ".", "hasSSE2", "(", ")", "?", "MVT", "::", "v2f64", ":", "MVT", "::", "v4f32", ";", "return", "true", ";", "}", "if", "(", "isTargetShuffleEquivalent", "(", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "(", "AllowFloatDomain", "||", "!", "Subtarget", ".", "hasSSE41", "(", ")", ")", ")", "{", "std", "::", "swap", "(", "V1", ",", "V2", ")", ";", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SrcVT", "=", "DstVT", "=", "MVT", "::", "v2f64", ";", "return", "true", ";", "}", "if", "(", "isTargetShuffleEquivalent", "(", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", "&&", "(", "AllowFloatDomain", "||", "!", "Subtarget", ".", "hasSSE41", "(", ")", ")", ")", "{", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SrcVT", "=", "DstVT", "=", "MVT", "::", "v4f32", ";", "return", "true", ";", "}", "}", "if", "(", "(", "(", "MaskVT", "==", "MVT", "::", "v8i16", "||", "MaskVT", "==", "MVT", "::", "v16i8", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "||", "(", "(", "MaskVT", "==", "MVT", "::", "v16i16", "||", "MaskVT", "==", "MVT", "::", "v32i8", ")", "&&", "Subtarget", ".", "hasInt256", "(", ")", ")", "||", "(", "(", "MaskVT", "==", "MVT", "::", "v32i16", "||", "MaskVT", "==", "MVT", "::", "v64i8", ")", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", "{", "if", "(", "matchShuffleWithPACK", "(", "MaskVT", ",", "SrcVT", ",", "V1", ",", "V2", ",", "Shuffle", ",", "Mask", ",", "DAG", ",", "Subtarget", ")", ")", "{", "DstVT", "=", "MaskVT", ";", "return", "true", ";", "}", "}", "if", "(", "(", "MaskVT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "MaskVT", ".", "is128BitVector", "(", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "||", "(", "MaskVT", ".", "is256BitVector", "(", ")", "&&", "<NUM_LIT>", "<=", "EltSizeInBits", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", "||", "(", "MaskVT", ".", "is256BitVector", "(", ")", "&&", "Subtarget", ".", "hasAVX2", "(", ")", ")", "||", "(", "MaskVT", ".", "is512BitVector", "(", ")", "&&", "Subtarget", ".", "hasAVX512", "(", ")", ")", ")", "{" ]

[ "dataLayout", "+=", "<STR_LIT>", "-i16:16:32", "<STR_LIT>", ";" ]

[ "static", "std", "::", "string", "computeDataLayout", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "const", "TargetOptions", "&", "Options", ")", "{", "std", "::", "string", "dataLayout", "=", "<STR_LIT>", "<STR_LIT>", ";", "dataLayout", "+=", "<STR_LIT>", "e", "<STR_LIT>", ";", "dataLayout", "+=", "<STR_LIT>", "-m:e", "<STR_LIT>", ";", "dataLayout", "+=", "<STR_LIT>", "-p:32:32", "<STR_LIT>", ";", "dataLayout", "+=", "<STR_LIT>", "-i1:8:32", "<STR_LIT>", ";", "dataLayout", "+=", "<STR_LIT>", "-i8:8:32", "<STR_LIT>", ";" ]

[ "InfoElement", ")", ";" ]

[ "PHIInfoElementT", "*", "InfoElement", "=", "findPHIInfoElement", "(", "DestReg", ")", ";", "PHIInfo", ".", "erase", "(" ]

[ ")", ";" ]

[ "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "unexpected token in argument list", "<STR_LIT>", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", "&&", "parseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "unexpected token in argument list", "<STR_LIT>", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "{", "if", "(", "parseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "else", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", "&&", "parseParenSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "unexpected token in argument list", "<STR_LIT>" ]

[ ",", "TiedDest", ",", "isLds", ">", ";" ]

[ "def", "_IDXEN", ":", "MUBUF_Load_Pseudo", "<", "opName", ",", "BUFAddrKind", ".", "IdxEn", ",", "load_vt" ]