Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ ".", "_", "_", "i", ";" ]

[ "union", "{", "int64x1x3_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ei", "_", "_", "o", ";", "}", "_", "_", "rv", ";", "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_neon_vld3_dupdi", "(", "(", "const", "_", "_", "builtin_neon_di", "*", ")", "_", "_", "a", ")", ";", "return", "_", "_", "rv" ]

[ "TM", ")", ")", ";" ]

[ "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", ")", "addPass", "(", "createGlobalMergePass", "(" ]

[ ",", "true", ",", "false", ")", ";" ]

[ "if", "(", "LastLoadedElt", "==", "NumElems", "-", "<NUM_LIT>", ")", "{", "if", "(", "isAfterLegalize", "&&", "!", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isOperationLegal", "(", "ISD", "::", "LOAD", ",", "VT", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewLd", "=", "SDValue", "(", ")", ";", "NewLd", "=", "DAG", ".", "getLoad", "(", "VT", ",", "DL", ",", "LDBase", "->", "getChain", "(", ")", ",", "LDBase", "->", "getBasePtr", "(", ")", ",", "LDBase", "->", "getPointerInfo", "(", ")", ",", "LDBase", "->", "isVolatile", "(", ")", ",", "LDBase", "->", "isNonTemporal", "(", ")", ",", "LDBase", "->", "isInvariant", "(", ")", ",", "LDBase", "->", "getAlignment", "(", ")", ")", ";", "if", "(", "LDBase", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", ")", "{", "SDValue", "NewChain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "SDValue", "(", "LDBase", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "NewLd", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "LDBase", ",", "<NUM_LIT>", ")", ",", "NewChain", ")", ";", "DAG", ".", "UpdateNodeOperands", "(", "NewChain", ".", "getNode", "(", ")", ",", "SDValue", "(", "LDBase", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "NewLd", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "}", "return", "NewLd", ";", "}", "if", "(", "NumElems", "==", "<NUM_LIT>", "&&", "LastLoadedElt", "==", "<NUM_LIT>", "&&", "(", "EltVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "&&", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "MVT", "::", "v2i64", ")", ")", "{", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "v2i64", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "LDBase", "->", "getChain", "(", ")", ",", "LDBase", "->", "getBasePtr", "(", ")", "}", ";", "SDValue", "ResNode", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Tys", ",", "Ops", ",", "MVT", "::", "i64", ",", "LDBase", "->", "getPointerInfo", "(", ")", ",", "LDBase", "->", "getAlignment", "(", ")", ",", "false" ]

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

[ "inline", "static", "unsigned", "getXRegFromWReg", "(", "unsigned", "Reg", ")", "{", "switch", "(", "Reg", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>" ]

[ "}", ";" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>" ]

[ "}" ]

[ "class", "Enc_5ccba9", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "II", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Pv4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pv4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<FIXS>", "LiveMask", "|=", "getDefRegMask", "(", "MO", ",", "*", "MRI", ")", ";", "<FIXE>" ]

[ "continue", ";", "auto", "&", "LiveMask", "=", "LiveRegs", "[", "Reg", "]", ";", "auto", "PrevMask", "=", "LiveMask", ";", "<BUGS>", "LiveMask", "|=", "getDefRegMask", "(", "MO", ")", ";", "<BUGE>", "CurPressure", ".", "inc", "(", "Reg", ",", "PrevMask", ",", "LiveMask", ",", "*", "MRI", ")", ";", "}" ]

[ "const", "char", "*", "output_condmove_single", "(", "rtx", "operands", "[", "]", ",", "rtx", "insn", ")", "{", "rtx", "dest", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "src", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", "{", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "<STR_LIT>", "cmov %z3, %2, %1, %e0", "<STR_LIT>", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "return", "<STR_LIT>", "cmovfg %3, %2, %1, %e0", "<STR_LIT>", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_QImode", ":", "return", "<STR_LIT>", "cldsb%I3%U3 %M3, %2, %1, %e0", "<STR_LIT>", ";", "case", "E_HImode", ":", "return", "<STR_LIT>", "cldsh%I3%U3 %M3, %2, %1, %e0", "<STR_LIT>", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "<STR_LIT>", "cld%I3%U3 %M3, %2, %1, %e0", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "<STR_LIT>", "cmov %., %2, %1, %e0", "<STR_LIT>", ";", "}", "else", "if", "(", "FPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "<STR_LIT>", "cmovgf %3, %2, %1, %e0", "<STR_LIT>", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "TARGET_HARD_FLOAT", ")", "return", "<STR_LIT>", "cfmovs %3,%2,%1,%e0", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "cmor %3, %3, %2, %1, %e0", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", "return", "<STR_LIT>", "cldf%I3%U3 %M3, %2, %1, %e0", "<STR_LIT>", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "<STR_LIT>", "cmovgf %., %2, %1, %e0", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_QImode", ":", "return", "<STR_LIT>", "cstb%I2%U2 %3, %M2, %1, %e0", "<STR_LIT>", ";", "case", "E_HImode", ":", "return", "<STR_LIT>", "csth%I2%U2 %3, %M2, %1, %e0", "<STR_LIT>", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "<STR_LIT>", "cst%I2%U2 %3, %M2, %1, %e0", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "FPR_P", "(", "src_regno", ")", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", ")", "return", "<STR_LIT>", "cstf%I2%U2 %3, %M2, %1, %e0", "<STR_LIT>", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_QImode", ":", "return", "<STR_LIT>", "cstb%I2%U2 %., %M2, %1, %e0", "<STR_LIT>", ";", "case", "E_HImode", ":", "return", "<STR_LIT>", "csth%I2%U2 %., %M2, %1, %e0", "<STR_LIT>", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "<STR_LIT>", "cst%I2%U2 %., %M2, %1, %e0", "<STR_LIT>", ";", "}", "}", "}", "fatal_insn", "(", "<STR_LIT>", "bad output_condmove_single operand", "<STR_LIT>", ",", "insn", ")", ";", "return", "<STR_LIT>", "<STR_LIT>", ";", "}" ]

[ "Return", "a", "string", "to", "output", "a", "single", "word", "conditional", "move", ".", "Operand0", "--", "EQ/NE", "of", "ccr", "register", "and", "0", "Operand1", "--", "CCR", "register", "Operand2", "--", "destination", "Operand3", "--", "source" ]

[ "<FIXS>", "unsigned", "int", "mask", ";", "<FIXE>" ]

[ "{", "char", "*", "p", "=", "ASTRDUP", "(", "opts", "->", "x_ix86_recip_name", ")", ";", "char", "*", "q", ";", "<BUGS>", "unsigned", "int", "mask", ",", "i", ";", "<BUGE>", "bool", "invert", ";", "while", "(", "(", "q", "=", "strtok", "(", "p", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ")", "!=", "NULL", ")" ]

[ ")" ]

[ "(", "define_reservation", "<STR_LIT>", "<STR_LIT>" ]

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

[ "class", "MOSRelaxationTable", ":", "GenericTable", "{", "let", "FilterClass", "=", "NAME", "#", "<STR_LIT>", ";", "let", "CppTypeName", "=", "<STR_LIT>", ";", "let", "Fields", "=", "[", "<STR_LIT>", ",", "<STR_LIT>", "]", ";" ]

[ "Inst", "(", "VTI", ".", "Vec", "MQPR", ":", "$", "in", ")", ",", "(", "VTI", ".", "Vec", "MQPR", ":", "$", "sh", ")", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "VTI", ".", "Vec", "(", "int_arm_mve_vshl_vector", "(", "VTI", ".", "Vec", "MQPR", ":", "$", "in", ")", ",", "(", "VTI", ".", "Vec", "MQPR", ":", "$", "sh", ")", ",", "(", "i32", "q", ")", ",", "(", "i32", "r", ")", ",", "(", "i32", "VTI", ".", "Unsigned", ")", ")", ")", ",", "(", "VTI", ".", "Vec", "(" ]

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

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "<", "ssescalarmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "<", "ssescalarmode", ">", "(", "match_operand", ":", "V48_256_512_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "{", "int", "byte_offset", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "*", "GET_MODE_SIZE", "(", "<", "ssescalarmode", ">", "mode", ")", "if", "(", "byte_offset", "%", "<NUM_LIT>", "=", "=", "<NUM_LIT>", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "byte_offset", "/", "<NUM_LIT>", ")", "if", "(", "byte_offset", "/", "<NUM_LIT>", "=" ]

[ "let", "ParserMatchClass", "=", "MipsUimm5Lsl2AsmOperand", ";" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "&", "MF", ")", "{" ]

[ "static", "bool", "isTargetDarwin", "(", "const", "MachineFunction" ]

[ "[", "(", "set", "EFLAGS", ",", "(", "opnode", "typeinfo", ".", "RegClass", ":", "$", "src1", ",", "typeinfo", ".", "Imm8Operator", ":", "$", "src2", ")", ")", "]", ">", ";" ]

