Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "SDValue", "CCReg", "=", "SelectCC", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CC", ",", "dl", ")", ";", "<FIXE>" ]

[ "SDValue", "(", "Tmp", ",", "<NUM_LIT>", ")", ")", ";", "}", "<BUGS>", "SDValue", "CCReg", "=", "SelectCC", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CC", ")", ";", "<BUGE>", "unsigned", "BROpc", "=", "getPredicateForSetCC", "(", "CC", ")", ";", "unsigned", "SelectCCOp", ";" ]

[ "}" ]

[ "case", "MEM", ":", "{", "int", "num_words", "=", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "memory_address_p", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "(", "x", ")", ",", "<NUM_LIT>", ")", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "num_words", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", "*", "num_words", ")", ";", "return", "true", ";", "}", "case", "FFS", ":", "case", "CTZ", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_NSA", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "CLZ", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_NSA", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "NOT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "(", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "ABS", ":", "{", "machine_mode", "xmode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "xmode", "==", "SFmode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_HARD_FLOAT", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "else", "if", "(", "xmode", "==", "DFmode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "PLUS", ":", "case", "MINUS", ":", "{", "machine_mode", "xmode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "xmode", "==", "SFmode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_HARD_FLOAT", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "else", "if", "(", "xmode", "==", "DFmode", "||", "xmode", "==", "DImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "NEG", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "(", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "MULT", ":", "{", "machine_mode", "xmode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "xmode", "==", "SFmode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_HARD_FLOAT", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "else", "if", "(", "xmode", "==", "DFmode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "xmode", "==", "DImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_MUL32_HIGH", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "else", "if", "(", "TARGET_MUL32", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "TARGET_MAC16", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "TARGET_MUL16", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "DIV", ":", "case", "MOD", ":", "{", "machine_mode", "xmode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "xmode", "==", "SFmode", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_HARD_FLOAT_DIV", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "else", "if", "(", "xmode", "==", "DFmode", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "}", "case", "UDIV", ":", "case", "UMOD", ":", "{", "machine_mode", "xmode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "xmode", "==", "DImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "TARGET_DIV32", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "SQRT", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_HARD_FLOAT_SQRT", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "SMIN", ":", "case", "UMIN", ":", "case", "SMAX", ":", "case", "UMAX", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_MINMAX", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "SIGN_EXTRACT", ":", "case", "SIGN_EXTEND", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "TARGET_SEXT", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "ZERO_EXTRACT", ":", "case", "ZERO_EXTEND", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";" ]

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

[ "int64_t", "ConstVal", "=", "CI", "->", "getZExtValue", "(", ")", ";", "return", "isUInt", "<", "<NUM_LIT>", ">", "(", "ConstVal", ")", "||", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "ConstVal", ">>", "<NUM_LIT>", ")", "&&", "!", "(", "ConstVal", "&", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "static", "bool", "avr_addr_space_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ",", "addr_space_t", "as", ")", "{", "bool", "ok", "=", "false", ";", "switch", "(", "as", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ADDR_SPACE_GENERIC", ":", "return", "avr_legitimate_address_p", "(", "mode", ",", "x", ",", "strict", ")", ";", "case", "ADDR_SPACE_FLASH", ":", "case", "ADDR_SPACE_FLASH1", ":", "case", "ADDR_SPACE_FLASH2", ":", "case", "ADDR_SPACE_FLASH3", ":", "case", "ADDR_SPACE_FLASH4", ":", "case", "ADDR_SPACE_FLASH5", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "ok", "=", "avr_reg_ok_for_pgm_addr", "(", "x", ",", "strict", ")", ";", "break", ";", "case", "POST_INC", ":", "ok", "=", "avr_reg_ok_for_pgm_addr", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "strict", ")", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "case", "ADDR_SPACE_MEMX", ":", "if", "(", "REG_P", "(", "x", ")", ")", "ok", "=", "(", "!", "strict", "&&", "can_create_pseudo_p", "(", ")", ")", ";", "if", "(", "LO_SUM", "==", "GET_CODE", "(", "x", ")", ")", "{", "rtx", "hi", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "lo", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "ok", "=", "(", "REG_P", "(", "hi", ")", "&&", "(", "!", "strict", "||", "REGNO", "(", "hi", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "&&", "REG_P", "(", "lo", ")", "&&", "REGNO", "(", "lo", ")", "==", "REG_Z", ")", ";", "}", "break", ";", "}", "if", "(", "avr_log", ".", "legitimate_address_p", ")", "{", "avr_edump", "(", "<STR_LIT>", "\\n%?: ret=%b, mode=%m strict=%d ", "<STR_LIT>", "<STR_LIT>", "reload_completed=%d reload_in_progress=%d %s:", "<STR_LIT>", ",", "ok", ",", "mode", ",", "strict", ",", "reload_completed", ",", "reload_in_progress", ",", "reg_renumber", "?", "<STR_LIT>", "(reg_renumber)", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ",", "<NUM_LIT>", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", "&&", "reg_renumber", ")", "{", "avr_edump", "(", "<STR_LIT>", "(r%d ---> r%d)", "<STR_LIT>", ",", "REGNO", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ",", "true_regnum", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", ";", "}", "avr_edump", "(", "<STR_LIT>", "\\n%r\\n", "<STR_LIT>", ",", "x", ")", ";", "}", "return", "ok", ";", "}" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P", "'", "." ]

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

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

[ "int", "Index", "=", "i", "&", "~", "(", "NumElementsPerLane", "-", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "!", "VecEltTy", "->", "isIntegerTy", "(", ")", ")", "return", ";", "unsigned", "EltTySize", "=", "VecEltTy", "->", "getIntegerBitWidth", "(", ")", ";", "if", "(", "EltTySize", "<", "<NUM_LIT>", "||", "EltTySize", ">", "ElSize", ")", "return", ";", "unsigned", "NumElements", "=", "MaskTySize", "/", "ElSize", ";", "assert", "(", "(", "NumElements", "==", "<NUM_LIT>", "||", "NumElements", "==", "<NUM_LIT>", "||", "NumElements", "==", "<NUM_LIT>", "||", "NumElements", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Unexpected number of vector elements.", "<STR_LIT>", ")", ";", "ShuffleMask", ".", "reserve", "(", "NumElements", ")", ";", "unsigned", "NumElementsPerLane", "=", "<NUM_LIT>", "/", "ElSize", ";", "unsigned", "Factor", "=", "ElSize", "/", "EltTySize", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumElements", ";", "++", "i", ")", "{", "Constant", "*", "COp", "=", "C", "->", "getAggregateElement", "(", "i", "*", "Factor", ")", ";", "if", "(", "!", "COp", ")", "{", "ShuffleMask", ".", "clear", "(", ")", ";", "return", ";", "}", "else", "if", "(", "isa", "<", "UndefValue", ">", "(", "COp", ")", ")", "{", "ShuffleMask", ".", "push_back", "(", "SM_SentinelUndef", ")", ";", "continue", ";", "}" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "MCUnaryExpr", "::", "createMinus", "(", "Expr", ",", "Ctx", ")", ")", ")", ";" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "UnExpr", "->", "getSubExpr", "(", ")", ")", ")", ";", "return", ";", "}", "}", "else", "if", "(", "const", "MCBinaryExpr", "*", "BinExpr", "=", "dyn_cast", "<", "MCBinaryExpr", ">", "(", "Expr", ")", ")", "{", "if", "(", "BinExpr", "->", "getOpcode", "(", ")", "==", "MCBinaryExpr", "::", "Sub", ")", "{", "const", "MCExpr", "*", "NE", "=", "MCBinaryExpr", "::", "createSub", "(", "BinExpr", "->", "getRHS", "(", ")", ",", "BinExpr", "->", "getLHS", "(", ")", ",", "Ctx", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "NE", ")", ")", ";", "return", ";", "}", "}" ]

[ "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "RelaxInstruction() unimplemented", "<STR_LIT>", ")", ";", "return", "false", ";", "}" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ ":", "$", "src", ",", "VPR64", ":", "$", "Rn", ",", "VPR64", ":", "$", "Rm", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v8i8", "(", "opnode", "(", "v8i8", "VPR64", ":", "$", "src", ")", ",", "VPR64", ":", "$", "Rn", ",", "VPR64", ":", "$", "Rm", ")", ")", ",", "(", "INST8B", "VPR64" ]

[ "}" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "unexpected operand type!", "<STR_LIT>", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "O", ")", ";", "break", ";", "}", "return", "false", ";", "case", "'", "A", "'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'", "*", "'", ";", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'", "b", "'", ":", "case", "'", "h", "'", ":", "case", "'", "w", "'", ":", "case", "'", "k", "'", ":", "case", "'", "q", "'", ":", "case", "'", "V", "'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "*", "this", ",", "MO", ",", "ExtraCode", "[", "<NUM_LIT>", "]", ",", "O", ")", ";", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'", "x", "'", ":", "case", "'", "t", "'", ":", "case", "'", "g", "'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmVRegister", "(", "MO", ",", "ExtraCode", "[", "<NUM_LIT>", "]", ",", "O", ")", ";", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'", "p", "'", ":", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "getType", "(", ")", "!=", "MachineOperand", "::", "MO_GlobalAddress", ")", "return", "true", ";", "PrintSymbolOperand", "(", "MO", ",", "O", ")", ";", "return", "false", ";", "}", "case", "'", "P", "'", ":", "PrintPCRelImm", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'", "n", "'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "-", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "O", "<<", "'", "-", "'", ";", "}" ]

[ "MCSymbol", "*", "Symbol2", "=", "OutContext", ".", "GetOrCreateSymbol", "(", "StringRef", "(", "<STR_LIT>", ".TOC.", "<STR_LIT>", ")", ")", ";" ]

[ "const", "MCSection", "*", "Current", "=", "OutStreamer", ".", "getCurrentSection", "(", ")", ";", "const", "MCSectionELF", "*", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "<STR_LIT>", ".opd", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "Section", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "CurrentFnSym", ")", ";", "OutStreamer", ".", "EmitValueToAlignment", "(", "<NUM_LIT>", ")", ";", "MCSymbol", "*", "Symbol1", "=", "OutContext", ".", "GetOrCreateSymbol", "(", "<STR_LIT>", ".L.", "<STR_LIT>", "+", "Twine", "(", "CurrentFnSym", "->", "getName", "(", ")", ")", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Symbol1", ",", "OutContext", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "const", "Register", "SDSTReg", "=", "SDST", "->", "getReg", "(", ")", ";", "<FIXE>" ]

[ "if", "(", "!", "SDST", ")", "return", "false", ";", "<BUGS>", "const", "unsigned", "SDSTReg", "=", "SDST", "->", "getReg", "(", ")", ";", "<BUGE>", "auto", "IsHazardFn", "=", "[", "SDSTReg", ",", "TRI", "]", "(", "MachineInstr", "*", "I", ")", "{", "return", "SIInstrInfo", "::", "isSMRD", "(", "*", "I", ")", "&&", "I", "->", "readsRegister", "(", "SDSTReg", ",", "TRI", ")", ";", "}", ";" ]

[ "{" ]

[ "class", "IsCall" ]

[ "void", "aarch64_register_pragmas", "(", "void", ")", "{", "targetm", ".", "target_option", ".", "pragma_parse", "=", "aarch64_pragma_target_parse", ";", "targetm", ".", "resolve_overloaded_builtin", "=", "aarch64_resolve_overloaded_builtin", ";", "targetm", ".", "check_builtin_call", "=", "aarch64_check_builtin_call", ";", "c_register_pragma", "(", "<STR_LIT>", "GCC", "<STR_LIT>", ",", "<STR_LIT>", "aarch64", "<STR_LIT>", ",", "aarch64_pragma_aarch64", ")", ";", "}" ]

[ "Implement", "REGISTER_TARGET_PRAGMAS", "." ]

[ "}" ]

[ "else", "if", "(", "new", "_", "tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new", "_", "tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";" ]

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

[ "def", "J4_cmpeqn1_tp0_jump_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "n1Const", ":", "$", "n1", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_3a2484", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "<STR_LIT>", ";" ]

[ "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::CMPICC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::CMPFCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::BRICC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::BRXCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::BRFCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::SELECT_ICC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::SELECT_XCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::SELECT_FCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::Hi", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::Lo", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SPISD::FTOI" ]

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

[ "void", "XtensaConstantPoolJumpTable", "::", "print", "(", "raw_ostream", "&", "O" ]

[ "emit_insn", "(", "gen_bmasksi_vis", "(", "gen_rtx_REG", "(", "SImode", ",", "<NUM_LIT>", ")", ",", "sel", ",", "const0_rtx", ")", ")", ";" ]

[ "final_insn", "=", "gen_bshufflev8qi_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sel", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "bmask", ")", ")", ";" ]

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

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

[ "<FIXS>", "SDValue", "boolInR8", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ",", "InFlag", ")", ";", "<FIXE>", "<FIXS>", "SDValue", "zeroReg", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ",", "InFlag", ")", ";", "<FIXE>" ]

[ "case", "MVT", "::", "i1", ":", "{", "<BUGS>", "SDValue", "boolInR8", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ",", "InFlag", ")", ";", "<BUGE>", "InFlag", "=", "boolInR8", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Chain", "=", "boolInR8", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "SDValue", "zeroReg", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ",", "InFlag", ")", ";", "<BUGE>", "InFlag", "=", "zeroReg", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Chain", "=", "zeroReg", ".", "getValue", "(", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "defm", ":", "ScalToVecWPermute", "v4i32", ",", "(", "i32", "i32", ":", "$", "A", ")", ",", "(", "MTVSRWS", "$", "A", ")", ",", "(", "MTVSRWS", "$", "A", ")", ">", ";", "<FIXE>" ]

[ "VSSRC", ")", ")", ">", ";", "<BUGS>", "def", ":", "Pat", "(", "v4i32", "(", "scalar_to_vector", "i32", ":", "$", "A", ")", ")", ",", "(", "v4i32", "(", "MTVSRWS", "$", "A", ")", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "v4i32", "(", "build_vector", "i32", ":", "$", "A", ",", "i32", ":", "$", "A", ",", "i32", ":", "$", "A", ",", "i32", ":", "$", "A", ")", ")", ",", "(", "v4i32", "(", "MTVSRWS", "$", "A", ")", ")", ">", ";", "def", ":", "Pat", "(", "v16i8", "(", "build_vector", "immNonAllOneAnyExt8", ":", "$", "A", ",", "immNonAllOneAnyExt8", ":", "$", "A", "," ]

[ "if", "(", "MustSaveLR", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MTLRInst", ")", ".", "addReg", "(", "ScratchReg", ")", ";" ]

[ "assert", "(", "FPOffset", "<=", "<NUM_LIT>", "&&", "BPOffset", "<=", "<NUM_LIT>", "&&", "PBPOffset", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Local offsets should be negative", "<STR_LIT>", ")", ";", "SPAdd", "=", "FrameSize", ";", "FPOffset", "+=", "FrameSize", ";", "BPOffset", "+=", "FrameSize", ";", "PBPOffset", "+=", "FrameSize", ";", "}", "}", "else", "{", "if", "(", "!", "HasRedZone", ")", "{", "if", "(", "!", "HasFP", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrInst", ",", "ScratchReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addReg", "(", "FPReg", ")", ";", "RBReg", "=", "FPReg", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "RBReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SPReg", ")", ";", "}", "}", "assert", "(", "RBReg", "!=", "ScratchReg", "&&", "<STR_LIT>", "Should have avoided ScratchReg", "<STR_LIT>", ")", ";", "assert", "(", "(", "isPPC64", "||", "!", "MustSaveCR", ")", "&&", "<STR_LIT>", "Epilogue CR restoring supported only in 64-bit mode", "<STR_LIT>", ")", ";", "if", "(", "MustSaveCR", "&&", "SingleScratchReg", "&&", "MustSaveLR", ")", "{", "assert", "(", "HasRedZone", "&&", "<STR_LIT>", "Expecting red zone", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LWZ8", ")", ",", "TempReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SPReg", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MustSaveCRs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MTOCRF8", ")", ",", "MustSaveCRs", "[", "i", "]", ")", ".", "addReg", "(", "TempReg", ",", "getKillRegState", "(", "i", "==", "e", "-", "<NUM_LIT>", ")", ")", ";", "}", "bool", "LoadedLR", "=", "false", ";", "if", "(", "MustSaveLR", "&&", "RBReg", "==", "SPReg", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "LROffset", "+", "SPAdd", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "ScratchReg", ")", ".", "addImm", "(", "LROffset", "+", "SPAdd", ")", ".", "addReg", "(", "RBReg", ")", ";", "LoadedLR", "=", "true", ";", "}", "if", "(", "MustSaveCR", "&&", "!", "(", "SingleScratchReg", "&&", "MustSaveLR", ")", ")", "{", "assert", "(", "isPPC64", "&&", "<STR_LIT>", "Expecting 64-bit mode", "<STR_LIT>", ")", ";", "assert", "(", "RBReg", "==", "SPReg", "&&", "<STR_LIT>", "Should be using SP as a base register", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LWZ8", ")", ",", "TempReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "RBReg", ")", ";", "}", "if", "(", "HasFP", ")", "{", "if", "(", "HasRedZone", "||", "RBReg", "==", "SPReg", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "FPReg", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "SPReg", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "ScratchReg", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ")", ".", "addReg", "(", "PPC", "::", "R30", ")", ".", "addImm", "(", "PBPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "if", "(", "HasBP", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "BPReg", ")", ".", "addImm", "(", "BPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "if", "(", "RBReg", "!=", "SPReg", "||", "SPAdd", "!=", "<NUM_LIT>", ")", "{", "assert", "(", "!", "HasRedZone", "&&", "<STR_LIT>", "This should not happen with red zone", "<STR_LIT>", ")", ";", "if", "(", "SPAdd", "==", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrInst", ",", "SPReg", ")", ".", "addReg", "(", "RBReg", ")", ".", "addReg", "(", "RBReg", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "AddImmInst", ",", "SPReg", ")", ".", "addReg", "(", "RBReg", ")", ".", "addImm", "(", "SPAdd", ")", ";", "assert", "(", "RBReg", "!=", "ScratchReg", "&&", "<STR_LIT>", "Should be using FP or SP as base register", "<STR_LIT>", ")", ";", "if", "(", "RBReg", "==", "FPReg", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrInst", ",", "FPReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ";", "if", "(", "MustSaveLR", "&&", "!", "LoadedLR", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "ScratchReg", ")", ".", "addImm", "(", "LROffset", ")", ".", "addReg", "(", "SPReg", ")", ";", "}", "if", "(", "MustSaveCR", "&&", "!", "(", "SingleScratchReg", "&&", "MustSaveLR", ")", ")", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MustSaveCRs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MTOCRF8", ")", ",", "MustSaveCRs", "[", "i", "]", ")", ".", "addReg", "(", "TempReg", ",", "getKillRegState", "(", "i", "==", "e", "-", "<NUM_LIT>", ")", ")", ";" ]

[ "if", "(", "NeedsCommute", ")", "MIB", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "return", "BuiltMI", ";", "}", "if", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "bool", "Op0IsGPR", "=", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "bool", "Op1IsGPR", "=", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "unsigned", "StoreOpcode", "=", "Op1IsGPR", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "BuildMI", "(", "*", "InsertPt", "->", "getParent", "(", ")", ",", "InsertPt", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "StoreOpcode", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "unsigned", "LoadOpcode", "=", "Op0IsGPR", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "BuildMI", "(", "*", "InsertPt", "->", "getParent", "(", ")", ",", "InsertPt", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "LoadOpcode", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "}", "}", "if", "(", "OpNum", "==", "<NUM_LIT>", "&&", "MI", ".", "hasOneMemOperand", "(", ")", ")", "{", "MachineMemOperand", "*", "MMO", "=", "*", "MI", ".", "memoperands_begin", "(", ")", ";", "if", "(", "MMO", "->", "getSize", "(", ")", "==", "Size", "&&", "!", "MMO", "->", "isVolatile", "(", ")", "&&", "!", "MMO", "->", "isAtomic", "(", ")", ")", "{", "if", "(", "isSimpleBD12Move", "(", "&", "MI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "return", "BuildMI", "(", "*", "InsertPt", "->", "getParent", "(", ")", ",", "InsertPt", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "Size", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "if", "(", "isSimpleBD12Move", "(", "&", "MI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "return", "BuildMI", "(", "*", "InsertPt", "->", "getParent", "(", ")", ",", "InsertPt", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addImm", "(", "Size", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "}", "}", "unsigned", "NumOps", "=", "MI", ".", "getNumExplicitOperands", "(", ")", ";", "int", "MemOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Opcode", ")", ";", "bool", "NeedsCommute", "=", "false", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Opcode", ")", "!=", "-", "<NUM_LIT>", "&&", "MemOpcode", "!=", "-", "<NUM_LIT>", ")", "{", "if", "(", "VRM", "==", "nullptr", ")", "MemOpcode", "=", "-", "<NUM_LIT>", ";", "else", "{", "assert", "(", "NumOps", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Expected two source registers.", "<STR_LIT>", ")", ";", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "DstPhys", "=", "(", "Register", "::", "isVirtualRegister", "(", "DstReg", ")", "?", "VRM", "->", "getPhys", "(", "DstReg", ")", ":", "DstReg", ")", ";", "Register", "SrcReg", "=", "(", "OpNum", "==", "<NUM_LIT>", "?", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ":", "(", "(", "OpNum", "==", "<NUM_LIT>", "&&", "MI", ".", "isCommutable", "(", ")", ")", "?", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ":", "Register", "(", ")", ")", ")", ";", "if", "(", "DstPhys", "&&", "!", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DstPhys", ")", "&&", "SrcReg", "&&", "Register", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "DstPhys", "==", "VRM", "->", "getPhys", "(", "SrcReg", ")", ")", "NeedsCommute", "=", "(", "OpNum", "==", "<NUM_LIT>", ")", ";", "else", "MemOpcode", "=", "-", "<NUM_LIT>", ";", "}", "}", "if", "(", "MemOpcode", ">=", "<NUM_LIT>", ")", "{", "if", "(", "(", "OpNum", "==", "NumOps", "-", "<NUM_LIT>", ")", "||", "NeedsCommute", ")", "{", "const", "MCInstrDesc", "&", "MemDesc", "=", "get", "(", "MemOpcode", ")", ";", "uint64_t", "AccessBytes", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MemDesc", ".", "TSFlags", ")", ";", "assert", "(", "AccessBytes", "!=", "<NUM_LIT>", "&&", "<STR_LIT>", "Size of access should be known", "<STR_LIT>", ")", ";", "assert", "(", "AccessBytes", "<=", "Size", "&&", "<STR_LIT>", "Access outside the frame index", "<STR_LIT>", ")", ";", "uint64_t", "Offset", "=", "Size", "-", "AccessBytes", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "InsertPt", "->", "getParent", "(", ")", ",", "InsertPt", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "MemOpcode", ")", ")", ";", "MIB", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheMipsTarget", ",", "createMipsMCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheMipselTarget", ",", "createMipsMCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheMips64Target", ",", "createMipsMCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheMips64elTarget", ",", "createMipsMCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheMipsTarget", ",", "createMipsMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheMipselTarget", ",", "createMipsMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheMips64Target", ",", "createMipsMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheMips64elTarget", ",", "createMipsMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheMipsTarget", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheMipselTarget", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheMips64Target", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheMips64elTarget", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheMipsTarget", ",", "createMipsBEAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheMipselTarget", ",", "createMipsLEAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheMips64Target", ",", "createMipsBEAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheMips64elTarget", ",", "createMipsLEAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheMipsTarget", ",", "createMipsMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheMipselTarget", ",", "createMipsMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheMipsTarget", ",", "createMipsMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheMipselTarget", ",", "createMipsMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheMips64Target", ",", "createMipsMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheMips64elTarget", ",", "createMipsMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheMipsTarget", ",", "createMipsMCInstPrinter", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheMipselTarget", ",", "createMipsMCInstPrinter", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheMips64Target", ",", "createMipsMCInstPrinter" ]

