Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "BI", "SCC_REG", ")", "(", "leu", ":", "BI", "(", "minus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

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

[ "FIST_ROUNDING", ")", ")", "(", "use", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "FIST_ROUNDING", ")", ")", "(", "use", "(", "match_dup" ]

[ "&&", "Value", "<=", "<NUM_LIT>", ")", ";" ]

[ "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return", "false", ";", "uint64_t", "Value", "=", "CE", "->", "getValue", "(", ")", ";", "return", "(", "Value", "%", "Angle", "==", "Remainder" ]

[ "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "reg", ",", "count", ";", "int", "int_or_sig_p", "=", "(", "interrupt_function_p", "(", "current_function_decl", ")", "||", "signal_function_p", "(", "current_function_decl", ")", ")", ";", "int", "leaf_func_p", "=", "leaf_function_p", "(", ")", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "<NUM_LIT>", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", "return", "<NUM_LIT>", ";", "for", "(", "reg", "=", "<NUM_LIT>", ";", "reg", "<", "<NUM_LIT>", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "leaf_func_p", "&&", "call_used_regs", "[", "reg", "]", ")", "||", "(", "regs_ever_live", "[", "reg", "]", "&&", "(", "int_or_sig_p", "||", "!", "call_used_regs", "[", "reg", "]", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "(", "REG_Y", "+", "<NUM_LIT>", ")", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}" ]

