Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "(", "unspec", ":", "V2SF", "[", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "BX_RET", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tBX_RET", ")", ")", "{", "<FIXE>" ]

[ "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "<BUGS>", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "BX_RET", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2BX_RET", ")", ")", "{", "<BUGE>", "MachineInstr", "*", "PrevMI", "=", "prior", "(", "MBBI", ")", ";", "if", "(", "PrevMI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "LDM", "||", "PrevMI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2LDM", ")", "{", "MachineOperand", "&", "MO", "=", "PrevMI", "->", "getOperand", "(", "PrevMI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "machine_mode", "mode", "=", "GET_MODE", "(", "ops", "[", "<NUM_LIT>", "]", ")", ";", "<FIXE>" ]

[ "intspu_split_store", "(", "rtx", "*", "ops", ")", "{", "<BUGS>", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "ops", "[", "<NUM_LIT>", "]", ")", ";", "<BUGE>", "rtx", "reg", ";", "rtx", "addr", ",", "p0", ",", "p1", ",", "p1_lo", ",", "smem", ";", "int", "aform", ";" ]

[ "<FIXS>", "LastSGPR", "=", "mc2PseudoReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "<FIXE>", "<FIXS>", "if", "(", "!", "SGPRsUsed", ".", "count", "(", "LastSGPR", ")", ")", "{", "SGPRsUsed", ".", "insert", "(", "LastSGPR", ")", ";", "+", "ConstantBusUseCount", ";", "<FIXE>" ]

[ "const", "MCOperand", "&", "MO", "=", "Inst", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "usesConstantBus", "(", "Inst", ",", "OpIdx", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "<BUGS>", "const", "unsigned", "Reg", "=", "mc2PseudoReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "<BUGE>", "<BUGS>", "if", "(", "!", "SGPRsUsed", ".", "count", "(", "Reg", ")", ")", "{", "SGPRsUsed", ".", "insert", "(", "Reg", ")", ";", "<BUGE>", "}", "}", "else", "{" ]

[ "}" ]

[ "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "true", ";" ]

[ "static", "void", "nios2_handle_custom_fpu_insn_option", "(", "int", "fpu_insn_index", ")", "{", "int", "param", "=", "N2FPU_N", "(", "fpu_insn_index", ")", ";", "if", "(", "param", ">=", "<NUM_LIT>", "&&", "param", "<=", "<NUM_LIT>", ")", "nios2_register_custom_code", "(", "param", ",", "CCS_FPU", ",", "fpu_insn_index", ")", ";", "else", "if", "(", "param", "!=", "-", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "switch %<-mcustom-%s%> value %d must be between 0 and 255", "<STR_LIT>", ",", "N2FPU_NAME", "(", "fpu_insn_index", ")", ",", "param", ")", ";", "}" ]

[ "Check", "individual", "FPU", "insn", "options", ",", "and", "register", "custom", "code", "." ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", "#", "Name", ";", "let", "ParserMatchClass", "=", "MatchClass", ";" ]

[ "_", "A", ",", "_", "_", "m128", "_", "_", "B", ",", "_", "_", "mmask8", "_", "_", "U", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask3_fnmsub_ss", "(", "_", "_", "m128", "_", "_", "W", ",", "_", "_", "m128", "_" ]

[ "}" ]

[ "const", "TargetLowering", "*", "getTargetLowering", "(", ")", "{", "return", "&", "TLI", ";" ]

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

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

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

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

[ ":", "$", "Rn", ")", ",", "fpimm0", ")", ",", "(", "implicit", "CPSR", ")", "]", ">", "{" ]

[ "def", "Dri", ":", "BaseOneOperandFPComparison", "<", "signalAllNans", ",", "FPR64", ",", "asm", ",", "[", "(", "OpNode", "(", "f64", "FPR64" ]

[ "if", "(", "RHS", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", ")", "{" ]

[ "SDLoc", "DL", "(", "N", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i1", ",", "Src", ",", "DAG", ".", "getConstant", "(", "NewMask", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "RHS", ")", "&&", "LHS", ".", "hasOneUse", "(", ")", "&&", "LHS", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "isa", "<", "ConstantSDNode", ">", "(", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "uint32_t", "Sel", "=", "getConstantPermuteMask", "(", "N", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "Sel", ")", "return", "SDValue", "(", ")", ";", "Sel", "|=", "LHS", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "Sel", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "&&", "LHS", ".", "hasOneUse", "(", ")", "&&", "RHS", ".", "hasOneUse", "(", ")", "&&", "N", "->", "isDivergent", "(", ")", "&&", "TII", "->", "pseudoToMCOpcode", "(", "AMDGPU", "::", "V_PERM_B32_e64", ")", "!=", "-", "<NUM_LIT>", ")", "{", "uint32_t", "LHSMask", "=", "getPermuteMask", "(", "DAG", ",", "LHS", ")", ";", "uint32_t", "RHSMask", "=", "getPermuteMask", "(", "DAG", ",", "RHS", ")", ";", "if", "(", "LHSMask", "!=", "~", "<NUM_LIT>", "u", "&&", "RHSMask", "!=", "~", "<NUM_LIT>", "u", ")", "{", "if", "(", "LHSMask", ">", "RHSMask", ")", "{", "std", "::", "swap", "(", "LHSMask", ",", "RHSMask", ")", ";", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "}", "uint32_t", "LHSUsedLanes", "=", "~", "(", "LHSMask", "&", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "uint32_t", "RHSUsedLanes", "=", "~", "(", "RHSMask", "&", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "if", "(", "!", "(", "LHSUsedLanes", "&", "RHSUsedLanes", ")", "&&", "!", "(", "LHSUsedLanes", "==", "<NUM_LIT>", "&&", "RHSUsedLanes", "==", "<NUM_LIT>", ")", ")", "{", "LHSMask", "&=", "~", "RHSUsedLanes", ";", "RHSMask", "&=", "~", "LHSUsedLanes", ";", "LHSMask", "|=", "LHSUsedLanes", "&", "<NUM_LIT>", ";", "uint32_t", "Sel", "=", "LHSMask", "|", "RHSMask", ";", "SDLoc", "DL", "(", "N", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "Sel", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "}", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", "||", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "LHS", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "&&", "RHS", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "ZERO_EXTEND", ")", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";" ]

[ ";" ]

[ "for", "(", "StringSet", "<", ">", "::", "iterator", "i", "=", "DLLExportedGVs", ".", "begin", "(", ")", ",", "e", "=", "DLLExportedGVs", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "O", "<<", "<STR_LIT>", "\\t db ' /EXPORT:", "<STR_LIT>", "<<", "i", "->", "getKeyData", "(", ")", "<<", "<STR_LIT>", ",data'\\n", "<STR_LIT>", ";", "for", "(", "StringSet", "<", ">", "::", "iterator", "i", "=", "DLLExportedFns", ".", "begin", "(", ")", ",", "e", "=", "DLLExportedFns", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "O", "<<", "<STR_LIT>", "\\t db ' /EXPORT:", "<STR_LIT>", "<<", "i", "->", "getKeyData", "(", ")", "<<", "<STR_LIT>", "'\\n", "<STR_LIT>", ";", "O", "<<", "<STR_LIT>", "_drectve\\t ends\\n", "<STR_LIT>", ";", "}", "bool", "Result", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "O", "<<", "<STR_LIT>", "\\tend\\n", "<STR_LIT>" ]

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

[ "rtx", "create_TOC_reference", "(", "rtx", "symbol", ",", "rtx", "largetoc_reg", ")", "{", "rtx", "tocrel", ",", "tocreg", ",", "hi", ";", "gcc_assert", "(", "TARGET_TOC", ")", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "if", "(", "SYMBOL_REF_P", "(", "symbol", ")", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\ncreate_TOC_reference, (symbol_ref %s)\\n", "<STR_LIT>", ",", "XSTR", "(", "symbol", ",", "<NUM_LIT>", ")", ")", ";", "else", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\ncreate_TOC_reference, code %s:\\n", "<STR_LIT>", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "symbol", ")", ")", ")", ";", "debug_rtx", "(", "symbol", ")", ";", "}", "}", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "df_set_regs_ever_live", "(", "TOC_REGISTER", ",", "true", ")", ";", "tocreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGISTER", ")", ";", "tocrel", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "symbol", ",", "tocreg", ")", ",", "UNSPEC_TOCREL", ")", ";", "if", "(", "TARGET_CMODEL", "==", "CMODEL_SMALL", "||", "can_create_pseudo_p", "(", ")", ")", "return", "tocrel", ";", "hi", "=", "gen_rtx_HIGH", "(", "Pmode", ",", "copy_rtx", "(", "tocrel", ")", ")", ";", "if", "(", "largetoc_reg", "!=", "NULL", ")", "{", "emit_move_insn", "(", "largetoc_reg", ",", "hi", ")", ";", "hi", "=", "largetoc_reg", ";", "}", "return", "gen_rtx_LO_SUM", "(", "Pmode", ",", "hi", ",", "tocrel", ")", ";", "}" ]

[ "Create", "a", "TOC", "reference", "for", "symbol_ref", "SYMBOL", ".", "If", "LARGETOC_REG", "is", "non-null", ",", "use", "that", "as", "the", "register", "to", "put", "the", "HIGH", "value", "into", "if", "register", "allocation", "is", "already", "done", "." ]

[ "}" ]

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

[ ",", "(", "OpTy", "(", "Neon_vduplane", "(", "EleOpTy", "EleOpVPR", ":", "$", "Re", ")", ",", "(", "i64", "OpImm", ":", "$", "Index", ")", ")", ")", ")", ")", ",", "(", "INST", "ResVPR", ":", "$", "src", ",", "OpVPR", ":", "$", "Rn", ",", "EleOpVPR", ":", "$", "Re", ",", "OpImm", ":", "$", "Index", ")", ">", ";" ]

[ "class", "NI_2VE_laneq", "<", "Instruction", "INST", ",", "Operand", "OpImm", ",", "SDPatternOperator", "op", ",", "RegisterOperand", "ResVPR", ",", "RegisterOperand", "OpVPR", ",", "RegisterOperand", "EleOpVPR", ",", "ValueType", "ResTy", ",", "ValueType", "OpTy", ",", "ValueType", "EleOpTy", ">", ":", "Pat", "<", "(", "ResTy", "(", "op", "(", "ResTy", "ResVPR", ":", "$", "src", ")", ",", "(", "OpTy", "OpVPR", ":", "$", "Rn", ")" ]

[ ";" ]

[ "int", "i", ";", "for", "(", "i", "=", "tilepro_multiply_insn_seq_MAX_OPERATIONS", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "if", "(", "tilepro_multiply_get_opcode", "(", "&", "seq", "->", "op", "[", "i", "]", ")", "!=", "CODE_FOR_nothing", ")", "return", "i", "+", "<NUM_LIT>", ";", "gcc_unreachable", "(", ")" ]

[ "<FIXS>", "||", "avr_current_device", "->", "n_flash", ">", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "int", "n_bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "n_bytes", ">", "<NUM_LIT>", "<BUGS>", "||", "avr_current_arch", "->", "n_segments", ">", "<NUM_LIT>", ")", ";", "<BUGE>", "}" ]

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

[ "(", "popcount", ":", "GPR", "(", "match_operand", ":", "GPR" ]

[ "unsigned", "LoopCount", "=", "Loop", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "DebugLoc", "DL", "=", "Cmp", ".", "getDebugLoc", "(", ")", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "<NUM_LIT>", ">", "VisitedBBs", ";", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "&", "MBB", ",", "Cmp", ".", "getOpcode", "(", ")", ",", "Cmp", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ",", "VisitedBBs", ")", ";", "if", "(", "!", "Loop", ")", "return", "<NUM_LIT>", ";", "if", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0i", "||", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop1i", ")", "{", "int64_t", "Offset", "=", "Loop", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", "<=", "<NUM_LIT>", ")", "Loop", "->", "eraseFromParent", "(", ")", ";", "else", "Loop", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "Offset", "-", "<NUM_LIT>", ")", ";", "return", "Offset", "-", "<NUM_LIT>", ";", "}", "assert", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0r", "&&", "<STR_LIT>", "Unexpected instruction", "<STR_LIT>", ")", ";" ]

[ "static", "bool", "s390_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_VX", "&&", "VECTOR_NOFP_REGNO_P", "(", "regno", ")", ")", "return", "false", ";", "switch", "(", "REGNO_REG_CLASS", "(", "regno", ")", ")", "{", "case", "VEC_REGS", ":", "return", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "s390_class_max_nregs", "(", "VEC_REGS", ",", "mode", ")", "==", "<NUM_LIT>", ")", "||", "mode", "==", "DFmode", "||", "(", "TARGET_VXE", "&&", "mode", "==", "SFmode", ")", "||", "s390_vector_mode_supported_p", "(", "mode", ")", ")", ";", "break", ";", "case", "FP_REGS", ":", "if", "(", "TARGET_VX", "&&", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "s390_class_max_nregs", "(", "FP_REGS", ",", "mode", ")", "==", "<NUM_LIT>", ")", "||", "mode", "==", "DFmode", "||", "s390_vector_mode_supported_p", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", "return", "true", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_FLOAT", ")", "return", "true", ";", "}", "break", ";", "case", "ADDR_REGS", ":", "if", "(", "FRAME_REGNO_P", "(", "regno", ")", "&&", "mode", "==", "Pmode", ")", "return", "true", ";", "case", "GENERAL_REGS", ":", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "TARGET_ZARCH", "||", "(", "mode", "!=", "TFmode", "&&", "mode", "!=", "TCmode", "&&", "mode", "!=", "TDmode", ")", ")", "return", "true", ";", "}", "break", ";", "case", "CC_REGS", ":", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "true", ";", "break", ";", "case", "ACCESS_REGS", ":", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "Pmode", ")", "return", "true", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "return", "false", ";", "}" ]

[ "Return", "true", "if", "it", "is", "legal", "to", "put", "a", "value", "with", "MODE", "into", "REGNO", "." ]

[ "<FIXS>", "if", "(", "reg_mask", "&&", "!", "flag_inhibit_size_directive", ")", "<FIXE>" ]

[ "}", "<BUGS>", "if", "(", "reg_mask", ")", "<BUGE>", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.fmask 0x%x,%d\\n", "<STR_LIT>", ",", "reg_mask", ",", "actual_start_reg_offset", "-", "frame_size", "+", "int_reg_save_area_size", ")", ";" ]

[ ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Mu2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Mu2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vv32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vv32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vw32" ]

[ ";" ]

[ "delete", "m_pGOT", ";", "delete", "m_pGOTPLT" ]

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

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

[ ",", "(", "_", "_", "v32qi", ")", "_", "_", "A", ")", ";" ]

[ "_", "_", "builtin_ia32_storedqu256", "(", "(", "char", "*", ")", "_", "_", "P" ]

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

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

[ "StackOffset", "CSKYFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "<NUM_LIT>", ";", "int", "MaxCSFI", "=", "-", "<NUM_LIT>", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "else", "if", "(", "RI", "->", "hasStackRealignment", "(", "MF", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", ")", ";", "if", "(", "!", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "FrameReg", "=", "hasBP", "(", "MF", ")", "?", "getBPReg", "(", "STI", ")", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "getFPReg", "(", "STI", ")", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "}", "else", "{", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "&&", "hasFP", "(", "MF", ")", ")", "{", "FrameReg", "=", "getFPReg", "(", "STI", ")", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "hasBP", "(", "MF", ")", "?", "getBPReg", "(", "STI", ")", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "}", "return", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "}" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "}" ]

[ "unsigned", "ElemsPerChunk", "=", "vectorWidth", "/", "ElVT", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "ElemsPerChunk", ")", "&&", "<STR_LIT>", "Elements per chunk not power of 2", "<STR_LIT>", ")", ";", "IdxVal", "&=", "~", "(", "ElemsPerChunk", "-", "<NUM_LIT>", ")", ";", "if", "(", "Vec", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "ResultVT", ",", "makeArrayRef", "(", "Vec", "->", "op_begin", "(", ")", "+", "IdxVal", ",", "ElemsPerChunk", ")", ")", ";", "SDValue", "VecIdx", "=", "DAG", ".", "getIntPtrConstant", "(", "IdxVal", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "ResultVT", ",", "Vec", ",", "VecIdx", ")", ";" ]

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

[ "op", "[", "<NUM_LIT>", "]", "=", "adjust_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "DImode", ",", "<NUM_LIT>", ")", "op", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "output_move_double", "(", "op", ",", "true", ",", "NULL", ")", "}", "[", "(", "set", "(", "attr", "<STR_LIT>", ")" ]

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

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

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

[ "if", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "val", ")", ")", "store_bit_field", "(", "new", "_", "rtx", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "SImode", ",", "val", ")", ";", "else", "{", "new", "_", "rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new", "_", "rtx", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "new", "_", "rtx", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "new", "_", "rtx", ",", "val", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "}", "break", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "new", "_", "rtx", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new", "_", "rtx", ",", "val", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "MULT", ":", "new", "_", "rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new", "_", "rtx", ",", "val", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "new", "_", "rtx", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "new", "_", "rtx", ",", "ac", ".", "modemask", ",", "NULL_RTX", "," ]

[ "}" ]

[ "case", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_OFST", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ":", "break", ";", "case", "Mips", "::", "fixup_Mips_PC16", ":", "Value", "-=", "<NUM_LIT>", ";", "Value", ">>=", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_26", ":", "Value", ">>=", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_HI16", ":", "case", "Mips", "::", "fixup_Mips_GOT_Local", ":", "case", "Mips", "::", "fixup_Mips_GOT_HI16", ":", "case", "Mips", "::", "fixup_Mips_CALL_HI16", ":", "case", "Mips", "::", "fixup_MICROMIPS_HI16", ":", "Value", "=", "(", "(", "Value", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_HIGHER", ":", "Value", "=", "(", "(", "Value", "+", "<NUM_LIT>", "LL", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_HIGHEST", ":", "Value", "=", "(", "(", "Value", "+", "<NUM_LIT>", "LL", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "break", ";" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR32Opnd", ",", "GPR32Opnd", ")", ";" ]

[ ",", "[", "IntrNoMem", "]", ">", ";" ]

[ "def", "int_HSAIL_cvt_f32_zero_i64", ":", "GCCBuiltin", "<", "<STR_LIT>", ">", ",", "Intrinsic", "<", "[", "llvm_float_ty", "]", ",", "[", "llvm_i64_ty", "]" ]

[ "(", ")", "-", "AFI", "->", "getFramePtrSpillOffset", "(", ")", ")", ";" ]

[ "}", "AddDefaultCC", "(", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "t2SUBrr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R4", ",", "RegState", "::", "Kill", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ")", ")", ";", "NumBytes", "=", "<NUM_LIT>", ";", "}", "if", "(", "NumBytes", ")", "{", "if", "(", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", "==", "<NUM_LIT>", "&&", "tryFoldSPUpdateIntoPushPop", "(", "STI", ",", "MF", ",", "LastPush", ",", "NumBytes", ")", ")", "DefCFAOffsetCandidates", ".", "addExtraBytes", "(", "LastPush", ",", "NumBytes", ")", ";", "else", "{", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "-", "NumBytes", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "DefCFAOffsetCandidates", ".", "addInst", "(", "std", "::", "prev", "(", "MBBI", ")", ",", "NumBytes", ")", ";", "}", "if", "(", "HasFP", "&&", "isARM", ")", "AFI", "->", "setShouldRestoreSPFromFP", "(", "true", ")", ";", "}", "if", "(", "HasFP", ")", "{", "MachineBasicBlock", "::", "iterator", "AfterPush", "=", "std", "::", "next", "(", "GPRCS1Push", ")", ";", "unsigned", "PushSize", "=", "sizeOfSPAdjustment", "(", "GPRCS1Push", ")", ";", "emitRegPlusImmediate", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ",", "MBB", ",", "AfterPush", ",", "dl", ",", "TII", ",", "FramePtr", ",", "ARM", "::", "SP", ",", "PushSize", "+", "FramePtrOffsetInPush", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "FramePtrOffsetInPush", "+", "PushSize", "!=", "<NUM_LIT>", ")", "{", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "FramePtr", ",", "true", ")", ",", "-", "(", "ArgRegsSaveSize", "-", "FramePtrOffsetInPush", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "AfterPush", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "FramePtr", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "AfterPush", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "if", "(", "GPRCS1Size", ">", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "Pos", "=", "std", "::", "next", "(", "GPRCS1Push", ")", ";", "int", "CFIIndex", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "int", "FI", "=", "Entry", ".", "getFrameIdx", "(", ")", ";", "switch", "(", "Reg", ")", "{", "case", "ARM", "::", "R8", ":", "case", "ARM", "::", "R9", ":", "case", "ARM", "::", "R10", ":", "case", "ARM", "::", "R11", ":", "case", "ARM", "::", "R12", ":", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "break", ";", "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", ":", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ",", "MFI", "->", "getObjectOffset", "(", "FI", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "Pos", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "break", ";", "}", "}", "}", "if", "(", "GPRCS2Size", ">", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "Pos", "=", "std", "::", "next", "(", "GPRCS2Push", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "int", "FI", "=", "Entry", ".", "getFrameIdx", "(", ")", ";", "switch", "(", "Reg", ")", "{", "case", "ARM", "::", "R8", ":", "case", "ARM", "::", "R9", ":", "case", "ARM", "::", "R10", ":", "case", "ARM", "::", "R11", ":", "case", "ARM", "::", "R12", ":", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "{", "unsigned", "DwarfReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "Pos", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "break", ";", "}", "}", "}", "if", "(", "DPRCSSize", ">", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "Pos", "=", "std", "::", "next", "(", "LastPush", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "int", "FI", "=", "Entry", ".", "getFrameIdx", "(", ")", ";", "if", "(", "(", "Reg", ">=", "ARM", "::", "D0", "&&", "Reg", "<=", "ARM", "::", "D31", ")", "&&", "(", "Reg", "<", "ARM", "::", "D8", "||", "Reg", ">=", "ARM", "::", "D8", "+", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ")", ")", "{", "unsigned", "DwarfReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "Pos", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "}", "DefCFAOffsetCandidates", ".", "emitDefCFAOffsets", "(", "MMI", ",", "MBB", ",", "dl", ",", "TII", ",", "HasFP", ")", ";", "if", "(", "STI", ".", "isTargetELF", "(", ")", "&&", "hasFP", "(", "MF", ")", ")", "MFI", "->", "setOffsetAdjustment", "(", "MFI", "->", "getOffsetAdjustment" ]

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

[ "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "<NUM_LIT>", ")", "mode", "=", "smallest_mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ",", "MODE_INT", ")", ";", "else", "mode", "=", "word_mode", ";", "intoffset", "/", "=", "BITS_PER_UNIT", ";", "do", "{", "regno", "=", "parms", "->", "regbase", "+", "this_slotno", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "parms", "->", "ret", ",", "<NUM_LIT>", ",", "parms", "->", "stack", "+", "parms", "->", "nregs", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "this_slotno", "+=", "<NUM_LIT>", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "<NUM_LIT>", ")", ")", "+", "<NUM_LIT>", ";", "mode", "=", "word_mode", ";", "parms", "->", "nregs", "+=", "<NUM_LIT>", ";" ]

[ ")" ]

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

[ "}" ]

[ "OCI", "!=", "OCE", ";", "++", "OCI", ")", "OS", "<<", "<STR_LIT>", ", 0x", "<STR_LIT>", "<<", "utohexstr", "(", "*", "OCI", ")", ";", "OS", "<<", "'", "\\n", "'", ";" ]

[ "}" ]

[ "}", "]", ",", "NegateImm", ">", ";", "def", "NegSubInlineConst16", ":", "ImmLeaf", "<", "i16", ",", "[", "{", "return", "Imm", "<", "-", "<NUM_LIT>", "&", "&", "Imm", ">", "=", "-", "<NUM_LIT>", ";", "}", "]", ",", "NegateImm", ">", ";", "def", "ShiftAmt32Imm", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "N", "-", ">", "getZExtValue", "(", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "SoppBrTarget", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";" ]

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

[ "vreinterpret_u64_p8", "(", "poly8x8_t", "_", "_", "a", ")", "{", "return", "(", "uint64x1_t", ")", "_" ]

[ "<FIXS>", "F", "(", "emit_insn", "(", "gen_movsf", "(", "gen_rtx_MEM", "(", "SFmode", ",", "addr", ")", ",", "gen_rtx_REG", "(", "SFmode", ",", "i", ")", ")", ")", ")", ";", "<FIXE>", "<FIXS>", "F", "(", "emit_move_insn", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "<FIXE>", "<FIXS>", "F", "(", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ")", ";", "<FIXE>" ]

[ "xsize", "+=", "<NUM_LIT>", ";", "}", "<BUGS>", "insn", "=", "emit_insn", "(", "gen_movsi", "(", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "}", "if", "(", "frame_pointer_needed", ")", "<BUGS>", "emit_move_insn", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "<BUGE>", "if", "(", "size", ")", "<BUGS>", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ";", "<BUGE>", "if", "(", "flag_pic", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "emit_insn", "(", "gen_GOTaddr2picreg", "(", ")", ")", ";", "}" ]

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

[ "def", "A5_ACS", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rxx32", ",", "PredRegs", ":", "$", "Pe4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rxx32in", ",", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_d1aa9eaa", ",", "TypeM", ">", ",", "Enc_831a7d", ",", "Requires", "<", "[", "HasV55", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "]" ]

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

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

[ "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "(", "get_frame_size", "(", ")", "+", "STACK_POINTER_OFFSET", "+", "crtl", "->", "outgoing_args_size", ")", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "s390_init_frame_layout", "(", ")", ";", "offset", "=", "cfun_frame_layout", ".", "frame_size", "+", "STACK_POINTER_OFFSET", ";", "break", ";", "case", "RETURN_ADDRESS_POINTER_REGNUM", ":", "s390_init_frame_layout", "(", ")", ";", "if", "(", "cfun_frame_layout", ".", "first_save_gpr_slot", "==", "-", "<NUM_LIT>", ")", "{", "if", "(", "cfun", "->", "stdarg", "&&", "!", "cfun_save_arg_fprs_p", ")", "return", "<NUM_LIT>", ";", "gcc_unreachable", "(", ")", ";", "}", "offset", "=", "(", "cfun_frame_layout", ".", "frame_size", "+", "cfun_frame_layout", ".", "gprs_offset", "+", "(", "RETURN_REGNUM", "-", "cfun_frame_layout", ".", "first_save_gpr_slot", ")", "*", "UNITS_PER_LONG", ")", ";", "break", ";", "case", "BASE_REGNUM", ":", "offset", "=", "<NUM_LIT>", ";", "break", ";", "default", ":" ]

[ "<FIXS>", "output_operand_lossage", "(", "<STR_LIT>", "operand is not a condition code, ", "<STR_LIT>", "<STR_LIT>", "invalid operand code 'D'", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "fputs", "(", "<STR_LIT>", "ord", "<STR_LIT>", ",", "file", ")", ";", "break", ";", "default", ":", "<BUGS>", "output_operand_lossage", "(", "<STR_LIT>", "operand is not a condition code, invalid operand code 'D'", "<STR_LIT>", ")", ";", "<BUGE>", "return", ";", "}", "}" ]

[ "CallOperandIsFixed", ".", "push_back", "(", "Outs", "[", "i", "]", ".", "IsFixed", ")", ";" ]

[ "void", "MipsCCState", "::", "PreAnalyzeCallOperands", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "std", "::", "vector", "<", "TargetLowering", "::", "ArgListEntry", ">", "&", "FuncArgs", ",", "const", "SDNode", "*", "CallNode", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Outs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "OriginalArgWasF128", ".", "push_back", "(", "or", "iginalTypeIsF128", "(", "FuncArgs", "[", "Outs", "[", "i", "]", ".", "OrigArgIndex", "]", ".", "Ty", ",", "CallNode", ")", ")", ";", "OriginalArgWasFloat", ".", "push_back", "(", "FuncArgs", "[", "Outs", "[", "i", "]", ".", "OrigArgIndex", "]", ".", "Ty", "->", "isFloatingPointTy", "(", ")", ")", ";" ]

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

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

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

[ "static", "SDValue", "getTestBitOperand", "(", "SDValue", "Op", ",", "unsigned", "&", "Bit", ",", "bool", "&", "Invert", ",", "SelectionDAG", "&", "DAG", ")", "{", "if", "(", "!", "Op", "->", "hasOneUse", "(", ")", ")", "return", "Op", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", "&&", "Bit", "<", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSizeInBits", "(", ")", ")", "{", "return", "getTestBitOperand", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Bit", ",", "Invert", ",", "DAG", ")", ";", "}", "if", "(", "Op", "->", "getNumOperands", "(", ")", "!=", "<NUM_LIT>", ")", "return", "Op", ";", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "C", ")", "return", "Op", ";", "switch", "(", "Op", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "Op", ";", "case", "ISD", "::", "AND", ":", "if", "(", "(", "C", "->", "getZExtValue", "(", ")", ">>", "Bit", ")", "&", "<NUM_LIT>", ")", "return", "getTestBitOperand", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Bit", ",", "Invert", ",", "DAG", ")", ";", "return", "Op", ";", "case", "ISD", "::", "SHL", ":", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "Bit", "&&", "(", "Bit", "-", "C", "->", "getZExtValue", "(", ")", ")", "<", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSizeInBits", "(", ")", ")", "{", "Bit", "=", "Bit", "-", "C", "->", "getZExtValue", "(", ")", ";", "return", "getTestBitOperand", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Bit", ",", "Invert", ",", "DAG", ")", ";", "}", "return", "Op", ";", "case", "ISD", "::", "SRA", ":", "Bit", "=", "Bit", "+", "C", "->", "getZExtValue", "(", ")", ";", "if", "(", "Bit", ">=", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSizeInBits", "(", ")", ")", "Bit", "=", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSizeInBits", "(", ")", "-", "<NUM_LIT>", ";", "return", "getTestBitOperand", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Bit", ",", "Invert", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL", ":", "if", "(", "(", "Bit", "+", "C", "->", "getZExtValue", "(", ")", ")", "<", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSizeInBits", "(", ")", ")", "{", "Bit", "=", "Bit", "+", "C", "->", "getZExtValue", "(", ")", ";", "return", "getTestBitOperand", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Bit", ",", "Invert", ",", "DAG", ")", ";", "}", "return", "Op", ";", "case", "ISD", "::", "XOR", ":", "if", "(", "(", "C", "->", "getZExtValue", "(", ")", ">>", "Bit", ")", "&", "<NUM_LIT>", ")", "Invert", "=", "!", "Invert", ";", "return", "getTestBitOperand", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Bit", "," ]

[ "<STR_LIT>", ")" ]

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

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

[ "class", "SRARI_B_ENC", ":", "MSA_BIT_B_FMT", "<", "<NUM_LIT>" ]

[ "}" ]

[ "SPIRVSubtarget", "::", "SPIRVSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "SPIRVTargetMachine", "&", "TM", ")", ":", "SPIRVGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "PointerSize", "(", "TM", ".", "getPointerSizeInBits", "(", "<NUM_LIT>", ")", ")", ",", "SPIRVVersion", "(", "<NUM_LIT>", ")", ",", "OpenCLVersion", "(", "<NUM_LIT>", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "initSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "TargetTriple", "(", "TT", ")", "{", "initAvailableExtensions", "(", ")", ";", "initAvailableExtInstSets", "(", ")", ";", "GR", "=", "std", "::", "make_unique", "<", "SPIRVGlobalRegistry", ">", "(", "PointerSize", ")", ";", "CallLoweringInfo", "=", "std", "::", "make_unique", "<", "SPIRVCallLowering", ">", "(", "TLInfo", ",", "GR", ".", "get", "(", ")", ")", ";", "Legalizer", "=", "std", "::", "make_unique", "<", "SPIRVLegalizerInfo", ">", "(", "*", "this", ")", ";", "RegBankInfo", "=", "std", "::", "make_unique", "<", "SPIRVRegisterBankInfo", ">", "(", ")", ";", "InstSelector", ".", "reset", "(", "createSPIRVInstructionSelector", "(", "TM", ",", "*", "this", ",", "*", "RegBankInfo", ".", "get", "(", ")", ")", ")", ";" ]

[ "<FIXS>", "case", "E_V16QImode", ":", "gen", "=", "gen_neon_vrev32v16qi", ";", "break", ";", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev32v8qi", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_neon_vrev64v8hi", ";", "break", ";", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vrev64v4hi", ";", "break", ";", "case", "E_V8HFmode", ":", "gen", "=", "gen_neon_vrev64v8hf", ";", "break", ";", "case", "E_V4HFmode", ":", "gen", "=", "gen_neon_vrev64v4hf", ";", "break", ";", "<FIXE>" ]

[ "case", "<NUM_LIT>", ":", "switch", "(", "d", "->", "vmode", ")", "{", "<BUGS>", "case", "V16QImode", ":", "gen", "=", "gen_neon_vrev32v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vrev32v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vrev64v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vrev64v4hi", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_neon_vrev64v8hf", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_neon_vrev64v4hf", ";", "break", ";", "<BUGE>", "default", ":", "return", "false", ";", "}" ]

[ "}" ]

[ "CriticalPathRCs", ".", "push_back", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "HasItin", "&&", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ";" ]

[ "<FIXS>", "replace_addli_pcrel", "(", "rtx_insn", "*", "insn", ")", "<FIXE>" ]

[ "static", "void", "<BUGS>", "replace_addli_pcrel", "(", "rtx", "insn", ")", "<BUGE>", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "set_src", ";" ]

[ "return", "Result", ";" ]

[ "}", "else", "if", "(", "Subtarget", "->", "isPICStyleStubPIC", "(", ")", ")", "{", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "Subtarget", "->", "isPICStyleStubNoDynamic", "(", ")", ")", "{", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "SDValue", "Result", "=", "DAG", ".", "getTargetExternalSymbol", "(", "Sym", ",", "getPointerTy", "(", ")", ",", "OpFlag", ")", ";", "DebugLoc", "DL", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "Result", "=", "DAG", ".", "getNode", "(", "WrapperKind", ",", "DL", ",", "getPointerTy", "(", ")", ",", "Result", ")", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "getPointerTy", "(", ")", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DebugLoc", "(", ")", ",", "getPointerTy", "(", ")", ")", ",", "Result", ")", ";", "}", "if", "(", "isGlobalStubReference", "(", "OpFlag", ")", ")", "Result", "=", "DAG", ".", "getLoad", "(", "getPointerTy", "(", ")", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Result", ",", "MachinePointerInfo", "::", "getGOT", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "vst4_s64", "(", "int64_t", "*", "_", "_", "a", ",", "int64x1x4_t", "_", "_", "b", ")", "{", "union", "{", "int64x1x4_t", "_", "_", "i", ";", "_", "_", "builtin_neon_oi", "_", "_", "o", ";", "}", "_", "_", "bu", "=", "{", "_", "_", "b", "}", ";", "_", "_", "builtin_neon_vst4di", "(", "(", "_", "_", "builtin_neon_di", "*", ")", "_", "_", "a", ",", "_", "_", "bu", ".", "_", "_", "o", ")", ";" ]

[ "static", "rtx", "frv_expand_mclracc_builtin", "(", "tree", "arglist", ")", "{", "enum", "insn_code", "icode", "=", "CODE_FOR_mclracc", ";", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "<NUM_LIT>", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}" ]

[ "Expand", "the", "MCLRACC", "builtin", ".", "This", "builtin", "takes", "a", "single", "accumulator", "number", "as", "argument", "." ]

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";" ]

[ "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "<NUM_LIT>", ")", ";" ]

[ ",", "misalignment", ",", "is_packed", ")", ";" ]

[ "if", "(", "TARGET_VX", ")", "return", "true", ";", "return", "default_builtin_support_vector_misalignment", "(", "mode", ",", "type" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "DI", "(", "reg", ":", "DI", "<NUM_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ ")", "_", "_", "B", ",", "(", "_", "_", "v4si", ")", "_", "_", "C", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_macc_epi32", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ",", "_", "_", "m128i", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpmacsdd", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v4si" ]

[ "<STR_LIT>" ]

[ "(", "vec_duplicate", ":", "VF_128", "(", "unsigned_float", ":", "<", "ssescalarmode", ">", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "<FIXS>", "if", "(", "Subtarget", ".", "isELF32_ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "}", "<FIXE>" ]

[ "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "<BUGS>", "if", "(", "!", "Subtarget", ".", "isDarwin", "(", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "<BUGE>" ]

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

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

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

[ "return", "_", "_", "builtin_aarch64_ceilv4sf", "(", "_" ]

[ "bool", "ARMBaseInstrInfo", "::", "produceSameValue", "(", "const", "MachineInstr", "*", "MI0", ",", "const", "MachineInstr", "*", "MI1", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "int", "Opcode", "=", "MI0", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "ARM", "::", "t2LDRpci", "||", "Opcode", "==", "ARM", "::", "t2LDRpci_pic", "||", "Opcode", "==", "ARM", "::", "tLDRpci", "||", "Opcode", "==", "ARM", "::", "tLDRpci_pic", "||", "Opcode", "==", "ARM", "::", "LDRLIT_ga_pcrel", "||", "Opcode", "==", "ARM", "::", "LDRLIT_ga_pcrel_ldr", "||", "Opcode", "==", "ARM", "::", "tLDRLIT_ga_pcrel", "||", "Opcode", "==", "ARM", "::", "MOV_ga_pcrel", "||", "Opcode", "==", "ARM", "::", "MOV_ga_pcrel_ldr", "||", "Opcode", "==", "ARM", "::", "t2MOV_ga_pcrel", ")", "{", "if", "(", "MI1", "->", "getOpcode", "(", ")", "!=", "Opcode", ")", "return", "false", ";", "if", "(", "MI0", "->", "getNumOperands", "(", ")", "!=", "MI1", "->", "getNumOperands", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO0", "=", "MI0", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MachineOperand", "&", "MO1", "=", "MI1", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "MO0", ".", "getOffset", "(", ")", "!=", "MO1", ".", "getOffset", "(", ")", ")", "return", "false", ";", "if", "(", "Opcode", "==", "ARM", "::", "LDRLIT_ga_pcrel", "||", "Opcode", "==", "ARM", "::", "LDRLIT_ga_pcrel_ldr", "||", "Opcode", "==", "ARM", "::", "tLDRLIT_ga_pcrel", "||", "Opcode", "==", "ARM", "::", "MOV_ga_pcrel", "||", "Opcode", "==", "ARM", "::", "MOV_ga_pcrel_ldr", "||", "Opcode", "==", "ARM", "::", "t2MOV_ga_pcrel", ")", "return", "MO0", ".", "getGlobal", "(", ")", "==", "MO1", ".", "getGlobal", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MI0", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineConstantPool", "*", "MCP", "=", "MF", "->", "getConstantPool", "(", ")", ";", "int", "CPI0", "=", "MO0", ".", "getIndex", "(", ")", ";", "int", "CPI1", "=", "MO1", ".", "getIndex", "(", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE0", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPI0", "]", ";", "const", "MachineConstantPoolEntry", "&", "MCPE1", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPI1", "]", ";", "bool", "isARMCP0", "=", "MCPE0", ".", "isMachineConstantPoolEntry", "(", ")", ";", "bool", "isARMCP1", "=", "MCPE1", ".", "isMachineConstantPoolEntry", "(", ")", ";", "if", "(", "isARMCP0", "&&", "isARMCP1", ")", "{", "ARMConstantPoolValue", "*", "ACPV0", "=", "static_cast", "<", "ARMConstantPoolValue", "*", ">", "(", "MCPE0", ".", "Val", ".", "MachineCPVal", ")", ";", "ARMConstantPoolValue", "*", "ACPV1", "=", "static_cast", "<", "ARMConstantPoolValue", "*", ">", "(", "MCPE1", ".", "Val", ".", "MachineCPVal", ")", ";", "return", "ACPV0", "->", "hasSameValue", "(", "ACPV1", ")", ";", "}", "else", "if", "(", "!", "isARMCP0", "&&", "!", "isARMCP1", ")", "{", "return", "MCPE0", ".", "Val", ".", "ConstVal", "==", "MCPE1", ".", "Val", ".", "ConstVal", ";", "}", "return", "false", ";", "}", "else", "if", "(", "Opcode", "==", "ARM", "::", "PICLDR", ")", "{", "if", "(", "MI1", "->", "getOpcode", "(", ")", "!=", "Opcode", ")", "return", "false", ";", "if", "(", "MI0", "->", "getNumOperands", "(", ")", "!=", "MI1", "->", "getNumOperands", "(", ")", ")", "return", "false", ";", "unsigned", "Addr0", "=", "MI0", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Addr1", "=", "MI1", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Addr0", "!=", "Addr1", ")", "{", "if", "(", "!", "MRI", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Addr0", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Addr1", ")", ")", "return", "false", ";", "MachineInstr", "*", "Def0", "=", "MRI", "->", "getVRegDef", "(", "Addr0", ")", ";", "MachineInstr", "*", "Def1", "=", "MRI", "->", "getVRegDef", "(", "Addr1", ")", ";", "if", "(", "!", "produceSameValue", "(", "Def0", ",", "Def1", ",", "MRI", ")", ")", "return", "false", ";", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI0", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO0", "=", "MI0", "->", "getOperand", "(", "i", ")", ";", "const", "MachineOperand", "&", "MO1", "=", "MI1", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO0", ".", "isIdenticalTo", "(", "MO1", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "return", "MI0", "->", "isIdenticalTo", "(", "MI1", ",", "MachineInstr", "::", "IgnoreVRegDefs", ")", ";", "}" ]

[ "Return", "true", "if", "two", "machine", "instructions", "would", "produce", "identical", "values", "." ]

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

[ "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>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "{" ]

[ "bool", "SystemZTargetLowering", "::", "useSoftFloat", "(", ")", "const" ]

[ "::", "GLOBAL_ADDRESS", ";" ]

[ "if", "(", "!", "LD", ")", "return", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ";", "assert", "(", "V", "->", "getType", "(", ")", "->", "isPointerTy", "(", ")", "&&", "V", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", ";", "const", "auto", "*", "Ptr", "=", "LD", "->", "getPointerOperand", "(", ")", ";", "if", "(", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", "return", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ";", "return", "AMDGPUAS" ]

[ "OtherVT", ">", "{" ]

[ "def", "am_tbrcond", ":", "Operand", "<" ]

[ ")" ]

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

[ "}" ]

[ "_", "_", "attribute__", "(", "(", "_", "_", "vector_size__", "(", "<NUM_LIT>", ")", ",", "_", "_", "may_alias__", ")", ")", ";", "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_add_pd", "(", "_", "_", "m256d", "_", "_", "A", ",", "_", "_", "m256d", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256d", ")", "(", "(", "_", "_", "v4df", ")", "_", "_", "A", "+", "(", "_", "_", "v4df", ")", "_", "_", "B", ")", ";" ]

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

[ "explicit", "rvexDAGToDAGISel", "(", "rvexTargetMachine", "&", "tm", ")", ":", "SelectionDAGISel", "(", "tm", ")", ",", "TM", "(", "tm", ")", ",", "Subtarget", "(", "tm", ".", "getSubtarget", "<", "rvexSubtarget", ">", "(" ]

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

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

[ "<FIXS>", "<FIXE>", "<FIXS>", "assert", "(", "MCID", "->", "getNumOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "+", "<NUM_LIT>", "&&", "<STR_LIT>", "converted opcode should be the same except for cc_out", "<STR_LIT>", ")", ";", "<FIXE>", "<FIXS>", "}", "unsigned", "ccOutIdx", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "<FIXE>" ]

[ "unsigned", "NewOpc", "=", "convertAddSubFlagsOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "<BUGS>", "unsigned", "ccOutIdx", ";", "<BUGE>", "if", "(", "NewOpc", ")", "{", "const", "ARMBaseInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MCID", "=", "&", "TII", "->", "get", "(", "NewOpc", ")", ";", "<BUGS>", "assert", "(", "MCID", "->", "getNumOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "+", "<NUM_LIT>", "-", "MI", ".", "getDesc", "(", ")", ".", "getSize", "(", ")", "&&", "<STR_LIT>", "converted opcode should be the same except for cc_out", "<STR_LIT>", "<STR_LIT>", " (and, on Thumb1, pred)", "<STR_LIT>", ")", ";", "<BUGE>", "MI", ".", "setDesc", "(", "*", "MCID", ")", ";", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "true", ")", ")", ";", "<BUGS>", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "{", "for", "(", "unsigned", "c", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "c", "--", ";", ")", "{", "MI", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "}", "for", "(", "unsigned", "i", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "--", ";", ")", "{", "const", "MachineOperand", "&", "op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "op", ".", "isReg", "(", ")", "&&", "op", ".", "isUse", "(", ")", ")", "{", "int", "DefIdx", "=", "MCID", "->", "getOperandConstraint", "(", "i", ",", "MCOI", "::", "TIED_TO", ")", ";", "if", "(", "DefIdx", "!=", "-", "<NUM_LIT>", ")", "MI", ".", "tieOperands", "(", "DefIdx", ",", "i", ")", ";", "}", "}", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "false", ")", ")", ";", "ccOutIdx", "=", "<NUM_LIT>", ";", "}", "elseccOutIdx", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "}", "elseccOutIdx", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "<BUGE>" ]

[ ";" ]

[ "unsigned", "JumpOffset", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "JumpOffset", ")", ")", ";", "return", "MCDisassembler", "::", "Success" ]

[ "return", "S", ";" ]

[ "if", "(", "msb", "!=", "<NUM_LIT>", ")", "msb_mask", "=", "(", "<NUM_LIT>", "U", "<<", "(", "msb", "+", "<NUM_LIT>", ")", ")", "-", "<NUM_LIT>", ";", "uint32_t", "lsb_mask", "=", "(", "<NUM_LIT>", "U", "<<", "lsb", ")", "-", "<NUM_LIT>", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "~", "(", "msb_mask", "^", "lsb_mask", ")", ")", ")", ";" ]

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

[ "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "int", "hi", "=", "TARGET_BIG_ENDIAN", "?", "<NUM_LIT>", ":", "UNITS_PER_WORD", "int", "lo", "=", "TARGET_BIG_ENDIAN", "?", "UNITS_PER_WORD", ":", "<NUM_LIT>", "rtx", "l0", "=", "simplify_gen_subreg", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "DImode", ",", "lo", ")", "rtx", "h0", "=", "simplify_gen_subreg", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "DImode", ",", "hi", ")", "rtx", "l1", "=", "simplify_gen_subreg", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "DImode", ",", "lo", ")", "rtx", "h1", "=", "simplify_gen_subreg", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "DImode", ",", "hi", ")", "rtx", "l2", "=", "simplify_gen_subreg", "(", "SImode", ",", "operands", "[" ]

[ "&", "ExitSU", ")", "SuccDep", ".", "setLatency", "(", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "PredDep", ".", "isWeak", "(", ")", ")", "continue", ";", "SUnit", "&", "SU", "=", "*", "PredDep", ".", "getSUnit", "(", ")", ";", "MachineInstr", "&", "Pred", "=", "*", "SU", ".", "getInstr", "(", ")", ";", "if", "(", "!", "shouldScheduleAdjacent", "(", "ST", ",", "&", "Pred", ",", "Branch", ")", ")", "continue", ";", "bool", "Success", "=", "DAG", "->", "addEdge", "(", "&", "ExitSU", ",", "SDep", "(", "&", "SU", ",", "SDep", "::", "Cluster", ")", ")", ";", "(", "void", ")", "Success", ";", "assert", "(", "Success", "&&", "<STR_LIT>", "No DAG nodes should be reachable from ExitSU", "<STR_LIT>", ")", ";", "for", "(", "SDep", "&", "PredDep", ":", "ExitSU", ".", "Preds", ")", "if", "(", "PredDep", ".", "getSUnit", "(", ")", "==", "&", "SU", ")", "PredDep", ".", "setLatency", "(", "<NUM_LIT>", ")", ";", "for", "(", "SDep", "&", "SuccDep", ":", "SU", ".", "Succs", ")", "if", "(", "SuccDep", ".", "getSUnit", "(", ")", "==" ]

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

[ "return", "(", "int32x2_t", ")", "_", "_", "builtin_neon_vqnegv2si", "(" ]

[ "static", "enum", "attr_type", "s390_safe_attr_type", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "<NUM_LIT>", ")", "return", "get_attr_type", "(", "insn", ")", ";", "else", "return", "TYPE_NONE", ";", "}" ]

[ "Return", "attribute", "type", "of", "insn", "." ]

[ "&&", "!", "IsVarArg", ";" ]

[ "return", "CC", "==", "CallingConv", "::", "M68k_RTD" ]

[ ".", "addReg", "(", "DupSrcReg", ")", ".", "addImm", "(", "DupSrcLane", ")", ";" ]

[ "MRI", ".", "constrainRegClass", "(", "DupSrcReg", ",", "RC", ")", ";", "unsigned", "DupSrcLane", "=", "Dup", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "IdxMulOp", "=", "IdxDupOp", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "MachineOperand", "&", "MulOp", "=", "Root", ".", "getOperand", "(", "IdxMulOp", ")", ";", "Register", "ResultReg", "=", "Root", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MachineInstrBuilder", "MIB", ";", "MIB", "=", "BuildMI", "(", "MF", ",", "MIMetadata", "(", "Root", ")", ",", "TII", "->", "get", "(", "MulOpc", ")", ",", "ResultReg", ")", ".", "add", "(", "MulOp", ")" ]

[ "void", "SystemZRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Outgoing arguments should be part of the frame", "<STR_LIT>", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "getFrameRegister", "(", "MF", ")", ";", "int64_t", "Offset", "=", "(", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", "+", "MI", "->", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", "->", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "unsigned", "OpcodeForOffset", "=", "TII", ".", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "if", "(", "OpcodeForOffset", ")", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "else", "{", "int64_t", "OldOffset", "=", "Offset", ";", "int64_t", "Mask", "=", "<NUM_LIT>", ";", "do", "{", "Offset", "=", "OldOffset", "&", "Mask", ";", "OpcodeForOffset", "=", "TII", ".", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "Mask", ">>=", "<NUM_LIT>", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "One offset must be OK", "<STR_LIT>", ")", ";", "}", "while", "(", "!", "OpcodeForOffset", ")", ";", "unsigned", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int64_t", "HighOffset", "=", "OldOffset", "-", "Offset", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MI", "->", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<NUM_LIT>", ")", "{", "TII", ".", "loadImmediate", "(", "MBB", ",", "MI", ",", "ScratchReg", ",", "HighOffset", ")", ";", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", "->", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "}", "else", "{", "unsigned", "LAOpcode", "=", "TII", ".", "getOpcodeForOffset", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "HighOffset", ")", ";", "if", "(", "LAOpcode", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LAOpcode", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "BasePtr", ")", ".", "addImm", "(", "HighOffset", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "else", "{", "TII", ".", "loadImmediate", "(", "MBB", ",", "MI", ",", "ScratchReg", ",", "HighOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "BasePtr", ")", ";", "}", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "}", "}", "MI", "->", "setDesc", "(", "TII", ".", "get", "(", "OpcodeForOffset", ")", ")", ";", "MI", "->", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "SDValue", "SubN0", "=", "Extract128BitVector", "(", "N0", ",", "N2", ",", "DAG", ",", "dl", ")", ";" ]

[ "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N2", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", ">", "<NUM_LIT>", ")", "{", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "N2", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "NumElems", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "IdxVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "N2", ")", "->", "getZExtValue", "(", ")", ";", "bool", "Upper", "=", "IdxVal", ">=", "NumElems", "/", "<NUM_LIT>", ";" ]

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

[ "return", "(", "(", "vec_ullong2", ")", "(", "si_dftsv", "(", "(", "qword", ")", "(", "a", ")" ]

[ "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "DestReg", ")", ")", "{" ]

[ "else", "if", "(", "X86", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "MOV16rr", ";", "else", "if", "(", "X86", "::", "GR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "(", "isHReg", "(", "DestReg", ")", "||", "isHReg", "(", "SrcReg", ")", ")", "&&", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "{", "Opc", "=", "X86", "::", "MOV8rr_NOREX", ";", "assert", "(", "X86", "::", "GR8_NOREXRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", "&&", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "}", "else", "Opc", "=", "X86", "::", "MOV8rr", ";", "}", "else", "if", "(", "X86", "::", "VR64RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "MMX_MOVQ64rr", ";", "else", "if", "(", "HasAVX512", ")", "Opc", "=", "copyPhysRegOpcode_AVX512", "(", "DestReg", ",", "SrcReg", ")", ";", "else", "if", "(", "X86", "::", "VR128RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "HasAVX", "?", "X86", "::", "VMOVAPSrr", ":", "X86", "::", "MOVAPSrr", ";", "else", "if", "(", "X86", "::", "VR256RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "VMOVAPSYrr", ";", "if", "(", "!", "Opc", ")", "Opc", "=", "CopyToFromAsymmetricReg", "(", "DestReg", ",", "SrcReg", ",", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ")", ";", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "if", "(", "SrcReg", "==", "X86", "::", "EFLAGS", ")", "{" ]

[ "<FIXS>", "if", "(", "!", "TARGET_V9", "||", "TARGET_ARCH64", ")", "<FIXE>" ]

[ "if", "(", "TARGET_V9", "&&", "TARGET_ARCH32", ")", "target_flags", "|=", "MASK_DEPRECATED_V8_INSNS", ";", "<BUGS>", "if", "(", "!", "TARGET_V9", ")", "<BUGE>", "target_flags", "&=", "~", "MASK_V8PLUS", ";" ]

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

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

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

[ "def", "A4_psxtbf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_fb6577", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "RParen", ")", ")", "{" ]

[ "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "unexpected token in argument list", "<STR_LIT>", ")", ";", "}", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::" ]

[ "}" ]

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "addImm", "(", "LPAC", "::", "ADD", ")", ";" ]

[ "NumTargetFixupKinds", ";" ]

[ "return", "Z80", "::" ]

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

[ "uint32x4_t", "_", "_", "arg1", "=", "_", "_", "arm_vuninitializedq_u32", "(", ")", ";", "uint32x4_t", "_", "_", "res", "=", "_", "_", "builtin_mve_viwdupq_m_n_uv4si", "(", "_", "_", "arg1", ",", "*", "_", "_", "a", ",", "_", "_", "c", "," ]

[ ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "V2SI", "(", "zero_extend", ":", "V4SI", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "<FIXS>", "return", "transferMemOperands", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "LD", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "PPCLowering", "->", "getPointerTy", "(", ")", ",", "MVT", "::", "Other", ",", "Ops", ")", ")", ";", "<FIXE>" ]

[ "SDValue", "Chain", "=", "LD", "->", "getChain", "(", ")", ";", "SDValue", "Base", "=", "LD", "->", "getBasePtr", "(", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "Offset", ",", "Chain", "}", ";", "<BUGS>", "return", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "LD", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "PPCLowering", "->", "getPointerTy", "(", ")", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "<BUGE>", "}", "}" ]

[ ")", ";" ]

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "LoongArch didn't implement copyPhysReg", "<STR_LIT>" ]