[ "<FIXS>", "fprintf", "(", "file", ",", "<STR_LIT>", ",0x%lx%04lx", "<STR_LIT>", ",", "xmask", ",", "(", "<NUM_LIT>", "&", "xregister_save_offset", ")", ")", ";", "<FIXE>" ]

[ "return_address_info", ",", "register_save_offset", ")", ";", "if", "(", "xmask", ")", "<BUGS>", "fprintf", "(", "file", ",", "<STR_LIT>", ",0x%x%04x", "<STR_LIT>", ",", "xmask", ",", "(", "<NUM_LIT>", "&", "xregister_save_offset", ")", ")", ";", "<BUGE>", "fputc", "(", "'", "\\n", "'", ",", "file", ")", ";", "text_section", "(", ")", ";" ]

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

[ "def", ":", "Pat", "<", "(", "ARM64neg", "(", "v16i8", "V128", ":", "$", "Rn", ")", ")", ",", "(", "NEGv16i8", "V128", ":", "$" ]

[ "}" ]

[ "def", "Xi", ":", "BaseMoveImmediate", "<", "opc", ",", "GPR64", ",", "movimm64_shift", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_cvtepu32_pd", "(", "_", "_", "m128d", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_cvtudq2pd128_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_" ]

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

[ "resolved", ";" ]

[ "vec_safe_push", "(", "params", ",", "args", "[", "<NUM_LIT>", "]", ")", ";", "vec_safe_push", "(", "params", ",", "args", "[", "<NUM_LIT>", "]", ")", ";", "tree", "add_sub_builtin", ";", "if", "(", "fcode", "==", "RS6000_OVLD_VEC_ADDE", ")", "add_sub_builtin", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_ADD", "]", ";", "else", "add_sub_builtin", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_SUB", "]", ";", "tree", "call", "=", "altivec_resolve_overloaded_builtin", "(", "loc", ",", "add_sub_builtin", ",", "params", ")", ";", "tree", "const1", "=", "build_int_cstu", "(", "TREE_TYPE", "(", "types", "[", "<NUM_LIT>", "]", ")", ",", "<NUM_LIT>", ")", ";", "tree", "ones_vector", "=", "build_vector_from_val", "(", "types", "[", "<NUM_LIT>", "]", ",", "const1", ")", ";", "tree", "and", "_", "expr", "=", "fold_build2_loc", "(", "loc", ",", "BIT_AND_EXPR", ",", "types", "[", "<NUM_LIT>", "]", ",", "args", "[", "<NUM_LIT>", "]", ",", "ones_vector", ")", ";", "params", "=", "make_tree_vector", "(", ")", ";", "vec_safe_push", "(", "params", ",", "call", ")", ";", "vec_safe_push", "(", "params", ",", "and", "_", "expr", ")", ";", "*", "res", "=" ]

