Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "gcc_assert", "(", "get_attr_trap", "(", "i", ")", "!=", "TRAP_YES", "||", "(", "!", "(", "sum", ".", "defd", ".", "i", "&", "sum", ".", "used", ".", "i", ")", "&&", "!", "(", "sum", ".", "defd", ".", "fp", "&", "sum", ".", "used", ".", "fp", ")", ")", ")", ";", "<FIXE>" ]

[ "||", "(", "sum", ".", "defd", ".", "mem", "&", "shadow", ".", "used", ".", "mem", ")", ")", "{", "<BUGS>", "if", "(", "get_attr_trap", "(", "i", ")", "==", "TRAP_YES", "&&", "(", "(", "sum", ".", "defd", ".", "i", "&", "sum", ".", "used", ".", "i", ")", "||", "(", "sum", ".", "defd", ".", "fp", "&", "sum", ".", "used", ".", "fp", ")", ")", ")", "abort", "(", ")", ";", "<BUGE>", "goto", "close_shadow", ";", "}" ]

[ "}" ]

[ "assert", "(", "isCFAlu", "(", "MI", ")", ")", ";", "return", "MI", "->", "getOperand", "(", "TII", "->", "getOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "Enabled", ")", ")", ".", "getImm", "(", ")", ";" ]

[ "MI", "->", "eraseFromParent", "(", ")", ";" ]

[ "if", "(", "!", "MBB", ".", "isEHPad", "(", ")", ")", "continue", ";", "MachineBasicBlock", "*", "TBB", "=", "nullptr", ",", "*", "FBB", "=", "nullptr", ";", "SmallVector", "<", "MachineOperand", ",", "<NUM_LIT>", ">", "Cond", ";", "MachineBasicBlock", "*", "EHPadLayoutPred", "=", "MBB", ".", "getPrevNode", "(", ")", ";", "MachineBasicBlock", "*", "Cont", "=", "&", "MBB", ";", "while", "(", "Cont", "->", "isEHPad", "(", ")", ")", "{", "MachineInstr", "*", "Try", "=", "EHPadToTry", "[", "Cont", "]", ";", "MachineInstr", "*", "EndTry", "=", "BeginToEnd", "[", "Try", "]", ";", "assert", "(", "EndTry", "->", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "DELEGATE", ")", ";", "Cont", "=", "EndTry", "->", "getParent", "(", ")", ";", "}", "bool", "Analyzable", "=", "!", "TII", ".", "analyzeBranch", "(", "*", "EHPadLayoutPred", ",", "TBB", ",", "FBB", ",", "Cond", ")", ";", "if", "(", "Analyzable", "&&", "(", "(", "Cond", ".", "empty", "(", ")", "&&", "TBB", "&&", "TBB", "==", "Cont", ")", "||", "(", "!", "Cond", ".", "empty", "(", ")", "&&", "FBB", "&&", "FBB", "==", "Cont", ")", ")", ")", "{", "bool", "ErasedUncondBr", "=", "false", ";", "(", "void", ")", "ErasedUncondBr", ";", "for", "(", "auto", "I", "=", "EHPadLayoutPred", "->", "end", "(", ")", ",", "E", "=", "EHPadLayoutPred", "->", "begin", "(", ")", ";", "I", "!=", "E", ";", "--", "I", ")", "{", "auto", "PrevI", "=", "std", "::", "prev", "(", "I", ")", ";", "if", "(", "PrevI", "->", "isTerminator", "(", ")", ")", "{", "assert", "(", "PrevI", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR", ")", ";", "PrevI", "->", "eraseFromParent", "(", ")", ";", "ErasedUncondBr", "=", "true", ";", "break", ";", "}", "}", "assert", "(", "ErasedUncondBr", "&&", "<STR_LIT>", "Unconditional branch not erased!", "<STR_LIT>", ")", ";", "}", "}", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "ToDelete", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "TRY", ")", "continue", ";", "MachineInstr", "*", "Try", "=", "&", "MI", ",", "*", "EndTry", "=", "BeginToEnd", "[", "Try", "]", ";", "if", "(", "EndTry", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "DELEGATE", ")", "continue", ";", "MachineBasicBlock", "*", "TryBB", "=", "Try", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "Cont", "=", "EndTry", "->", "getParent", "(", ")", ";", "int64_t", "RetType", "=", "Try", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "for", "(", "auto", "B", "=", "Try", "->", "getIterator", "(", ")", ",", "E", "=", "std", "::", "next", "(", "EndTry", "->", "getIterator", "(", ")", ")", ";", "B", "!=", "TryBB", "->", "begin", "(", ")", "&&", "E", "!=", "Cont", "->", "end", "(", ")", "&&", "std", "::", "prev", "(", "B", ")", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BLOCK", "&&", "E", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "END_BLOCK", "&&", "std", "::", "prev", "(", "B", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "RetType", ";", "--", "B", ",", "++", "E", ")", "{", "ToDelete", ".", "push_back", "(", "&", "*", "std", "::", "prev", "(", "B", ")", ")", ";", "ToDelete", ".", "push_back", "(", "&", "*", "E", ")", ";", "}", "}", "}", "for", "(", "auto", "*", "MI", ":", "ToDelete", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BLOCK", ")", "unregisterScope", "(", "MI", ")", ";" ]

[ ")", ")", ")", ">", ";" ]

[ "def", ":", "GCNPat", "<", "(", "AMDGPUurecip", "i32", ":", "$", "src0", ")", ",", "(", "V_CVT_U32_F32_e32", "(", "V_MUL_F32_e32", "(", "i32", "CONST", ".", "FP_UINT_MAX_PLUS_1", ")", ",", "(", "V_RCP_IFLAG_F32_e32", "(", "V_CVT_F32_U32_e32", "$", "src0", ")" ]

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

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

[ "<STR_LIT>" ]

[ "(", "ashiftrt", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]" ]

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