[ "Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "." ]

[ "<FIXS>", "return", "output_millicode_call", "(", "insn", ",", "gen_rtx", "(", "SYMBOL_REF", ",", "SImode", ",", "buf", ")", ")", ";", "<FIXE>", "<FIXS>", "return", "output_millicode_call", "(", "insn", ",", "gen_rtx", "(", "SYMBOL_REF", ",", "SImode", ",", "buf", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "unsignedp", ")", "{", "sprintf", "(", "buf", ",", "<STR_LIT>", "$$divU_%d", "<STR_LIT>", ",", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "<BUGS>", "return", "output_call", "(", "insn", ",", "gen_rtx", "(", "SYMBOL_REF", ",", "SImode", ",", "buf", ")", ",", "gen_rtx", "(", "REG", ",", "SImode", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}", "else", "{", "sprintf", "(", "buf", ",", "<STR_LIT>", "$$divI_%d", "<STR_LIT>", ",", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "<BUGS>", "return", "output_call", "(", "insn", ",", "gen_rtx", "(", "SYMBOL_REF", ",", "SImode", ",", "buf", ")", ",", "gen_rtx", "(", "REG", ",", "SImode", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}", "}" ]

[ "]", ")" ]

[ "(", "V4SI", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")" ]

[ "}" ]

[ "void", "SetMinSize", "(", "bool", "MinSize_", ")", "{", "MinSize", "=", "MinSize_", ";" ]

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

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

[ "NumElts", "*", "Scale", ",", "SM_SentinelUndef", ")", ";" ]

[ "if", "(", "isOneConstant", "(", "N1", ")", "&&", "N0", "->", "hasOneUse", "(", ")", ")", "{", "SDValue", "Src", "=", "N0", ";", "while", "(", "(", "Src", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "||", "Src", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "&&", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", "->", "hasOneUse", "(", ")", ")", "Src", "=", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "bool", "ContainsNOT", "=", "false", ";", "X86", "::", "CondCode", "X86CC", "=", "X86", "::", "COND_B", ";", "if", "(", "isBitwiseNot", "(", "Src", ")", ")", "{", "Src", "=", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "X86CC", "=", "X86", "::", "COND_AE", ";", "ContainsNOT", "=", "true", ";", "}", "if", "(", "Src", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "!", "isa", "<", "ConstantSDNode", ">", "(", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "BitNo", "=", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Src", "=", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "isBitwiseNot", "(", "Src", ")", ")", "{", "Src", "=", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "X86CC", "=", "X86CC", "==", "X86", "::", "COND_AE", "?", "X86", "::", "COND_B", ":", "X86", "::", "COND_AE", ";", "ContainsNOT", "=", "true", ";", "}", "if", "(", "!", "(", "Subtarget", ".", "hasBMI2", "(", ")", "&&", "!", "ContainsNOT", "&&", "VT", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", ")", "if", "(", "SDValue", "BT", "=", "getBT", "(", "Src", ",", "BitNo", ",", "dl", ",", "DAG", ")", ")", "return", "DAG", ".", "getZExtOrTrunc", "(", "getSETCC", "(", "X86CC", ",", "BT", ",", "dl", ",", "DAG", ")", ",", "dl", ",", "VT", ")", ";", "}", "}", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "SDValue", "Op", "(", "N", ",", "<NUM_LIT>", ")", ";", "if", "(", "SDValue", "Res", "=", "combineX86ShufflesRecursively", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ")", "return", "Res", ";", "auto", "GetDemandedMasks", "=", "[", "&", "]", "(", "SDValue", "Op", ")", "{", "APInt", "UndefElts", ";", "SmallVector", "<", "APInt", ">", "EltBits", ";", "int", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "int", "EltSizeInBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "APInt", "DemandedBits", "=", "APInt", "::", "getAllOnes", "(", "EltSizeInBits", ")", ";", "APInt", "DemandedElts", "=", "APInt", "::", "getAllOnes", "(", "NumElts", ")", ";", "if", "(", "getTargetConstantBitsFromNode", "(", "Op", ",", "EltSizeInBits", ",", "UndefElts", ",", "EltBits", ")", ")", "{", "DemandedBits", ".", "clearAllBits", "(", ")", ";", "DemandedElts", ".", "clearAllBits", "(", ")", ";", "for", "(", "int", "I", "=", "<NUM_LIT>", ";", "I", "!=", "NumElts", ";", "++", "I", ")", "if", "(", "!", "EltBits", "[", "I", "]", ".", "isZero", "(", ")", ")", "{", "DemandedBits", "|=", "EltBits", "[", "I", "]", ";", "DemandedElts", ".", "setBit", "(", "I", ")", ";", "}", "}", "return", "std", "::", "make_pair", "(", "DemandedBits", ",", "DemandedElts", ")", ";", "}", ";", "std", "::", "pair", "<", "APInt", ",", "APInt", ">", "Demand0", "=", "GetDemandedMasks", "(", "N1", ")", ";", "std", "::", "pair", "<", "APInt", ",", "APInt", ">", "Demand1", "=", "GetDemandedMasks", "(", "N0", ")", ";", "if", "(", "TLI", ".", "SimplifyDemandedVectorElts", "(", "N0", ",", "Demand0", ".", "second", ",", "DCI", ")", "||", "TLI", ".", "SimplifyDemandedVectorElts", "(", "N1", ",", "Demand1", ".", "second", ",", "DCI", ")", "||", "TLI", ".", "SimplifyDemandedBits", "(", "N0", ",", "Demand0", ".", "first", ",", "Demand0", ".", "second", ",", "DCI", ")", "||", "TLI", ".", "SimplifyDemandedBits", "(", "N1", ",", "Demand1", ".", "first", ",", "Demand1", ".", "second", ",", "DCI", ")", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "DELETED_NODE", ")", "DCI", ".", "AddToWorklist", "(", "N", ")", ";", "return", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "SDValue", "NewN0", "=", "TLI", ".", "SimplifyMultipleUseDemandedBits", "(", "N0", ",", "Demand0", ".", "first", ",", "Demand0", ".", "second", ",", "DAG", ")", ";", "SDValue", "NewN1", "=", "TLI", ".", "SimplifyMultipleUseDemandedBits", "(", "N1", ",", "Demand1", ".", "first", ",", "Demand1", ".", "second", ",", "DAG", ")", ";", "if", "(", "NewN0", "||", "NewN1", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "NewN0", "?", "NewN0", ":", "N0", ",", "NewN1", "?", "NewN1", ":", "N1", ")", ";", "}", "if", "(", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", "&&", "isa", "<", "ConstantSDNode", ">", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "BitMask", "=", "N1", ";", "SDValue", "SrcVec", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "SrcVecVT", "=", "SrcVec", ".", "getValueType", "(", ")", ";", "APInt", "UndefElts", ";", "SmallVector", "<", "APInt", ",", "<NUM_LIT>", ">", "EltBits", ";", "if", "(", "VT", "==", "SrcVecVT", ".", "getScalarType", "(", ")", "&&", "N0", "->", "isOnlyUserOf", "(", "SrcVec", ".", "getNode", "(", ")", ")", "&&", "getTargetConstantBitsFromNode", "(", "BitMask", ",", "<NUM_LIT>", ",", "UndefElts", ",", "EltBits", ")", "&&", "llvm", "::", "all_of", "(", "EltBits", ",", "[", "]", "(", "const", "APInt", "&", "M", ")", "{", "return", "M", ".", "isZero", "(", ")", "||", "M", ".", "isAllOnes", "(", ")", ";", "}", ")", ")", "{", "unsigned", "NumElts", "=", "SrcVecVT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "Scale", "=", "SrcVecVT", ".", "getScalarSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "unsigned", "Idx", "=", "N0", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleMask", "(" ]

[ "v256f64", ":", "$", "vz", ",", "(", "ULO7", "$", "N", ")", ",", "i32", ":", "$", "vl", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vsrawsx_vvsl", "v256f64", ":", "$", "vz", ",", "uimm6", ":", "$", "N", ",", "i32", ":", "$", "vl", ")", ",", "(", "VSRAWSXvil" ]

[ "break", ";" ]

[ "for", "(", "int", "j", "=", "<NUM_LIT>", ";", "j", "<", "n", ";", "j", "++", ")", "args", "[", "j", "]", "=", "fully_fold_convert", "(", "arg_type", "[", "j", "]", ",", "args", "[", "j", "]", ")", ";", "gcc_assert", "(", "MAX_OVLD_ARGS", "<=", "<NUM_LIT>", ")", ";", "tree", "call", ";", "switch", "(", "n", ")", "{", "case", "<NUM_LIT>", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "<NUM_LIT>", ",", "args", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "<NUM_LIT>", ",", "args", "[", "<NUM_LIT>", "]", ",", "args", "[", "<NUM_LIT>", "]", ")", ";" ]

[ "static", "int", "ix86_int_cmp_code_to_pcmp_immediate", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "<NUM_LIT>", ";", "case", "LT", ":", "case", "LTU", ":", "return", "<NUM_LIT>", ";", "case", "LE", ":", "case", "LEU", ":", "return", "<NUM_LIT>", ";", "case", "NE", ":", "return", "<NUM_LIT>", ";", "case", "GE", ":", "case", "GEU", ":", "return", "<NUM_LIT>", ";", "case", "GT", ":", "case", "GTU", ":", "return", "<NUM_LIT>", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}" ]

[ "Helper", "for", "ix86_cmp_code_to_pcmp_immediate", "for", "int", "modes", "." ]

[ "<FIXS>", "unsigned", "getCacheLineSize", "(", ")", "const", "override", ";", "unsigned", "getPrefetchDistance", "(", ")", "const", "override", ";", "<FIXE>" ]

[ "bool", "enableInterleavedAccessVectorization", "(", ")", ";", "unsigned", "getNumberOfRegisters", "(", "bool", "Vector", ")", ";", "unsigned", "getRegisterBitWidth", "(", "bool", "Vector", ")", "const", ";", "<BUGS>", "unsigned", "getCacheLineSize", "(", ")", ";", "unsigned", "getPrefetchDistance", "(", ")", ";", "<BUGE>", "unsigned", "getMaxInterleaveFactor", "(", "unsigned", "VF", ")", ";", "int", "vectorCostAdjustment", "(", "int", "Cost", ",", "unsigned", "Opcode", ",", "Type", "*", "Ty1", ",", "Type", "*", "Ty2", ")", ";", "int", "getArithmeticInstrCost", "(" ]

[ "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";" ]

[ "diff", "=", "t", "-", "f", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "<NUM_LIT>", "&&", "exact_log2", "(", "diff", ")", ">", "<NUM_LIT>", "&&", "(", "diff", "<=", "<NUM_LIT>", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "<NUM_LIT>", "&&", "t", "==", "-", "<NUM_LIT>", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "<NUM_LIT>", "||", "diff", "==", "<NUM_LIT>", "||", "diff", "==", "<NUM_LIT>", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "<NUM_LIT>", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(" ]

[ "else", "if", "(", "reload_completed", "&&", "(", "code", "==", "LABEL_REF", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "use_ldrd", "=", "(", "TARGET_LDRD", "&&", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", ")", ";", "if", "(", "code", "==", "POST_INC", "||", "code", "==", "PRE_DEC", "||", "(", "(", "code", "==", "PRE_INC", "||", "code", "==", "POST_DEC", ")", "&&", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "<NUM_LIT>", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "strict_p", ")", ";", "else", "if", "(", "(", "code", "==", "POST_MODIFY", "||", "code", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "strict_p", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "{", "rtx", "addend", "=", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "use_ldrd", "&&", "GET_CODE", "(", "x", ")", "==", "POST_MODIFY", "&&", "REG_P", "(", "addend", ")", ")", "return", "<NUM_LIT>", ";", "return", "(", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "<NUM_LIT>", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "addend", ",", "outer", ",", "strict_p", ")", ")", ";", "}" ]

[ "if", "(", "!", "PrevElemFromFirstVec", "&&", "Mask", "[", "i", "]", ">=", "NumElts", ")", "return", "false", ";" ]

[ "bool", "PrevElemFromFirstVec", "=", "Mask", "[", "<NUM_LIT>", "]", "<", "NumElts", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "Mask", ".", "size", "(", ")", ";", "i", "<", "e", ";", "i", "++", ")", "{", "if", "(", "PrevElemFromFirstVec", "&&", "Mask", "[", "i", "]", "<", "NumElts", ")", "return", "false", ";" ]

[ "}" ]

[ "if", "(", "Mask", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND_INREG", ")", "{", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "NewOps", "(", "N", "->", "op_begin", "(", ")", ",", "N", "->", "op_end", "(", ")", ")", ";", "NewOps", "[", "<NUM_LIT>", "]", "=", "Mask", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DAG", ".", "UpdateNodeOperands", "(", "N", ",", "NewOps", ")", ";" ]

[ ")", ";" ]

[ "--", "I", ";", "if", "(", "I", "->", "isEHLabel", "(", ")", ")", "return", "true", ";", "}", "while", "(", "I", "!=", "MBB", ".", "instr_begin", "(", ")", ")", ";", "I", "=", "MBB", ".", "instr_end", "(", ")", ";", "--", "I", ";", "while", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "AllowModify", "&&", "I", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "JMP", "&&", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\nErasing the jump to successor block\\n", "<STR_LIT>", ";", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "instr_end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "!", "isUnpredicatedTerminator", "(", "I", ")", ")", "return", "false", ";", "MachineInstr", "*", "LastInst", "=", "I", ";", "MachineInstr", "*", "SecondLastInst", "=", "NULL", ";", "do", "{", "if", "(", "&", "*", "I", "!=", "LastInst", "&&", "!", "I", "->", "isBundle", "(", ")", "&&", "isUnpredicatedTerminator", "(", "I", ")", ")", "{", "if", "(", "!", "SecondLastInst", ")", "SecondLastInst", "=", "I", ";", "else", "return", "true", ";", "}", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "break", ";", "--", "I", ";", "}", "while", "(", "I", ")", ";", "int", "LastOpcode", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "bool", "LastOpcodeHasJMP_c", "=", "PredOpcodeHasJMP_c", "(", "LastOpcode", ")", ";", "bool", "LastOpcodeHasNot", "=", "PredOpcodeHasNot", "(", "LastOpcode", ")", ";", "if", "(", "LastInst", "&&", "!", "SecondLastInst", ")", "{", "if", "(", "LastOpcode", "==", "Hexagon", "::", "JMP", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "LastOpcode", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "false", ";", "}", "if", "(", "LastOpcodeHasJMP_c", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "LastOpcodeHasNot", ")", "{", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ")", ";", "}", "Cond", ".", "push_back", "(", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "int", "SecLastOpcode", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "bool", "SecLastOpcodeHasJMP_c", "=", "PredOpcodeHasJMP_c", "(", "SecLastOpcode", ")", ";", "bool", "SecLastOpcodeHasNot", "=", "PredOpcodeHasNot", "(", "SecLastOpcode", ")", ";", "if", "(", "SecLastOpcodeHasJMP_c", "&&", "(", "LastOpcode", "==", "Hexagon", "::", "JMP", ")", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "SecLastOpcodeHasNot", ")", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "SecLastOpcode", "==", "Hexagon", "::", "JMP", "&&", "LastOpcode", "==", "Hexagon", "::", "JMP", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "I", "=", "LastInst", ";", "if", "(", "AllowModify", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "false", ";", "}", "if", "(", "SecLastOpcode", "==", "Hexagon", "::", "ENDLOOP0", "&&", "LastOpcode", "==", "Hexagon", "::", "JMP", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(" ]

[ ";" ]

[ "rtx", "c", "=", "get_pool_constant", "(", "x", ")", ";", "machine_mode", "cmode", "=", "get_pool_mode", "(", "x", ")", ";", "if", "(", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "c", ",", "cmode", ")", ")", "return", "true", ";", "}", "return", "false" ]

[ "const", "TargetRegisterClass", "*", "XNCMRegisterInfo", "::", "getPointerRegClass", "(", "unsigned", "Kind", ")", "const", "{", "return", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ ",", "MachinePointerInfo", "(", "SrcSV", ")", ")", ";" ]

[ "unsigned", "VaListSize", "=", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", "||", "Subtarget", "->", "isTargetWindows", "(", ")", ")", "?", "PtrSize", ":", "<NUM_LIT>", ";", "const", "Value", "*", "DestSV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "const", "Value", "*", "SrcSV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "return", "DAG", ".", "getMemcpy", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DL", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "VaListSize", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "PtrSize", ",", "false", ",", "false", ",", "false", ",", "MachinePointerInfo", "(", "DestSV", ")" ]

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

[ "}" ]

[ "const", "ArgDescriptor", "*", "Arg", "=", "getArgDescriptor", "(", "B", ",", "ArgType", ")", ";", "if", "(", "!", "Arg", ")", "return", "false", ";", "if", "(", "!", "loadInputValue", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "B", ",", "Arg", ")", ")", "return", "false", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";" ]

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

[ "if", "(", "HiOperand", ".", "isGlobal", "(", ")", ")", "{", "BuildMI", "(", "*", "BB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "COMBINE_Ii", ")", ",", "DoubleDestReg", ")", ".", "addGlobalAddress", "(", "HiOperand", ".", "getGlobal", "(", ")", ",", "HiOperand", ".", "getOffset", "(", ")", ",", "HiOperand", ".", "getTargetFlags", "(", ")", ")", ".", "addImm", "(", "LoOperand", ".", "getImm", "(", ")", ")", ";", "return", ";", "}", "if", "(", "LoOperand", ".", "isGlobal", "(", ")", ")", "{", "BuildMI", "(", "*", "BB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "COMBINE_iI_V4", ")", ",", "DoubleDestReg", ")", ".", "addImm", "(", "HiOperand", ".", "getImm", "(", ")", ")", ".", "addGlobalAddress", "(", "LoOperand", ".", "getGlobal", "(", ")", ",", "LoOperand", ".", "getOffset", "(", ")", ",", "LoOperand", ".", "getTargetFlags", "(", ")", ")", ";", "return", ";", "}", "if", "(", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "HiOperand", "." ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "}", "else", "if", "(", "ACPV", "->", "isBlockAddress", "(", ")", ")", "{", "const", "BlockAddress", "*", "BA", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getBlockAddress", "(", ")", ";", "MCSym", "=", "GetBlockAddressSymbol", "(", "BA", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isGlobalValue", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getGV", "(", ")", ";", "unsigned", "char", "TF", "=", "Subtarget", "->", "isTargetMachO", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "MCSym", "=", "GetARMGVSymbol", "(", "GV", ",", "TF", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isMachineBasicBlock", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "cast", "<", "ARMConstantPoolMBB", ">", "(", "ACPV", ")", "->", "getMBB", "(", ")", ";", "MCSym", "=", "MBB", "->", "getSymbol", "(", ")", ";", "}", "else", "{", "assert", "(", "ACPV", "->", "isExtSymbol", "(", ")", "&&", "<STR_LIT>", "unrecognized constant pool value", "<STR_LIT>", ")", ";", "auto", "Sym", "=", "cast", "<", "ARMConstantPoolSymbol", ">", "(", "ACPV", ")", "->", "getSymbol", "(", ")", ";", "MCSym", "=", "GetExternalSymbolSymbol", "(", "Sym", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ",", "getModifierVariantKind", "(", "ACPV", "->", "getModifier", "(", ")", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ")", "{", "MCSymbol", "*", "PCLabel", "=", "getPICLabel", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ",", "getFunctionNumber", "(", ")", ",", "ACPV", "->", "getLabelId", "(", ")", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PCRelExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "PCLabel", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createAdd", "(", "PCRelExpr", ",", "MCConstantExpr", "::", "create", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ",", "OutContext", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "mustAddCurrentAddress", "(", ")", ")", "{", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "createTempSymbol", "(", ")", ";", "OutStreamer", "->", "EmitLabel", "(", "DotSym", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "DotSym", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createSub", "(", "PCRelExpr", ",", "DotExpr", ",", "OutContext", ")", ";", "}", "Expr", "=", "MCBinaryExpr", "::", "createSub", "(", "Expr", ",", "PCRelExpr", ",", "OutContext", ")", ";", "}", "else", "if", "(", "ACPV", "->", "getModifier", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "auto", "*", "F", "=", "cast", "<", "Function", ">", "(", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getGV", "(", ")", ")", ";", "const", "MCSymbol", "*", "BinSym", "=", "GetSectionSymbol", "(", "F", ")", ";", "const", "MCExpr", "*", "BinExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "BinSym", ",", "OutContext", ")", ";", "Expr", "=", "MCBinaryExpr", "::", "createSub", "(", "Expr", ",", "BinExpr", ",", "OutContext", ")", ";", "}", "OutStreamer", "->", "EmitValue", "(", "Expr", ",", "Size", ")", ";" ]

[ ";" ]

[ "static", "void", "PrepareTailCall", "(", "SelectionDAG", "&", "DAG", ",", "SDValue", "&", "InFlag", ",", "SDValue", "&", "Chain", ",", "SDLoc", "dl", ",", "bool", "isPPC64", ",", "int", "SPDiff", ",", "unsigned", "NumBytes", ",", "SDValue", "LROp", ",", "SDValue", "FPOp", ",", "bool", "isDarwinABI", ",", "SmallVector", "<", "TailCallArgumentInfo", ",", "<NUM_LIT>", ">", "&", "TailCallArguments", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains2", ";", "InFlag", "=", "SDValue", "(", ")" ]

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

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

[ ":" ]

[ "case", "X86", "::", "VMOVDQUrm", ":", "case", "X86", "::", "VMOVUPSYrm", ":", "case", "X86", "::", "VMOVAPSYrm", ":", "case", "X86", "::", "VMOVUPDYrm", ":", "case", "X86", "::", "VMOVAPDYrm", ":", "case", "X86", "::", "VMOVDQUYrm", ":", "case", "X86", "::", "VMOVDQAYrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "VMOVSSZrm", ":", "case", "X86", "::", "VMOVSDZrm", ":", "case", "X86", "::", "VMOVAPSZrm", ":", "case", "X86", "::", "VMOVAPSZ128rm", ":", "case", "X86", "::", "VMOVAPSZ256rm", ":", "case", "X86", "::", "VMOVUPSZrm", ":", "case", "X86", "::", "VMOVUPSZ128rm", ":", "case", "X86", "::", "VMOVUPSZ256rm", ":", "case", "X86", "::", "VMOVAPDZrm", ":", "case", "X86", "::", "VMOVAPDZ128rm", ":", "case", "X86", "::", "VMOVAPDZ256rm", ":", "case", "X86", "::", "VMOVUPDZrm", ":", "case", "X86", "::", "VMOVUPDZ128rm", ":", "case", "X86", "::", "VMOVUPDZ256rm", ":", "case", "X86", "::", "VMOVDQA32Zrm", ":", "case", "X86", "::", "VMOVDQA32Z128rm", ":", "case", "X86", "::", "VMOVDQA32Z256rm", ":", "case", "X86", "::", "VMOVDQU32Zrm", ":", "case", "X86", "::", "VMOVDQU32Z128rm", ":", "case", "X86", "::", "VMOVDQU32Z256rm", ":", "case", "X86", "::", "VMOVDQA64Zrm", ":", "case", "X86", "::", "VMOVDQA64Z128rm", ":", "case", "X86", "::", "VMOVDQA64Z256rm" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "div", ":", "DF", "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "for", "(", "MCRegAliasIterator", "AI", "(", "R", ",", "&", "TRI", ",", "false", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "AS", ".", "push_back", "(", "RegisterRef", "(", "{", "*", "AI", ",", "<NUM_LIT>", "}", ")", ")", ";", "return", "AS", ";" ]

[ ";" ]

[ "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>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_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", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "dst", ")", ",", "(", "OpNode", "(", "v4i32", "V128", ":", "$", "Rd", ")", ",", "(", "v4i16", "V64", ":", "$", "Rn", ")", ",", "(", "v4i16", "V64", ":", "$", "Rm", ")", ")", ")", "]", ">", ";" ]

[ "def", "v4i16_v4i32", ":", "BaseSIMDDifferentThreeVectorTied", "<", "U", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V64", ",", "V64", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v4i32", "V128", ":", "$" ]

[ "_", "p", ")", ";" ]

[ "return", "_", "_", "builtin_mve_vctp64q_mv2qi", "(", "_", "_", "a", ",", "_" ]

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

[ "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "hasPAC", "=", "AFI", "->", "shouldSignReturnAddress", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "isTailCall", "=", "false", ";", "bool", "isInterrupt", "=", "false", ";", "bool", "isTrap", "=", "false", ";", "bool", "isCmseEntry", "=", "false", ";", "if", "(", "MBB", ".", "end", "(", ")", "!=", "MI", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "RetOpcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "isTailCall", "=", "(", "RetOpcode", "==", "ARM", "::", "TCRETURNdi", "||", "RetOpcode", "==", "ARM", "::", "TCRETURNri", ")", ";", "isInterrupt", "=", "RetOpcode", "==", "ARM", "::", "SUBS_PC_LR", "||", "RetOpcode", "==", "ARM", "::", "t2SUBS_PC_LR", ";", "isTrap", "=", "RetOpcode", "==", "ARM", "::", "TRAP", "||", "RetOpcode", "==", "ARM", "::", "TRAPNaCl", "||", "RetOpcode", "==", "ARM", "::", "tTRAP", ";", "isCmseEntry", "=", "(", "RetOpcode", "==", "ARM", "::", "tBXNS", "||", "RetOpcode", "==", "ARM", "::", "tBXNS_RET", ")", ";", "}", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "Regs", ";", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "while", "(", "i", "!=", "<NUM_LIT>", ")", "{", "unsigned", "LastReg", "=", "<NUM_LIT>", ";", "bool", "DeleteRet", "=", "false", ";", "for", "(", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "CalleeSavedInfo", "&", "Info", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ";", "Register", "Reg", "=", "Info", ".", "getReg", "(", ")", ";", "if", "(", "!", "(", "Func", ")", "(", "Reg", ",", "STI", ".", "splitFramePushPop", "(", "MF", ")", ")", ")", "continue", ";", "if", "(", "Reg", ">=", "ARM", "::", "D8", "&&", "Reg", "<", "ARM", "::", "D8", "+", "NumAlignedDPRCS2Regs", ")", "continue", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", "&&", "!", "isTailCall", "&&", "!", "isVarArg", "&&", "!", "isInterrupt", "&&", "!", "isCmseEntry", "&&", "!", "isTrap", "&&", "AFI", "->", "getArgumentStackToRestore", "(", ")", "==", "<NUM_LIT>", "&&", "STI", ".", "hasV5TOps", "(", ")", "&&", "MBB", ".", "succ_empty", "(", ")", "&&", "!", "hasPAC", "&&", "!", "STI", ".", "splitFramePointerPush", "(", "MF", ")", ")", "{", "Reg", "=", "ARM", "::", "PC", ";", "DeleteRet", "=", "true", ";", "LdmOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDMIA_RET", ":", "ARM", "::", "LDMIA_RET", ";", "}", "if", "(", "NoGap", "&&", "LastReg", "&&", "LastReg", "!=", "Reg", "-", "<NUM_LIT>", ")", "break", ";", "LastReg", "=", "Reg", ";", "Regs", ".", "push_back", "(", "Reg", ")", ";", "}", "if", "(", "Regs", ".", "empty", "(", ")", ")", "continue", ";", "llvm", "::", "sort", "(", "Regs", ",", "[", "&", "]", "(", "unsigned", "LHS", ",", "unsigned", "RHS", ")", "{", "return", "TRI", ".", "getEncodingValue", "(", "LHS", ")", "<", "TRI", ".", "getEncodingValue", "(", "RHS", ")", ";", "}", ")", ";", "if", "(", "Regs", ".", "size", "(", ")", ">", "<NUM_LIT>", "||", "LdrOpc", "==", "<NUM_LIT>", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdmOpc", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Regs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "MIB", ".", "addReg", "(", "Regs", "[", "i", "]", ",", "getDefRegState", "(", "true", ")", ")", ";", "if", "(", "DeleteRet", ")", "{", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MIB", ".", "copyImplicitOps", "(", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "MI", "=", "MIB", ";", "}", "else", "if", "(", "Regs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "Regs", "[", "<NUM_LIT>", "]", "==", "ARM", "::", "PC", ")", "Regs", "[", "<NUM_LIT>", "]", "=", "ARM", "::", "LR", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ",", "Regs", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "ARM", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "LdrOpc", "==", "ARM", "::", "LDR_POST_REG", "||", "LdrOpc", "==", "ARM", "::", "LDR_POST_IMM", ")", "{", "MIB", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MIB", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "::", "<STR_LIT>", "," ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "match_parallel", "<NUM_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

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

[ "vqrdmlah_s32", "(", "int32x2_t", "_", "_", "a", ",", "int32x2_t", "_", "_", "b", ",", "int32x2_t", "_", "_", "c", ")", "{", "return", "(", "int32x2_t", ")", "_", "_", "builtin_neon_vqrdmlahv2si", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_" ]

[ "}" ]

[ "static", "_", "_", "inline", "qword", "si_roti", "(", "qword", "a", ",", "int", "b", ")", "{", "return", "(", "(", "qword", ")", "(", "vec_rl", "(", "(", "vec_uint4", ")", "(", "a", ")", ",", "vec_splat", "(", "(", "vec_uint4", ")", "(", "si_from_int", "(", "b", ")", ")", ",", "<NUM_LIT>", ")", ")", ")", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "Wri", ":", "BaseBitfieldImmWith2RegArgs", "<", "opc", ",", "GPR32", ",", "imm0_31", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "let", "isCommutable", "=", "<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>", ";" ]

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

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

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "PowerPC Branch Selector", "<STR_LIT>", ";", "}" ]

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

[ "}" ]

[ "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "X86ScalarSSEf64", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "X86ScalarSSEf32", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f80", ")", "return", "false", ";", "return", "(", "AllowI1", "&&", "VT", "==", "MVT", "::", "i1", ")", "||", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";" ]

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

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

[ "(", "Kind", "&", "VK_SymLocBits", ")", ";" ]

[ "static", "VariantKind", "getSymbolLoc", "(", "VariantKind", "Kind", ")", "{", "return", "static_cast", "<", "VariantKind", ">" ]

[ ">", "(", "INST", "#", "<STR_LIT>", ")", "V128", ":", "$", "Rd", ",", "V128", ":", "$", "Rn", ",", "(", "SUBREG_TO_REG", "(", "i32", "<NUM_LIT>", ")", ",", "(", "f16", "FPR16Op_lo", ":", "$", "Rm", ")", ",", "hsub", ")", ",", "(", "i64", "<NUM_LIT>", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v8f16", "(", "OpNode", "(", "v8f16", "V128", ":", "$", "Rd", ")", ",", "(", "v8f16", "V128", ":", "$", "Rn", ")", ",", "(", "AArch64dup", "(", "f16", "FPR16Op_lo", ":", "$", "Rm", ")", ")", ")", ")", ",", "(", "!", "cast", "<", "Instruction" ]

[ "}" ]

[ "def", "uimm_exact64", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "Imm", "=", "=", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass", "=", "exact64_asmoperand", ";" ]

[ ";" ]

[ "for", "(", "unsigned", "Chan", "=", "<NUM_LIT>", ";", "Chan", "<", "<NUM_LIT>", ";", "Chan", "++", ")", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "TII", "->", "getOperandIdx", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "dst", ")", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src0", "=", "MI", ".", "getOperand", "(", "TII", "->", "getOperandIdx", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src1", "=", "<NUM_LIT>", ";", "if", "(", "!", "IsCube", ")", "{", "int", "Src1Idx", "=", "TII", "->", "getOperandIdx", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "!=", "-", "<NUM_LIT>", ")", "{", "Src1", "=", "MI", ".", "getOperand", "(", "Src1Idx", ")", ".", "getReg", "(", ")", ";", "}", "}", "if", "(", "IsReduction", ")", "{", "unsigned", "SubRegIndex", "=", "AMDGPURegisterInfo", "::", "getSubRegFromChannel", "(", "Chan", ")", ";", "Src0", "=", "TRI", ".", "getSubReg", "(", "Src0", ",", "SubRegIndex", ")", ";", "Src1", "=", "TRI", ".", "getSubReg", "(", "Src1", ",", "SubRegIndex", ")", ";", "}", "else", "if", "(", "IsCube", ")", "{", "static", "const", "int", "CubeSrcSwz", "[", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "unsigned", "SubRegIndex0", "=", "AMDGPURegisterInfo", "::", "getSubRegFromChannel", "(", "CubeSrcSwz", "[", "Chan", "]", ")", ";", "unsigned", "SubRegIndex1", "=", "AMDGPURegisterInfo", "::", "getSubRegFromChannel", "(", "CubeSrcSwz", "[", "<NUM_LIT>", "-", "Chan", "]", ")", ";", "Src1", "=", "TRI", ".", "getSubReg", "(", "Src0", ",", "SubRegIndex1", ")", ";", "Src0", "=", "TRI", ".", "getSubReg", "(", "Src0", ",", "SubRegIndex0", ")", ";", "}", "bool", "Mask", "=", "false", ";", "bool", "NotLast", "=", "true", ";", "if", "(", "IsCube", ")", "{", "unsigned", "SubRegIndex", "=", "AMDGPURegisterInfo", "::", "getSubRegFromChannel", "(", "Chan", ")", ";", "DstReg", "=", "TRI", ".", "getSubReg", "(", "DstReg", ",", "SubRegIndex", ")", ";", "}", "else", "{", "Mask", "=", "(", "Chan", "!=", "TRI", ".", "getHWRegChan", "(", "DstReg", ")", ")", ";", "unsigned", "DstBase", "=", "TRI", ".", "getEncodingValue", "(", "DstReg", ")", "&", "HW_REG_MASK", ";", "DstReg", "=", "AMDGPU", "::", "R600_TReg32RegClass", ".", "getRegister", "(", "(", "DstBase", "*", "<NUM_LIT>", ")", "+", "Chan", ")", ";", "}", "NotLast", "=", "(", "Chan", "!=", "<NUM_LIT>", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "CUBE_r600_pseudo", ":", "Opcode", "=", "AMDGPU", "::", "CUBE_r600_real", ";", "break", ";", "case", "AMDGPU", "::", "CUBE_eg_pseudo", ":", "Opcode", "=", "AMDGPU", "::", "CUBE_eg_real", ";", "break", ";", "default", ":", "break", ";", "}", "MachineInstr", "*", "NewMI", "=", "TII", "->", "buildDefaultInstruction", "(", "MBB", ",", "I", ",", "Opcode", ",", "DstReg", ",", "Src0", ",", "Src1", ")", ";", "if", "(", "Chan", "!=", "<NUM_LIT>", ")", "NewMI", "->", "bundleWithPred", "(", ")", ";", "if", "(", "Mask", ")", "{", "TII", "->", "addFlag", "(", "*", "NewMI", ",", "<NUM_LIT>", ",", "MO_FLAG_MASK", ")", ";", "}", "if", "(", "NotLast", ")", "{", "TII", "->", "addFlag", "(", "*", "NewMI", ",", "<NUM_LIT>", ",", "MO_FLAG_NOT_LAST", ")", ";", "}", "SetFlagInNewMI", "(", "NewMI", ",", "&", "MI", ",", "AMDGPU", "::", "OpName", "::", "clamp", ")", ";", "SetFlagInNewMI", "(", "NewMI", ",", "&", "MI", ",", "AMDGPU", "::", "OpName", "::", "literal", ")", ";", "SetFlagInNewMI", "(", "NewMI", ",", "&", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_abs", ")", ";", "SetFlagInNewMI", "(", "NewMI", ",", "&", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_abs", ")", ";", "SetFlagInNewMI", "(", "NewMI", ",", "&", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_neg", ")", ";", "SetFlagInNewMI", "(", "NewMI", ",", "&", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_neg", ")", ";", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "}", "return", "false" ]

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

[ "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CCFP", "VFPCC_REGNUM", ")", "(", "compare", ":", "CCFP", "(", "match_dup", "<NUM_LIT>", ")" ]

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

[ "}", "else", "if", "(", "MI", "->", "mayStore", "(", ")", ")", "{", "BasePos", "=", "<NUM_LIT>", ";", "OffsetPos", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "MI", "->", "mayLoad", "(", ")", ")", "{", "BasePos", "=", "<NUM_LIT>", ";", "OffsetPos", "=", "<NUM_LIT>", ";", "}", "else" ]

[ "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sign_extend", ":", "SI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashift", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashiftrt", ":", "SI", "(" ]

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

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

[ ")", ";" ]

[ "_", "_", "GET_HIGH", "(", "s16" ]

[ "->", "dump", "(", ")", ")", ";" ]

[ "switch", "(", "getMnemonicFromOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "case", "FlagArithMnemonic", "::", "ADC", ":", "case", "FlagArithMnemonic", "::", "ADCX", ":", "case", "FlagArithMnemonic", "::", "RCL", ":", "case", "FlagArithMnemonic", "::", "RCR", ":", "case", "FlagArithMnemonic", "::", "SBB", ":", "case", "FlagArithMnemonic", "::", "SETB", ":", "Cond", "=", "X86", "::", "COND_B", ";", "Addend", "=", "<NUM_LIT>", ";", "break", ";", "case", "FlagArithMnemonic", "::", "ADOX", ":", "Cond", "=", "X86", "::", "COND_O", ";", "Addend", "=", "<NUM_LIT>", ";", "break", ";", "}", "unsigned", "&", "CondReg", "=", "CondRegs", "[", "Cond", "]", ";", "if", "(", "!", "CondReg", ")", "CondReg", "=", "promoteCondToReg", "(", "TestMBB", ",", "TestPos", ",", "TestLoc", ",", "Cond", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "Register", "TmpReg", "=", "MRI", "->", "createVirtualRegister", "(", "PromoteRC", ")", ";", "auto", "AddI", "=", "BuildMI", "(", "MBB", ",", "MI", ".", "getIterator", "(", ")", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "ADD8ri", ")", ")", ".", "addDef", "(", "TmpReg", ",", "RegState", "::", "Dead", ")", ".", "addReg", "(", "CondReg", ")", ".", "addImm", "(", "Addend", ")", ";", "(", "void", ")", "AddI", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " add cond: ", "<STR_LIT>", ";", "AddI" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RdaLoDest", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "X", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_8", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "A", ";" ]

[ "SMLoc", "SuffixLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "(", "Head", ".", "data", "(", ")", "-", "Name", ".", "data", "(", ")", ")", "+", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "Head", "==", "<STR_LIT>", "ic", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "dc", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "at", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "tlbi", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "cfp", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "dvp", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "cpp", "<STR_LIT>", ")", "return", "parseSysAlias", "(", "Head", ",", "NameLoc", ",", "Operands", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "Head", ",", "NameLoc", ",", "getContext", "(", ")", ")", ")", ";", "Mnemonic", "=", "Head", ";", "if", "(", "Head", "==", "<STR_LIT>", "b", "<STR_LIT>", "&&", "Next", "!=", "StringRef", "::", "npos", ")", "{", "Start", "=", "Next", ";", "Next", "=", "Name", ".", "find", "(", "'", ".", "'", ",", "Start", "+", "<NUM_LIT>", ")", ";", "Head", "=", "Name", ".", "slice", "(", "Start", "+", "<NUM_LIT>", ",", "Next", ")", ";", "SMLoc", "SuffixLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "(", "Head", ".", "data", "(", ")", "-", "Name", ".", "data", "(", ")", ")", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "parseCondCodeString", "(", "Head", ")", ";", "if", "(", "CC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "Error", "(", "SuffixLoc", ",", "<STR_LIT>", "invalid condition code", "<STR_LIT>", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", ".", "<STR_LIT>", ",", "SuffixLoc", ",", "getContext", "(", ")", ",", "true", ")", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateCondCode", "(", "CC", ",", "NameLoc", ",", "NameLoc", ",", "getContext", "(", ")", ")", ")", ";", "}", "while", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "Start", "=", "Next", ";", "Next", "=", "Name", ".", "find", "(", "'", ".", "'", ",", "Start", "+", "<NUM_LIT>", ")", ";", "Head", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";" ]

[ "createShiftOr", "<", "false", ">", "(", "MCOperand", "::", "CreateExpr", "(", "LoExpr", ")", ",", "RegNo", ",", "SMLoc", "(", ")", ",", "Instructions", ")", ";" ]

[ "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "RegNo", ")", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "HighestExpr", ")", ")", ";", "Instructions", ".", "push_back", "(", "tmpInst", ")", ";", "createShiftOr", "<", "false", ">", "(", "MCOperand", "::", "CreateExpr", "(", "HigherExpr", ")", ",", "RegNo", ",", "SMLoc", "(", ")", ",", "Instructions", ")", ";", "createShiftOr", "<", "true", ">", "(", "MCOperand", "::", "CreateExpr", "(", "HiExpr", ")", ",", "RegNo", ",", "SMLoc", "(", ")", ",", "Instructions", ")", ";", "createShiftOr", "<", "true", ">", "(", "MCOperand", "::", "CreateExpr", "(", "LoExpr", ")", ",", "RegNo", ",", "SMLoc", "(", ")", ",", "Instructions", ")", ";", "}", "else", "{", "tmpInst", ".", "setOpcode", "(", "Mips", "::", "LUi", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "RegNo", ")", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "HiExpr", ")", ")", ";", "Instructions", ".", "push_back", "(", "tmpInst", ")", ";" ]

[ "<FIXS>", "IntRegs", ":", "$", "andend", ")", ",", "ADDRriU6_1", ":", "$", "addr", ")", "]", ">", ",", "<FIXE>" ]

[ "(", "ins", "MEMri", ":", "$", "addr", ",", "IntRegs", ":", "$", "andend", ")", ",", "<STR_LIT>", ",", "[", "(", "truncstorei16", "(", "and", "(", "sextloadi16", "ADDRriU6_1", ":", "$", "addr", ")", ",", "<BUGS>", "(", "i32", "IntRegs", ":", "$", "andend", ")", ")", ",", "ADDRriU6_1", ":", "$", "addr", ")", "]", ">", ",", "<BUGE>", "Requires", "[", "HasV4T", ",", "UseMEMOP", "]", ">", ";" ]

[ "case", "GT", ":", "test", "=", "ITEST_GT", ";", "break", ";" ]

[ "static", "enum", "internal_test", "map_test_to_internal_test", "(", "enum", "rtx_code", "test_code", ")", "{", "enum", "internal_test", "test", "=", "ITEST_MAX", ";", "switch", "(", "test_code", ")", "{", "case", "EQ", ":", "test", "=", "ITEST_EQ", ";", "break", ";", "case", "NE", ":", "test", "=", "ITEST_NE", ";", "break", ";" ]

[ "}" ]

[ "virtual", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";" ]

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

[ "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_OR_B64", ")", ",", "Dst", ")", ".", "addReg", "(", "Vcc", ")", ".", "addReg", "(", "Src", ")", ";", "MI", ".", "eraseFromParent" ]

[ "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";" ]

[ "case", "MVT", "::", "v2f32", ":", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v4f32", ":", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "}", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "SDValue", "InVal", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Ins", "[", "i", "]", ".", "Flags", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "Flags", ".", "getByValSize", "(", ")", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "InVal", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", ")", ")", ";", "}", "else", "{", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "if", "(", "ObjSize", ">", "<NUM_LIT>", ")", "{", "llvm_unreachable", "(", "<NUM_LIT>", ")", ";", "}", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", "," ]

[ "DecodeStatus", "SystemZDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "<NUM_LIT>", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "uint8_t", "*", "Table", ";", "if", "(", "Bytes", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Table", "=", "DecoderTable16", ";", "}", "else", "if", "(", "Bytes", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Table", "=", "DecoderTable32", ";", "}", "else", "{", "Size", "=", "<NUM_LIT>", ";", "Table", "=", "DecoderTable48", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", "<", "Size", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint64_t", "Inst", "=", "<NUM_LIT>", ";", "for", "(", "uint64_t", "I", "=", "<NUM_LIT>", ";", "I", "<", "Size", ";", "++", "I", ")", "Inst", "=", "(", "Inst", "<<", "<NUM_LIT>", ")", "|", "Bytes", "[", "I", "]", ";", "return", "decodeInstruction", "(", "Table", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "Value", "*", "ConstVec", "=", "TCP", ".", "Predicate", "->", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "ConstantInt", "*", "VF", "=", "ConstantInt", "::", "get", "(", "cast", "<", "IntegerType", ">", "(", "TCP", ".", "TripCount", "->", "getType", "(", ")", ")", ",", "TCP", ".", "VecTy", "->", "getNumElements", "(", ")", ")", ";", "using", "namespace", "PatternMatch", ";", "CmpInst", "::", "Predicate", "CC", ";", "if", "(", "!", "match", "(", "TCP", ".", "Predicate", ",", "m_ICmp", "(", "CC", ",", "m_Instruction", "(", "TCP", ".", "Induction", ")", ",", "m_AnyIntegralConstant", "(", ")", ")", ")", "||", "CC", "!=", "ICmpInst", "::", "ICMP_ULT", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: icmp with constants: ", "<STR_LIT>", ";", "TCP", ".", "Predicate", "->", "dump", "(", ")", ";", ")", ";" ]

[ "a", ";" ]

[ "return", "(", "poly16x8_t", ")", "_", "_" ]

[ "}" ]

[ "LLVMTargetMachine", "(", "T", ",", "<STR_LIT>", "E-m:e-S32-p:32:32:32-i32:32:32-a:32:32-n32", "<STR_LIT>", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ".", "getValueOr", "(", "Reloc", "::", "Model", "::", "Static", ")", ",", "CM", ".", "getValueOr", "(", "CodeModel", "::", "Model", "::", "Tiny", ")", ",", "OL", ")", ",", "TLOF", "(", "std", "::", "make_unique", "<", "TargetLoweringObjectFileELF", ">", "(", ")", ")", ",", "DefaultSubtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";" ]

[ "b", ")", "{" ]

[ "_", "_", "arm_vcmpleq_n_s8", "(", "int8x16_t", "_", "_", "a", ",", "int8_t", "_", "_" ]

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

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

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

[ "(", "ior", "(", "match_operand" ]

[ "void", "XCoreInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "Register", "VReg", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "I", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ ";" ]

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

[ "(", "clobber", "(", "reg", ":", "CC", "VAX_PSL_REGNUM", ")", ")", "]", ")", "]" ]

[ "(", "xor", ":", "VAXint", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")" ]

[ "!", "reg_unused_after_insn", "(", "m_ccreg", ",", "e", ".", "cstore", ".", "insn", ")", ")", "{" ]

[ "bool", "sh_treg_combine", "::", "can_remove_comparison", "(", "const", "bb_entry", "&", "e", ",", "const", "cbranch_trace", "&", ")", "const", "{", "if", "(", "reg_used_between_p", "(", "m_ccreg", ",", "e", ".", "setcc", ".", "insn", ",", "e", ".", "cstore", ".", "insn", ")", ")", "{", "log_msg", "(", "<STR_LIT>", "can't remove insn\\n", "<STR_LIT>", ")", ";", "log_insn", "(", "e", ".", "setcc", ".", "insn", ")", ";", "log_return", "(", "false", ",", "<STR_LIT>", "\\nbecause the ccreg is used otherwise\\n", "<STR_LIT>", ")", ";", "}", "if", "(", "!", "reg_dead_after_insn", "(", "m_ccreg", ",", "e", ".", "cstore", ".", "insn", ")", "&&" ]

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

[ "def", "VulcanWrite_8Cyc_LS01_F01", ":", "SchedWriteRes", "<", "[", "VulcanLS01", ",", "VulcanF01", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_BUILTIN_ROUND", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REG", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "true", ";" ]

[ "if", "(", "GV", "->", "isDeclaration", "(", ")", "&&", "!", "GV", "->", "isMaterializable", "(", ")", ")", "isDecl", "=", "true", ";", "if", "(", "!", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "->", "hasLocalLinkage", "(", ")", "||", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "else", "{", "if", "(", "RelocM", "==", "Reloc", "::", "PIC_", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "false", ";" ]

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

[ "DebugLoc", "dl", ";", "bool", "NeedsStackRealignment", "=", "RegInfo", ".", "shouldRealignStack", "(", "MF", ")", ";", "if", "(", "NeedsStackRealignment", "&&", "!", "RegInfo", ".", "canRealignStack", "(", "MF", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Function \\\"", "<STR_LIT>", "+", "Twine", "(", "MF", ".", "getName", "(", ")", ")", "+", "<STR_LIT>", "\\\" required ", "<STR_LIT>", "<STR_LIT>", "stack re-alignment, but LLVM couldn't handle it ", "<STR_LIT>", "<STR_LIT>", "(probably because it has a dynamic alloca).", "<STR_LIT>", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "SAVErr", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "<NUM_LIT>", ")", "return", ";", "SAVEri", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SAVErr", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "if", "(", "MFI", ".", "adjustsStack", "(", ")", "&&", "hasReservedCallFrame", "(", "MF", ")", ")", "NumBytes", "+=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "NumBytes", "=", "Subtarget", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "NumBytes", "=", "alignTo", "(", "NumBytes", ",", "MFI", ".", "getMaxAlign", "(", ")", ")", ";", "MFI", ".", "setStackSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "-", "NumBytes", ",", "SAVErr", ",", "SAVEri", ")", ";", "unsigned", "regFP", "=", "RegInfo", ".", "getDwarfRegNum", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "regFP", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "nullptr", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "unsigned", "regInRA", "=", "RegInfo", ".", "getDwarfRegNum", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "RegInfo", ".", "getDwarfRegNum", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ")", ";", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "nullptr", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "if", "(", "NeedsStackRealignment", ")", "{", "int64_t", "Bias", "=", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "unsigned", "regUnbiased", ";", "if", "(", "Bias", ")", "{", "regUnbiased", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "regUnbiased", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Bias", ")", ";", "}", "else", "regUnbiased", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Align", "MaxAlign", "=", "MFI", ".", "getMaxAlign", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "regUnbiased", ")", ".", "addReg", "(", "regUnbiased", ")", ".", "addImm", "(", "MaxAlign", ".", "value", "(", ")", "-", "<NUM_LIT>", "U", ")", ";" ]

[ ")", "]" ]

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

[ "}" ]

[ "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "FALSE", ";", "ind", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "if", "(", "reload_completed", "&&", "(", "LABEL_REF_P", "(", "ind", ")", "||", "(", "GET_CODE", "(", "ind", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", ")", ")", "return", "TRUE", ";", "if", "(", "REG_P", "(", "ind", ")", ")", "return", "arm_address_register_rtx_p", "(", "ind", ",", "<NUM_LIT>", ")", ";", "if", "(", "wb_level", ">", "<NUM_LIT>", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "POST_INC", "||", "GET_CODE", "(", "ind", ")", "==", "PRE_DEC", "||", "(", "wb_level", ">", "<NUM_LIT>", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "ind", ")", "==", "POST_DEC", ")", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "wb_level", ">", "<NUM_LIT>", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "POST_MODIFY", "||", "GET_CODE", "(", "ind", ")", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ")", ")", "ind", "=", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ";", "int", "factor", "=", "MIN", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "ind", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ")", "&&", "REG_MODE_OK_FOR_BASE_P", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ",", "VOIDmode", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ")", ",", "-", "<NUM_LIT>", "*", "factor", ",", "<NUM_LIT>", "*", "factor", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "<NUM_LIT>", ")", ")", "&", "(", "factor", "-", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", "return", "TRUE", ";", "return", "FALSE", ";" ]

[ "let", "isTaken", "=", "Inst", "{", "<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>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ ";" ]

[ "def", "SwitchRhazRsAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>" ]

[ "int", "priority", ")", "{" ]

[ "static", "void", "rx_elf_asm_destructor", "(", "rtx", "symbol", "," ]

[ "return", "Hexagon", "::", "V6_vS32b_new_pi", ";" ]

[ "llvm", "::", "report_fatal_error", "(", "std", "::", "string", "(", "<STR_LIT>", "Unknown .new type: ", "<STR_LIT>", ")", "+", "std", "::", "to_string", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "c_str", "(", ")", ")", ";", "case", "Hexagon", "::", "S4_storerb_ur", ":", "return", "Hexagon", "::", "S4_storerbnew_ur", ";", "case", "Hexagon", "::", "S2_storerb_pci", ":", "return", "Hexagon", "::", "S2_storerb_pci", ";", "case", "Hexagon", "::", "S2_storeri_pci", ":", "return", "Hexagon", "::", "S2_storeri_pci", ";", "case", "Hexagon", "::", "S2_storerh_pci", ":", "return", "Hexagon", "::", "S2_storerh_pci", ";", "case", "Hexagon", "::", "S2_storerd_pci", ":", "return", "Hexagon", "::", "S2_storerd_pci", ";", "case", "Hexagon", "::", "S2_storerf_pci", ":", "return", "Hexagon", "::", "S2_storerf_pci", ";", "case", "Hexagon", "::", "V6_vS32b_ai", ":", "return", "Hexagon", "::", "V6_vS32b_new_ai", ";", "case", "Hexagon", "::", "V6_vS32b_pi", ":" ]

[ ")", ";" ]

[ "SDValue", "TmpAns", "=", "b", ".", "AND", "(", "b", ".", "NOT", "(", "b", ".", "SHL", "<", "<NUM_LIT>", ">", "(", "Tmp", ")", ")", ",", "b", ".", "NOT", "(", "Tmp", ")", ")", ";", "return", "b", ".", "IFH1", "(", "b", ".", "HiMask", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "TmpAns", ",", "b", ".", "SRL", "<", "<NUM_LIT>", ">", "(", "TmpAns", ")", ")", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "GENLower of icmp eq is misused.", "<STR_LIT>" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "isIntN", "(", "<NUM_LIT>", ",", "BrOffset", ")", ";", "}" ]

[ "void", "ARMBaseRegisterInfo", "::", "updateRegAllocHint", "(", "Register", "Reg", ",", "Register", "NewReg", ",", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "Register", ">", "Hint", "=", "MRI", "->", "getRegAllocationHint", "(", "Reg", ")", ";", "if", "(", "(", "Hint", ".", "first", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Hint", ".", "first", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "Hint", ".", "second", ".", "isVirtual", "(", ")", ")", "{", "Register", "OtherReg", "=", "Hint", ".", "second", ";", "Hint", "=", "MRI", "->", "getRegAllocationHint", "(", "OtherReg", ")", ";", "if", "(", "Hint", ".", "second", "==", "Reg", ")", "{", "MRI", "->", "setRegAllocationHint", "(", "OtherReg", ",", "Hint", ".", "first", ",", "NewReg", ")", ";", "if", "(", "NewReg", ".", "isVirtual", "(", ")", ")", "MRI", "->", "setRegAllocationHint", "(", "NewReg", ",", "Hint", ".", "first", "==", "<STR_LIT>", "::", "<STR_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ",", "OtherReg", ")", ";", "}", "}", "}" ]

[ "A", "callback", "to", "allow", "target", "a", "chance", "to", "update", "register", "allocation", "hints", "when", "a", "register", "is", "``", "changed", "''", "(", "e.g", "." ]

[ "<FIXS>", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "ret", "+=", "(", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "current_function_pretend_args_size", ")", "-", "current_function_pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "<FIXE>" ]

[ "ret", "=", "alpha_sa_size", "(", ")", ";", "ret", "+=", "ALPHA_ROUND", "(", "current_function_outgoing_args_size", ")", ";", "<BUGS>", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "ret", "+=", "(", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "current_function_pretend_args_size", ")", "-", "current_function_pretend_args_size", ")", ";", "elseabort", "(", ")", ";", "<BUGE>", "return", "ret", ";", "}" ]

[ "GVar", ")", "continue", ";" ]

[ "MachineInstr", "*", "ToErase", "=", "nullptr", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "*", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "ToErase", ")", "{", "ToErase", "->", "eraseFromParent", "(", ")", ";", "ToErase", "=", "nullptr", ";", "}", "if", "(", "!", "isLoadInst", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "if", "(", "SkipInsts", ".", "find", "(", "&", "MI", ")", "!=", "SkipInsts", ".", "end", "(", ")", ")", "continue", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "||", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "continue", ";", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "DefInst", "=", "MRI", "->", "getUniqueVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "DefInst", ")", "continue", ";", "if", "(", "DefInst", "->", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";", "const", "MachineOperand", "&", "MO", "=", "DefInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "continue", ";", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "!" ]

[ "(", "xor", "<STR_LIT>", ")", "(", "mult", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_code_attr", "atomic_op_name", "[", "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "(", "and", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")" ]

[ "s", ";" ]

[ "output_asm_insn", "(", "<STR_LIT>", "xvsetallnez.%v0\\t$fcc7,%u2", "<STR_LIT>", ",", "operands", ")", ";", "output_asm_insn", "(", "s", ",", "operands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "bcnez\\t$fcc7,1f", "<STR_LIT>", ",", "operands", ")", ";", "}", "else", "if", "(", "ISA_HAS_LSX", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "vsetallnez.%v0\\t$fcc7,%w2", "<STR_LIT>", ",", "operands", ")", ";", "output_asm_insn", "(", "s", ",", "operands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "bcnez\\t$fcc7,1f", "<STR_LIT>", ",", "operands", ")", ";", "}", "s", "=", "<STR_LIT>", "break\\t7\\n1:", "<STR_LIT>", ";", "}", "return" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "(", "match_operand", ":", "avxpermvecmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "[", "(", "set", "(", "match_operand", ":", "AVXMODEF2P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "AVXMODEF2P", "[", "(", "match_operand", ":", "AVXMODEF2P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "AVXMODEF2P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_MASKLOAD", ")", ")", "]", "<STR_LIT>" ]

[ "unsigned", "int", "regno", ")", "{" ]

[ "static", "bool", "moxie_function_value_regno_p", "(", "const" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>" ]

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

[ "def", "Xr", ":", "BaseAddSubCarry", "<", "isSub", ",", "GPR64", ",", "asm", ",", "OpNode", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ")", "{" ]

[ "void", "setLRIsSpilledForFarJump", "(", "bool", "s" ]

[ "<FIXS>", "#", "endif", "<FIXE>" ]

[ "}", "if", "(", "IsLevel2", ")", "<BUGS>", "#", "endif", "<BUGE>", "PotentialADROpportunities", ".", "insert", "(", "Def", ")", ";", "continue", ";", "}" ]

[ "}" ]

[ "const", "MCExpr", "*", "ImmVal", ";", "if", "(", "getParser", "(", ")", ".", "ParseExpression", "(", "ImmVal", ")", ")", "return", "MatchOperand_ParseFail", ";", "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "ImmVal", ")", ";", "if", "(", "!", "MCE", ")", "return", "TokError", "(", "<STR_LIT>", "immediate value expected for vector index", "<STR_LIT>", ")", ";", "SMLoc", "E", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RBrac", ")", ")", "return", "Error", "(", "E", ",", "<STR_LIT>", "']' expected", "<STR_LIT>", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateVectorIndex", "(", "MCE", "->", "getValue", "(", ")", ",", "SIdx", ",", "E", ",", "getContext", "(", ")", ")", ")", ";", "}", "return", "false", ";" ]