[ "class", "BinOpRI8_F", "<", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "string", "mnemonic", ",", "X86TypeInfo", "typeinfo", ",", "SDPatternOperator", "opnode", ",", "Format", "f", ">", ":", "BinOpRI8", "<", "opcode", ",", "mnemonic", ",", "typeinfo", ",", "f", ",", "(", "outs", ")", ",", "WriteALU", "," ]

[ "UNSPEC_ROUND", ")", ")", "]" ]

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

[ ")", ";" ]

[ "unsigned", "LogBase", "=", "Scale", "->", "getValue", "(", ")", ".", "logBase2", "(", ")", ";", "auto", "*", "ShiftAmount", "=", "ConstantInt", "::", "get", "(", "Start", "->", "getType", "(", ")", ",", "LogBase", ",", "false", ")", ";", "auto", "*", "StartI", "=", "Builder", ".", "CreateAShr", "(", "Start", ",", "ShiftAmount", ")", ";", "Builder", ".", "SetInsertPoint", "(", "PHI", "->", "getParent", "(", ")", "->", "getFirstNonPHI", "(", ")", ")", ";", "auto", "*", "NewIV", "=", "Builder", ".", "CreateAdd", "(", "StartI", ",", "OtherPHI", ")", ";", "NewIV", "=", "Builder", ".", "CreateShl", "(", "NewIV", ",", "ShiftAmount", ")", ";", "if", "(", "CI", ")", "{", "Builder", ".", "SetInsertPoint", "(", "PHI", "->", "getParent", "(", ")", "->", "getFirstNonPHI", "(", ")", ")", ";", "auto", "*", "NewIVWithoutOffset", "=", "Builder", ".", "CreateShl", "(", "OtherPHI", ",", "ShiftAmount", ")", ";", "unsigned", "Counter", "=", "<NUM_LIT>", ";", "SmallVector", "<", "User", "*", ",", "<NUM_LIT>", ">", "PhiUsers", "(", "PHI", "->", "users", "(", ")", ")", ";", "for", "(", "auto", "*", "U", ":", "PhiUsers", ")", "{", "BitCastInst", "*", "BC", "=", "nullptr", ";", "GetElementPtrInst", "*", "Gep", ";", "Value", "*", "PointerOpnd", ";", "if", "(", "Counter", "<", "MAX_LOOPSTRENGTH_LOOPVARS", "&&", "IsHoistableGEPCandidate", "(", "U", ",", "EntryBB", ",", "PHI", ",", "Gep", ",", "PointerOpnd", ",", "BC", ")", ")", "{", "Counter", "++", ";", "Builder", ".", "SetInsertPoint", "(", "EntryBB", "->", "getTerminator", "(", ")", ")", ";", "auto", "*", "Clone", "=", "Builder", ".", "Insert", "(", "Gep", "->", "clone", "(", ")", ")", ";", "if", "(", "BC", ")", "{", "Builder", ".", "SetInsertPoint", "(", "Clone", ")", ";", "auto", "*", "NewPointerOpnd", "=", "Builder", ".", "CreateBitCast", "(", "PointerOpnd", ",", "BC", "->", "getType", "(", ")", ")", ";", "Clone", "->", "replaceUsesOfWith", "(", "BC", ",", "NewPointerOpnd", ")", ";", "}", "for", "(", "unsigned", "J", "=", "<NUM_LIT>", ";", "J", "<", "Gep", "->", "getNumOperands", "(", ")", ";", "++", "J", ")", "{", "Value", "*", "Opnd", "=", "Clone", "->", "getOperand", "(", "J", ")", ";", "Value", "*", "NewOpnd", "=", "ConstantInt", "::", "get", "(", "Opnd", "->", "getType", "(", ")", ",", "Opnd", "==", "PHI", "?", "CI", "->", "getSExtValue", "(", ")", ":", "<NUM_LIT>", ")", ";", "Clone", "->", "setOperand", "(", "J", ",", "NewOpnd", ")", ";", "}", "Builder", ".", "SetInsertPoint", "(", "EntryBB", "->", "getTerminator", "(", ")", ")", ";", "Clone", "=", "cast", "<", "Instruction", ">", "(", "Builder", ".", "CreateBitCast", "(", "Clone", ",", "Gep", "->", "getPointerOperand", "(", ")", "->", "getType", "(", ")", ")", ")", ";", "Gep", "->", "replaceUsesOfWith", "(", "Gep", "->", "getPointerOperand", "(", ")", ",", "Clone", ")", ";", "Gep", "->", "replaceUsesOfWith", "(", "PHI", ",", "NewIVWithoutOffset", ")", ";", "}", "}", "}", "PHI", "->", "replaceAllUsesWith", "(", "NewIV", ")", ";", "}", "}", "if", "(", "Start", "->", "getType", "(", ")", "->", "isPointerTy", "(", ")", ")", "{", "auto", "*", "GepI", "=", "cast", "<", "GetElementPtrInst", ">", "(", "I", ")", ";", "Builder", ".", "SetInsertPoint", "(", "PHI", "->", "getParent", "(", ")", "->", "getFirstNonPHI", "(", ")", ")", ";", "Type", "*", "BaseTy", "=", "Start", "->", "getType", "(", ")", "->", "getPointerElementType", "(", ")", ";", "uint64_t", "ElemTypeSize", "=", "DL", ".", "getTypeStoreSize", "(", "BaseTy", ")", ";", "int64_t", "ScaleVal", "=", "Scale", "->", "getSExtValue", "(", ")", ";", "if", "(", "!", "BaseTy", "->", "isSingleValueType", "(", ")", "||", "(", "ScaleVal", "%", "ElemTypeSize", ")", "!=", "<NUM_LIT>", ")", "{", "LLVMContext", "&", "Context", "=", "BB", "->", "getContext", "(", ")", ";", "Type", "*", "NewBaseType", "=", "Type", "::", "getInt8Ty", "(", "Context", ")", ";", "if", "(", "ScaleVal", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "NewBaseType", "=", "Type", "::", "getInt64Ty", "(", "Context", ")", ";", "else", "if", "(", "ScaleVal", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "NewBaseType", "=", "Type", "::", "getInt32Ty", "(", "Context", ")", ";", "else", "if", "(", "ScaleVal", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "NewBaseType", "=", "Type", "::", "getInt16Ty", "(", "Context", ")", ";", "ElemTypeSize", "=", "DL", ".", "getTypeStoreSize", "(", "NewBaseType", ")", ";", "Start", "=", "Builder", ".", "CreateBitCast", "(", "Start", ",", "NewBaseType", "->", "getPointerTo", "(", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VI_HW_QHS", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VI_HW_QHS", "[", "(", "match_operand", ":", "VI_HW_QHS", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI_HW_QHS", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VEC_VFEE", ")", ")", "(", "set", "(", "reg", ":", "CCRAW", "CC_REGNUM", ")", "(", "unspec", ":", "CCRAW", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_VEC_VFEECC", ")", ")", "]", "<STR_LIT>", "{", "unsigned", "HOST_WIDE_INT", "flags", "=", "UINTVAL" ]

[ "}" ]

[ "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "unsigned", "SubReg", "=", "MO", ".", "getSubReg", "(", ")", ")", "{", "return", "RI", ".", "getSubRegIdxSize", "(", "SubReg", ")", "/", "<NUM_LIT>", ";", "}", "}", "return", "RI", ".", "getRegSizeInBits", "(", "*", "getOpRegClass", "(", "MI", ",", "OpNo", ")", ")", "/", "<NUM_LIT>", ";" ]

[ "Amount", "-=", "InternalAmt", ";" ]