[ "}", "else", "if", "(", "IsThumb1", ")", "{", "BuildMI", "(", "*", "BB", ",", "Pos", ",", "dl", ",", "TII", "->", "get", "(", "StOpc", ")", ")", ".", "addReg", "(", "Data", ")", ".", "addReg", "(", "AddrIn", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "BuildMI", "(", "*", "BB", ",", "Pos", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tADDi8", ")", ",", "AddrOut", ")", ".", "add", "(", "t1CondCodeOp", "(", ")", ")", ".", "addReg", "(", "AddrIn", ")", ".", "addImm", "(", "StSize", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "}", "else", "if", "(", "IsThumb2", ")", "{", "BuildMI", "(", "*", "BB", ",", "Pos", ",", "dl", ",", "TII", "->", "get", "(", "StOpc", ")", ",", "AddrOut", ")", ".", "addReg", "(", "Data", ")", ".", "addReg", "(", "AddrIn", ")", ".", "addImm", "(", "StSize", ")", ".", "add", "(", "predOps" ]

[ ")", ")" ]

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

[ ")" ]

[ "<STR_LIT>", "{", "switch", "(", "which_alternative", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "=", "=", "MODE_VECTOR_BOOL", ")", "operands", "[", "<NUM_LIT>", "]", "=", "mve_bool_vec_to_const", "(", "operands", "[", "<NUM_LIT>", "]", ")", "else", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "default", ":", "gcc_unreachable", "(", ")", "}", "}", "[", "(", "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>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ ",", "Y", ")", ";" ]

[ "if", "(", "!", "OpVT", ".", "isScalarInteger", "(", ")", "||", "OpSize", "<", "<NUM_LIT>", "||", "isNullConstant", "(", "Y", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "SetCC", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "SetCC", ")", ";", "if", "(", "(", "OpSize", "==", "<NUM_LIT>", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "||", "(", "OpSize", "==", "<NUM_LIT>", "&&", "Subtarget", ".", "hasAVX2", "(", ")", ")", ")", "{", "EVT", "VecVT", "=", "OpSize", "==", "<NUM_LIT>", "?", "MVT", "::", "v16i8", ":", "MVT", "::", "v32i8", ";", "SDValue", "VecX", "=", "DAG", ".", "getBitcast", "(", "VecVT", ",", "X", ")", ";", "SDValue", "VecY", "=", "DAG", ".", "getBitcast", "(", "VecVT" ]

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

[ "<STR_LIT>", "{", "return", "<STR_LIT>", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "<STR_LIT>", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "mm_permutex2var_epi32", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "I", ",", "_", "_", "m128i", "_", "_", "B", ")", "{" ]

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

[ "static", "reg_class_t", "visium_secondary_reload", "(", "bool", "in_p", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "reg_class_t", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "secondary_reload_info", "*", "sri", "ATTRIBUTE_UNUSED", ")", "{", "int", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "regno", "==", "-", "<NUM_LIT>", "&&", "(", "rclass", "==", "MDB", "||", "rclass", "==", "MDC", "||", "rclass", "==", "FP_REGS", ")", ")", "return", "GENERAL_REGS", ";", "else", "if", "(", "(", "(", "regno", "==", "R_MDB", "||", "regno", "==", "R_MDC", ")", "&&", "rclass", "==", "FP_REGS", ")", "||", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "rclass", "==", "MDB", "||", "rclass", "==", "MDC", ")", ")", ")", "return", "GENERAL_REGS", ";", "else", "if", "(", "(", "regno", "==", "R_MDB", "&&", "rclass", "==", "MDC", ")", "||", "(", "rclass", "==", "MDB", "&&", "regno", "==", "R_MDC", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}" ]

[ "Return", "the", "register", "class", "required", "for", "an", "intermediate", "register", "used", "to", "copy", "a", "register", "of", "RCLASS", "from/to", "X", ".", "If", "no", "such", "intermediate", "register", "is", "required", ",", "return", "NO_REGS", ".", "If", "more", "than", "one", "such", "intermediate", "register", "is", "required", ",", "describe", "the", "one", "that", "is", "closest", "in", "the", "copy", "chain", "to", "the", "reload", "register", "." ]

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

[ "def", "M2_vcmpy_s0_sat_i", ":", "T_M2_vmpy", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ ",", "Sched", "<", "[", "WriteVecMoveFromGpr", "]", ">", ";" ]

[ "def", "MOV64toPQIrr", ":", "RS2I", "<", "<NUM_LIT>", ",", "MRMSrcReg", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "v2i64", "(", "scalar_to_vector", "GR64", ":", "$", "src", ")", ")", ")", "]", ">" ]

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

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "getImm", "(", ")", ")", ")", ";", "return", ";", "}", "const", "MCConstantExpr", "*", "CE", "=", "cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";", "int", "Val", "=", "CE", "->", "getValue" ]

[ ")" ]

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

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

[ "def", "tvecshiftR16", ":", "Operand", "<", "i32", ">", ",", "TImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "Indirect", ")", ";", "<FIXE>" ]

[ "if", "(", "Opcode", "==", "X86", "::", "MOV64ri", ")", "rt", "=", "X86", "::", "reloc_absolute_dword", ";", "if", "(", "MO1", ".", "isGlobal", "(", ")", ")", "{", "<BUGS>", "bool", "MayNeedFarStub", "=", "isa", "Function", ">", "(", "MO1", ".", "getGlobal", "(", ")", ")", ";", "<BUGE>", "bool", "Indirect", "=", "gvNeedsNonLazyPtr", "(", "MO1", ",", "TM", ")", ";", "emitGlobalAddress", "(", "MO1", ".", "getGlobal", "(", ")", ",", "rt", ",", "MO1", ".", "getOffset", "(", ")", ",", "<NUM_LIT>", ",", "<BUGS>", "MayNeedFarStub", ",", "Indirect", ")", ";", "<BUGE>", "}", "else", "if", "(", "MO1", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO1", ".", "getSymbolName", "(", ")", ",", "rt", ")", ";", "else", "if", "(", "MO1", ".", "isCPI", "(", ")", ")" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "if", "(", "!", "Subtarget", ".", "hasFastDPWSSD", "(", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "DPWSSD", ")", ";", "return", "true", ";", "}", "break", ";", "<FIXE>" ]

[ "bool", "DoRegPressureReduce", ")", "const", "{", "unsigned", "Opc", "=", "Root", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "<BUGS>", "default", ":", "return", "TargetInstrInfo", "::", "getMachineCombinerPatterns", "(", "Root", ",", "Patterns", ",", "DoRegPressureReduce", ")", ";", "<BUGE>", "case", "X86", "::", "VPDPWSSDrr", ":", "case", "X86", "::", "VPDPWSSDrm", ":", "case", "X86", "::", "VPDPWSSDYrr", ":", "case", "X86", "::", "VPDPWSSDYrm", ":", "{", "<BUGS>", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "DPWSSD", ")", ";", "return", "true", ";", "<BUGE>", "}", "case", "X86", "::", "VPDPWSSDZ128r", ":", "case", "X86", "::", "VPDPWSSDZ128m", ":" ]

[ "let", "Uses", "=", "[", "USR", "]", ";" ]

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

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

[ "[", "(", "set", "(", "match_operand" ]

[ "else", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "RegState", "::", "ImplicitKill", ")", ";" ]

[ "}", "else", "if", "(", "LP64", ")", "{", "if", "(", "EnableRegisterScavenging", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LD", ")", ",", "Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LD", ")", ",", "PPC", "::", "X0", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LWZ", ")", ",", "Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ";", "}", "if", "(", "LP64", ")", "{", "if", "(", "EnableRegisterScavenging", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STDUX", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STDUX", ")", ")", ".", "addReg", "(", "PPC", "::", "X0", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI8", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI8", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "RegState", "::", "ImplicitKill", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STWUX", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ";" ]

[ "for", "(", "const", "auto", "&", "VI", ":", "I", ".", "second", ")", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ";", "VI", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";" ]

[ "void", "PPCExpandISEL", "::", "DumpISELInstructions", "(", ")", "const", "{", "for", "(", "const", "auto", "&", "I", ":", "ISELInstructions", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "printMBBReference", "(", "*", "MF", "->", "getBlockNumbered", "(", "I", ".", "first", ")", ")", "<<", "<STR_LIT>", ":\\n", "<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>", "<STR_LIT>" ]

[ "else", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";" ]

[ "DebugLoc", "dl", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "assert", "(", "TBB", "&&", "<STR_LIT>", "InsertBranch must not be told to insert a fallthrough", "<STR_LIT>", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", "||", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Alpha branch conditions have two components!", "<STR_LIT>", ")", ";", "if", "(", "FBB", "==", "<NUM_LIT>", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "else", "if", "(", "isAlphaIntCondCode", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ")", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "<NUM_LIT>", ";", "}", "if", "(", "isAlphaIntCondCode", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ")", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";" ]

[ "}" ]

[ "class", "sve_int_perm_tbl", "<", "bits", "<", "<NUM_LIT>", ">", "sz8_64", ",", "string", "asm", ",", "ZPRRegOp", "zprty", ",", "RegisterOperand", "VecList", ">", ":", "I", "<", "(", "outs", "zprty", ":", "$", "Zd", ")", ",", "(", "ins", "VecList", ":", "$", "Zn", ",", "zprty", ":", "$", "Zm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Zd", ";", "bits", "<", "<NUM_LIT>", ">", "Zm", ";", "bits", "<", "<NUM_LIT>", ">", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz8_64", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zd", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "icode", ",", "CONSTM1_RTX", "(", "VNx16BImode", ")", ")", ";" ]