[ "}" ]

[ "AU", ".", "addRequired", "<", "MemorySSAWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";" ]

[ ";" ]

[ "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "Register" ]

[ ")", ",", "(", "LDURBBi", "GPR64sp", ":", "$", "Rn", ",", "simm9", ":", "$", "offset", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "extloadi1", "(", "am_unscaled8", "GPR64sp", ":", "$", "Rn", ",", "simm9", ":", "$", "offset", ")", ")" ]

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

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "_", "_", "lsx_vdiv_du", "(", "_", "_", "m128i", "_", "<NUM_LIT>", ",", "_", "_", "m128i", "_", "<NUM_LIT>", ")", "{" ]

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

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_xor_pd", "(", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "m512d", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_xorpd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "mm512_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{" ]

[ "void", "CSKYMCInstLower", "::", "Lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";" ]

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

[ "virtual", "const", "char", "*", "getPassName", "(" ]

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

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

[ ")", ";" ]

[ "}", "assert", "(", "(", "STI", ".", "hasFeature", "(", "X86", "::", "Mode64Bit", ")", "||", "!", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "&&", "<STR_LIT>", "REX.W requires 64bit mode.", "<STR_LIT>", ")", ";", "bool", "HasREX", "=", "STI", ".", "hasFeature", "(", "X86", "::", "Mode64Bit", ")", "?", "emitREXPrefix", "(", "MemOperand", ",", "MI", ",", "OS", ")", ":", "false", ";", "switch", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitByte", "(", "<NUM_LIT>", ",", "OS", ")", ";", "break", ";", "}", "switch", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitByte", "(", "<NUM_LIT>", ",", "OS" ]

[ "void", "ARMBaseRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "DebugLoc", "&", "dl", ",", "Register", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "<STR_LIT>", "::", "<STR_LIT>", "Pred", ",", "Register", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "Pred", ",", "PredReg", ")", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ ",", "Offset", ",", "IsImmutable", ")", ";" ]

[ "Register", "M68kIncomingValueHandler", "::", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "const", "bool", "IsImmutable", "=", "!", "Flags", ".", "isByVal", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size" ]

[ ".", "getReg", "(", ")", ")", ")", "return", "nullptr", ";" ]

[ "if", "(", "MI", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", "return", "nullptr", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isUse", "(", ")", "||", "!", "Register", "::", "isVirtualRegister", "(", "MO" ]

[ "}" ]

[ "if", "(", "isSI", "(", "STI", ")", "||", "isCI", "(", "STI", ")", "||", "isVI", "(", "STI", ")", ")", "return", "ID_SYMBOLIC_FIRST_GFX9_", ";", "else", "if", "(", "isGFX9", "(", "STI", ")", ")", "return", "ID_SYMBOLIC_FIRST_GFX10_", ";", "else", "if", "(", "isGFX10", "(", "STI", ")", "&&", "!", "isGFX10_BEncoding", "(", "STI", ")", ")", "return", "ID_SYMBOLIC_FIRST_GFX1030_", ";", "else", "return", "ID_SYMBOLIC_LAST_", ";" ]

[ ";" ]

[ "Mod", "=", "&", "M", ";", "return", "false" ]

[ "NewSramEccSetting", ";" ]

[ "void", "setSramEccSetting", "(", "TargetIDSetting", "NewSramEccSetting", ")", "{", "SramEccSetting", "=" ]

[ ",", "OpNode", ">", ";" ]

[ "def", "Xrr", ":", "BaseLogicalRegPseudo", "<", "GPR64" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_automaton", "<STR_LIT>", ")", "(", "automata_option", "<STR_LIT>", ")", "(", "automata_option" ]

[ "]", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "and", ":", "SI", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "def", "am_unscaled128", ":", "am_unscaled_operand", ",", "ComplexPattern", "<", "i64", ",", "<NUM_LIT>", ",", "<STR_LIT>", "," ]

[ "}" ]

[ "def", "C2_all8", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ")", ",", "<STR_LIT>", ",", "tc_de554571", ",", "TypeCR", ">", ",", "Enc_65d691", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "dag", "LE_DWORD_0", "=", "(", "XXPERMDI", "LE_DWORD_1", ",", "LE_DWORD_1", ",", "<NUM_LIT>", ")", ";" ]

[ "dag", "BE_WORD_0", "=", "(", "MTVSRD", "(", "RLDICR", "(", "INSERT_SUBREG", "(", "i64", "(", "IMPLICIT_DEF", ")", ")", ",", "$", "A", ",", "sub_32", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "dag", "BE_DWORD_0", "=", "(", "MTVSRD", "$", "A", ")", ";", "dag", "LE_MTVSRW", "=", "(", "MTVSRD", "(", "INSERT_SUBREG", "(", "i64", "(", "IMPLICIT_DEF", ")", ")", ",", "$", "A", ",", "sub_32", ")", ")", ";", "dag", "LE_WORD_1", "=", "(", "v2i64", "(", "INSERT_SUBREG", "(", "v2i64", "(", "IMPLICIT_DEF", ")", ")", ",", "LE_MTVSRW", ",", "sub_64", ")", ")", ";", "dag", "LE_WORD_0", "=", "(", "XXPERMDI", "LE_WORD_1", ",", "LE_WORD_1", ",", "<NUM_LIT>", ")", ";", "dag", "LE_DWORD_1", "=", "(", "v2i64", "(", "INSERT_SUBREG", "(", "v2i64", "(", "IMPLICIT_DEF", ")", ")", ",", "BE_DWORD_0", ",", "sub_64", ")", ")", ";" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "DL", ",", "VT", ",", "LO", ",", "HI", ")", ";" ]

[ "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "SDValue", "V0_LO", "=", "extract128BitVector", "(", "V0", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "SDValue", "V0_HI", "=", "extract128BitVector", "(", "V0", ",", "NumElts", "/", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "SDValue", "V1_LO", "=", "extract128BitVector", "(", "V1", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "SDValue", "V1_HI", "=", "extract128BitVector", "(", "V1", ",", "NumElts", "/", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "MVT", "NewVT", "=", "V0_LO", ".", "getSimpleValueType", "(", ")", ";", "SDValue", "LO", "=", "DAG", ".", "getUNDEF", "(", "NewVT", ")", ";", "SDValue", "HI", "=", "DAG", ".", "getUNDEF", "(", "NewVT", ")", ";", "if", "(", "Mode", ")", "{", "if", "(", "!", "isUndefLO", "&&", "!", "V0", "->", "isUndef", "(", ")", ")", "LO", "=", "DAG", ".", "getNode", "(", "X86Opcode", ",", "DL", ",", "NewVT", ",", "V0_LO", ",", "V0_HI", ")", ";", "if", "(", "!", "isUndefHI", "&&", "!", "V1", "->", "isUndef", "(", ")", ")", "HI", "=", "DAG", ".", "getNode", "(", "X86Opcode", ",", "DL", ",", "NewVT", ",", "V1_LO", ",", "V1_HI", ")", ";", "}", "else", "{", "if", "(", "!", "isUndefLO", "&&", "(", "!", "V0_LO", "->", "isUndef", "(", ")", "||", "!", "V1_LO", "->", "isUndef", "(", ")", ")", ")", "LO", "=", "DAG", ".", "getNode", "(", "X86Opcode", ",", "DL", ",", "NewVT", ",", "V0_LO", ",", "V1_LO", ")", ";", "if", "(", "!", "isUndefHI", "&&", "(", "!", "V0_HI", "->", "isUndef", "(", ")", "||", "!", "V1_HI", "->", "isUndef", "(", ")", ")", ")", "HI", "=", "DAG", ".", "getNode", "(", "X86Opcode", ",", "DL", ",", "NewVT", ",", "V0_HI", ",", "V1_HI", ")", ";", "}" ]

[ "const", "int", "_", "_", "b", ")", "{" ]

[ "vcvt_n_u16_f16", "(", "float16x4_t", "_", "_", "a", "," ]

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

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

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

[ "int", "NewReturnAddrFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "SlotSize", ",", "(", "int64_t", ")", "FPDiff", "-", "SlotSize", ",", "false", ")", ";", "SDValue", "NewRetAddrFrIdx", "=", "DAG", ".", "getFrameIndex", "(", "NewReturnAddrFI", ",", "PtrVT", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "RetAddrFrIdx", ",", "NewRetAddrFrIdx", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", "," ]

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

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

[ "rtx", "replace_n_hard_rtx", "(", "rtx", "x", ",", "rtx", "*", "replacements", ",", "int", "n_replacements", ",", "int", "modify", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "x", "!=", "<NUM_LIT>", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "return", "x", ";", "for", "(", "i", "=", "n_replacements", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "if", "(", "x", "==", "replacements", "[", "i", "*", "<NUM_LIT>", "]", "&&", "GET_MODE", "(", "x", ")", "==", "GET_MODE", "(", "replacements", "[", "i", "*", "<NUM_LIT>", "+", "<NUM_LIT>", "]", ")", ")", "return", "replacements", "[", "i", "*", "<NUM_LIT>", "+", "<NUM_LIT>", "]", ";", "if", "(", "x", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "{", "rtx", "new", "=", "replace_n_hard_rtx", "(", "SUBREG_REG", "(", "x", ")", ",", "replacements", ",", "n_replacements", ",", "modify", ")", ";", "if", "(", "GET_CODE", "(", "new", ")", "==", "CONST_INT", ")", "{", "x", "=", "simplify_subreg", "(", "GET_MODE", "(", "x", ")", ",", "new", ",", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ",", "SUBREG_BYTE", "(", "x", ")", ")", ";", "if", "(", "!", "x", ")", "abort", "(", ")", ";", "}", "else", "if", "(", "modify", ")", "SUBREG_REG", "(", "x", ")", "=", "new", ";", "return", "x", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "unsigned", "regno", "=", "REGNO", "(", "x", ")", ";", "unsigned", "nregs", "=", "(", "regno", "<", "FIRST_PSEUDO_REGISTER", "?", "HARD_REGNO_NREGS", "(", "regno", ",", "GET_MODE", "(", "x", ")", ")", ":", "<NUM_LIT>", ")", ";", "rtx", "result", "=", "NULL_RTX", ";", "for", "(", "i", "=", "n_replacements", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "rtx", "from", "=", "replacements", "[", "i", "*", "<NUM_LIT>", "]", ";", "rtx", "to", "=", "replacements", "[", "i", "*", "<NUM_LIT>", "+", "<NUM_LIT>", "]", ";", "unsigned", "from_regno", ",", "from_nregs", ",", "to_regno", ",", "new", "_", "regno", ";", "if", "(", "GET_CODE", "(", "from", ")", "!=", "REG", ")", "continue", ";", "from_regno", "=", "REGNO", "(", "from", ")", ";", "from_nregs", "=", "(", "from_regno", "<", "FIRST_PSEUDO_REGISTER", "?", "HARD_REGNO_NREGS", "(", "from_regno", ",", "GET_MODE", "(", "from", ")", ")", ":", "<NUM_LIT>", ")", ";", "if", "(", "regno", "<", "from_regno", "+", "from_nregs", "&&", "regno", "+", "nregs", ">", "from_regno", ")", "{", "if", "(", "regno", "<", "from_regno", "||", "regno", "+", "nregs", ">", "from_regno", "+", "nregs", "||", "GET_CODE", "(", "to", ")", "!=", "REG", "||", "result", ")", "return", "NULL_RTX", ";", "to_regno", "=", "REGNO", "(", "to", ")", ";", "if", "(", "to_regno", "<", "FIRST_PSEUDO_REGISTER", ")", "{", "new", "_", "regno", "=", "regno", "+", "to_regno", "-", "from_regno", ";", "if", "(", "(", "unsigned", ")", "HARD_REGNO_NREGS", "(", "new", "_", "regno", ",", "GET_MODE", "(", "x", ")", ")", "!=", "nregs", ")", "return", "NULL_RTX", ";", "result", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "x", ")", ",", "new", "_", "regno", ")", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "<=", "GET_MODE", "(", "to", ")", ")", "result", "=", "gen_lowpart_common", "(", "GET_MODE", "(", "x", ")", ",", "to", ")", ";", "else", "result", "=", "gen_lowpart_SUBREG", "(", "GET_MODE", "(", "x", ")", ",", "to", ")", ";", "}", "}", "return", "result", "?", "result", ":", "x", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTEND", ")", "{", "rtx", "new", "=", "replace_n_hard_rtx", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "replacements", ",", "n_replacements", ",", "modify", ")", ";", "if", "(", "GET_CODE", "(", "new", ")", "==", "CONST_INT", ")", "{", "x", "=", "simplify_unary_operation", "(", "ZERO_EXTEND", ",", "GET_MODE", "(", "x", ")", ",", "new", ",", "GET_MODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "!", "x", ")", "abort", "(", ")", ";", "}", "else", "if", "(", "modify", ")", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", "=", "new", ";", "return", "x", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "rtx", "new", ";", "if", "(", "fmt", "[", "i", "]", "==", "'", "e", "'", ")", "{", "new", "=", "replace_n_hard_rtx", "(", "XEXP", "(", "x", ",", "i", ")", ",", "replacements", ",", "n_replacements", ",", "modify", ")", ";", "if", "(", "!", "new", ")", "return", "NULL_RTX", ";", "if", "(", "modify", ")", "XEXP", "(", "x", ",", "i", ")", "=", "new", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'", "E", "'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "<NUM_LIT>", ";", "j", ">=", "<NUM_LIT>", ";", "j", "--", ")", "{", "new", "=", "replace_n_hard_rtx", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ",", "replacements", ",", "n_replacements", ",", "modify", ")", ";", "if", "(", "!", "new", ")", "return", "NULL_RTX", ";", "if", "(", "modify", ")", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", "=", "new", ";", "}", "}", "return", "x", ";", "}" ]

[ "Replace", "any", "occurrence", "of", "FROM", "(", "n", ")", "in", "X", "with", "TO", "(", "n", ")", ".", "The", "function", "does", "not", "enter", "into", "CONST_DOUBLE", "for", "the", "replace", ".", "Note", "that", "copying", "is", "not", "done", "so", "X", "must", "not", "be", "shared", "unless", "all", "copies", "are", "to", "be", "modified", ".", "This", "is", "like", "replace_rtx", ",", "except", "that", "we", "operate", "on", "N_REPLACEMENTS", "replacements", "simultaneously", "-", "FROM", "(", "n", ")", "is", "replacements", "[", "n", "*", "2", "]", "and", "to", "(", "n", ")", "is", "replacements", "[", "n", "*", "2+1", "]", "-", "and", "that", "we", "take", "mode", "changes", "into", "account", ".", "If", "a", "replacement", "is", "ambiguous", ",", "return", "NULL_RTX", ".", "If", "MODIFY", "is", "zero", ",", "do", "n't", "modify", "any", "rtl", "in", "place", ",", "just", "return", "zero", "or", "nonzero", "for", "failure", "/", "success", "." ]

[ ")", ";" ]

[ "rtx", "xops", "[", "<NUM_LIT>", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "<STR_LIT>", "LPSRL", "<STR_LIT>", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "<NUM_LIT>", "]", "=", "reg1", ";", "xops", "[", "<NUM_LIT>", "]", "=", "reg3", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "<STR_LIT>", "sub.d\\t%0,%0,%2", "<STR_LIT>", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "<STR_LIT>", "sub.w\\t%0,%0,%2", "<STR_LIT>", ",", "xops" ]

[ "}" ]

[ "const", "F2003fSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "override", "{", "return", "&", "Subtarget", ";" ]

[ "=", "Imm1_16Operand", ";" ]

[ "def", "vecshiftR16", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass" ]

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

[ "static", "bool", "save_local_or_in_reg_p", "(", "unsigned", "int", "regno", ",", "int", "leaf_function", ")", "{", "if", "(", "!", "call_used_regs", "[", "regno", "]", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")" ]

[ "}" ]

[ "void", "Mips16InstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Amount", ")", ")", "BuildAddiuSpImm", "(", "MBB", ",", "I", ",", "Amount", ")", ";", "else", "adjustStackPtrBigUnrestricted", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";" ]

[ "Results", ".", "push_back", "(", "Upper", ")", ";" ]

[ "SDValue", "Result", "=", "LowerWindowsDIVLibCall", "(", "Op", ",", "DAG", ",", "Signed", ",", "DBZCHK", ")", ";", "SDValue", "Lower", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Result", ")", ";", "SDValue", "Upper", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "MVT", "::", "i64", ",", "Result", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "TLI", ".", "getPointerTy", "(", "DL", ")", ")", ")", ";", "Upper", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Upper", ")", ";", "Results", ".", "push_back", "(", "Lower", ")", ";" ]

[ "}" ]

[ "bool", "SITargetLowering", "::", "isLegalGlobalAddressingMode", "(", "const", "AddrMode", "&", "AM", ")", "const", "{", "if", "(", "Subtarget", "->", "hasFlatGlobalInsts", "(", ")", ")", "return", "isInt", "<", "<NUM_LIT>", ">", "(", "AM", ".", "BaseOffs", ")", "&&", "AM", ".", "Scale", "==", "<NUM_LIT>", ";", "if", "(", "!", "Subtarget", "->", "hasAddr64", "(", ")", "||", "Subtarget", "->", "useFlatForGlobal", "(", ")", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";" ]

[ "}" ]

[ "static", "bool", "sh_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "regno", "==", "FIRST_RET_REG", "||", "(", "TARGET_SH2E", "&&", "regno", "==", "FIRST_FP_RET_REG", ")", ";" ]

[ "}" ]

[ "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "(", "<STR_LIT>", ",", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "*", "this", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "ErrorIfNotPending", "(", "Loc", ",", "<STR_LIT>", "unexpected token in argument list", "<STR_LIT>", ")", ";" ]

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

[ "Register", "VirtReg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "VirtReg", ")", "->", "getID", "(", ")", "==", "X86", "::", "TILERegClassID", ")", "{", "HasVirtTileReg", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasVirtTileReg", ")", "return", "false", ";", "StackSlotForVirtReg", ".", "resize", "(", "NumVirtRegs", ")", ";", "MayLiveAcrossBlocks", ".", "clear", "(", ")", ";", "MayLiveAcrossBlocks", ".", "resize", "(", "NumVirtRegs", "*", "<NUM_LIT>", ")", ";", "bool", "Change", "=", "false", ";", "assert", "(", "MRI", "->", "isSSA", "(" ]

[ "}" ]

[ "const", "Function", "&", "Fn", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "const", "Module", "*", "M", "=", "Fn", ".", "getParent", "(", ")", ";", "const", "char", "*", "CalleeName", "=", "E", "->", "getSymbol", "(", ")", ";", "CalleeFn", "=", "M", "->", "getFunction", "(", "CalleeName", ")", ";" ]

[ "nullptr", ";" ]

[ "case", "<NUM_LIT>", ":", "return", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "RC", ")", "!=", "nullptr", ";", "case", "<NUM_LIT>", ":", "return", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_64RegClass", ",", "RC", ")", "!=", "nullptr", ";", "case", "<NUM_LIT>", ":", "return", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_96RegClass", ",", "RC", ")", "!=", "nullptr", ";", "case", "<NUM_LIT>", ":", "return", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_128RegClass", ",", "RC", ")", "!=", "nullptr", ";", "case", "<NUM_LIT>", ":", "return", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_256RegClass", ",", "RC", ")", "!=" ]

[ "}" ]

[ "for", "(", "SmallVector", "<", "TerminatorInfo", ",", "<NUM_LIT>", ">", "::", "iterator", "TI", "=", "Terminators", ".", "begin", "(", ")", ",", "TE", "=", "Terminators", ".", "end", "(", ")", ";", "TI", "!=", "TE", ";", "++", "TI", ")", "if", "(", "mustRelaxBranch", "(", "*", "TI", ",", "TI", "->", "Address", ")", ")", "return", "true", ";", "return", "false", ";" ]

[ "}" ]

[ "bool", "isBigEndian", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isBigEndian", "(", ")", ";", "SDLoc", "DL", "(", "St", ")", ";", "SDValue", "BasePtr", "=", "St", "->", "getBasePtr", "(", ")", ";", "SDValue", "NewST1", "=", "DAG", ".", "getStore", "(", "St", "->", "getChain", "(", ")", ",", "DL", ",", "StVal", ".", "getNode", "(", ")", "->", "getOperand", "(", "isBigEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ",", "BasePtr", ",", "St", "->", "getPointerInfo", "(", ")", ",", "St", "->", "isVolatile", "(", ")", ",", "St", "->", "isNonTemporal", "(", ")", ",", "St", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "OffsetPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i32", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getStore", "(", "NewST1", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "StVal", ".", "getNode", "(", ")", "->", "getOperand", "(", "isBigEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ",", "OffsetPtr", ",", "St", "->", "getPointerInfo", "(", ")", ",", "St", "->", "isVolatile", "(", ")", ",", "St", "->", "isNonTemporal", "(", ")", ",", "std", "::", "min", "(", "<NUM_LIT>", "U", ",", "St", "->", "getAlignment", "(", ")", "/", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "StVal", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", "&&", "StVal", ".", "getNode", "(", ")", "->", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "dl", "(", "StVal", ")", ";", "SDValue", "IntVec", "=", "StVal", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "FloatVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "f64", ",", "IntVec", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ")", ";", "SDValue", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "FloatVT", ",", "IntVec", ")", ";", "SDValue", "ExtElt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "f64", ",", "Vec", ",", "StVal", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "dl", "=", "SDLoc", "(", "N", ")", ";", "SDValue", "V", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "i64", ",", "ExtElt", ")", ";", "DCI", ".", "AddToWorklist", "(", "Vec", ".", "getNode", "(", ")", ")", ";", "DCI", ".", "AddToWorklist", "(", "ExtElt", ".", "getNode", "(", ")", ")", ";", "DCI", ".", "AddToWorklist", "(", "V", ".", "getNode", "(", ")", ")", ";", "return", "DAG", ".", "getStore", "(", "St", "->", "getChain", "(", ")", ",", "dl", ",", "V", ",", "St", "->", "getBasePtr", "(", ")", ",", "St", "->", "getPointerInfo", "(", ")", ",", "St", "->", "isVolatile", "(", ")", ",", "St", "->", "isNonTemporal", "(", ")", ",", "St", "->", "getAlignment", "(", ")", ",", "St", "->", "getAAInfo", "(", ")", ")", ";" ]

[ ",", "bool", "*", "Fast", ")", "const", "{" ]

[ "bool", "Mips16TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "Align", ",", "MachineMemOperand", "::", "Flags" ]

[ "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "cond", "[", "(", "ne", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")", "]", "(", "const_string", "<STR_LIT>", ")", ")", ")", "]", ")", "<FIXE>" ]

[ "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_split", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", ";" ]

[ "}", "MFI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "MFI", "->", "setLowReg", "(", "LowReg", ")", ";", "MFI", "->", "setHighReg", "(", "HighReg", ")", ";", "if", "(", "StartOffset", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "(", "LowReg", "==", "HighReg", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ")", ";", "MIB", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "StartOffset", ")", ";", "if", "(", "LowReg", "==", "HighReg", ")", "MIB", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MIB", ".", "addReg", "(", "LowReg", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "LowReg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "HighReg", ",", "RegState", "::", "Kill", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg" ]

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

[ "def", "W9", ":", "AArch64Reg", "<", "<NUM_LIT>", ",", "<STR_LIT>", ">", "," ]

[ "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";" ]

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

[ "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "Unknown operand kind in printOperand", "<STR_LIT>", ")", ";" ]

[ "const", "MCOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "printRegName", "(", "O", ",", "MO", ".", "getReg", "(", ")", ")", ";", "return", ";", "}", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "formatHex", "(", "MO", ".", "getImm", "(", ")", ")", ";", "return", ";", "}" ]

[ "<FIXS>", "SDNode", "OpNodeRnd", ",", "X86SchedWriteWidths", "sched", ">", "{", "<FIXE>" ]

[ "multiclass", "avx512_cvttpd2dq", "bits", "<NUM_LIT>", ">", "opc", ",", "string", "OpcodeStr", ",", "SDNode", "OpNode", ",", "<BUGS>", "SDNode", "OpNode128", ",", "SDNode", "OpNodeRnd", ",", "X86SchedWriteWidths", "sched", ">", "{", "<BUGE>", "let", "Predicates", "=", "[", "HasAVX512", "]", "in", "{", "defm", "Z", ":", "avx512_vcvt_fp", "opc", ",", "OpcodeStr", ",", "v8i32x_info", ",", "v8f64_info", ",", "OpNode", ",", "sched", ".", "ZMM", ">", "," ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR32", ",", "arith_extend", ")", ";" ]

[ "return", "<STR_LIT>" ]

[ "ops", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", "+", "<NUM_LIT>", ")", "ops", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", "+", "<NUM_LIT>", ")", "ops", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", "+", "<NUM_LIT>", ")", "output_asm_insn", "(", "<STR_LIT>", ",", "ops", ")" ]

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

[ "}", "unsigned", "FrameReg", ";", "if", "(", "FrameIndex", ">=", "MinCSFI", "&&", "FrameIndex", "<=", "MaxCSFI", ")", "FrameReg", "=", "Mips", "::", "SP", ";", "else", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "FrameReg", "=", "Mips", "::", "S0", ";", "}", "else", "{", "if", "(", "(", "MI", ".", "getNumOperands", "(", ")", ">", "OpNo", "+", "<NUM_LIT>", ")", "&&", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", "FrameReg", "=", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "else", "FrameReg", "=", "Mips", "::", "SP", ";", "}", "}", "int64_t", "Offset", ";", "bool", "IsKill", "=", "false", ";", "Offset", "=", "SPOffset", "+", "(", "int64_t", ")", "StackSize", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "Offset : ", "<STR_LIT>", "<<", "Offset", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "<--------->\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "MI", ".", "isDebugValue", "(", ")", "&&", "!", "Mips16InstrInfo", "::", "validImmediate", "(", "MI", ".", "getOpcode", "(", ")", ",", "FrameReg", ",", "Offset", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent" ]

[ "return", "SDValue", "(", "Res", ",", "<NUM_LIT>", ")", ";" ]

[ "MVT", "MaskVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "Index", ".", "getSimpleValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ")", ";", "SDValue", "VMask", "=", "getMaskNode", "(", "Mask", ",", "MaskVT", ",", "&", "Subtarget", ",", "DAG", ",", "dl", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MaskVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "Scale", ",", "Index", ",", "Disp", ",", "Segment", ",", "VMask", ",", "Src", ",", "Chain", "}", ";", "SDNode", "*", "Res", "=", "DAG", ".", "getMachineNode", "(", "Opc", ",", "dl", ",", "VTs", ",", "Ops", ")", ";" ]

[ "case", "M68k", "::", "TAILJMPj", ":" ]

[ "if", "(", "MI", "->", "isPseudo", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Pseudo opcode(", "<STR_LIT>", "<<", "MI", "->", "getOpcode", "(", ")", "<<", "<STR_LIT>", ") found in EmitInstruction()\\n", "<STR_LIT>", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Cannot proceed", "<STR_LIT>", ")", ";", "}", "break", ";", "}" ]

[ "}" ]

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

[ "M", ".", "getNode", "(", ")", ")", ";" ]

[ "CurDAG", "->", "RepositionNode", "(", "N", ".", "getNode", "(", ")", "->", "getIterator", "(", ")", "," ]

[ "Lowering", ",", "unsigned", "NumBytes", ")", "{" ]

[ "static", "unsigned", "EnsureStackAlignment", "(", "const", "PPCFrameLowering", "*" ]

[ "}" ]

[ "assert", "(", "TM", ".", "TargetABI", "!=", "ARMBaseTargetMachine", "::", "ARM_ABI_UNKNOWN", ")", ";", "return", "TM", ".", "TargetABI", "==", "ARMBaseTargetMachine", "::", "ARM_ABI_APCS", ";" ]

[ ";" ]

[ "bool", "Changed", "=", "false", ";", "if", "(", "ST", "->", "has16BitInsts", "(", ")", "&&", "needsPromotionToI32", "(", "I", ".", "getType", "(", ")", ")", "&&", "UA", "->", "isUniform", "(", "&", "I", ")", ")", "Changed", "|=", "promoteUniformBitreverseToI32", "(", "I", ")", ";", "return", "Changed" ]

[ "<FIXS>", "assert", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Expected register and none was found", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "Rt", ".", "setReg", "(", "getHexagonRegisterPair", "(", "Rt", ".", "getReg", "(", ")", ",", "RI", ")", ")", ";", "return", ";", "}", "case", "Hexagon", "::", "V6_vd0", ":", "case", "Hexagon", "::", "V6_vd0_128B", ":", "{", "MCInst", "TmpInst", ";", "<BUGS>", "assert", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Expected register and none was found", "<STR_LIT>", ")", ";", "<BUGE>", "TmpInst", ".", "setOpcode", "(", "Hexagon", "::", "V6_vxor", ")", ";", "TmpInst", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

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

[ "def", "BothDivModOp", ":", "Operand", "<", "i8", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "BothDivModAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "i8imm", ":", "$" ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC_FP", "CCFP_REGNUM", ")" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "else", "{", "unsigned", "SrcReg", ",", "DstReg", ",", "SrcSubIdx", ",", "DstSubIdx", ";", "if", "(", "NCC", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "TII", "->", "isMoveInstr", "(", "*", "NMI", ",", "SrcReg", ",", "DstReg", ",", "SrcSubIdx", ",", "DstSubIdx", ")", ")", "{", "assert", "(", "SrcSubIdx", "==", "<NUM_LIT>", "&&", "DstSubIdx", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Sub-register indices still around?", "<STR_LIT>", ")", ";", "if", "(", "!", "Uses", ".", "count", "(", "DstReg", ")", "&&", "!", "Defs", ".", "count", "(", "SrcReg", ")", ")", "{", "--", "MBBI", ";", "MBB", ".", "remove", "(", "NMI", ")", ";", "MBB", ".", "insert", "(", "InsertPos", ",", "NMI", ")", ";", "++", "NumMovedInsts", ";", "continue", ";", "}", "}", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "(", "!", "MI", "->", "getDesc", "(", ")", ".", "isBranch", "(", ")", "&&", "!", "MI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", ")", ";", "++", "MBBI", ")", "{", "if", "(", "MBBI", "->", "isDebugValue", "(", ")", ")", "continue", ";", "MachineInstr", "*", "NMI", "=", "&", "*", "MBBI", ";", "MI", "=", "NMI", ";", "<BUGS>", "DebugLoc", "ndl", "=", "NMI", "->", "getDebugLoc", "(", ")", ";", "<BUGE>", "unsigned", "NPredReg", "=", "<NUM_LIT>", ";", "<STR_LIT>", "::", "<STR_LIT>", "NCC", "=", "getPredicate", "(", "NMI", ",", "NPredReg", ")", ";", "if", "(", "NCC", "==", "CC", "||", "NCC", "==", "OCC", ")", "Mask", "|=", "(", "NCC", "&", "<NUM_LIT>", ")", "<<", "Pos", ";", "<BUGS>", "else", "<BUGE>", "break", ";", "<BUGS>", "-", "Pos", ";", "<BUGE>", "}", "Mask", "|=", "(", "<NUM_LIT>", "<<", "Pos", ")", ";", "Mask", "|=", "(", "CC", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";" ]

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

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

[ "(", "VNx4SI", "<STR_LIT>", ")", "(", "VNx2SI", "<STR_LIT>", ")" ]

[ "(", "V4x4HF", "<STR_LIT>", ")", "(", "V4x2SF", "<STR_LIT>", ")", "(", "V4x1DF", "<STR_LIT>", ")", "(", "V4x4BF", "<STR_LIT>", ")", "(", "V4x16QI", "<STR_LIT>", ")", "(", "V4x8HI", "<STR_LIT>", ")", "(", "V4x4SI", "<STR_LIT>", ")", "(", "V4x2DI", "<STR_LIT>", ")", "(", "V4x8HF", "<STR_LIT>", ")", "(", "V4x4SF", "<STR_LIT>", ")", "(", "V4x2DF", "<STR_LIT>", ")", "(", "V4x8BF", "<STR_LIT>", ")", "(", "VNx16BI", "<STR_LIT>", ")", "(", "VNx8BI", "<STR_LIT>", ")", "(", "VNx4BI", "<STR_LIT>", ")", "(", "VNx2BI", "<STR_LIT>", ")", "(", "VNx16QI", "<STR_LIT>", ")", "(", "VNx8QI", "<STR_LIT>", ")", "(", "VNx4QI", "<STR_LIT>", ")", "(", "VNx2QI", "<STR_LIT>", ")", "(", "VNx8HI", "<STR_LIT>", ")", "(", "VNx4HI", "<STR_LIT>", ")", "(", "VNx2HI", "<STR_LIT>", ")", "(", "VNx8HF", "<STR_LIT>", ")", "(", "VNx4HF", "<STR_LIT>", ")", "(", "VNx2HF", "<STR_LIT>", ")", "(", "VNx8BF", "<STR_LIT>", ")", "(", "VNx4BF", "<STR_LIT>", ")", "(", "VNx2BF", "<STR_LIT>", ")" ]

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

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

[ "static", "void", "rx_get_stack_layout", "(", "unsigned", "int", "*", "lowest", ",", "unsigned", "int", "*", "highest", ",", "unsigned", "int", "*", "register_mask", ",", "unsigned", "int", "*", "frame_size", ",", "unsigned", "int", "*", "stack_size", ")", "{", "unsigned", "int", "reg", ";", "unsigned", "int", "low", ";", "unsigned", "int", "high", ";", "unsigned", "int", "fixed_reg", "=", "<NUM_LIT>", ";", "unsigned", "int", "save_mask", ";", "unsigned", "int", "pushed_mask", ";", "unsigned", "int", "unneeded_pushes", ";", "if", "(", "is_naked_func", "(", "NULL_TREE", ")", ")", "{", "*", "lowest", "=", "<NUM_LIT>", ";", "*", "highest", "=", "<NUM_LIT>", ";", "*", "register_mask", "=", "<NUM_LIT>", ";", "*", "frame_size", "=", "<NUM_LIT>", ";", "*", "stack_size", "=", "<NUM_LIT>", ";", "return", ";", "}", "for", "(", "save_mask", "=", "high", "=", "low", "=", "<NUM_LIT>", ",", "reg", "=", "<NUM_LIT>", ";", "reg", "<", "CC_REGNUM", ";", "reg", "++", ")", "{", "if", "(", "(", "df_regs_ever_live_p", "(", "reg", ")", "||", "(", "call_used_regs", "[", "reg", "]", "&&", "is_interrupt_func", "(", "NULL_TREE", ")", "&&", "!", "crtl", "->", "is_leaf", ")", ")", "&&", "(", "!", "call_used_regs", "[", "reg", "]", "||", "is_interrupt_func", "(", "NULL_TREE", ")", "||", "(", "is_fast_interrupt_func", "(", "NULL_TREE", ")", "&&", "!", "IN_RANGE", "(", "reg", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", "{", "if", "(", "low", "==", "<NUM_LIT>", ")", "low", "=", "reg", ";", "high", "=", "reg", ";", "save_mask", "|=", "<NUM_LIT>", "<<", "reg", ";", "}", "if", "(", "low", "!=", "<NUM_LIT>", "&&", "fixed_reg", "==", "<NUM_LIT>", "&&", "fixed_regs", "[", "reg", "]", ")", "fixed_reg", "=", "reg", ";", "}", "if", "(", "MUST_SAVE_ACC_REGISTER", "&&", "bit_count", "(", "save_mask", ")", "<", "<NUM_LIT>", ")", "{", "save_mask", "|=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "|", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";", "if", "(", "low", "==", "<NUM_LIT>", ")", "low", "=", "<NUM_LIT>", ";", "if", "(", "high", "==", "<NUM_LIT>", "||", "low", "==", "high", ")", "high", "=", "low", "+", "<NUM_LIT>", ";", "}", "pushed_mask", "=", "(", "-", "<NUM_LIT>", "<<", "low", ")", "&", "~", "(", "-", "<NUM_LIT>", "<<", "(", "high", "+", "<NUM_LIT>", ")", ")", ";", "unneeded_pushes", "=", "(", "pushed_mask", "&", "(", "~", "save_mask", ")", ")", "&", "pushed_mask", ";", "if", "(", "(", "fixed_reg", "&&", "fixed_reg", "<=", "high", ")", "||", "(", "optimize_function_for_speed_p", "(", "cfun", ")", "&&", "bit_count", "(", "save_mask", ")", "<", "bit_count", "(", "unneeded_pushes", ")", ")", ")", "{", "*", "lowest", "=", "<NUM_LIT>", ";", "*", "highest", "=", "<NUM_LIT>", ";", "*", "register_mask", "=", "save_mask", ";", "}", "else", "{", "*", "lowest", "=", "low", ";", "*", "highest", "=", "high", ";", "*", "register_mask", "=", "<NUM_LIT>", ";", "}", "*", "frame_size", "=", "rx_round_up", "(", "get_frame_size", "(", ")", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "crtl", "->", "args", ".", "size", ">", "<NUM_LIT>", ")", "*", "frame_size", "+=", "rx_round_up", "(", "crtl", "->", "args", ".", "size", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "*", "stack_size", "=", "rx_round_up", "(", "crtl", "->", "outgoing_args_size", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "}" ]

[ "Returns", "either", "the", "lowest", "numbered", "and", "highest", "numbered", "registers", "that", "occupy", "the", "call-saved", "area", "of", "the", "stack", "frame", ",", "if", "the", "registers", "are", "stored", "as", "a", "contiguous", "block", ",", "or", "else", "a", "bitmask", "of", "the", "individual", "registers", "if", "they", "are", "stored", "piecemeal", ".", "Also", "computes", "the", "size", "of", "the", "frame", "and", "the", "size", "of", "the", "outgoing", "arguments", "block", "(", "in", "bytes", ")", "." ]

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

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float_extend", ":", "V4SF", "(", "vec_select", ":", "ssehalfvecmode", ">", "<BUGS>", "(", "match_operand", ":", "VHFBF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V8SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float_extend", ":", "V8SF", "(", "vec_select", ":", "ssehalfvecmode", ">", "<BUGS>", "(", "match_operand", ":", "VHFBF_256", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")" ]

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

[ "(", "define_predicate", "<STR_LIT>", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")" ]