[ "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "TII", ".", "getFrameSize", "(", "*", "I", ")", ":", "<NUM_LIT>", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "TII", ".", "getFrameAdjustment", "(", "*", "I", ")", ":", "<NUM_LIT>", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "auto", "InsertPos", "=", "skipDebugInstructionsForward", "(", "I", ",", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "(", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", "->", "needsUnwindTableEntry", "(", ")", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "<NUM_LIT>", ")", "return", "I", ";" ]

[ "(", "_", "_", "v8di", ")", "_", "_", "W", ",", "_", "_", "M", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pminuq512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v8di", ")", "_", "_", "B", "," ]

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

[ "(", "define_constraint", "<STR_LIT>", "<STR_LIT>" ]

[ "Register", "AMDGPULegalizerInfo", "::", "handleD16VData", "(", "MachineIRBuilder", "&", "B", ",", "MachineRegisterInfo", "&", "MRI", ",", "Register", "Reg", ",", "bool", "ImageStore", ")", "const", "{", "const", "LLT", "S16", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "LLT", "StoreVT", "=", "MRI", ".", "getType", "(", "Reg", ")", ";", "assert", "(", "StoreVT", ".", "isVector", "(", ")", "&&", "StoreVT", ".", "getElementType", "(", ")", "==", "S16", ")", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", ")", "{", "auto", "Unmerge", "=", "B", ".", "buildUnmerge", "(", "S16", ",", "Reg", ")", ";", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "WideRegs", ";", "for", "(", "int", "I", "=", "<NUM_LIT>", ",", "E", "=", "Unmerge", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "I", "!=", "E", ";", "++", "I", ")", "WideRegs", ".", "push_back", "(", "B", ".", "buildAnyExt", "(", "S32", ",", "Unmerge", ".", "getReg", "(", "I", ")", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "int", "NumElts", "=", "StoreVT", ".", "getNumElements", "(", ")", ";", "return", "B", ".", "buildBuildVector", "(", "LLT", "::", "fixed_vector", "(", "NumElts", ",", "S32", ")", ",", "WideRegs", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "ImageStore", "&&", "ST", ".", "hasImageStoreD16Bug", "(", ")", ")", "{", "if", "(", "StoreVT", ".", "getNumElements", "(", ")", "==", "<NUM_LIT>", ")", "{", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "PackedRegs", ";", "Reg", "=", "B", ".", "buildBitcast", "(", "S32", ",", "Reg", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "PackedRegs", ".", "push_back", "(", "Reg", ")", ";", "PackedRegs", ".", "resize", "(", "<NUM_LIT>", ",", "B", ".", "buildUndef", "(", "S32", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "return", "B", ".", "buildBuildVector", "(", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "S32", ")", ",", "PackedRegs", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "StoreVT", ".", "getNumElements", "(", ")", "==", "<NUM_LIT>", ")", "{", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "PackedRegs", ";", "auto", "Unmerge", "=", "B", ".", "buildUnmerge", "(", "S16", ",", "Reg", ")", ";", "for", "(", "int", "I", "=", "<NUM_LIT>", ",", "E", "=", "Unmerge", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "I", "!=", "E", ";", "++", "I", ")", "PackedRegs", ".", "push_back", "(", "Unmerge", ".", "getReg", "(", "I", ")", ")", ";", "PackedRegs", ".", "resize", "(", "<NUM_LIT>", ",", "B", ".", "buildUndef", "(", "S16", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "Reg", "=", "B", ".", "buildBuildVector", "(", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "S16", ")", ",", "PackedRegs", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "return", "B", ".", "buildBitcast", "(", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "S32", ")", ",", "Reg", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "StoreVT", ".", "getNumElements", "(", ")", "==", "<NUM_LIT>", ")", "{", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "PackedRegs", ";", "Reg", "=", "B", ".", "buildBitcast", "(", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "S32", ")", ",", "Reg", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "auto", "Unmerge", "=", "B", ".", "buildUnmerge", "(", "S32", ",", "Reg", ")", ";", "for", "(", "int", "I", "=", "<NUM_LIT>", ",", "E", "=", "Unmerge", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "I", "!=", "E", ";", "++", "I", ")", "PackedRegs", ".", "push_back", "(", "Unmerge", ".", "getReg", "(", "I", ")", ")", ";", "PackedRegs", ".", "resize", "(", "<NUM_LIT>", ",", "B", ".", "buildUndef", "(", "S32", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "return", "B", ".", "buildBuildVector", "(", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "S32", ")", ",", "PackedRegs", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "invalid data type", "<STR_LIT>", ")", ";", "}", "return", "Reg", ";", "}" ]

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

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

[ "int", "i", ",", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "rtx", "first", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_VECTOR", "||", "GET_MODE", "(", "op", ")", "!=", "mode", ")", "return", "false", ";", "first", "=", "CONST_VECTOR_ELT", "(", "op", ",", "<NUM_LIT>", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nunits", ";", "i", "++", ")", "if", "(", "!", "rtx_equal_p", "(", "first", ",", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ")", ")", "return", "false", ";" ]

[ "<FIXS>", "gen_safe_add", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ",", "NULL_RTX", ",", "true", ")", ";", "<FIXE>" ]

[ "gen_safe_add", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "(", "HOST_WIDE_INT", ")", "frame_size", ")", ",", "true", ")", ";", "else", "<BUGS>", "gen_safe_add", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ",", "NULL_RTX", ",", "false", ")", ";", "<BUGE>", "}", "}" ]

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

[ "class", "StoreExclusivePair", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "o2", ",", "bit", "L", ",", "bit", "o1", ",", "bit", "o0", ",", "RegisterClass", "regtype", ",", "string", "asm", ">", ":", "BaseLoadStoreExclusive", "<", "sz", ",", "o2", ",", "L", ",", "o1", ",", "o0", ",", "(", "outs", "GPR32", ":", "$", "Ws", ")", ",", "(", "ins", "regtype", ":", "$", "Rt", ",", "regtype", ":", "$", "Rt2", ",", "GPR64sp0", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", ">", ",", "Sched", "<", "[", "WriteSTX", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Ws", ";" ]

[ ")", "NewImm", "=", "Imm", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumLaneElts", "/", "<NUM_LIT>", ";", "++", "i", ")", "{", "ShuffleMask", ".", "push_back", "(", "NewImm", "%", "NumLaneElts", "+", "NumElts", "+", "l", ")", ";", "NewImm", "/", "=", "NumLaneElts", ";", "}", "if", "(", "NumLaneElts", "==", "<NUM_LIT>" ]

[ ")", ")", "]" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM" ]

[ "<NUM_LIT>", ";" ]

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

[ "SDValue", "LC3TargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "Loc", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "const", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "CLI", ".", "IsTailCall", "=", "false", ";", "if", "(", "isVarArg", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented", "<STR_LIT>", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_LC3", ")", ";", "const", "unsigned", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "NumBytes", ",", "Loc", ",", "true", ")", ",", "Loc", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "assert", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Full", "&&", "<STR_LIT>", "Unhandled loc info", "<STR_LIT>", ")", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "<STR_LIT>", "Only support passing arguments through registers or via the stack", "<STR_LIT>", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i16", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "VA", ".", "getLocMemOffset", "(", ")", ",", "Loc", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "Loc", ",", "MVT", "::", "i16", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "Loc", ",", "Arg", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "{", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "Loc", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "auto", "&", "Reg", ":", "RegsToPass", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "Loc", ",", "Reg", ".", "first", ",", "Reg", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ";", "assert", "(", "G", "&&", "<STR_LIT>", "We only support the calling of global addresses", "<STR_LIT>", ")", ";", "EVT", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "Callee", "=", "DAG", ".", "getGlobalAddress", "(", "G", "->", "getGlobal", "(", ")", ",", "Loc", ",", "PtrVT", ",", "<NUM_LIT>", ")", ";", "std", "::", "vector", "<", "SDValue", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "for", "(", "auto", "&", "Reg", ":", "RegsToPass", ")", "{", "Ops", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ".", "first", ",", "Reg", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "}", "const", "uint32_t", "*", "Mask", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "DAG", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "Missing call preserved mask for calling convention", "<STR_LIT>", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "SDVTList", "NodeTys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "Loc", ",", "NodeTys", ",", "Ops", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "NumBytes", ",", "Loc", ",", "true", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "Loc", ",", "true", ")", ",", "InFlag", ",", "Loc", ")", ";", "if", "(", "!", "Ins", ".", "empty", "(", ")", ")", "{", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "return", "LowerCallResult", "(", "Chain", ",", "InFlag", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "Loc", ",", "DAG", ",", "InVals", ")", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "<STR_LIT>" ]

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

[ ")", "nregs", "++", ";" ]

[ "for", "(", "regno", "=", "<NUM_LIT>", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ",", "true", ")" ]

[ ")", "_", "_", "B", ",", "(", "_", "_", "v4di", ")", "_", "mm256_avx512_setzero_si256", "(", ")", ",", "_", "_", "M", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_pminuq256_mask", "(", "(", "_", "_", "v4di", ")", "_", "_", "A", ",", "(", "_", "_", "v4di" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cvttps_epi64", "(", "_", "_", "m512i", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_cvttps2qq512_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8di", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

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

[ "def", "J2_trap1_noregmap", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "u8_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_b9e09e03", ",", "TypeMAPPING", ">", "{", "let", "hasSideEffects", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "let", "DiagnosticType", "=", "<STR_LIT>" ]

[ "}" ]

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

[ "Info", ".", "writeMem", "=", "true", ";" ]

[ "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "align", "=", "<NUM_LIT>", ";", "const", "ConstantInt", "*", "Vol", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Info", ".", "vol", "=", "!", "Vol", "||", "!", "Vol", "->", "isZero", "(", ")", ";", "Info", ".", "readMem", "=", "true", ";" ]

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

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

[ "SDValue", "Val", "=", "DAG", ".", "getLoad", "(", "ValVT", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";" ]

[ "ISD", "::", "ArgFlagsTy", "Flags", "=", "Ins", "[", "i", "]", ".", "Flags", ";", "bool", "AlwaysUseMutable", "=", "shouldGuaranteeTCO", "(", "CallConv", ",", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", ";", "bool", "isImmutable", "=", "!", "AlwaysUseMutable", "&&", "!", "Flags", ".", "isByVal", "(", ")", ";", "EVT", "ValVT", ";", "bool", "ExtendedInMem", "=", "VA", ".", "isExtInLoc", "(", ")", "&&", "VA", ".", "getValVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", "||", "ExtendedInMem", ")", "ValVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "else", "ValVT", "=", "VA", ".", "getValVT", "(", ")", ";", "int", "Offset", "=", "<NUM_LIT>", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "X86_INTR", ")", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "static_cast", "<", "const", "X86Subtarget", "&", ">", "(", "DAG", ".", "getSubtarget", "(", ")", ")", ";", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "*", "(", "(", "i", "+", "<NUM_LIT>", ")", "%", "Ins", ".", "size", "(", ")", "-", "<NUM_LIT>", ")", ";", "}", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "unsigned", "Bytes", "=", "Flags", ".", "getByValSize", "(", ")", ";", "if", "(", "Bytes", "==", "<NUM_LIT>", ")", "Bytes", "=", "<NUM_LIT>", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "Bytes", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "isImmutable", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "X86_INTR", ")", "{", "MFI", "->", "setObjectOffset", "(", "FI", ",", "Offset", ")", ";", "}", "return", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "}", "else", "{", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ValVT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "isImmutable", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "{", "MFI", "->", "setObjectZExt", "(", "FI", ",", "true", ")", ";", "}", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "{", "MFI", "->", "setObjectSExt", "(", "FI", ",", "true", ")", ";", "}", "if", "(", "CallConv", "==", "CallingConv", "::", "X86_INTR", ")", "{", "MFI", "->", "setObjectOffset", "(", "FI", ",", "Offset", ")", ";", "}", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";" ]

[ ":" ]

[ "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "PreserveMost", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "case", "CallingConv", "::", "Swift", ":", "if", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "IsVarArg", ")", "return", "CC_AArch64_Win64_VarArg", ";", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "CC_AArch64_AAPCS", ";", "if", "(", "!", "IsVarArg", ")", "return", "CC_AArch64_DarwinPCS", ";", "return", "Subtarget", "->", "isTargetILP32", "(", ")", "?", "CC_AArch64_DarwinPCS_ILP32_VarArg", ":", "CC_AArch64_DarwinPCS_VarArg", ";", "case", "CallingConv", "::", "Win64" ]

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

[ "(", "match_operand", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")", ")" ]

[ "break", ";" ]

[ "if", "(", "Offset", "<=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "Offset", "%", "SlotSize", ")", "return", "false", ";", "int", "NumPops", "=", "Offset", "/", "SlotSize", ";", "if", "(", "NumPops", "!=", "<NUM_LIT>", "&&", "NumPops", "!=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "Prev", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "if", "(", "!", "Prev", "->", "isCall", "(", ")", "||", "!", "Prev", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isRegMask", "(", ")", ")", "return", "false", ";", "unsigned", "Regs", "[", "<NUM_LIT>", "]", ";", "unsigned", "FoundRegs", "=", "<NUM_LIT>", ";", "auto", "RegMask", "=", "Prev", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "auto", "&", "RegClass", "=", "Is64Bit", "?", "X86", "::", "GR64_NOREX_NOSPRegClass", ":", "X86", "::", "GR32_NOREX_NOSPRegClass", ";", "for", "(", "auto", "Candidate", ":", "RegClass", ")", "{", "if", "(", "!", "RegMask", ".", "clobbersPhysReg", "(", "Candidate", ")", ")", "continue", ";", "bool", "IsDef", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "Prev", "->", "implicit_operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "(", "TRI", "->", "isSubRegisterEq", "(", "MO", ".", "getReg", "(", ")", ",", "Candidate", ")", "||", "TRI", "->", "isSuperRegister", "(", "MO", ".", "getReg", "(", ")", ",", "Candidate", ")", ")", ")", "{", "IsDef", "=", "true", ";" ]

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

[ "machine", "->", "naked_p", "=", "<NUM_LIT>", ";", "machine", "->", "fp_as_gp_p" ]

[ "}" ]

[ "int", "j", ";", "rtx_insn", "*", "label", ";", "for", "(", "j", "=", "GET_NUM_ELEM", "(", "vec", ")", "-", "<NUM_LIT>", ";", "j", ">=", "<NUM_LIT>", ";", "--", "j", ")", "{", "label", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XEXP", "(", "RTVEC_ELT", "(", "vec", ",", "j", ")", ",", "<NUM_LIT>", ")", ")", ";", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "aarch_bti_j_insn_p", "(", "next", ")", ")", "continue", ";", "bti_insn", "=", "aarch_gen_bti_j", "(", ")", ";", "emit_insn_after", "(", "bti_insn", ",", "label", ")", ";", "}", "}", "}", "if", "(", "CALL_P", "(", "insn", ")", "&&", "(", "find_reg_note", "(", "insn", ",", "REG_SETJMP", ",", "NULL", ")", ")", ")", "{", "bti_insn", "=", "aarch_gen_bti_j", "(", ")", ";", "emit_insn_after", "(", "bti_insn", ",", "insn", ")", ";", "continue", ";" ]

[ "<FIXS>", "PatFrag", "StoreOp", ",", "SDNode", "ExtractOp", ",", "Operand", "AddrMode", ">", "<FIXE>", "<FIXS>", "(", "ins", "AddrMode", ":", "$", "Rn", ",", "DPR", ":", "$", "Vd", ",", "nohash_imm", ":", "$", "lane", ")", ",", "<FIXE>", "<FIXS>", "[", "(", "StoreOp", "(", "ExtractOp", "(", "Ty", "DPR", ":", "$", "Vd", ")", ",", "imm", ":", "$", "lane", ")", ",", "AddrMode", ":", "$", "Rn", ")", "]", ">", "{", "<FIXE>" ]

[ "class", "VST1LN", "bits", "<NUM_LIT>", ">", "op11_8", ",", "bits", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "ValueType", "Ty", ",", "<BUGS>", "PatFrag", "StoreOp", ",", "SDNode", "ExtractOp", ">", "<BUGE>", ":", "NLdStLn", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op11_8", ",", "op7_4", ",", "(", "outs", ")", ",", "<BUGS>", "(", "ins", "addrmode6", ":", "$", "Rn", ",", "DPR", ":", "$", "Vd", ",", "nohash_imm", ":", "$", "lane", ")", ",", "<BUGE>", "IIC_VST1ln", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "[", "(", "StoreOp", "(", "ExtractOp", "(", "Ty", "DPR", ":", "$", "Vd", ")", ",", "imm", ":", "$", "lane", ")", ",", "addrmode6", ":", "$", "Rn", ")", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "}", "class", "VST1LN32", "bits", "<NUM_LIT>", ">", "op11_8", ",", "bits", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "ValueType", "Ty", ",", "PatFrag", "StoreOp", ",", "SDNode", "ExtractOp", ">", ":", "NLdStLn", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op11_8", ",", "op7_4", ",", "(", "outs", ")", ",", "(", "ins", "addrmode6oneL32", ":", "$", "Rn", ",", "DPR", ":", "$", "Vd", ",", "nohash_imm", ":", "$", "lane", ")", ",", "IIC_VST1ln", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "StoreOp", "(", "ExtractOp", "(", "Ty", "DPR", ":", "$", "Vd", ")", ",", "imm", ":", "$", "lane", ")", ",", "addrmode6oneL32", ":", "$", "Rn", ")", "]", ">", "{", "<BUGE>", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "}" ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

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

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

[ "I", "=", "std", "::", "make_unique", "<", "R600Subtarget", ">", "(", "TargetTriple", ",", "GPU", ",", "FS", ",", "*", "this", ")", ";" ]

[ "SmallString", "<", "<NUM_LIT>", ">", "SubtargetKey", "(", "GPU", ")", ";", "SubtargetKey", ".", "append", "(", "FS", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "SubtargetKey", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";" ]

[ "static", "bool", "arm_valid_target_attribute_rec", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", ")", "{", "bool", "ret", "=", "true", ";", "for", "(", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "!", "arm_valid_target_attribute_rec", "(", "TREE_VALUE", "(", "args", ")", ",", "opts", ")", ")", "ret", "=", "false", ";", "return", "ret", ";", "}", "else", "if", "(", "TREE_CODE", "(", "args", ")", "!=", "STRING_CST", ")", "{", "error", "(", "<STR_LIT>", "attribute %<target%> argument not a string", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "char", "*", "argstr", "=", "ASTRDUP", "(", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "char", "*", "q", ";", "while", "(", "(", "q", "=", "strtok", "(", "argstr", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ")", "!=", "NULL", ")", "{", "argstr", "=", "NULL", ";", "if", "(", "!", "strcmp", "(", "q", ",", "<STR_LIT>", "thumb", "<STR_LIT>", ")", ")", "{", "opts", "->", "x_target_flags", "|=", "MASK_THUMB", ";", "if", "(", "TARGET_FDPIC", "&&", "!", "arm_arch_thumb2", ")", "sorry", "(", "<STR_LIT>", "FDPIC mode is not supported in Thumb-1 mode", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "!", "strcmp", "(", "q", ",", "<STR_LIT>", "arm", "<STR_LIT>", ")", ")", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "else", "if", "(", "!", "strcmp", "(", "q", ",", "<STR_LIT>", "general-regs-only", "<STR_LIT>", ")", ")", "opts", "->", "x_target_flags", "|=", "MASK_GENERAL_REGS_ONLY", ";", "else", "if", "(", "startswith", "(", "q", ",", "<STR_LIT>", "fpu=", "<STR_LIT>", ")", ")", "{", "int", "fpu_index", ";", "if", "(", "!", "opt_enum_arg_to_value", "(", "OPT_mfpu_", ",", "q", "+", "<NUM_LIT>", ",", "&", "fpu_index", ",", "CL_TARGET", ")", ")", "{", "error", "(", "<STR_LIT>", "invalid fpu for target attribute or pragma %qs", "<STR_LIT>", ",", "q", ")", ";", "return", "false", ";", "}", "if", "(", "fpu_index", "==", "TARGET_FPU_auto", ")", "{", "sorry", "(", "<STR_LIT>", "auto fpu selection not currently permitted here", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "opts", "->", "x_arm_fpu_index", "=", "(", "enum", "fpu_type", ")", "fpu_index", ";", "}", "else", "if", "(", "startswith", "(", "q", ",", "<STR_LIT>", "arch=", "<STR_LIT>", ")", ")", "{", "char", "*", "arch", "=", "q", "+", "<NUM_LIT>", ";", "const", "arch_option", "*", "arm_selected_arch", "=", "arm_parse_arch_option_name", "(", "all_architectures", ",", "<STR_LIT>", "arch", "<STR_LIT>", ",", "arch", ")", ";", "if", "(", "!", "arm_selected_arch", ")", "{", "error", "(", "<STR_LIT>", "invalid architecture for target attribute or pragma %qs", "<STR_LIT>", ",", "q", ")", ";", "return", "false", ";", "}", "opts", "->", "x_arm_arch_string", "=", "xstrndup", "(", "arch", ",", "strlen", "(", "arch", ")", ")", ";", "}", "else", "if", "(", "q", "[", "<NUM_LIT>", "]", "==", "'", "+", "'", ")", "{", "opts", "->", "x_arm_arch_string", "=", "xasprintf", "(", "<STR_LIT>", "%s%s", "<STR_LIT>", ",", "opts", "->", "x_arm_arch_string", ",", "q", ")", ";", "}", "else", "{", "error", "(", "<STR_LIT>", "unknown target attribute or pragma %qs", "<STR_LIT>", ",", "q", ")", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Inner", "function", "to", "process", "the", "attribute", "(", "(", "target", "(", "...", ")", ")", ")", ",", "take", "an", "argument", "and", "set", "the", "current", "options", "from", "the", "argument", ".", "If", "we", "have", "a", "list", ",", "recursively", "go", "over", "the", "list", "." ]

[ "case", "Mips", "::", "LoadImmDoubleGPR", ":" ]

[ "case", "Mips", "::", "LoadImm32", ":", "return", "expandLoadImm", "(", "Inst", ",", "true", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "LoadImm64", ":", "return", "expandLoadImm", "(", "Inst", ",", "false", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "LoadAddrImm32", ":", "case", "Mips", "::", "LoadAddrImm64", ":", "assert", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "expected register operand kind", "<STR_LIT>", ")", ";", "assert", "(", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "||", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isExpr", "(", ")", ")", "&&", "<STR_LIT>", "expected immediate operand kind", "<STR_LIT>", ")", ";", "return", "expandLoadAddress", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "Mips", "::", "NoRegister", ",", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Inst", ".", "getOpcode", "(", ")", "==", "Mips", "::", "LoadAddrImm32", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "LoadAddrReg32", ":", "case", "Mips", "::", "LoadAddrReg64", ":", "assert", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "expected register operand kind", "<STR_LIT>", ")", ";", "assert", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "expected register operand kind", "<STR_LIT>", ")", ";", "assert", "(", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "||", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isExpr", "(", ")", ")", "&&", "<STR_LIT>", "expected immediate operand kind", "<STR_LIT>", ")", ";", "return", "expandLoadAddress", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Inst", ".", "getOpcode", "(", ")", "==", "Mips", "::", "LoadAddrReg32", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "B_MM_Pseudo", ":", "case", "Mips", "::", "B_MMR6_Pseudo", ":", "return", "expandUncondBranchMMPseudo", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "SWM_MM", ":", "case", "Mips", "::", "LWM_MM", ":", "return", "expandLoadStoreMultiple", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "JalOneReg", ":", "case", "Mips", "::", "JalTwoReg", ":", "return", "expandJalWithRegs", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "BneImm", ":", "case", "Mips", "::", "BeqImm", ":", "case", "Mips", "::", "BEQLImmMacro", ":", "case", "Mips", "::", "BNELImmMacro", ":", "return", "expandBranchImm", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "BLT", ":", "case", "Mips", "::", "BLE", ":", "case", "Mips", "::", "BGE", ":", "case", "Mips", "::", "BGT", ":", "case", "Mips", "::", "BLTU", ":", "case", "Mips", "::", "BLEU", ":", "case", "Mips", "::", "BGEU", ":", "case", "Mips", "::", "BGTU", ":", "case", "Mips", "::", "BLTL", ":", "case", "Mips", "::", "BLEL", ":", "case", "Mips", "::", "BGEL", ":", "case", "Mips", "::", "BGTL", ":", "case", "Mips", "::", "BLTUL", ":", "case", "Mips", "::", "BLEUL", ":", "case", "Mips", "::", "BGEUL", ":", "case", "Mips", "::", "BGTUL", ":", "case", "Mips", "::", "BLTImmMacro", ":", "case", "Mips", "::", "BLEImmMacro", ":", "case", "Mips", "::", "BGEImmMacro", ":", "case", "Mips", "::", "BGTImmMacro", ":", "case", "Mips", "::", "BLTUImmMacro", ":", "case", "Mips", "::", "BLEUImmMacro", ":", "case", "Mips", "::", "BGEUImmMacro", ":", "case", "Mips", "::", "BGTUImmMacro", ":", "case", "Mips", "::", "BLTLImmMacro", ":", "case", "Mips", "::", "BLELImmMacro", ":", "case", "Mips", "::", "BGELImmMacro", ":", "case", "Mips", "::", "BGTLImmMacro", ":", "case", "Mips", "::", "BLTULImmMacro", ":", "case", "Mips", "::", "BLEULImmMacro", ":", "case", "Mips", "::", "BGEULImmMacro", ":", "case", "Mips", "::", "BGTULImmMacro", ":", "return", "expandCondBranches", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "SDivMacro", ":", "case", "Mips", "::", "SDivIMacro", ":", "return", "expandDiv", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ",", "false", ",", "true", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "DSDivMacro", ":", "case", "Mips", "::", "DSDivIMacro", ":", "return", "expandDiv", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ",", "true", ",", "true", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "UDivMacro", ":", "case", "Mips", "::", "UDivIMacro", ":", "return", "expandDiv", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ",", "false", ",", "false", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "DUDivMacro", ":", "case", "Mips", "::", "DUDivIMacro", ":", "return", "expandDiv", "(", "Inst", ",", "IDLoc", ",", "Out", ",", "STI", ",", "true", ",", "false", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "PseudoTRUNC_W_S", ":", "return", "expandTrunc", "(", "Inst", ",", "false", ",", "false", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "PseudoTRUNC_W_D32", ":", "return", "expandTrunc", "(", "Inst", ",", "true", ",", "false", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "PseudoTRUNC_W_D", ":", "return", "expandTrunc", "(", "Inst", ",", "true", ",", "true", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "LoadImmSingleGPR", ":", "return", "expandLoadImmReal", "(", "Inst", ",", "true", ",", "true", ",", "false", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";", "case", "Mips", "::", "LoadImmSingleFGR", ":", "return", "expandLoadImmReal", "(", "Inst", ",", "true", ",", "false", ",", "false", ",", "IDLoc", ",", "Out", ",", "STI", ")", "?", "MER_Fail", ":", "MER_Success", ";" ]

[ ",", "MI", ",", "Context", ")", ";" ]

[ "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TFL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "X86RegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "STI", "->", "getRegisterInfo", "(", ")", ")", ";", "SlotSize", "=", "RegInfo", ".", "getSlotSize", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "SlotSize", ")", "&&", "<STR_LIT>", "Expect power of 2 stack slot size", "<STR_LIT>", ")", ";", "Log2SlotSize", "=", "Log2_32", "(", "SlotSize", ")", ";", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "!", "isLegal", "(", "MF", ")", ")", "return", "false", ";", "unsigned", "FrameSetupOpcode", "=", "TII", "->", "getCallFrameSetupOpcode", "(", ")", ";", "bool", "Changed", "=", "false", ";", "ContextVector", "CallSeqVector", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "FrameSetupOpcode", ")", "{", "CallContext", "Context", ";", "collectCallInfo", "(", "MF", ",", "MBB" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "return", "new", "M88kMCCodeEmitter", "(", "MCII", ",", "Ctx", ")", ";", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "M88kGenMCCodeEmitter.inc", "<STR_LIT>", "MCCodeEmitter", "*", "llvm", "::", "createM88kMCCodeEmitter", "(", "const", "MCInstrInfo", "&", "MCII", ",", "<BUGS>", "const", "MCRegisterInfo", "&", "MRI", ",", "<BUGE>", "MCContext", "&", "Ctx", ")", "{", "<BUGS>", "return", "new", "M88kMCCodeEmitter", "(", "MCII", ",", "MRI", ",", "Ctx", ")", ";", "<BUGE>", "}" ]

[ ")" ]

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

[ "b", ")", ";" ]

[ "_", "_", "vector", "unsigned", "char", "a", ",", "b", ",", "c", ";", "a", "=", "(", "_", "_", "vector", "unsigned", "char", ")", "vec_splats", "(", "_", "_", "m1", ")", ";", "b", "=", "(", "_", "_", "vector", "unsigned", "char", ")", "vec_splats", "(", "_", "_", "m2", ")", ";", "c", "=", "vec_subs", "(", "a", "," ]

[ "<NUM_LIT>", ";" ]

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

[ "kt0", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "kt1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Default", "(", "-", "<NUM_LIT>", ")", ";" ]

[ "CC", "=", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "<STR_LIT>", "zero", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "at", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "a0", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "a1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "a2", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "a3", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "v0", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "v1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s0", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s2", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s3", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s4", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s5", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s6", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s7", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "k0", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "k1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "gp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "fp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "s8", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "ra", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t0", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t2", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t3", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t4", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t5", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t6", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t7", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t8", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "t9", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Default", "(", "-", "<NUM_LIT>", ")", ";", "if", "(", "!", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "return", "CC", ";", "if", "(", "<NUM_LIT>", "<=", "CC", "&&", "CC", "<=", "<NUM_LIT>", ")", "CC", "+=", "<NUM_LIT>", ";", "if", "(", "CC", "==", "-", "<NUM_LIT>", ")", "CC", "=", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "<STR_LIT>", "a4", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "a5", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "a6", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "a7", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>" ]

[ "->", "allocateMemRefsArray", "(", "<NUM_LIT>", ")", ";" ]

[ "SDValue", "CPTmpN1_1", ";", "const", "HexagonInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "SelectADDRriS11_2", "(", "N1", ",", "CPTmpN1_0", ",", "CPTmpN1_1", ")", "&&", "N1", ".", "getNode", "(", ")", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "TII", "->", "isValidAutoIncImm", "(", "LoadedVT", ",", "Val", ")", ")", "{", "SDValue", "TargetConstVal", "=", "CurDAG", "->", "getTargetConstant", "(", "Val", ",", "MVT", "::", "i32", ")", ";", "SDValue", "TargetConst0", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDNode", "*", "Result_1", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Base", ",", "TargetConstVal", ",", "Chain", ")", ";", "SDNode", "*", "Result_2", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "TFRI", ",", "dl", ",", "MVT", "::", "i32", ",", "TargetConst0", ")", ";", "SDNode", "*", "Result_3", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "COMBINE_rr", ",", "dl", ",", "MVT", "::", "i64", ",", "MVT", "::", "Other", ",", "SDValue", "(", "Result_2", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "Result_1", ",", "<NUM_LIT>", ")", ")", ";", "MachineSDNode", "::", "mmo_iterator", "MemOp", "=", "MF", "->", "allocateMemRefsArray", "(", "<NUM_LIT>", ")", ";", "MemOp", "[", "<NUM_LIT>", "]", "=", "LD", "->", "getMemOperand", "(", ")", ";", "cast", "<", "MachineSDNode", ">", "(", "Result_1", ")", "->", "setMemRefs", "(", "MemOp", ",", "MemOp", "+", "<NUM_LIT>", ")", ";", "const", "SDValue", "Froms", "[", "]", "=", "{", "SDValue", "(", "LD", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "LD", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "LD", ",", "<NUM_LIT>", ")", "}", ";", "const", "SDValue", "Tos", "[", "]", "=", "{", "SDValue", "(", "Result_3", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "Result_1", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "Result_1", ",", "<NUM_LIT>", ")", "}", ";", "ReplaceUses", "(", "Froms", ",", "Tos", ",", "<NUM_LIT>", ")", ";", "return", "Result_3", ";", "}", "SDValue", "TargetConst0", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "TargetConstVal", "=", "CurDAG", "->", "getTargetConstant", "(", "Val", ",", "MVT", "::", "i32", ")", ";", "SDNode", "*", "Result_1", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Base", ",", "TargetConst0", ",", "Chain", ")", ";", "SDNode", "*", "Result_2", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "TFRI", ",", "dl", ",", "MVT", "::", "i32", ",", "TargetConst0", ")", ";", "SDNode", "*", "Result_3", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "COMBINE_rr", ",", "dl", ",", "MVT", "::", "i64", ",", "MVT", "::", "Other", ",", "SDValue", "(", "Result_2", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "Result_1", ",", "<NUM_LIT>", ")", ")", ";", "SDNode", "*", "Result_4", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "ADD_ri", ",", "dl", ",", "MVT", "::", "i32", ",", "Base", ",", "TargetConstVal", ",", "SDValue", "(", "Result_1", ",", "<NUM_LIT>", ")", ")", ";", "MachineSDNode", "::", "mmo_iterator", "MemOp", "=", "MF" ]

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

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

[ "<STR_LIT>", ";" ]

[ "def", "fpzero_izero_asmoperand", ":", "AsmOperandClass", "{", "let", "Name", "=" ]

[ "default", ":" ]

[ "case", "Intrinsic", "::", "s390_vstrchs", ":", "case", "Intrinsic", "::", "s390_vstrcfs", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_vstrczbs", ":", "case", "Intrinsic", "::", "s390_vstrczhs", ":", "case", "Intrinsic", "::", "s390_vstrczfs", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_vstrsb", ":", "case", "Intrinsic", "::", "s390_vstrsh", ":", "case", "Intrinsic", "::", "s390_vstrsf", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_vstrszb", ":", "case", "Intrinsic", "::", "s390_vstrszh", ":", "case", "Intrinsic", "::", "s390_vstrszf", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_vfcedbs", ":", "case", "Intrinsic", "::", "s390_vfcesbs", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_vfchdbs", ":", "case", "Intrinsic", "::", "s390_vfchsbs", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_vfchedbs", ":", "case", "Intrinsic", "::", "s390_vfchesbs", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_vftcidb", ":", "case", "Intrinsic", "::", "s390_vftcisb", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";", "case", "Intrinsic", "::", "s390_tdc", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CCValid", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "true", ";" ]

[ ")", "]" ]

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

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

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

[ "<FIXS>", "(", "bc_v8i64", "(", "v16i32", "(", "X86SubVBroadcast", "(", "loadv8i32", "addr", ":", "$", "src", ")", ")", ")", ")", ",", "<FIXE>", "<FIXS>", "(", "bc_v8i64", "(", "v16i32", "(", "X86SubVBroadcast", "(", "loadv8i32", "addr", ":", "$", "src", ")", ")", ")", ")", ",", "<FIXE>" ]

[ "VR512", ":", "$", "src0", ")", ",", "(", "VBROADCASTF64X4rmk", "VR512", ":", "$", "src0", ",", "VK8WM", ":", "$", "mask", ",", "addr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "vselect", "VK8WM", ":", "$", "mask", ",", "<BUGS>", "(", "bc_v8i64", "(", "v16i32", "(", "X86SubVBroadcast", "(", "bc_v8i32", "(", "loadv4i64", "addr", ":", "$", "src", ")", ")", ")", ")", ")", ",", "<BUGE>", "(", "bc_v8i64", "(", "v16i32", "immAllZerosV", ")", ")", ")", ",", "(", "VBROADCASTI64X4rmkz", "VK8WM", ":", "$", "mask", ",", "addr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "vselect", "VK8WM", ":", "$", "mask", ",", "<BUGS>", "(", "bc_v8i64", "(", "v16i32", "(", "X86SubVBroadcast", "(", "bc_v8i32", "(", "loadv4i64", "addr", ":", "$", "src", ")", ")", ")", ")", ")", ",", "<BUGE>", "VR512", ":", "$", "src0", ")", ",", "(", "VBROADCASTI64X4rmk", "VR512", ":", "$", "src0", ",", "VK8WM", ":", "$", "mask", ",", "addr", ":", "$", "src", ")", ">", ";", "}" ]

[ "let", "cofMax1", "=", "<NUM_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", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";" ]

[ ")" ]

[ "V2DF", "V1TI", "(", "KF", "\t", "<STR_LIT>", ")", "(", "TF", "\t", "<STR_LIT>", ")", "TI", "]" ]

[ ")", ")" ]

[ "(", "define_constraint", "<STR_LIT>", "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")" ]

[ "<FIXS>", "uint64_t", "StackSize", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "}", "<FIXE>" ]

[ "}", "MachineInstrBuilder", "&", "MIB", ";", "<BUGS>", "uint64_t", "StackSize", ";", "<BUGE>", "}", ";", "<BUGS>", "}", "<BUGE>", "void", "ARMCallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "ArgInfo", ">", "&", "SplitArgs", "," ]

[ "i32", ")", ";" ]

[ "inline", "SDValue", "getI32Imm", "(", "unsigned", "Imm", ")", "{", "return", "CurDAG", "->", "getTargetConstant", "(", "Imm", ",", "MVT", "::" ]

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

[ "class", "BaseIntegerToFPUnscaled", "<", "bit", "isUnsigned", ",", "RegisterClass", "srcType", ",", "RegisterClass", "dstType", ",", "ValueType", "dvt", ",", "string", "asm", ",", "SDNode", "node", ">", ":", "I", "<", "(", "outs", "dstType", ":", "$", "Rd", ")", ",", "(", "ins", "srcType", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "dvt", "dstType", ":", "$", "Rd", ")", ",", "(", "node", "srcType", ":", "$", "Rn", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteFCvt", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "scale", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "class", "Enc_a94f3b", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Rs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

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

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

[ "}" ]

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

[ "void", "\\", "toc_section", "(", ")", "\\", "{", "\\", "if", "(", "TARGET_MINIMAL_TOC", ")", "\\", "{", "\\", "\\", "if", "(", "!", "toc_initialized", ")", "\\", "{", "\\", "fputs", "(", "<STR_LIT>", "\\t.toc\\nLCTOC..1:\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "\\", "fputs", "(", "<STR_LIT>", "\\t.tc toc_table[TC],toc_table[RW]\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "\\", "toc_initialized", "=", "<NUM_LIT>", ";", "\\", "}", "\\", "\\", "if", "(", "in_section", "!=", "toc", ")", "\\", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.csect toc_table[RW]%s\\n", "<STR_LIT>", ",", "\\", "(", "TARGET_32BIT", "?", "<STR_LIT>", "<STR_LIT>", ":", "<STR_LIT>", ",3", "<STR_LIT>", ")", ")", ";", "\\", "}", "\\", "else", "\\", "{", "\\", "if", "(", "in_section", "!=", "toc", ")", "\\", "fputs", "(", "<STR_LIT>", "\\t.toc\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "\\", "}", "\\", "in_section", "=", "toc", ";", "\\", "}" ]

[ "This", "is", "just", "a", "placeholder", "to", "make", "linking", "work", "without", "having", "to", "add", "this", "to", "the", "generic", "Darwin", "EXTRA_SECTIONS", ".", "If", "-mcall-aix", "is", "ever", "needed", "for", "Darwin", "(", "not", "too", "likely", "!", ")", "this", "would", "have", "to", "get", "a", "real", "definition", "." ]

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

[ "def", "A2_combine_hl", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_3op", ">", ",", "Enc_bd6011", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "Imm", ")", ";" ]

[ "return", "Emiti1Ext", "(", "SrcReg", ",", "DestVT", ",", "isZExt", ")", ";", "case", "MVT", "::", "i8", ":", "if", "(", "DestVT", "==", "MVT", "::", "i64", ")", "Opc", "=", "isZExt", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "Opc", "=", "isZExt", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "Imm", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "i16", ":", "if", "(", "DestVT", "==", "MVT", "::", "i64", ")", "Opc", "=", "isZExt", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "Opc", "=", "isZExt", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "Imm", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "i32", ":", "assert", "(", "DestVT", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "IntExt i32 to i32?!?", "<STR_LIT>", ")", ";", "Opc", "=", "isZExt", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "Imm", "=", "<NUM_LIT>", ";", "break", ";", "}", "if", "(", "DestVT", "==", "MVT", "::", "i8", "||", "DestVT", "==", "MVT", "::", "i16", ")", "DestVT", "=", "MVT", "::", "i32", ";", "else", "if", "(", "DestVT", "==", "MVT", "::", "i64", ")", "{", "unsigned", "Src64", "=", "MRI", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "Src64", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SrcReg", "=", "Src64", ";", "}", "unsigned", "ResultReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "DestVT", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addReg" ]

[ "}" ]

[ "unsigned", "Base", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Reg", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "COP2RegClassID", ",", "Reg", ")", ";", "Base", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR32RegClassID", ",", "Base", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Reg", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Base", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Offset", ")", ")", ";", "return", "MCDisassembler", "::", "Success", ";" ]

[ "rtx", "bsp", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")" ]

[ "[", "(", "use", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{" ]

[ "updateValueMap", "(", "I", ",", "DestReg", ")", ";" ]

[ "if", "(", "!", "isTypeLegal", "(", "SrcTy", ",", "SrcVT", ")", ")", "return", "false", ";", "if", "(", "SrcVT", "!=", "MVT", "::", "f32", "&&", "SrcVT", "!=", "MVT", "::", "f64", ")", "return", "false", ";", "unsigned", "SrcReg", "=", "getRegForValue", "(", "Src", ")", ";", "if", "(", "SrcReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "DestReg", "=", "createResultReg", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "unsigned", "TempReg", "=", "createResultReg", "(", "&", "Mips", "::", "FGR32RegClass", ")", ";", "unsigned", "Opc", "=", "(", "SrcVT", "==", "MVT", "::", "f32", ")", "?", "Mips", "::", "TRUNC_W_S", ":", "Mips", "::", "TRUNC_W_D32", ";", "emitInst", "(", "Opc", ",", "TempReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "emitInst", "(", "Mips", "::", "MFC1", ",", "DestReg", ")", ".", "addReg", "(", "TempReg", ")", ";" ]

[ "<FIXS>", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "<FIXE>", "<FIXS>", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "case", "E_XFmode", ":", "case", "E_RFmode", ":", "<FIXE>", "<FIXS>", "case", "E_TFmode", ":", "<FIXE>" ]

[ "{", "switch", "(", "mode", ")", "{", "<BUGS>", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "TImode", ":", "<BUGE>", "return", "true", ";", "<BUGS>", "case", "SFmode", ":", "case", "DFmode", ":", "case", "XFmode", ":", "case", "RFmode", ":", "<BUGE>", "return", "true", ";", "<BUGS>", "case", "TFmode", ":", "<BUGE>", "return", "true", ";", "default", ":" ]

[ "}" ]

[ "bool", "isTrapHandlerEnabled", "(", ")", "const", "{", "return", "TrapHandler", ";" ]

[ ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "match_test", "<STR_LIT>", ")" ]

[ "}" ]

[ "unsigned", "int", "count", "=", "<NUM_LIT>", ";", "unsigned", "int", "n", "=", "<NUM_LIT>", ";", "sbitmap_iterator", "sbi", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "bmap", ",", "<NUM_LIT>", ",", "n", ",", "sbi", ")", "count", "++", ";", "return", "count", ";" ]

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

[ "def", "J2_jumprfnew", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_b51dc29a", ",", "TypeJ", ">", ",", "Enc_88d4d9", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";" ]

[ "break", ";", "case", "'", "D", "'", ":", "case", "'", "L", "'", ":", "case", "'", "M", "'", ":", "{", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "return", "true", ";", "const", "MachineOperand", "&", "FlagsOP", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "<NUM_LIT>", ")", ";", "if", "(", "!", "FlagsOP", ".", "isImm", "(", ")", ")", "return", "true", ";", "const", "InlineAsm", "::", "Flag", "Flags", "(", "FlagsOP", ".", "getImm", "(", ")", ")", ";", "const", "unsigned", "NumVals", "=", "Flags", ".", "getNumOperandRegisters", "(", ")", ";", "if", "(", "NumVals", "!=", "<NUM_LIT>", ")", "{", "if", "(", "Subtarget", "->", "isGP64bit", "(", ")", "&&", "NumVals", "==", "<NUM_LIT>", "&&", "MO", ".", "isReg", "(", ")", ")", "{", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "O", "<<", "'", "$", "'", "<<", "MipsInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "unsigned", "RegOp", "=", "OpNum", ";", "if", "(", "!", "Subtarget", "->", "isGP64bit", "(", ")", ")", "{", "switch", "(", "ExtraCode", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "M", "'", ":", "RegOp", "=", "(", "Subtarget", "->", "isLittle", "(", ")", ")", "?", "OpNum", "+", "<NUM_LIT>", ":", "OpNum", ";", "break", ";", "case", "'", "L", "'", ":", "RegOp", "=", "(", "Subtarget", "->", "isLittle", "(", ")", ")", "?", "OpNum", ":", "OpNum", "+", "<NUM_LIT>", ";", "break", ";", "case", "'", "D", "'", ":", "RegOp", "=", "OpNum", "+", "<NUM_LIT>", ";", "}", "if", "(", "RegOp", ">=", "MI", "->", "getNumOperands", "(", ")", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "RegOp", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "O", "<<", "'", "$", "'", "<<", "MipsInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "break", ";", "}", "case", "'", "w", "'", ":", "{", "MCRegister", "w", "=", "getMSARegFromFReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "w", "!=", "Mips", "::", "NoRegister", ")", "{", "O", "<<", "'", "$", "'", "<<", "MipsInstPrinter", "::", "getRegisterName", "(", "w", ")", ";", "return", "false", ";", "}", "break", ";", "}", "}", "}" ]

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

[ "return", "(", "alpha_cpu", "==", "PROCESSOR_EV4", "?" ]

[ "}" ]

[ "if", "(", "!", "IsPermitted", "&&", "HasReversePairs", ")", "{", "for", "(", "auto", "R", ":", "ReversePairs", ")", "reportError", "(", "<STR_LIT>", "register pair `", "<STR_LIT>", "+", "Twine", "(", "RI", ".", "getName", "(", "R", ")", ")", "+", "<STR_LIT>", "' is not permitted for this architecture", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "return", "true", ";" ]

[ "}" ]

[ "let", "RenderMethod", "=", "<STR_LIT>", ";", "let", "DiagnosticType", "=", "<STR_LIT>", ";" ]

[ "case", "k_Register", ":" ]

[ "case", "k_Memory", ":", "OS", "<<", "<STR_LIT>", "Mem<", "<STR_LIT>", ";", "OS", "<<", "Mem", ".", "Base", ";", "OS", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "OS", "<<", "*", "Mem", ".", "Off", ";", "OS", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";" ]

[ "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_broadcastb_epi8", "(", "_", "_", "mmask16", "_", "_", "M", ",", "_", "_", "m128i" ]

[ "break", ";" ]

[ "case", "X86", "::", "FsFLD0SD", ":", "case", "X86", "::", "FsFLD0SS", ":", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "!=", "CodeModel", "::", "Small", "&&", "TM", ".", "getCodeModel", "(", ")", "!=", "CodeModel", "::", "Kernel", ")", "return", "NULL", ";", "unsigned", "PICBase", "=", "<NUM_LIT>", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "PICBase", "=", "X86", "::", "RIP", ";", "else", "return", "NULL", ";", "}", "MachineConstantPool", "&", "MCP", "=", "*", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Type", "*", "Ty", ";", "unsigned", "Opc", "=", "LoadMI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "X86", "::", "FsFLD0SS", ")", "Ty", "=", "Type", "::", "getFloatTy", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ";", "else", "if", "(", "Opc", "==", "X86", "::", "FsFLD0SD", ")", "Ty", "=", "Type", "::", "getDoubleTy", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ";", "else", "if", "(", "Opc", "==", "X86", "::", "AVX_SET0PSY", "||", "Opc", "==", "X86", "::", "AVX_SET0PDY", ")", "Ty", "=", "VectorType", "::", "get", "(", "Type", "::", "getFloatTy", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "<NUM_LIT>", ")", ";", "else", "Ty", "=", "VectorType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "<NUM_LIT>", ")", ";", "const", "Constant", "*", "C", "=", "LoadMI", "->", "getOpcode", "(", ")", "==", "X86", "::", "V_SETALLONES", "?", "Constant", "::", "getAllOnesValue", "(", "Ty", ")", ":", "Constant", "::", "getNullValue", "(", "Ty", ")", ";", "unsigned", "CPI", "=", "MCP", ".", "getConstantPoolIndex", "(", "C", ",", "Alignment", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "PICBase", ",", "false", ")", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "false", ")", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateCPI", "(", "CPI", ",", "<NUM_LIT>", ")", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "false", ")", ")", ";", "break", ";", "}", "default", ":", "{", "unsigned", "NumOps", "=", "LoadMI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "i", "=", "NumOps", "-", "X86", "::", "AddrNumOperands", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "MOs", ".", "push_back", "(", "LoadMI", "->", "getOperand", "(", "i", ")", ")", ";" ]

[ ")", ";" ]

[ "Ovr", ".", "schedule", "(", ")", ";", "const", "auto", "RP", "=", "getRegionPressure", "(", "*", "R", ")", ";", "LLVM_DEBUG", "(", "printSchedRP", "(", "dbgs", "(", ")", ",", "R", "->", "MaxPressure", ",", "RP", ")", ")", ";", "if", "(", "RP", ".", "getOccupancy", "(", "ST", ")", "<", "TgtOcc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Didn't fit into target occupancy O", "<STR_LIT>", "<<", "TgtOcc", ")", ";", "if", "(", "R", "->", "BestSchedule", ".", "get", "(", ")", "&&", "R", "->", "BestSchedule", "->", "MaxPressure", ".", "getOccupancy", "(", "ST", ")", ">=", "TgtOcc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ", scheduling minimal register\\n", "<STR_LIT>", ")", ";", "scheduleBest", "(", "*", "R", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ", restoring\\n", "<STR_LIT>" ]

[ "<NUM_LIT>", ";" ]

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

[ "<FIXS>", "(", "IntId64", "(", "bitconvert", "(", "load_mmx", "addr", ":", "$", "src", ")", ")", ")", ")", "]", ",", "<FIXE>" ]

[ "def", "rm64", ":", "MMXSS38I", "opc", ",", "MRMSrcMem", ",", "(", "outs", "VR64", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ")", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "VR64", ":", "$", "dst", ",", "<BUGS>", "(", "IntId64", "(", "bitconvert", "(", "memopmmx", "addr", ":", "$", "src", ")", ")", ")", ")", "]", ",", "<BUGE>", "itins", ".", "rm", ">", ",", "Sched", "[", "itins", ".", "Sched", ".", "Folded", "]", ">", ";", "}" ]

[ "}" ]

[ "bool", "hasSSSE3orAVX", "(", ")", "const", "{", "return", "hasSSSE3", "(", ")", "||", "hasAVX", "(", ")", ";" ]

[ "StringMap", "<", "unsigned", ">", "::", "const_iterator", "Entry", "=", "RegisterReqs", ".", "find", "(", "lowerCase", ")", ";" ]

[ "unsigned", "RegNum", "=", "MatchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "!", "RegNum", ")", "{", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "<STR_LIT>", "r13", "<STR_LIT>", ",", "ARM", "::", "SP", ")", ".", "Case", "(", "<STR_LIT>", "r14", "<STR_LIT>", ",", "ARM", "::", "LR", ")", ".", "Case", "(", "<STR_LIT>", "r15", "<STR_LIT>", ",", "ARM", "::", "PC", ")", ".", "Case", "(", "<STR_LIT>", "ip", "<STR_LIT>", ",", "ARM", "::", "R12", ")", ".", "Case", "(", "<STR_LIT>", "a1", "<STR_LIT>", ",", "ARM", "::", "R0", ")", ".", "Case", "(", "<STR_LIT>", "a2", "<STR_LIT>", ",", "ARM", "::", "R1", ")", ".", "Case", "(", "<STR_LIT>", "a3", "<STR_LIT>", ",", "ARM", "::", "R2", ")", ".", "Case", "(", "<STR_LIT>", "a4", "<STR_LIT>", ",", "ARM", "::", "R3", ")", ".", "Case", "(", "<STR_LIT>", "v1", "<STR_LIT>", ",", "ARM", "::", "R4", ")", ".", "Case", "(", "<STR_LIT>", "v2", "<STR_LIT>", ",", "ARM", "::", "R5", ")", ".", "Case", "(", "<STR_LIT>", "v3", "<STR_LIT>", ",", "ARM", "::", "R6", ")", ".", "Case", "(", "<STR_LIT>", "v4", "<STR_LIT>", ",", "ARM", "::", "R7", ")", ".", "Case", "(", "<STR_LIT>", "v5", "<STR_LIT>", ",", "ARM", "::", "R8", ")", ".", "Case", "(", "<STR_LIT>", "v6", "<STR_LIT>", ",", "ARM", "::", "R9", ")", ".", "Case", "(", "<STR_LIT>", "v7", "<STR_LIT>", ",", "ARM", "::", "R10", ")", ".", "Case", "(", "<STR_LIT>", "v8", "<STR_LIT>", ",", "ARM", "::", "R11", ")", ".", "Case", "(", "<STR_LIT>", "sb", "<STR_LIT>", ",", "ARM", "::", "R9", ")", ".", "Case", "(", "<STR_LIT>", "sl", "<STR_LIT>", ",", "ARM", "::", "R10", ")", ".", "Case", "(", "<STR_LIT>", "fp", "<STR_LIT>", ",", "ARM", "::", "R11", ")", ".", "Default", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "!", "RegNum", ")", "{" ]

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

[ "(", "plus", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "abs", ":", "ANYF", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]