[ "rtx", "function_expander", "::", "use_contiguous_load_insn", "(", "insn_code", "icode", ")", "{", "machine_mode", "mem_mode", "=", "memory_vector_mode", "(", ")", ";", "add_output_operand", "(", "icode", ")", ";", "add_mem_operand", "(", "mem_mode", ",", "get_contiguous_base", "(", "mem_mode", ")", ")", ";", "add_input_operand", "(", "icode", ",", "args", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "GET_MODE_UNIT_BITSIZE", "(", "mem_mode", ")", "<", "type_suffix", "(", "<NUM_LIT>", ")", ".", "element_bits", ")", "add_input_operand", "(" ]

[ "<FIXS>", "kernargs", "->", "args", ".", "argc", "=", "kernel_argc", ";", "kernargs", "->", "args", ".", "argv", "=", "(", "int64_t", ")", "args", "->", "argv_data", ";", "kernargs", "->", "abi", ".", "out_ptr", "=", "(", "int64_t", ")", "&", "kernargs", "->", "output_data", ";", "<FIXE>" ]

[ "XHSA", "(", "hsa_fns", ".", "hsa_memory_assign_agent_fn", "(", "heap", ",", "device", ",", "HSA_ACCESS_PERMISSION_RW", ")", ",", "<STR_LIT>", "Assign heap to device agent", "<STR_LIT>", ")", ";", "<BUGS>", "kernargs", "->", "argc", "=", "kernel_argc", ";", "kernargs", "->", "argv", "=", "(", "int64_t", ")", "args", "->", "argv_data", ";", "kernargs", "->", "out_ptr", "=", "(", "int64_t", ")", "&", "kernargs", "->", "output_data", ";", "<BUGE>", "kernargs", "->", "output_data", ".", "return_value", "=", "<NUM_LIT>", ";", "kernargs", "->", "output_data", ".", "next_output", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "(", "sizeof", "(", "kernargs", "->", "output_data", ".", "queue", ")" ]

[ "}" ]

[ "return", "cost", ";", "}", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", "||", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "return", "MAX", "(", "<NUM_LIT>", ",", "ix86_cost", "->", "mmxsse_to_integer", ")", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "fp_move", ";", "if", "(", "MAYBE_SSE_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "sse_move", ";", "if", "(", "MAYBE_MMX_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "mmx_move", ";", "return", "<NUM_LIT>", ";" ]

[ ")", ",", "<STR_LIT>", ",", "[", "(", "AVRbrcond", "bb", ":", "$", "target", ",", "AVR_COND_SH", ")", "]", ">", ";" ]

[ "def", "BRSHk", ":", "FBRsk", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "relbrtarget_7", ":", "$", "target" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "IEEE128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "IEEE128", "(", "match_operand", ":", "IEEE128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "}" ]

[ "if", "(", "fn", "==", "AARCH64_SIMD_BUILTIN_UNOP_sqrtv2df", ")", "return", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RSQRT_V2DF", "]", ";", "if", "(", "fn", "==", "AARCH64_SIMD_BUILTIN_UNOP_sqrtv2sf", ")", "return", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RSQRT_V2SF", "]", ";", "if", "(", "fn", "==", "AARCH64_SIMD_BUILTIN_UNOP_sqrtv4sf", ")", "return", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RSQRT_V4SF", "]", ";", "return", "NULL_TREE", ";" ]

[ "UNSPEC_NVRINTP", "UNSPEC_NVRINTM", "UNSPEC_NVRINTA", "]", ")" ]

[ "(", "define_int_iterator", "NEON_VCVT", "[" ]

[ "ExceptionsType", "=", "ExceptionHandling", "::", "SjLj", ";" ]

[ "ARMMCAsmInfoDarwin", "::", "ARMMCAsmInfoDarwin", "(", ")", "{", "Data64bitsDirective", "=", "<NUM_LIT>", ";", "CommentString", "=", "<STR_LIT>", "@", "<STR_LIT>", ";", "Code16Directive", "=", "<STR_LIT>", ".code\\t16", "<STR_LIT>", ";", "Code32Directive", "=", "<STR_LIT>", ".code\\t32", "<STR_LIT>", ";", "UseDataRegionDirectives", "=", "true", ";", "SupportsDebugInformation", "=", "true", ";" ]

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

[ "SDValue", "PPCTargetLowering", "::", "lowerLog", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "lowerLibCallBase", "(", "<STR_LIT>", "__xl_log", "<STR_LIT>", ",", "<STR_LIT>", "__xl_logf", "<STR_LIT>", ",", "<STR_LIT>", "__xl_log_finite", "<STR_LIT>", ",", "<STR_LIT>", "__xl_logf_finite", "<STR_LIT>", "," ]

[ "HasFP", ")", "{" ]

[ "NumBytes", "=", "DPRCSOffset", ";", "int", "FramePtrOffsetInBlock", "=", "<NUM_LIT>", ";", "unsigned", "adjustedGPRCS1Size", "=", "GPRCS1Size", ";", "if", "(", "GPRCS1Size", ">", "<NUM_LIT>", "&&", "GPRCS2Size", "==", "<NUM_LIT>", "&&", "tryFoldSPUpdateIntoPushPop", "(", "STI", ",", "MF", ",", "&", "*", "std", "::", "prev", "(", "MBBI", ")", ",", "NumBytes", ")", ")", "{", "FramePtrOffsetInBlock", "=", "NumBytes", ";", "adjustedGPRCS1Size", "+=", "NumBytes", ";", "NumBytes", "=", "<NUM_LIT>", ";", "}", "if", "(", "adjustedGPRCS1Size", ")", "{", "CFAOffset", "-=", "adjustedGPRCS1Size", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "CFAOffset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "int", "FI", "=", "I", "->", "getFrameIdx", "(", ")", ";", "switch", "(", "Reg", ")", "{", "case", "ARM", "::", "R8", ":", "case", "ARM", "::", "R9", ":", "case", "ARM", "::", "R10", ":", "case", "ARM", "::", "R11", ":", "case", "ARM", "::", "R12", ":", "if", "(", "STI", ".", "splitFramePushPop", "(", "MF", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "ARM", "::", "R0", ":", "case", "ARM", "::", "R1", ":", "case", "ARM", "::", "R2", ":", "case", "ARM", "::", "R3", ":", "case", "ARM", "::", "R4", ":", "case", "ARM", "::", "R5", ":", "case", "ARM", "::", "R6", ":", "case", "ARM", "::", "R7", ":", "case", "ARM", "::", "LR", ":", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ",", "MFI", ".", "getObjectOffset", "(", "FI", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "break", ";", "}", "}", "if", "(", "HasFP", ")", "{", "FramePtrOffsetInBlock", "+=", "MFI", ".", "getObjectOffset", "(", "FramePtrSpillFI", ")", "+", "GPRCS1Size", "+", "ArgRegsSaveSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tADDrSPi", ")", ",", "FramePtr", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "addImm", "(", "FramePtrOffsetInBlock", "/", "<NUM_LIT>", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "if", "(", "FramePtrOffsetInBlock", ")", "{", "CFAOffset", "+=", "FramePtrOffsetInBlock", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "FramePtr", ",", "true", ")", ",", "CFAOffset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "FramePtr", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "NumBytes", ">", "<NUM_LIT>", ")", "AFI", "->", "setShouldRestoreSPFromFP", "(", "true", ")", ";", "}", "while", "(", "true", ")", "{", "MachineBasicBlock", "::", "iterator", "OldMBBI", "=", "MBBI", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tMOVr", ")", "MBBI", "++", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", ")", "{", "MBBI", "++", ";", "}", "else", "{", "MBBI", "=", "OldMBBI", ";", "break", ";", "}", "}", "for", "(", "auto", "&", "I", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "int", "FI", "=", "I", ".", "getFrameIdx", "(", ")", ";", "switch", "(", "Reg", ")", "{", "case", "ARM", "::", "R8", ":", "case", "ARM", "::", "R9", ":", "case", "ARM", "::", "R10", ":", "case", "ARM", "::", "R11", ":", "case", "ARM", "::", "R12", ":", "{", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ",", "MFI", ".", "getObjectOffset", "(", "FI", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "if", "(", "NumBytes", ")", "{", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "-", "NumBytes", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "!" ]

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

[ "(", "define_mode_attr", "fcvt_change_mode", "[", "(", "SI", "<STR_LIT>" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "Absolute", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "SafeToReplace", ")", "{" ]

[ "LIS", "->", "RemoveMachineInstrFromMaps", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "Next", ";", "Changed", "=", "true", ";", "}", "if", "(", "I", "!=", "E", ")", "continue", ";", "for", "(", "auto", "*", "Pred", ":", "CurBB", "->", "predecessors", "(", ")", ")", "{", "if", "(", "Pred", "->", "succ_size", "(", ")", "==", "<NUM_LIT>", ")", "Blocks", ".", "push_back", "(", "Pred", ")", ";", "}", "}", "continue", ";", "}", "auto", "Lead", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "MBB", ".", "succ_size", "(", ")", "!=", "<NUM_LIT>", "||", "Lead", "==", "E", "||", "!", "isEndCF", "(", "*", "Lead", ",", "TRI", ")", ")", "continue", ";", "const", "MachineBasicBlock", "*", "Succ", "=", "*", "MBB", ".", "succ_begin", "(", ")", ";", "if", "(", "!", "MBB", ".", "isLayoutSuccessor", "(", "Succ", ")", ")", "continue", ";", "auto", "I", "=", "std", "::", "next", "(", "Lead", ")", ";", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "!", "TII", "->", "isSALU", "(", "*", "I", ")", "||", "I", "->", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "break", ";", "if", "(", "I", "!=", "E", ")", "continue", ";", "const", "auto", "NextLead", "=", "Succ", "->", "begin", "(", ")", ";", "if", "(", "NextLead", "==", "Succ", "->", "end", "(", ")", "||", "!", "isEndCF", "(", "*", "NextLead", ",", "TRI", ")", "||", "!", "getOrExecSource", "(", "*", "NextLead", ",", "*", "TII", ",", "MRI", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Redundant EXEC = S_OR_B64 found: ", "<STR_LIT>", "<<", "*", "Lead", "<<", "'", "\\n", "'", ")", ";", "auto", "SaveExec", "=", "getOrExecSource", "(", "*", "Lead", ",", "*", "TII", ",", "MRI", ")", ";", "unsigned", "SaveExecReg", "=", "getOrNonExecReg", "(", "*", "Lead", ",", "*", "TII", ")", ";", "for", "(", "auto", "&", "Op", ":", "Lead", "->", "operands", "(", ")", ")", "{", "if", "(", "Op", ".", "isReg", "(", ")", ")", "RecalcRegs", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", "LIS", "->", "RemoveMachineInstrFromMaps", "(", "*", "Lead", ")", ";", "Lead", "->", "eraseFromParent", "(", ")", ";", "if", "(", "SaveExecReg", ")", "{", "LIS", "->", "removeInterval", "(", "SaveExecReg", ")", ";", "LIS", "->", "createAndComputeVirtRegInterval", "(", "SaveExecReg", ")", ";", "}", "Changed", "=", "true", ";", "if", "(", "!", "SaveExec", "||", "!", "SaveExec", "->", "isFullCopy", "(", ")", ")", "continue", ";", "unsigned", "SavedExec", "=", "SaveExec", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "SafeToReplace", "=", "true", ";", "for", "(", "auto", "&", "U", ":", "MRI", ".", "use_nodbg_instructions", "(", "SavedExec", ")", ")", "{", "if", "(", "U", ".", "getParent", "(", ")", "!=", "SaveExec", "->", "getParent", "(", ")", ")", "{", "SafeToReplace", "=", "false", ";", "break", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Redundant EXEC COPY: ", "<STR_LIT>", "<<", "*", "SaveExec", "<<", "'", "\\n", "'", ")", ";", "}" ]

[ "<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", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=" ]

[ "getOperand", "(", "i", ")", ";" ]

[ "case", "X86", "::", "RETL", ":", "case", "X86", "::", "RETQ", ":", "case", "X86", "::", "RETIL", ":", "case", "X86", "::", "RETIQ", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "<NUM_LIT>", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->" ]

[ "static", "void", "mips16e_mask_registers", "(", "unsigned", "int", "*", "mask_ptr", ",", "const", "unsigned", "char", "*", "regs", ",", "unsigned", "int", "size", ",", "unsigned", "int", "*", "num_regs_ptr", ")", "{", "unsigned", "int", "i", ";", "i", "=", "mips16e_find_first_register", "(", "*", "mask_ptr", ",", "regs", ",", "size", ")", ";", "for", "(", "i", "++", ";", "i", "<", "size", ";", "i", "++", ")", "if", "(", "!", "BITSET_P", "(", "*", "mask_ptr", ",", "regs", "[", "i", "]", ")", ")", "{", "*", "num_regs_ptr", "+=", "<NUM_LIT>", ";", "*", "mask_ptr", "|=", "<NUM_LIT>", "<<", "regs", "[", "i", "]", ";", "}", "}" ]

[ "*", "MASK_PTR", "is", "a", "mask", "of", "general-purpose", "registers", "and", "*", "NUM_REGS_PTR", "is", "the", "number", "of", "set", "bits", ".", "If", "*", "MASK_PTR", "contains", "REGS", "[", "X", "]", "for", "some", "X", "in", "[", "0", ",", "SIZE", ")", ",", "adjust", "*", "MASK_PTR", "and", "*", "NUM_REGS_PTR", "so", "that", "the", "same", "is", "true", "for", "all", "indexes", "(", "X", ",", "SIZE", ")", "." ]

[ "assert", "(", "(", "Opcode", "==", "ARM", "::", "tCBNZ", "||", "Opcode", "==", "ARM", "::", "tCBZ", ")", "&&", "<STR_LIT>", "Invalid opcode", "<STR_LIT>", ")", ";" ]

[ "return", "true", ";", "}", "if", "(", "Opcode", "==", "ARM", "::", "tADDspi", "||", "Opcode", "==", "ARM", "::", "tSUBspi", ")", "{", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "ARM", "::", "SP", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "ARM", "::", "SP", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "getT1Imm7", "(", "insn", ")", ")", ")", ";", "NumOpsAdded", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "ARM", "::", "t2IT", ")", "{", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "NumOpsAdded", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "ARM", "::", "tBKPT", ")", "{", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "getT1Imm8", "(", "insn", ")", ")", ")", ";", "NumOpsAdded", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "ARM", "::", "tCPS", ")", "{", "unsigned", "Option", "=", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", "|", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", "|", "<NUM_LIT>", "<<", "<NUM_LIT>", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Option", ")", ")", ";", "NumOpsAdded", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "assert", "(", "NumOps", ">=", "<NUM_LIT>", "&&", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", "==", "ARM", "::", "tGPRRegClassID", "&&", "(", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", "==", "<NUM_LIT>", "||", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", "==", "ARM", "::", "tGPRRegClassID", ")", "&&", "<STR_LIT>", "Expect >=2 operands", "<STR_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "getRegisterEnum", "(", "B", ",", "ARM", "::", "tGPRRegClassID", ",", "getT1tRd", "(", "insn", ")", ")", ")", ")", ";", "if", "(", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", "==", "ARM", "::", "tGPRRegClassID", ")", "{", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "getRegisterEnum", "(", "B", ",", "ARM", "::", "tGPRRegClassID", ",", "getT1tRn", "(", "insn", ")", ")", ")", ")", ";", "}", "else", "{" ]

[ ";" ]

[ "void", "X86DAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "if", "(", "TM", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", ";", "SelectionDAG", "::", "allnodes_iterator", "Position", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "Position", "!=", "CurDAG", "->", "allnodes_begin", "(", ")", ")", "{", "SDNode", "*", "N", "=", "&", "*", "--", "Position", ";", "if", "(", "N", "->", "use_empty", "(", ")", "||", "!", "N", "->", "isMachineOpcode", "(", ")", ")", "continue", ";", "if", "(", "tryOptimizeRem8Extend", "(", "N", ")", ")", "{", "MadeChange", "=", "true", ";", "continue", ";", "}", "unsigned", "Opc", "=", "N", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "X86", "::", "TEST8rr", "||", "Opc", "==", "X86", "::", "TEST16rr", "||", "Opc", "==", "X86", "::", "TEST32rr", "||", "Opc", "==", "X86", "::", "TEST64rr", ")", "&&", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "==", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "&&", "N", "->", "isOnlyUserOf", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "&&", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isMachineOpcode", "(", ")", ")", "{", "SDValue", "And", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "N0Opc", "=", "And", ".", "getMachineOpcode", "(", ")", ";", "if", "(", "N0Opc", "==", "X86", "::", "AND8rr", "||", "N0Opc", "==", "X86", "::", "AND16rr", "||", "N0Opc", "==", "X86", "::", "AND32rr", "||", "N0Opc", "==", "X86", "::", "AND64rr", ")", "{", "MachineSDNode", "*", "Test", "=", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "ReplaceUses", "(", "N", ",", "Test", ")", ";", "MadeChange", "=", "true", ";", "continue", ";", "}", "if", "(", "N0Opc", "==", "X86", "::", "AND8rm", "||", "N0Opc", "==", "X86", "::", "AND16rm", "||", "N0Opc", "==", "X86", "::", "AND32rm", "||", "N0Opc", "==", "X86", "::", "AND64rm", ")", "{", "unsigned", "NewOpc", ";", "switch", "(", "N0Opc", ")", "{", "case", "X86", "::", "AND8rm", ":", "NewOpc", "=", "X86", "::", "TEST8mr", ";", "break", ";", "case", "X86", "::", "AND16rm", ":", "NewOpc", "=", "X86", "::", "TEST16mr", ";", "break", ";", "case", "X86", "::", "AND32rm", ":", "NewOpc", "=", "X86", "::", "TEST32mr", ";", "break", ";", "case", "X86", "::", "AND64rm", ":", "NewOpc", "=", "X86", "::", "TEST64mr", ";", "break", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "MachineSDNode", "*", "Test", "=", "CurDAG", "->", "getMachineNode", "(", "NewOpc", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "CurDAG", "->", "setNodeMemRefs", "(", "Test", ",", "cast", "<", "MachineSDNode", ">", "(", "And", ".", "getNode", "(", ")", ")", "->", "memoperands", "(", ")", ")", ";", "ReplaceUses", "(", "N", ",", "Test", ")", ";", "MadeChange", "=", "true" ]

[ ",", "OpNum", ",", "O", ")", ";" ]

[ "printUImmOperand", "<", "<NUM_LIT>", ">", "(", "MI" ]

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

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

[ "::", "VMOVDQU8Z128rm", ":" ]

[ "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV8rm_NOREX", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVUPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MOVDQUrm", ":", "case", "X86", "::", "VMOVSSrm", ":", "case", "X86", "::", "VMOVSDrm", ":", "case", "X86", "::", "VMOVAPSrm", ":", "case", "X86", "::", "VMOVUPSrm", ":", "case", "X86", "::", "VMOVAPDrm", ":", "case", "X86", "::", "VMOVUPDrm", ":", "case", "X86", "::", "VMOVDQArm", ":", "case", "X86", "::", "VMOVDQUrm", ":", "case", "X86", "::", "VMOVAPSYrm", ":", "case", "X86", "::", "VMOVUPSYrm", ":", "case", "X86", "::", "VMOVAPDYrm", ":", "case", "X86", "::", "VMOVUPDYrm", ":", "case", "X86", "::", "VMOVDQAYrm", ":", "case", "X86", "::", "VMOVDQUYrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "VMOVSSZrm", ":", "case", "X86", "::", "VMOVSDZrm", ":", "case", "X86", "::", "VMOVAPDZ128rm", ":", "case", "X86", "::", "VMOVAPDZ256rm", ":", "case", "X86", "::", "VMOVAPDZrm", ":", "case", "X86", "::", "VMOVAPSZ128rm", ":", "case", "X86", "::", "VMOVAPSZ256rm", ":", "case", "X86", "::", "VMOVAPSZ128rm_NOVLX", ":", "case", "X86", "::", "VMOVAPSZ256rm_NOVLX", ":", "case", "X86", "::", "VMOVAPSZrm", ":", "case", "X86", "::", "VMOVDQA32Z128rm", ":", "case", "X86", "::", "VMOVDQA32Z256rm", ":", "case", "X86", "::", "VMOVDQA32Zrm", ":", "case", "X86", "::", "VMOVDQA64Z128rm", ":", "case", "X86", "::", "VMOVDQA64Z256rm", ":", "case", "X86", "::", "VMOVDQA64Zrm", ":", "case", "X86", "::", "VMOVDQU16Z128rm", ":", "case", "X86", "::", "VMOVDQU16Z256rm", ":", "case", "X86", "::", "VMOVDQU16Zrm", ":", "case", "X86", "::", "VMOVDQU32Z128rm", ":", "case", "X86", "::", "VMOVDQU32Z256rm", ":", "case", "X86", "::", "VMOVDQU32Zrm", ":", "case", "X86", "::", "VMOVDQU64Z128rm", ":", "case", "X86", "::", "VMOVDQU64Z256rm", ":", "case", "X86", "::", "VMOVDQU64Zrm", ":", "case", "X86" ]

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

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

[ "<FIXS>", "}", "else", "if", "(", "!", "useSoftFloat", "(", ")", "&&", "X86ScalarSSEf32", "&&", "(", "UseX87", "||", "Is64Bit", ")", ")", "{", "<FIXE>", "<FIXS>", "if", "(", "UseX87", ")", "addRegisterClass", "(", "MVT", "::", "f64", ",", "&", "X86", "::", "RFP64RegClass", ")", ";", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "FGETSIGN", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FGETSIGN", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "<BUGS>", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "}", "else", "if", "(", "UseX87", "&&", "X86ScalarSSEf32", ")", "{", "<BUGE>", "addRegisterClass", "(", "MVT", "::", "f32", ",", "&", "X86", "::", "FR32RegClass", ")", ";", "<BUGS>", "addRegisterClass", "(", "MVT", "::", "f64", ",", "&", "X86", "::", "RFP64RegClass", ")", ";", "<BUGE>", "setOperationAction", "(", "ISD", "::", "FABS", ",", "MVT", "::", "f32", ",", "Custom", ")", ";" ]

[ "machine_mode", "mode", "=", "V4HImode", ";" ]

[ "for", "(", "unsigned", "int", "regno", "=", "<NUM_LIT>", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "STACK_REGNO_P", "(", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ")", "{", "need_zero_all_mm", "=", "true", ";", "break", ";", "}", "if", "(", "!", "need_zero_all_mm", ")", "return", "false", ";", "rtx", "zero_mmx", "=", "NULL_RTX", ";" ]

[ "(", "implicit", "EFLAGS", ")", "]", ">", ";" ]

[ "def", "DEC64m", ":", "RI", "<", "<NUM_LIT>", ",", "MRM1m", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "dst", ")", ",", "<STR_LIT>", ",", "[", "(", "store", "(", "add", "(", "loadi64", "addr", ":", "$", "dst", ")", ",", "-", "<NUM_LIT>", ")", ",", "addr", ":", "$", "dst", ")", "," ]

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

[ "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "SrcA", "=", "<NUM_LIT>", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";" ]

[ "_", "_", "a", ";" ]

[ "vreinterpretq_s32_s8", "(", "int8x16_t", "_", "_", "a", ")", "{", "return", "(", "int32x4_t", ")" ]

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

[ "class", "BaseSIMDThreeScalar", "<", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteVd", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";" ]

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

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

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

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

[ "<FIXS>", "SDValue", "(", "CurDAG", "->", "getTargetNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i64", ",", "<FIXE>", "<FIXS>", "return", "CurDAG", "->", "getTargetNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i64", ",", "MVT", "::", "Other", ",", "Tmp", ",", "<FIXE>" ]

[ "GlobalValue", "*", "GV", "=", "cast", "GlobalAddressSDNode", ">", "(", "N", ")", "->", "getGlobal", "(", ")", ";", "SDValue", "GA", "=", "CurDAG", "->", "getTargetGlobalAddress", "(", "GV", ",", "MVT", "::", "i64", ")", ";", "SDValue", "Tmp", "=", "<BUGS>", "SDValue", "(", "CurDAG", "->", "getTargetNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ",", "<BUGE>", "CurDAG", "->", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ")", ",", "GA", ")", ",", "<NUM_LIT>", ")", ";", "<BUGS>", "return", "CurDAG", "->", "getTargetNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ",", "MVT", "::", "Other", ",", "Tmp", ",", "<BUGE>", "CurDAG", "->", "getEntryNode", "(", ")", ")", ";", "}" ]

[ "<STR_LIT>" ]

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

[ "static", "bool", "aarch64_rtx_arith_op_extract_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTRACT", "||", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTRACT", ")", "{", "rtx", "op0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "op1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "op2", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MULT", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "op2", "==", "const0_rtx", "&&", "CONST_INT_P", "(", "XEXP", "(", "op0", ",", "<NUM_LIT>", ")", ")", "&&", "aarch64_is_extend_from_extract", "(", "mode", ",", "XEXP", "(", "op0", ",", "<NUM_LIT>", ")", ",", "op1", ")", ")", "{", "return", "true", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTEND", "||", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTEND", ")", "return", "REG_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", "false", ";", "}" ]

[ "Return", "true", "if", "X", "is", "a", "zero", "or", "sign", "extract", "usable", "in", "an", "ADD", "or", "SUB", "(", "extended", "register", ")", "instruction", "." ]

[ "<FIXS>", "for", "(", "const", "MachineOperand", "&", "Use", ":", "MRI", ".", "use_operands", "(", "Reg", ")", ")", "{", "<FIXE>" ]

[ "const", "MachineInstr", "*", "OneUseInst", "=", "OneUse", ".", "getParent", "(", ")", ";", "VNInfo", "*", "OneUseVNI", "=", "LI", ".", "getVNInfoBefore", "(", "LIS", ".", "getInstructionIndex", "(", "*", "OneUseInst", ")", ")", ";", "<BUGS>", "for", "(", "const", "MachineOperand", "&", "Use", ":", "MRI", ".", "use_nodbg_operands", "(", "Reg", ")", ")", "{", "<BUGE>", "if", "(", "&", "Use", "==", "&", "OneUse", ")", "continue", ";" ]

[ "Success", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addMBB", "(", "loop1MBB", ")", ";" ]

[ "BB", "->", "addSuccessor", "(", "loop1MBB", ")", ";", "loop1MBB", "->", "addSuccessor", "(", "exitMBB", ")", ";", "loop1MBB", "->", "addSuccessor", "(", "loop2MBB", ")", ";", "loop2MBB", "->", "addSuccessor", "(", "loop1MBB", ")", ";", "loop2MBB", "->", "addSuccessor", "(", "exitMBB", ")", ";", "BB", "=", "loop1MBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "LL", ")", ",", "Dest", ")", ".", "addReg", "(", "Ptr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "BNE", ")", ")", ".", "addReg", "(", "Dest", ")", ".", "addReg", "(", "OldVal", ")", ".", "addMBB", "(", "exitMBB", ")", ";", "BB", "=", "loop2MBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "SC", ")", ",", "Success", ")", ".", "addReg", "(", "NewVal", ")", ".", "addReg", "(", "Ptr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "BEQ", ")", ")", ".", "addReg", "(" ]

[ "}" ]

[ "ISDNo", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "OpTy", "=", "MVT", "::", "v8f32", ";", "break", ";", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v4f64", ":", "if", "(", "!", "Subtarget", "->", "hasAVX", "(", ")", ")", "return", "SDValue", "(", ")", ";", "ISDNo", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "OpTy", "=", "MVT", "::", "v4f64", ";", "break", ";", "}", "assert", "(", "ISDNo", "&&", "<STR_LIT>", "Invalid Op Number", "<STR_LIT>", ")", ";", "unsigned", "MaskVals", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "{", "int", "EltIdx", "=", "SVOp", "->", "getMaskElt", "(", "i", ")", ";", "if", "(", "EltIdx", "==", "(", "int", ")", "i", "||", "EltIdx", "<", "<NUM_LIT>", ")", "MaskVals", "|=", "(", "<NUM_LIT>", "<<", "i", ")", ";", "else", "if", "(", "EltIdx", "==", "(", "int", ")", "(", "i", "+", "NumElems", ")", ")", "continue", ";", "else", "return", "SDValue", "(", ")", ";", "}", "V1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "OpTy", ",", "V1", ")", ";", "V2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "OpTy", ",", "V2", ")", ";", "SDValue", "Ret", "=", "DAG", ".", "getNode", "(", "ISDNo", ",", "dl", ",", "OpTy", ",", "V1", ",", "V2", ",", "DAG", ".", "getConstant", "(", "MaskVals", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VT", ",", "Ret", ")", ";" ]

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

[ "def", "F2_conv_d2sf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op", ">", ",", "Enc_90cd8b", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "_", "_", "c", ")", ";" ]

[ "_", "_", "smlatb", "(", "int32_t", "_", "_", "a", ",", "int32_t", "_", "_", "b", ",", "int32_t", "_", "_", "c", ")", "{", "return", "_", "_", "builtin_arm_smlatb", "(", "_", "_", "a", ",", "_", "_", "b", "," ]

[ ")", ";", "j", "<", "e", ";", "j", "++", ")", "{" ]

[ "else", "Offset", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "unsigned", "Swizzle", "=", "MI", ".", "getOperand", "(", "i", "+", "Offset", ")", ".", "getImm", "(", ")", "+", "<NUM_LIT>", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ",", "e", "=", "RemapChan", ".", "size", "(" ]

[ ",", "<STR_LIT>", ",", "[", "(", "TLCS900retiflag", ")", "]", ">", ";" ]

[ "def", "RETI", ":", "II16r", "<", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", ")" ]

[ "}" ]

[ "def", "A57Write_4cyc_2X", ":", "SchedWriteRes", "<", "[", "A57UnitX", ",", "A57UnitX", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ ",", "asm", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ";" ]

[ "def", "v2i64_v4i32", ":", "BaseSIMDDifferentThreeVectorTied", "<", "U", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V128", ",", "V128" ]

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

[ "let", "SchedRW", "=", "[", "WriteLDS", "]", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";", "let", "AsmMatchConverter", "=", "<STR_LIT>", ";", "string", "Mnemonic", "=", "opName", ";", "string", "AsmOperands", "=", "asmOps", ";", "bits", "<", "<NUM_LIT>", ">", "has_vdst", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_addr", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_data0", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_data1", "=", "<NUM_LIT>", ";" ]

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

[ "return", "\\\"\\\"}", "<STR_LIT>", "length", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "cc", "<STR_LIT>", "clobber", "<STR_LIT>", "*", "v850_not1_3", "<STR_LIT>", "indirect_operand", "<STR_LIT>", "=", "m", "<STR_LIT>", "power_of_two_operand", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "*", "{" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "VDQV", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VDQV", "[", "(", "match_operand", ":", "VDQV", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_ADDV", ")", ")", "]", "<STR_LIT>" ]

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

[ "unsigned", "int", "rs6000_dbx_register_number", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "<=", "<NUM_LIT>", "||", "write_symbols", "!=", "DWARF2_DEBUG", ")", "return", "regno", ";", "if", "(", "regno", "==", "MQ_REGNO", ")", "return", "<NUM_LIT>", ";", "if", "(", "regno", "==", "LINK_REGISTER_REGNUM", ")", "return", "<NUM_LIT>", ";", "if", "(", "regno", "==", "COUNT_REGISTER_REGNUM", ")", "return", "<NUM_LIT>", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "CR0_REGNO", "+", "<NUM_LIT>", ";", "if", "(", "regno", "==", "XER_REGNO", ")", "return", "<NUM_LIT>", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_ALTIVEC_REGNO", "+", "<NUM_LIT>", ";", "if", "(", "regno", "==", "VRSAVE_REGNO", ")" ]

[ "<FIXS>", "real_2expN", "(", "&", "offset", ",", "<NUM_LIT>", ")", "<FIXE>" ]

[ "rtx", "label2", "=", "gen_label_rtx", "(", ")", "REAL_VALUE_TYPE", "offset", "<BUGS>", "real_2expN", "(", "&", "offset", ",", "<NUM_LIT>", ",", "DFmode", ")", "<BUGE>", "if", "(", "reg1", ")", "\t", "\t", "\t", "{" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";" ]

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

[ "(", "float", ":", "V2DF", "(", "vec_select", ":", "V2SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>" ]

[ "}" ]

[ "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "m_to_int64", "(", "_", "_", "m64", "_", "_", "i", ")", "{", "return", "(", "long", "long", ")", "_", "_", "i", ";" ]

[ "{" ]

[ "(", "match_operand", ":", "<", "VEC_GATHER_IDXSI", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", ")", "(", "unspec", ":", "VI48F", "[", "(", "match_operand", ":", "<", "avx512fmaskmode", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI48F", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_SCATTER", ")", ")", "(", "clobber", "(", "match_scratch", ":", "<", "avx512fmaskmode", ">", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>" ]

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

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

[ ".", "addMBB", "(", "TBB", ")", ";" ]

[ "MachineBasicBlock", "*", "Sink", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "FBB", ")", ";", "F", "->", "insert", "(", "It", ",", "TBB", ")", ";", "F", "->", "insert", "(", "It", ",", "Sink", ")", ";", "Sink", "->", "splice", "(", "Sink", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "Sink", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "FBB", ")", ";", "BB", "->", "addSuccessor", "(", "TBB", ")", ";", "FBB", "->", "addSuccessor", "(", "Sink", ")", ";", "TBB", "->", "addSuccessor", "(", "Sink", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "BPOSGE32", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "BPOSGE32C_MMR3", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "unsigned", "VR2", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "*", "FBB", ",", "FBB", "->", "end", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ADDiu", ")", ",", "VR2", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "FBB", ",", "FBB", "->", "end", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "B", ")", ")", ".", "addMBB", "(", "Sink", ")", ";", "unsigned", "VR1", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "*", "TBB", ",", "TBB", "->", "end", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ADDiu", ")", ",", "VR1", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "Sink", ",", "Sink", "->", "begin", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "VR2", ")", ".", "addMBB", "(", "FBB", ")", ".", "addReg", "(", "VR1", ")" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "lsl", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "lsr", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "asr", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ror", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "msl", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxtb", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxth", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxtw", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxtx", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxtb", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxth", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxtw", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxtx", "<STR_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", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC" ]

[ ",", "mve_pred16_t", "_", "_", "p", ")", "{" ]

[ "_", "_", "arm_vldrhq_gather_shifted_offset_z", "(", "float16_t", "const", "*", "_", "_", "base", ",", "uint16x8_t", "_", "_", "offset" ]

[ "if", "(", "STI", ".", "isTargetIOS", "(", ")", ")", "return", "true", ";" ]

[ "bool", "ARMFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";" ]

[ "]", ")" ]

[ "if", "(", "TARGET_MIPS16", ")", "return", "<STR_LIT>", "else", "return", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "&", "*", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{" ]

[ "(", "define_code_attr", "plusminus_insn", "[", "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_code_iterator", "logical", "[", "and", "ior", "xor", "]", ")", "(", "define_code_attr", "logical_insn", "[", "(", "and", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "]", ")", "(", "define_code_attr", "logical_opcode", "[", "(", "and", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "]", ")", "(", "define_code_iterator", "plusminus", "[", "plus", "minus", "]", ")" ]

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

[ "(", "V4SF", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")", "(", "V2DF", "<STR_LIT>", ")", "(", "DI", "\t", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "\t", "<STR_LIT>", ")", "(", "TF", "\t", "<STR_LIT>", ")", "(", "KF", "\t", "<STR_LIT>", ")", "(", "V1TI", "<STR_LIT>", ")" ]

[ "return", "word_mode", ";" ]

[ "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")" ]

[ "<FIXS>", "internal_error", "(", "<STR_LIT>", "MMIX Internal: %s is not a shiftable integer", "<STR_LIT>", ",", "s", ")", ";", "<FIXE>" ]

[ "{", "char", "s", "[", "sizeof", "(", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", "]", ";", "sprintf", "(", "s", ",", "<STR_LIT>", "%#", "<STR_LIT>", "PRIx64", ",", "value", ")", ";", "<BUGS>", "internal_error", "(", "<STR_LIT>", "MMIX Internal: %s is not a shiftable int", "<STR_LIT>", ",", "s", ")", ";", "<BUGE>", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<NUM_LIT>", ";", "i", "++", ")" ]

[ "}" ]

[ "unsigned", "P", "=", "I", ";", "if", "(", "!", "Defs", ".", "count", "(", "P", ")", "||", "LatePreds", ".", "count", "(", "P", ")", "||", "Defs", ".", "count", "(", "Hexagon", "::", "P3_0", ")", ")", "{", "reportErrorNewValue", "(", "P", ")", ";", "return", "false", ";", "}" ]

[ "<FIXS>", "emit_clobber", "(", "reg0", ")", "<FIXE>" ]

[ "rtx", "addr0", "=", "gen_lowpart", "(", "Pmode", ",", "gen_highpart", "(", "word_mode", ",", "reg0", ")", ")", "rtx", "len0", "=", "gen_lowpart", "(", "Pmode", ",", "reg0", ")", "<BUGS>", "emit_insn", "(", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "reg0", ")", ")", "<BUGE>", "emit_move_insn", "(", "addr0", ",", "force_operand", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "NULL_RTX", ")", ")", "emit_move_insn", "(", "len0", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "<FIXS>", "defm", "WriteALU", ":", "X86SchedWritePair", ";", "def", "WriteALURMW", ":", "WriteSequence", "[", "WriteALULd", ",", "WriteStore", "]", ">", ";", "defm", "WriteIMul", ":", "X86SchedWritePair", ";", "defm", "WriteIMul64", ":", "X86SchedWritePair", ";", "def", "WriteIMulH", ":", "SchedWrite", ";", "def", "WriteLEA", ":", "SchedWrite", ";", "<FIXE>" ]

[ "def", "WriteMove", ":", "SchedWrite", ";", "<BUGS>", "defm", "WriteALU", ":", "X86SchedWritePair", ";", "def", "WriteALURMW", ":", "WriteSequence", "[", "WriteALULd", ",", "WriteStore", "]", ">", ";", "defm", "WriteIMul", ":", "X86SchedWritePair", ";", "def", "WriteIMulH", ":", "SchedWrite", ";", "def", "WriteLEA", ":", "SchedWrite", ";", "<BUGE>", "defm", "WriteDiv8", ":", "X86SchedWritePair", ";" ]

[ "}", "else", "{" ]

[ "llvm", "::", "MachineBasicBlock", "*", "PPCTargetLowering", "::", "emitEHSjLjSetJmp", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "BasicBlock", "*", "BB", "=", "MBB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "++", "MBB", "->", "getIterator", "(", ")", ";", "MachineInstr", "::", "mmo_iterator", "MMOBegin", "=", "MI", "->", "memoperands_begin", "(", ")", ";", "MachineInstr", "::", "mmo_iterator", "MMOEnd", "=", "MI", "->", "memoperands_end", "(", ")", ";", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "DstReg", ")", ";", "assert", "(", "RC", "->", "hasType", "(", "MVT", "::", "i32", ")", "&&", "<STR_LIT>", "Invalid destination!", "<STR_LIT>", ")", ";", "unsigned", "mainDstReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "restoreDstReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MVT", "PVT", "=", "getPointerTy", "(", "MF", "->", "getDataLayout", "(", ")", ")", ";", "assert", "(", "(", "PVT", "==", "MVT", "::", "i64", "||", "PVT", "==", "MVT", "::", "i32", ")", "&&", "<STR_LIT>", "Invalid Pointer Size!", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "thisMBB", "=", "MBB", ";", "MachineBasicBlock", "*", "mainMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "BB", ")", ";", "MF", "->", "insert", "(", "I", ",", "mainMBB", ")", ";", "MF", "->", "insert", "(", "I", ",", "sinkMBB", ")", ";", "MachineInstrBuilder", "MIB", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "MBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "MBB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "MBB", ")", ";", "const", "int64_t", "LabelOffset", "=", "<NUM_LIT>", "*", "PVT", ".", "getStoreSize", "(", ")", ";", "const", "int64_t", "TOCOffset", "=", "<NUM_LIT>", "*", "PVT", ".", "getStoreSize", "(", ")", ";", "const", "int64_t", "BPOffset", "=", "<NUM_LIT>", "*", "PVT", ".", "getStoreSize", "(", ")", ";", "const", "TargetRegisterClass", "*", "PtrRC", "=", "getRegClassFor", "(", "PVT", ")", ";", "unsigned", "LabelReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "unsigned", "BufReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", "&&", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "setUsesTOCBasePtr", "(", "*", "MBB", "->", "getParent", "(", ")", ")", ";", "MIB", "=", "BuildMI", "(", "*", "thisMBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "STD", ")", ")", ".", "addReg", "(", "PPC", "::", "X2", ")", ".", "addImm", "(", "TOCOffset", ")", ".", "addReg", "(", "BufReg", ")", ";", "MIB", ".", "setMemRefs", "(", "MMOBegin", ",", "MMOEnd", ")", ";", "}", "unsigned", "BaseReg", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ")", "BaseReg", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "else", "BaseReg", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "BP8", ":", "PPC", "::", "BP", ";", "MIB", "=", "BuildMI", "(", "*", "thisMBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "STD", ":", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "BaseReg", ")", ".", "addImm", "(", "BPOffset", ")", ".", "addReg", "(", "BufReg", ")", ";", "MIB", ".", "setMemRefs", "(", "MMOBegin", ",", "MMOEnd", ")", ";", "MIB", "=", "BuildMI", "(", "*", "thisMBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "BCLalways", ")", ")", ".", "addMBB", "(", "mainMBB", ")", ";", "const", "PPCRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", "->", "getNoPreservedMask", "(", ")", ")", ";", "BuildMI", "(", "*", "thisMBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "LI", ")", ",", "restoreDstReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MIB", "=", "BuildMI", "(", "*", "thisMBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "EH_SjLj_Setup", ")", ")", ".", "addMBB", "(", "mainMBB", ")", ";", "MIB", "=", "BuildMI", "(", "*", "thisMBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "B", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "thisMBB", "->", "addSuccessor", "(", "mainMBB", ",", "<NUM_LIT>", ")", ";", "thisMBB", "->", "addSuccessor", "(", "sinkMBB", ",", "<NUM_LIT>", ")", ";", "MIB", "=", "BuildMI", "(", "mainMBB", ",", "DL", ",", "TII", "->", "get", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "MFLR8", ":", "PPC", "::", "MFLR", ")", ",", "LabelReg", ")", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "MIB", "=", "BuildMI", "(", "mainMBB", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "STD", ")", ")", ".", "addReg", "(", "LabelReg", ")", ".", "addImm", "(", "LabelOffset", ")", ".", "addReg", "(", "BufReg", ")", ";" ]

[ "case", "ISD", "::", "SETGE", ":" ]

[ "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "EVT", "ResVT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "CmpVT", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "SDValue", "LHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "RHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "TV", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "FV", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDNodeFlags", "Flags", "=", "Op", ".", "getNode", "(", ")", "->", "getFlags", "(", ")", ";", "if", "(", "Subtarget", ".", "hasP9Vector", "(", ")", "&&", "LHS", "==", "TV", "&&", "RHS", "==", "FV", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETOGT", ":", "case", "ISD", "::", "SETGT", ":", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ")", ";", "case", "ISD", "::", "SETOLT", ":", "case", "ISD", "::", "SETLT", ":", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ")", ";", "}", "}", "if", "(", "(", "!", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "NoInfsFPMath", "&&", "!", "Flags", ".", "hasNoInfs", "(", ")", ")", "||", "(", "!", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "NoNaNsFPMath", "&&", "!", "Flags", ".", "hasNoNaNs", "(", ")", ")", ")", "return", "Op", ";", "SDValue", "Sel1", ";", "if", "(", "isFloatingPointZero", "(", "RHS", ")", ")", "switch", "(", "CC", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETNE", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SETEQ", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ";", "Sel1", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "LHS", ",", "TV", ",", "FV", ")", ";", "if", "(", "Sel1", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Sel1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Sel1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ",", "Sel1", ",", "FV", ")", ";", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETLT", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SETOGE", ":", "case", "ISD", "::", "SETGE", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "LHS", ",", "TV", ",", "FV", ")", ";", "case", "ISD", "::", "SETUGT", ":", "case", "ISD", "::", "SETGT", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SETOLE", ":", "case", "ISD", "::", "SETLE", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ",", "TV", ",", "FV", ")", ";", "}", "SDValue", "Cmp", ";", "switch", "(", "CC", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETNE", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SETEQ", ":", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "CmpVT", ",", "LHS", ",", "RHS", ",", "Flags", ")", ";", "if", "(", "Cmp", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ";", "Sel1", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "Cmp", ",", "TV", ",", "FV", ")", ";", "if", "(", "Sel1", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Sel1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Sel1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ",", "Sel1", ",", "FV", ")", ";", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETLT", ":", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "CmpVT", ",", "LHS", ",", "RHS", ",", "Flags", ")", ";", "if", "(", "Cmp", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "Cmp", ",", "FV", ",", "TV", ")", ";", "case", "ISD", "::", "SETOGE", ":" ]

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

[ "void", "Cpu0AsmPrinter", "::", "EmitFunctionBodyEnd", "(", ")", "{", "if", "(", "OutStreamer", "->", "hasRawTextSupport", "(", ")", ")", "{", "if", "(", "Cpu0MFI", "->", "getEmitNOAT", "(", ")", ")", "OutStreamer", "->", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.set\\tat", "<STR_LIT>", ")", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.set\\tmacro", "<STR_LIT>" ]

[ "<FIXS>", "case", "TYPE_ALU_IMM", ":", "case", "TYPE_ALUS_IMM", ":", "case", "TYPE_LOGIC_IMM", ":", "case", "TYPE_LOGICS_IMM", ":", "<FIXE>" ]

[ "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "<BUGS>", "case", "TYPE_ARLO_IMM", ":", "<BUGE>", "case", "TYPE_EXTEND", ":", "case", "TYPE_MVN_IMM", ":", "case", "TYPE_MOV_IMM", ":" ]

[ "UseLargeMem", ";" ]

[ "bool", "usingLargeMem", "(", ")", "const", "{", "return" ]

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

[ "def", "A2_vcmpweq", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeALU64", ">", ",", "Enc_fcf7a7", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]