Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "Ops", ",", "Op", ")", ";" ]

[ "LoadSDNode", "*", "load", "=", "static_cast", "<", "LoadSDNode", "*", ">", "(", "Op", ".", "getNode", "(", ")", ")", ";", "assert", "(", "load", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "i1", ")", ";", "SDValue", "new", "Load", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "i32", ",", "Op", ",", "load", "->", "getChain", "(", ")", ",", "load", "->", "getBasePtr", "(", ")", ",", "load", "->", "getOffset", "(", ")", ",", "MVT", "::", "i8", ",", "load", "->", "getMemOperand", "(", ")", ")", ";", "SDValue", "new", "Trunc", "=", "DAG", ".", "getZExtOrTrunc", "(", "new", "Load", ",", "Op", ",", "MVT", "::", "i1", ")", ";", "SDValue", "Ops", "[", "<NUM_LIT>", "]", "=", "{", "new", "Trunc", ",", "new", "Load", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(" ]

[ "}" ]

[ "MachineInstr", "*", "matchImpl", "(", "MachineInstr", "*", "Instr", ",", "unsigned", "int", "Index", ",", "int", "First", ",", "ArgsT", ".", ".", ".", "Args", ")", "{", "if", "(", "!", "checkOperand", "(", "Instr", ",", "Index", ",", "First", ")", ")", "return", "nullptr", ";", "return", "matchImpl", "(", "Instr", ",", "Index", "+", "<NUM_LIT>", ",", "Args", ".", ".", ".", ")", ";" ]

[ "}" ]

[ "Cond", "[", "<NUM_LIT>", "]", ".", "setImm", "(", "(", "invflag", ")", "?", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ")", ";", "return", "false", ";" ]

[ "SDValue", "Imm", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ";" ]

[ "unsigned", "EltSizeInBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "||", "(", "EltSizeInBits", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "SDValue", "N0", "=", "peekThroughBitcasts", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "N1", "=", "peekThroughBitcasts", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", "||", "N1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "Subtarget", ".", "hasXOP", "(", ")", "||", "useVPTERNLOG", "(", "Subtarget", ",", "VT", ")", "||", "!", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "hasOneUse", "(", ")", "||", "!", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "hasOneUse", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "APInt", "UndefElts0", ",", "UndefElts1", ";", "SmallVector", "<", "APInt", ",", "<NUM_LIT>", ">", "EltBits0", ",", "EltBits1", ";", "if", "(", "!", "getTargetConstantBitsFromNode", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "UndefElts0", ",", "EltBits0", ",", "false", ",", "false", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "getTargetConstantBitsFromNode", "(", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "UndefElts1", ",", "EltBits1", ",", "false", ",", "false", ")", ")", "return", "SDValue", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "EltBits0", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "UndefElts0", "[", "i", "]", "||", "UndefElts1", "[", "i", "]", ")", "return", "SDValue", "(", ")", ";", "if", "(", "EltBits0", "[", "i", "]", "!=", "~", "EltBits1", "[", "i", "]", ")", "return", "SDValue", "(", ")", ";", "}", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "useVPTERNLOG", "(", "Subtarget", ",", "VT", ")", ")", "{", "MVT", "OpSVT", "=", "EltSizeInBits", "==", "<NUM_LIT>", "?", "MVT", "::", "i32", ":", "MVT", "::", "i64", ";", "MVT", "OpVT", "=", "MVT", "::", "getVectorVT", "(", "OpSVT", ",", "VT", ".", "getSizeInBits", "(", ")", "/", "OpSVT", ".", "getSizeInBits", "(", ")", ")", ";", "SDValue", "A", "=", "DAG", ".", "getBitcast", "(", "OpVT", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "B", "=", "DAG", ".", "getBitcast", "(", "OpVT", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "C", "=", "DAG", ".", "getBitcast", "(", "OpVT", ",", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ ")" ]

[ "(", "subreg", ":", "V8QI", "(", "ashiftrt", ":", "TI", "(", "subreg", ":", "TI", "(", "vec_concat", ":", "V16QI", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<NUM_LIT>", ")", "(", "mult", ":", "SI", "(", "zero_extract", ":", "SI", "(", "reg", ":", "SI", "WCGR0", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "}" ]

[ "if", "(", "flags", "&", "CP_PREFETCH_MEMORY", ")", "return", "true", ";", "return", "flags", "&", "(", "CP_WRITE_MEMORY", "|", "CP_WRITE_FFR", ")", ";" ]

[ ";" ]

[ "Pred", "=", "CurDAG", "->", "getTargetConstant", "(", "CN", "->", "getZExtValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "Reg", "=", "CurDAG", "->", "getRegister", "(", "ARM", "::", "CPSR", ",", "MVT", "::", "i32", ")", ";", "return", "true" ]

[ "return", "ELF", "::", "R_PATMOS_ALUL_ABS", ";" ]

[ "return", "ELF", "::", "R_PATMOS_ABS_32", ";", "case", "FK_Patmos_BO_7", ":", "return", "ELF", "::", "R_PATMOS_MEMB_ABS", ";", "case", "FK_Patmos_HO_7", ":", "return", "ELF", "::", "R_PATMOS_MEMH_ABS", ";", "case", "FK_Patmos_WO_7", ":", "return", "ELF", "::", "R_PATMOS_MEMW_ABS", ";", "case", "FK_Patmos_abs_ALUi", ":", "return", "ELF", "::", "R_PATMOS_ALUI_ABS", ";", "case", "FK_Patmos_abs_CFLi", ":", "return", "ELF", "::", "R_PATMOS_CFLI_ABS", ";", "case", "FK_Patmos_abs_ALUl", ":" ]

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

[ "def", "r20", ":", "GR", "<", "<NUM_LIT>", ",", "<STR_LIT>", ">", ",", "DwarfRegNum", "<" ]

[ ">", ";" ]

[ "def", "PPCvcmp_rec", ":", "SDNode", "<", "<STR_LIT>", ",", "SDT_PPCvcmp", ",", "[", "SDNPOutGlue", "]" ]

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

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

[ "const", "RegisterBank", "&", "DstRB", "=", "*", "RBI", ".", "getRegBank", "(", "DstReg", ",", "MRI", ",", "TRI", ")", ";" ]

[ "if", "(", "RBI", ".", "getRegBank", "(", "DstReg", ",", "MRI", ",", "TRI", ")", "->", "getID", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Cannot extract into GPR.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "auto", "VRegAndVal", "=", "getConstantVRegValWithLookThrough", "(", "LaneIdxOp", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "!", "VRegAndVal", ")", "return", "false", ";", "unsigned", "LaneIdx", "=", "VRegAndVal", "->", "Value", ";", "MachineIRBuilder", "MIRBuilder", "(", "I", ")", ";" ]

[ "<FIXS>", "reg", "=", "(", "invert", "||", "eqne_p", ")", "?", "gen_reg_rtx", "(", "mode", ")", ":", "result", ";", "convert_move", "(", "reg", ",", "gen_rtx", "(", "p_info", "->", "test_code", ",", "mode", ",", "cmp0", ",", "cmp1", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "convert_move", "(", "result", ",", "gen_rtx", "(", "GTU", ",", "mode", ",", "reg", ",", "const0_rtx", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "reg2", "=", "(", "invert", ")", "?", "gen_reg_rtx", "(", "mode", ")", ":", "result", ";", "convert_move", "(", "reg2", ",", "gen_rtx", "(", "LTU", ",", "mode", ",", "reg", ",", "const1_rtx", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "convert_move", "(", "result", ",", "gen_rtx", "(", "XOR", ",", "mode", ",", "reg", ",", "const1_rtx", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "reg", "=", "cmp0", ";", "else", "{", "<BUGS>", "reg", "=", "(", "invert", "||", "eqne_p", ")", "?", "gen_reg_rtx", "(", "SImode", ")", ":", "result", ";", "emit_move_insn", "(", "reg", ",", "gen_rtx", "(", "p_info", "->", "test_code", ",", "SImode", ",", "cmp0", ",", "cmp1", ")", ")", ";", "<BUGE>", "}", "if", "(", "test", "==", "ITEST_NE", ")", "{", "<BUGS>", "emit_move_insn", "(", "result", ",", "gen_rtx", "(", "GTU", ",", "SImode", ",", "reg", ",", "const0_rtx", ")", ")", ";", "<BUGE>", "invert", "=", "FALSE", ";", "}", "else", "if", "(", "test", "==", "ITEST_EQ", ")", "{", "<BUGS>", "reg2", "=", "(", "invert", ")", "?", "gen_reg_rtx", "(", "SImode", ")", ":", "result", ";", "emit_move_insn", "(", "reg2", ",", "gen_rtx", "(", "LTU", ",", "SImode", ",", "reg", ",", "const1_rtx", ")", ")", ";", "<BUGE>", "reg", "=", "reg2", ";", "}", "if", "(", "invert", ")", "<BUGS>", "emit_move_insn", "(", "result", ",", "gen_rtx", "(", "XOR", ",", "SImode", ",", "reg", ",", "const1_rtx", ")", ")", ";", "<BUGE>", "return", "result", ";", "}" ]

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

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

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

[ "(", "define_mode_iterator", "MOVE128", "[", "TI" ]

[ "}" ]

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

[ "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "Switches", "=", "sw", ";", "let", "OperandType", "=", "OpType", ".", "FP32", ";" ]

[ "(", ")", "==", "<NUM_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{" ]

[ "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg" ]

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

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

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

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

[ "<NUM_LIT>", ";" ]

[ "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=" ]

[ "}", "]", ">", "{", "let", "ParserMatchClass", "=", "Imm0_255Operand", ";" ]

[ "def", "Imm0_255Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "imm0_255", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";" ]

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

[ "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "endBit", ";", "bits", "<", "<NUM_LIT>", ">", "immOpNum", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "immOpNum", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OType", ";", "bits", "<", "<NUM_LIT>", ">", "ImmOpCount", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SecondImmOp", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "ThirdImmOp", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "FirstImmBits", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SecondImmBits", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "ThirdImmBits", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "HasCompositeImm", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ImmOpCount", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SecondImmOp", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ThirdImmOp", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "FirstImmBits", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SecondImmBits", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ThirdImmBits", ";", "bits", "<", "<NUM_LIT>", ">", "Lanes", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "case", "AsmToken", "::", "Integer", ":", "{", "int64_t", "Imm", ";", "if", "(", "getParser", "(", ")", ".", "parseAbsoluteExpression", "(", "Imm", ")", ")", "return", "MatchOperand_ParseFail", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "this", ",", "Imm", ",", "S", ")", ")", ";", "return", "MatchOperand_Success", ";" ]

[ "false", ")", ")", "break", ";" ]

[ "unsigned", "xlogue_layout", "::", "count_stub_managed_regs", "(", ")", "{", "bool", "hfp", "=", "frame_pointer_needed", "||", "stack_realign_fp", ";", "unsigned", "i", ",", "count", ";", "unsigned", "regno", ";", "for", "(", "count", "=", "i", "=", "MIN_REGS", ";", "i", "<", "MAX_REGS", ";", "++", "i", ")", "{", "regno", "=", "REG_ORDER", "[", "i", "]", ";", "if", "(", "regno", "==", "BP_REG", "&&", "hfp", ")", "continue", ";", "if", "(", "!", "ix86_save_reg", "(", "regno", ",", "false", "," ]

[ ")", ";" ]

[ "paddw_u", "(", "uint32x2_t", "s", ",", "uint32x2_t", "t", ")", "{", "return", "_", "_", "builtin_loongson_paddw_u", "(", "s", ",", "t" ]

[ "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";" ]

[ "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MRI", ".", "getTargetRegisterInfo", "(", ")", ";", "for", "(", "int", "Idx", ":", "llvm", "::", "seq", "<", "int", ">", "(", "<NUM_LIT>", ",", "NewMI", ".", "getNumOperands", "(", ")", ")", ")", "{", "MachineOperand", "&", "MO", "=", "NewMI", ".", "getOperand", "(", "Idx", ")", ";" ]

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

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

[ ",", "v8i32", ",", "VReg_256", ">", ";" ]

[ "def", ":", "BitConvert", "<", "v32i8" ]

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

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

[ "=", "WordAccess", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize" ]

[ "}" ]

[ "SUnit", "&", "Succ", "=", "*", "I", "->", "getSUnit", "(", ")", ";", "if", "(", "!", "Succ", ".", "isScheduled", ")", "{", "if", "(", "OnlyAvailableSucc", "&&", "OnlyAvailableSucc", "!=", "&", "Succ", ")", "return", "<NUM_LIT>", ";", "OnlyAvailableSucc", "=", "&", "Succ", ";", "}", "}", "return", "OnlyAvailableSucc", ";" ]

[ "SDValue", "FMAAcc", "=", "FMA", ".", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDLoc", "SL", "(", "N", ")", ";", "if", "(", "!", "Subtarget", "->", "hasDotInsts", "(", ")", "||", "VT", "!=", "MVT", "::", "f32", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op2", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "FMA", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "FMA", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "FMA", "||", "Op1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", "||", "Op2", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "return", "SDValue", "(", ")", ";", "const", "TargetOptions", "&", "Options", "=", "DAG", ".", "getTarget", "(", ")", ".", "Options", ";", "if", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", "||", "(", "N", "->", "getFlags", "(", ")", ".", "hasAllowContract", "(", ")", "&&", "FMA", "->", "getFlags", "(", ")", ".", "hasAllowContract", "(", ")", ")", ")", "{", "Op1", "=", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Op2", "=", "Op2", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", "||", "Op2", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Vec1", "=", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Idx1", "=", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Vec2", "=", "Op2", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "FMAOp1", "=", "FMA", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "FMAOp2", "=", "FMA", ".", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

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

[ "return", "isShuffleMaskLegal", "(", "M", "," ]

[ "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "<NUM_LIT>", ")", "{" ]

[ "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", "->", "CreateFixedObject", "(", "isPPC64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", "->", "CreateFixedObject", "(", "isPPC64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "FI", "->", "getPICBasePointerSaveIndex", "(", ")", ";", "PBPSI", "=", "MFI", "->", "CreateFixedObject", "(", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "int", "TCSPDelta", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "if", "(", "!", "reg_or_7bit_operand", "(", "op1", ",", "SImode", ")", ")", "*", "total", "+=", "set_src_cost", "(", "op1", ",", "mode", ",", "speed", ")", ";", "}", "else", "if", "(", "mode", "==", "DImode", ")", "{", "*", "total", "=", "<NUM_LIT>", "*", "cost2", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", "||", "!", "satisfies_constraint_Ks7", "(", "op1", ")", ")", "*", "total", "+=", "rtx_cost", "(", "op1", ",", "mode", ",", "PLUS", ",", "<NUM_LIT>", ",", "speed", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op0", ")", "!=", "SUBREG", "||", "GET_CODE", "(", "SUBREG_REG", "(", "op0", ")", ")", "!=", "REG", ")", ")", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "mode", ",", "PLUS", ",", "<NUM_LIT>", ",", "speed", ")", ";", "}", "return", "true", ";", "case", "MINUS", ":", "if", "(", "mode", "==", "DImode", ")", "*", "total", "=", "<NUM_LIT>", "*", "cost2", ";", "else", "*", "total", "=", "cost2", ";", "return", "true", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "if", "(", "mode", "==", "DImode", ")", "*", "total", "=", "<NUM_LIT>", "*", "cost2", ";", "else", "*", "total", "=", "cost2", ";", "op0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op0", ")", "!=", "SUBREG", "||", "GET_CODE", "(", "SUBREG_REG", "(", "op0", ")", ")", "!=", "REG", ")", ")", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "mode", ",", "code", ",", "<NUM_LIT>", ",", "speed", ")", ";", "return", "true", ";", "case", "IOR", ":", "case", "AND", ":", "case", "XOR", ":", "op0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "code", "==", "IOR", ")", "{", "if", "(", "(", "GET_CODE", "(", "op0", ")", "==", "LSHIFTRT", "&&", "GET_CODE", "(", "op1", ")", "==", "ASHIFT", ")", "||", "(", "GET_CODE", "(", "op0", ")", "==", "ASHIFT", "&&", "GET_CODE", "(", "op1", ")", "==", "ZERO_EXTEND", ")", "||", "(", "GET_CODE", "(", "op0", ")", "==", "ASHIFT", "&&", "GET_CODE", "(", "op1", ")", "==", "LSHIFTRT", ")", "||", "(", "GET_CODE", "(", "op0", ")", "==", "AND", "&&", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", ")", "{", "*", "total", "=", "cost2", ";", "return", "true", ";", "}", "}", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op0", ")", "!=", "SUBREG", "||", "GET_CODE", "(", "SUBREG_REG", "(", "op0", ")", ")", "!=", "REG", ")", ")", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "mode", ",", "code", ",", "<NUM_LIT>", ",", "speed", ")", ";", "if", "(", "mode", "==", "DImode", ")", "{", "*", "total", "=", "<NUM_LIT>", "*", "cost2", ";", "return", "true", ";", "}", "*", "total", "=", "cost2", ";", "if", "(", "mode", "!=", "SImode", ")", "return", "true", ";", "if", "(", "code", "==", "AND", ")", "{", "if", "(", "!", "rhs_andsi3_operand", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "SImode", ")", ")", "*", "total", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "mode", ",", "code", ",", "<NUM_LIT>", ",", "speed", ")", ";", "}", "else", "{", "if", "(", "!", "regorlog2_operand", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "SImode", ")", ")", "*", "total", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "mode", ",", "code", ",", "<NUM_LIT>", ",", "speed", ")", ";", "}", "return", "true", ";", "case", "ZERO_EXTRACT", ":", "case", "SIGN_EXTRACT", ":", "if", "(", "outer_code", "==", "SET", "&&", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", "==", "const1_rtx", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", ")", "{", "*", "total", "=", "<NUM_LIT>", "*", "cost2", ";", "return", "true", ";", "}", "case", "SIGN_EXTEND", ":", "case", "ZERO_EXTEND", ":", "*", "total", "=", "cost2", ";", "return", "true", ";", "case", "MULT", ":", "{", "op0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "GET_CODE", "(", "op1", ")", "&&", "(", "GET_CODE", "(", "op0", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "op0", ")", "==", "SIGN_EXTEND", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "op0", "=", "XEXP", "(", "op0", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "op1", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "!", "speed", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op0", ")", "!=", "SUBREG", "||", "GET_CODE", "(", "SUBREG_REG", "(", "op0", ")", ")", "!=", "REG", ")", ")", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "mode", ",", "MULT", ",", "<NUM_LIT>", ",", "speed", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op1", ")", "!=", "SUBREG", "||", "GET_CODE", "(", "SUBREG_REG", "(", "op1", ")", ")", "!=", "REG", ")", ")", "*", "total", "+=", "rtx_cost", "(", "op1", ",", "mode", ",", "MULT", ",", "<NUM_LIT>", ",", "speed", ")", ";" ]

[ "Offset", ",", "AlignAmt", ")", ";" ]

[ "unsigned", "AlignAmt", "=", "<NUM_LIT>", "<<", "Align", ";", "unsigned", "ParentAlign", "=", "MBB", ".", "getParent", "(", ")", "->", "getAlignment", "(", ")", ";", "if", "(", "Align", "<=", "ParentAlign", ")", "return", "OffsetToAlignment", "(" ]

[ "return", "MMO", ";" ]

[ "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ",", "flags", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";" ]

[ "<FIXS>", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "MEM", ")", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "CONST_INT", ")", "<FIXE>" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "machopic_indirect_call_target", "(", "operands", "[", "<NUM_LIT>", "]", ")", "#", "endif", "<BUGS>", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "MEM", "|", "|", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "CONST_INT", ")", "abort", "(", ")", "<BUGE>", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "SImode", ")" ]

[ "#", "<STR_LIT>", ",", "asmstr", "#", "<STR_LIT>", ")", ",", "IIC_VecFP", ",", "[", "]", ">", ",", "RegConstraint", "<", "<STR_LIT>", ">", ";" ]

[ "def", "PM", "#", "NAME", ":", "MMIRR_XX3Form_XY4P2_XAB6", "<", "opcode", ",", "!", "or", "(", "xo", ",", "<NUM_LIT>", ")", ",", "(", "outs", "acc", ":", "$", "AT", ")", ",", "!", "con", "(", "IOL", ",", "(", "ins", "u4imm", ":", "$", "XMSK", ",", "u4imm", ":", "$", "YMSK", ",", "u2imm", ":", "$", "PMSK", ")", ")", ",", "!", "strconcat", "(", "<STR_LIT>", "#", "asmbase" ]

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

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

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

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

[ "::", "PUSH64i32", ":" ]

[ "case", "X86", "::", "PUSH32rmr", ":", "case", "X86", "::", "PUSH32i", ":", "case", "X86", "::", "PUSH64r", ":", "case", "X86", "::", "PUSH64rmm", ":", "case", "X86", "::", "PUSH64rmr", ":", "case", "X86" ]

[ "<FIXS>", "(", "S_OR_B32", "$", "src", ",", "<NUM_LIT>", ")", "<FIXE>" ]

[ "def", ":", "Pat", "(", "fneg", "(", "fabs", "f32", ":", "$", "src", ")", ")", ",", "<BUGS>", "(", "S_OR_B32", "$", "src", ",", "<NUM_LIT>", ")", "<BUGE>", ">", ";" ]

[ ";" ]

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

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

[ "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned" ]

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

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

[ "asm", ">", "{" ]

[ "def", "SWr", ":", "BaseUnscaledConversion", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "FPR32", ",", "GPR32", "," ]

[ ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "store", "(", "v4f32", "FPR128", ":", "$", "Rn", ")", ",", "ro_indexed128", ":", "$", "addr", ")", ",", "(", "STRQro", "FPR128", ":", "$", "Rn", ",", "ro_indexed128" ]

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

[ "def", "J2_jumpfnew", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_20cdee80", ",", "TypeJ", ">", ",", "Enc_daea09", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";" ]

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

[ "AddThumb1SBit", "(", "MI", ",", "InITBlock", ")", ";", "return", "Result", ";", "}", "Result", "=", "decodeInstruction", "(", "DecoderTableThumb216", ",", "MI", ",", "Insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", "&&", "ITBlock", ".", "instrInITBlock", "(", ")", ")", "Result", "=", "MCDisassembler", "::", "SoftFail", ";", "Check", "(", "Result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Firstcond", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "Mask", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "ITBlock", ".", "setITState", "(", "Firstcond", ",", "Mask", ")", ";", "if", "(", "Firstcond", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "!", "isPowerOf2_32", "(", "Mask", ")", ")", "CS", "<<", "<STR_LIT>", "unpredictable IT predicate sequence", "<STR_LIT>", ";", "}", "return", "Result", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "Insn32", "=", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableMVE32", ",", "MI", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "if", "(", "isVPTOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", "&&", "VPTBlock", ".", "instrInVPTBlock", "(", ")", ")", "Result", "=", "MCDisassembler", "::", "SoftFail", ";", "Check", "(", "Result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "if", "(", "isVPTOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "Mask", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "VPTBlock", ".", "setVPTState", "(", "Mask", ")", ";", "}", "return", "Result", ";", "}", "Result", "=", "decodeInstruction", "(", "DecoderTableThumb32", ",", "MI", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "bool", "InITBlock", "=", "ITBlock", ".", "instrInITBlock", "(", ")", ";", "Check", "(", "Result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "AddThumb1SBit", "(", "MI", ",", "InITBlock", ")", ";", "return", "Result", ";", "}", "Result", "=", "decodeInstruction", "(", "DecoderTableThumb232", ",", "MI", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "Result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "checkDecodedInstruction", "(", "MI", ",", "Size", ",", "Address", ",", "OS", ",", "CS", ",", "Insn32", ",", "Result", ")", ";", "}", "if", "(", "fieldFromInstruction", "(", "Insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableVFP32", ",", "MI", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "UpdateThumbVFPPredicate", "(", "Result", ",", "MI", ")", ";", "return", "Result", ";", "}", "}", "Result", "=", "decodeInstruction", "(", "DecoderTableVFPV832", ",", "MI", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "Result", ";", "}", "if", "(", "fieldFromInstruction", "(", "Insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableNEONDup32", ",", "MI", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "Result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "Result", ";", "}", "}", "if", "(", "fieldFromInstruction", "(", "Insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "uint32_t", "NEONLdStInsn", "=", "Insn32", ";", "NEONLdStInsn", "&=", "<NUM_LIT>", ";", "NEONLdStInsn", "|=", "<NUM_LIT>", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableNEONLoadStore32", ",", "MI", ",", "NEONLdStInsn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "Result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "Result", ";", "}", "}", "if", "(", "fieldFromInstruction", "(", "Insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "uint32_t", "NEONDataInsn", "=", "Insn32", ";", "NEONDataInsn", "&=", "<NUM_LIT>", ";", "NEONDataInsn", "|=", "(", "NEONDataInsn", "&" ]

[ "addr", ")", ",", "bsub", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v8i8", "(", "scalar_to_vector", "(", "i32", "(", "extloadi8", "am_indexed8", ":", "$", "addr", ")", ")", ")", ")", ",", "(", "INSERT_SUBREG", "(", "v8i8", "(", "IMPLICIT_DEF", ")", ")", ",", "(", "LDRBui", "am_indexed8", ":", "$" ]

[ "<FIXS>", "dbgs", "(", ")", "<<", "<STR_LIT>", "unreachable block BB", "<STR_LIT>", "<<", "bb", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "<FIXE>" ]

[ "BlockT", "*", "bb", "=", "&", "(", "*", "blockIter1", ")", ";", "sccNum", "=", "getSCCNum", "(", "bb", ")", ";", "if", "(", "sccNum", "==", "INVALIDSCCNUM", ")", "{", "<BUGS>", "errs", "(", ")", "<<", "<STR_LIT>", "unreachable block BB", "<STR_LIT>", "<<", "bb", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "<BUGE>", "}", "}", "}" ]

[ "}" ]

[ "class", "CMP_EQ_QB_R2_DESC_BASE", "<", "string", "instr_asm", ",", "SDPatternOperator", "OpNode", ",", "InstrItinClass", "itin", ",", "RegisterOperand", "ROS", ",", "RegisterOperand", "ROT", "=", "ROS", ">", "{", "dag", "OutOperandList", "=", "(", "outs", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROS", ":", "$", "rs", ",", "ROT", ":", "$", "rt", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "OpNode", "ROS", ":", "$", "rs", ",", "ROT", ":", "$", "rt", ")", "]", ";", "InstrItinClass", "Itinerary", "=", "itin", ";", "string", "BaseOpcode", "=", "instr_asm", ";" ]

[ "ADDE", ":" ]

[ "case", "ISD", "::", "PREFETCH", ":", "return", "LowerPREFETCH", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAME_TO_ARGS_OFFSET", ":", "return", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETJMP", ":", "return", "LowerEH_SJLJ_SETJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "LowerEH_SJLJ_LONGJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "ExpandBITCAST", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShift", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "return", "LowerCTTZ", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "CTPOP", ":", "return", "LowerCTPOP", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerVSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "LowerConstantFP", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIV", ":", "return", "LowerSDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIV", ":", "return", "LowerUDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDC", ":", "case", "ISD", "::" ]

[ "Value", ";" ]

[ "case", "FK_Data_4", ":", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_LO16", ":", "case", "Mips", "::", "fixup_Mips_GPREL16", ":", "case", "Mips", "::", "fixup_Mips_GPOFF_HI", ":", "case", "Mips", "::", "fixup_Mips_GPOFF_LO", ":", "case", "Mips", "::", "fixup_Mips_GOT_PAGE", ":", "case", "Mips", "::", "fixup_Mips_GOT_OFST", ":", "case", "Mips", "::", "fixup_Mips_GOT_DISP", ":", "case", "Mips", "::", "fixup_Mips_GOT_LO16", ":", "case", "Mips", "::", "fixup_Mips_CALL_LO16", ":", "case", "Mips", "::", "fixup_MICROMIPS_LO16", ":", "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", "=", "(", "int64_t", ")", "Value", "/", "<NUM_LIT>", ";", "if", "(", "!", "isIntN", "(", "<NUM_LIT>", ",", "Value", ")", "&&", "Ctx", ")", "Ctx", "->", "FatalError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "out of range PC16 fixup", "<STR_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", ";", "case", "Mips", "::", "fixup_MICROMIPS_26_S1", ":", "Value", ">>=", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC16_S1", ":", "Value", "-=", "<NUM_LIT>", ";", "Value", "=", "(", "int64_t", ")", "Value", "/", "<NUM_LIT>", ";", "if", "(", "!", "isIntN", "(", "<NUM_LIT>", ",", "Value", ")", "&&", "Ctx", ")", "Ctx", "->", "FatalError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "out of range PC16 fixup", "<STR_LIT>", ")", ";", "break", ";", "}", "return" ]

[ "}" ]

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

[ "}" ]

[ "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";" ]

[ "}", "else", "if", "(", "Subtarget", "->", "hasVFP3", "(", ")", ")", "{" ]

[ "}", "AttrEmitter", "->", "MaybeSwitchVendor", "(", "<STR_LIT>", "aeabi", "<STR_LIT>", ")", ";", "std", "::", "string", "CPUString", "=", "Subtarget", "->", "getCPUString", "(", ")", ";", "if", "(", "CPUString", "==", "<STR_LIT>", "cortex-a8", "<STR_LIT>", "||", "Subtarget", "->", "isCortexA8", "(", ")", ")", "{", "AttrEmitter", "->", "EmitTextAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "cortex-a8", "<STR_LIT>", ")", ";", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "CPUString", "==", "<STR_LIT>", "xscale", "<STR_LIT>", ")", "{", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "hasV8Ops", "(", ")", ")", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "if", "(", "Subtarget", "->", "hasV7Ops", "(", ")", ")", "{", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "hasV6T2Ops", "(", ")", ")", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "if", "(", "Subtarget", "->", "hasV6Ops", "(", ")", ")", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "if", "(", "Subtarget", "->", "hasV5TEOps", "(", ")", ")", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "if", "(", "Subtarget", "->", "hasV5TOps", "(", ")", ")", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "if", "(", "Subtarget", "->", "hasV4TOps", "(", ")", ")", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "emitFPU", ")", "{", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", ")", "AttrEmitter", "->", "EmitTextAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "neon-fp-armv8", "<STR_LIT>", ")", ";", "else", "if", "(", "Subtarget", "->", "hasVFP4", "(", ")", ")", "AttrEmitter", "->", "EmitTextAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "neon-vfpv4", "<STR_LIT>", ")", ";", "else", "AttrEmitter", "->", "EmitTextAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "neon", "<STR_LIT>", ")", ";", "emitFPU", "=", "false", ";", "}", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", ")", "{", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "emitFPU", ")", "AttrEmitter", "->", "EmitTextAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "fp-armv8", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "hasVFP4", "(", ")", ")", "{", "AttrEmitter", "->", "EmitAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "emitFPU", ")", "AttrEmitter", "->", "EmitTextAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "vfpv4", "<STR_LIT>", ")", ";" ]

[ "return", "IN_RANGE", "(", "val", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "val", "&=", "GET_MODE_MASK", "(", "GET_MODE_INNER", "(", "GET_MODE", "(", "x", ")", ")", ")", ";", "if", "(", "val", "&", "<NUM_LIT>", ")", "return", "IN_RANGE", "(", "val", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>" ]

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

[ "LocInfo", ",", "Info", ".", "Flags", ",", "State", ")", ";" ]

[ "if", "(", "Info", ".", "IsFixed", ")", "return", "AssignFn", "(", "ValNo", ",", "ValVT", ",", "LocVT", "," ]

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

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

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

[ "vget_low_p16", "(", "poly16x8_t", "_", "_" ]

[ "VFPNeonA8Domain", ";" ]

[ "def", "VCMPS", ":", "ASuI", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "SPR", ":", "$", "Sd", ",", "SPR", ":", "$", "Sm", ")", ",", "IIC_fpCMP32", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "arm_cmpfp", "SPR", ":", "$", "Sd", ",", "SPR", ":", "$", "Sm", ")", "]", ">", "{", "let", "D", "=" ]

[ ")", "]" ]

[ "[", "(", "set", "(", "reg", ":", "V8DI", "ZT0_REGNUM", ")", "(", "unspec_volatile", ":", "V8DI", "[", "(", "reg", ":", "V8DI", "ZT0_REGNUM", ")", "(", "reg", ":", "DI", "SME_STATE_REGNUM", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPECV_ASM_UPDATE_ZT0", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "VF_512", "(", "fma", ":", "VF_512", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "avx512fmaskmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "VF_512", "(", "fma", ":", "VF_512", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "avx512fmaskmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<FIXE>" ]

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

[ "<FIXS>", "static", "rtx", "find_addr_reg", "PARAMS", "(", "(", "rtx", ")", ")", ";", "static", "int", "reg_clobbered_p", "PARAMS", "(", "(", "rtx", ",", "rtx", ")", ")", ";", "static", "const", "char", "*", "singlemove_string", "PARAMS", "(", "(", "rtx", "*", ")", ")", ";", "static", "const", "char", "*", "load_opcode", "PARAMS", "(", "(", "enum", "machine_mode", ",", "const", "char", "*", ",", "rtx", ")", ")", ";", "static", "const", "char", "*", "store_opcode", "PARAMS", "(", "(", "enum", "machine_mode", ",", "const", "char", "*", ",", "rtx", ")", ")", ";", "static", "void", "output_size_for_block_move", "PARAMS", "(", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", ";", "<FIXE>", "<FIXS>", "const", "char", "*", "i860_reg_prefix", "=", "I860_REG_PREFIX", ";", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "insn-attr.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "function.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "expr.h", "<STR_LIT>", "<BUGS>", "static", "rtx", "find_addr_reg", "(", ")", ";", "<BUGE>", "#", "ifndef", "I860_REG_PREFIX", "#", "define", "I860_REG_PREFIX", "<STR_LIT>", "<STR_LIT>", "#", "endif", "<BUGS>", "char", "*", "i860_reg_prefix", "=", "I860_REG_PREFIX", ";", "<BUGE>" ]

[ "}" ]

[ "return", "DAG", ".", "getVectorShuffle", "(", "VT", ",", "DL", ",", "V", ",", "DAG", ".", "getUNDEF", "(", "VT", ")", ",", "ShMask", ")", ";", "}", ";", "if", "(", "Subtarget", ".", "hasSSE41", "(", ")", ")", "{", "if", "(", "Offset", "&&", "Scale", "==", "<NUM_LIT>", "&&", "VT", ".", "is128BitVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "MVT", "ExtVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "getIntegerVT", "(", "EltBits", "*", "Scale", ")", ",", "NumElements", "/", "Scale", ")", ";", "InputV", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ExtVT", ",", "ShuffleOffset", "(", "InputV", ")", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "InputV", ")", ";", "}", "assert", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Only 128-bit vectors can be extended.", "<STR_LIT>", ")", ";", "if", "(", "AnyExt", "&&", "EltBits", "==", "<NUM_LIT>", ")", "{", "int", "PSHUFDMask", "[", "<NUM_LIT>", "]", "=", "{", "Offset", ",", "-", "<NUM_LIT>", ",", "SafeOffset", "(", "Offset", "+", "<NUM_LIT>", ")", "?", "Offset", "+", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4i32", ",", "DAG", ".", "getBitcast", "(", "MVT", "::", "v4i32", ",", "InputV", ")", ",", "getV4X86ShuffleImm8ForMask", "(", "PSHUFDMask", ",", "DL", ",", "DAG", ")", ")", ")", ";", "}", "if", "(", "AnyExt", "&&", "EltBits", "==", "<NUM_LIT>", "&&", "Scale", ">", "<NUM_LIT>", ")", "{", "int", "PSHUFDMask", "[", "<NUM_LIT>", "]", "=", "{", "Offset", "/", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "SafeOffset", "(", "Offset", "+", "<NUM_LIT>", ")", "?", "(", "Offset", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "InputV", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4i32", ",", "DAG", ".", "getBitcast", "(", "MVT", "::", "v4i32", ",", "InputV", ")", ",", "getV4X86ShuffleImm8ForMask", "(", "PSHUFDMask", ",", "DL", ",", "DAG", ")", ")", ";", "int", "PSHUFWMask", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "unsigned", "OddEvenOp", "=", "(", "Offset", "&", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "DAG", ".", "getNode", "(", "OddEvenOp", ",", "DL", ",", "MVT", "::", "v8i16", ",", "DAG", ".", "getBitcast", "(", "MVT", "::", "v8i16", ",", "InputV", ")", ",", "getV4X86ShuffleImm8ForMask", "(", "PSHUFWMask", ",", "DL", ",", "DAG", ")", ")", ")", ";", "}", "if", "(", "(", "Scale", "*", "EltBits", ")", "==", "<NUM_LIT>", "&&", "EltBits", "<", "<NUM_LIT>", "&&", "Subtarget", ".", "hasSSE4A", "(", ")", ")", "{", "assert", "(", "NumElements", "==", "(", "int", ")", "Mask", ".", "size", "(", ")", "&&", "<STR_LIT>", "Unexpected shuffle mask size!", "<STR_LIT>", ")", ";", "assert", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Unexpected vector width!", "<STR_LIT>", ")", ";", "int", "LoIdx", "=", "Offset", "*", "EltBits", ";", "SDValue", "Lo", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v2i64", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "InputV", ",", "DAG", ".", "getConstant", "(", "EltBits", ",", "DL", ",", "MVT", "::", "i8", ")", ",", "DAG", ".", "getConstant", "(", "LoIdx", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ")", ";", "if", "(", "isUndefInRange", "(", "Mask", ",", "NumElements", "/", "<NUM_LIT>", ",", "NumElements", "/", "<NUM_LIT>", ")", "||", "!", "SafeOffset", "(", "Offset", "+", "<NUM_LIT>", ")", ")", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "Lo", ")", ";", "int", "HiIdx", "=", "(", "Offset", "+", "<NUM_LIT>", ")", "*", "EltBits", ";", "SDValue", "Hi", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v2i64", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "InputV", ",", "DAG", ".", "getConstant", "(", "EltBits", ",", "DL", ",", "MVT", "::", "i8", ")", ",", "DAG", ".", "getConstant", "(", "HiIdx", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v2i64", ",", "Lo", ",", "Hi", ")", ")", ";" ]

[ "bool", "rl78_hl_b_c_addr_p", "(", "rtx", "op", ")", "{", "rtx", "hl", ",", "bc", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", ")", "return", "false", ";", "hl", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "bc", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "hl", ")", "==", "ZERO_EXTEND", ")", "{", "rtx", "tmp", "=", "hl", ";", "hl", "=", "bc", ";", "bc", "=", "tmp", ";", "}", "if", "(", "GET_CODE", "(", "hl", ")", "!=", "REG", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "bc", ")", "!=", "ZERO_EXTEND", ")", "return", "false", ";", "bc", "=", "XEXP", "(", "bc", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "bc", ")", "!=", "REG", ")", "return", "false", ";", "if", "(", "REGNO", "(", "hl", ")", "!=", "HL_REG", ")", "return", "false", ";", "if", "(", "REGNO", "(", "bc", ")", "!=", "B_REG", "&&", "REGNO", "(", "bc", ")", "!=", "C_REG", ")", "return", "false", ";", "return", "true", ";", "}" ]

[ "Used", "by", "the", "Whb", "constraint", ".", "Match", "addresses", "that", "use", "HL+B", "or", "HL+C", "addressing", "." ]

[ "d", "=", "&", "mips_builtins", "[", "i", "]", ";" ]

[ "const", "struct", "mips_builtin_description", "*", "d", ";", "unsigned", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "ARRAY_SIZE", "(", "mips_builtins", ")", ";", "i", "++", ")", "{" ]

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

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

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

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

[ "assemble_end_function", "(", "thunkdecl", ",", "fnname", ")", ";" ]

[ "else", "if", "(", "delta", "<", "<NUM_LIT>", ")", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tsub%s ", "<STR_LIT>", "HOST_WIDE_INT_PRINT_DEC", "<STR_LIT>", ",$%s\\n", "<STR_LIT>", ",", "ADDITIVE_SIZE_MODIFIER", "(", "-", "delta", ")", ",", "-", "delta", ",", "reg_names", "[", "CRIS_FIRST_ARG_REG", "]", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tjump ", "<STR_LIT>", ")", ";", "assemble_name", "(", "stream", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "funcdecl", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "final_end_function", "(", ")", ";" ]

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

[ "class", "t2am_imm7_offset", "<", "int", "shift", ">", ":", "MemOperand", ",", "ComplexPattern", "<", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ",", "[", "]", ",", "[", "SDNPWantRoot", "]", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "!", "cast", "<", "AsmOperandClass", ">", "(", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ")", ";", "let", "EncoderMethod", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";" ]

[ "return", "costs", "->", "cond_taken_branch_cost", ";" ]

[ "static", "int", "aarch64_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "elements", ";", "const", "cpu_vector_cost", "*", "costs", "=", "aarch64_tune_params", ".", "vec_costs", ";", "bool", "fp", "=", "false", ";", "if", "(", "vectype", "!=", "NULL", ")", "fp", "=", "FLOAT_TYPE_P", "(", "vectype", ")", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "fp", "?", "costs", "->", "scalar_fp_stmt_cost", ":", "costs", "->", "scalar_int_stmt_cost", ";", "case", "scalar_load", ":", "return", "costs", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "costs", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "fp", "?", "costs", "->", "vec_fp_stmt_cost", ":", "costs", "->", "vec_int_stmt_cost", ";", "case", "vector_load", ":", "return", "costs", "->", "vec_align_load_cost", ";", "case", "vector_store", ":", "return", "costs", "->", "vec_store_cost", ";", "case", "vec_to_scalar", ":", "return", "costs", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "costs", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "return", "costs", "->", "vec_unalign_load_cost", ";", "case", "unaligned_store", ":", "return", "costs", "->", "vec_unalign_store_cost", ";", "case", "cond_branch_taken", ":" ]

[ "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "BROpcode", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ".", "addImm", "(", "CC", ")", ";", "<FIXE>" ]

[ "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", ".", "get", "(", "BROpcode", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ".", "addImm", "(", "CC", ")", ";", "<BUGE>", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";" ]

[ "PCMPISTRIREG", ":" ]

[ "unsigned", "Opc", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "illegal opcode!", "<STR_LIT>", ")", ";", "case", "X86", "::", "FP32_TO_INT16_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp16m32", ";", "break", ";", "case", "X86", "::", "FP32_TO_INT32_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp32m32", ";", "break", ";", "case", "X86", "::", "FP32_TO_INT64_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp64m32", ";", "break", ";", "case", "X86", "::", "FP64_TO_INT16_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp16m64", ";", "break", ";", "case", "X86", "::", "FP64_TO_INT32_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp32m64", ";", "break", ";", "case", "X86", "::", "FP64_TO_INT64_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp64m64", ";", "break", ";", "case", "X86", "::", "FP80_TO_INT16_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp16m80", ";", "break", ";", "case", "X86", "::", "FP80_TO_INT32_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp32m80", ";", "break", ";", "case", "X86", "::", "FP80_TO_INT64_IN_MEM", ":", "Opc", "=", "X86", "::", "IST_Fp64m80", ";", "break", ";", "}", "X86AddressMode", "AM", ";", "MachineOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "AM", ".", "BaseType", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "AM", ".", "Base", ".", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "}", "else", "{", "AM", ".", "BaseType", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "AM", ".", "Base", ".", "FrameIndex", "=", "Op", ".", "getIndex", "(", ")", ";", "}", "Op", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "AM", ".", "Scale", "=", "Op", ".", "getImm", "(", ")", ";", "Op", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "AM", ".", "IndexReg", "=", "Op", ".", "getImm", "(", ")", ";", "Op", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "isGlobal", "(", ")", ")", "{", "AM", ".", "GV", "=", "Op", ".", "getGlobal", "(", ")", ";", "}", "else", "{", "AM", ".", "Disp", "=", "Op", ".", "getImm", "(", ")", ";", "}", "addFullAddress", "(", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ")", ",", "AM", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getReg", "(", ")", ")", ";", "addFrameReference", "(", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "FLDCW16m", ")", ")", ",", "CWFrameIdx", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "case", "X86", "::", "PCMPISTRM128REG", ":", "case", "X86", "::", "VPCMPISTRM128REG", ":", "case", "X86", "::", "PCMPISTRM128MEM", ":", "case", "X86", "::", "VPCMPISTRM128MEM", ":", "case", "X86", "::", "PCMPESTRM128REG", ":", "case", "X86", "::", "VPCMPESTRM128REG", ":", "case", "X86", "::", "PCMPESTRM128MEM", ":", "case", "X86", "::", "VPCMPESTRM128MEM", ":", "assert", "(", "Subtarget", "->", "hasSSE42", "(", ")", "&&", "<STR_LIT>", "Target must have SSE4.2 or AVX features enabled", "<STR_LIT>", ")", ";", "return", "EmitPCMPSTRM", "(", "MI", ",", "BB", ",", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "case", "X86", "::" ]

[ "<FIXS>", "MRI", ".", "setRegClass", "(", "Reg", ",", "SpvType", "?", "GR", "->", "getRegClass", "(", "SpvType", ")", ":", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "if", "(", "SpvType", ")", "GR", "->", "assignSPIRVTypeToVReg", "(", "SpvType", ",", "Reg", ",", "MIB", ".", "getMF", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "getRegClassOrNull", "(", "Reg", ")", ")", "<BUGS>", "MRI", ".", "setRegClass", "(", "Reg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "}", "}", "return", "SpvType", ";" ]

[ "}" ]

[ "Item", "=", "getShuffleVectorZeroOrUndef", "(", "Item", ",", "<NUM_LIT>", ",", "true", ",", "Subtarget", ",", "DAG", ")", ";", "if", "(", "Idx", "!=", "<NUM_LIT>", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", ";", "Mask", ".", "push_back", "(", "Idx", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "VecElts", ";", "++", "i", ")", "Mask", ".", "push_back", "(", "i", ")", ";", "Item", "=", "DAG", ".", "getVectorShuffle", "(", "VecVT", ",", "dl", ",", "Item", ",", "DAG", ".", "getUNDEF", "(", "VecVT", ")", ",", "&", "Mask", "[", "<NUM_LIT>", "]", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VT", ",", "Item", ")", ";", "}", "}", "if", "(", "Idx", "==", "<NUM_LIT>", ")", "{", "if", "(", "NumZero", "==", "<NUM_LIT>", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VT", ",", "Item", ")", ";", "if", "(", "ExtVT", "==", "MVT", "::", "i32", "||", "ExtVT", "==", "MVT", "::", "f32", "||", "ExtVT", "==", "MVT", "::", "f64", "||", "(", "ExtVT", "==", "MVT", "::", "i64", "&&", "Subtarget", "->", "is64Bit", "(", ")", ")", ")", "{", "if", "(", "VT", ".", "is256BitVector", "(", ")", "||", "VT", ".", "is512BitVector", "(", ")", ")", "{", "SDValue", "ZeroVec", "=", "getZeroVector", "(", "VT", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "dl", ",", "VT", ",", "ZeroVec", ",", "Item", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "}", "assert", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Expected an SSE value type!", "<STR_LIT>", ")", ";", "Item", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VT", ",", "Item", ")", ";", "return", "getShuffleVectorZeroOrUndef", "(", "Item", ",", "<NUM_LIT>", ",", "true", ",", "Subtarget", ",", "DAG", ")", ";", "}", "if", "(", "ExtVT", "==", "MVT", "::", "i16", "||", "ExtVT", "==", "MVT", "::", "i8", ")", "{", "Item", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Item", ")", ";", "Item", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v4i32", ",", "Item", ")", ";", "if", "(", "VT", ".", "is256BitVector", "(", ")", ")", "{", "SDValue", "ZeroVec", "=", "getZeroVector", "(", "MVT", "::", "v8i32", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ";", "Item", "=", "Insert128BitVector", "(", "ZeroVec", ",", "Item", ",", "<NUM_LIT>", ",", "DAG", ",", "dl", ")", ";", "}", "else", "{", "assert", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Expected an SSE value type!", "<STR_LIT>", ")", ";", "Item", "=", "getShuffleVectorZeroOrUndef", "(", "Item", ",", "<NUM_LIT>", ",", "true", ",", "Subtarget", ",", "DAG", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VT", ",", "Item", ")", ";", "}", "}", "if", "(", "NumElems", "==", "<NUM_LIT>", "&&", "Idx", "==", "<NUM_LIT>", "&&", "X86", "::", "isZeroNode", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "!", "X86", "::", "isZeroNode", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "unsigned", "NumBits", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "return", "getVShift", "(", "true", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ",", "NumBits", "/", "<NUM_LIT>", ",", "DAG", ",", "*", "this", ",", "dl", ")", ";", "}", "if", "(", "IsAllConstants", ")", "return", "SDValue", "(", ")", ";", "if", "(", "EVTBits", "==", "<NUM_LIT>", ")", "{", "Item", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VT", ",", "Item", ")", ";", "Item", "=", "getShuffleVectorZeroOrUndef", "(", "Item", ",", "<NUM_LIT>", ",", "NumZero", ">", "<NUM_LIT>", ",", "Subtarget", ",", "DAG", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "MaskVec", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "MaskVec", ".", "push_back", "(", "i", "==", "Idx", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getVectorShuffle", "(", "VT", ",", "dl", ",", "Item", ",", "DAG", ".", "getUNDEF", "(", "VT", ")", ",", "&", "MaskVec", "[", "<NUM_LIT>", "]", ")", ";", "}", "}", "if", "(", "Values", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "EVTBits", "==", "<NUM_LIT>", ")", "{", "unsigned", "Idx", "=", "countTrailingZeros", "(", "NonZeros", ")", ";", "SDValue", "Item", "=", "Op", ".", "getOperand", "(", "Idx", ")", ";", "if", "(", "Op", ".", "getNode", "(", ")", "->", "isOnlyUserOf", "(", "Item", ".", "getNode", "(", ")", ")", ")", "return", "LowerAsSplatVectorLoad", "(", "Item", ",", "VT", ",", "dl", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";" ]

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

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

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

[ "(", "parallel", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_BIG_ENDIAN", ")", "{", "const", "char", "*", "pats", "[", "]", "=", "{", "<STR_LIT>", ",", "<STR_LIT>", "}", "return", "pats", "[", "which_alternative", "]", "}", "else", "{", "const", "char", "*", "pats", "[", "]", "=", "{", "<STR_LIT>", ",", "<STR_LIT>", "}", "return", "pats", "[", "which_alternative", "]", "}", "}", "[", "(", "set_attr" ]

[ "<FIXS>", "printOperand", "(", "MI", ",", "Index", ",", "O", ")", ";", "<FIXE>" ]

[ "}", "else", "{", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "}", "<BUGS>", "printParamOperand", "(", "MI", ",", "Index", ",", "O", ")", ";", "<BUGE>", "Index", "++", ";", "}" ]

[ "}" ]

[ "def", "VORRiv4i32", ":", "N1ModImm", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "{", "<NUM_LIT>", ",", "?", ",", "?", ",", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "nImmSplatI32", ":", "$", "SIMM", ",", "QPR", ":", "$", "src", ")", ",", "IIC_VMOVImm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "QPR", ":", "$", "Vd", ",", "(", "v4i32", "(", "NEONvorrImm", "QPR", ":", "$", "src", ",", "timm", ":", "$", "SIMM", ")", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SIMM", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "if", "(", "inner_bytes", ">=", "<NUM_LIT>", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";" ]

[ "static", "rtx", "rs6000_complex_function_value", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ";", "rtx", "r1", ",", "r2", ";", "machine_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "unsigned", "int", "inner_bytes", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_FLOAT128_TYPE", "&&", "(", "mode", "==", "KCmode", "||", "(", "mode", "==", "TCmode", "&&", "TARGET_IEEEQUAD", ")", ")", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "{", "regno", "=", "GP_ARG_RETURN", ";", "if", "(", "TARGET_32BIT", "&&", "inner_bytes", ">=", "<NUM_LIT>", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}" ]

[ "<NUM_LIT>", ";" ]

[ "def", "L2_loadrb_pi", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "s4_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_222336", ",", "PredNewRel", ",", "PostInc_BaseImm", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=" ]

[ "}" ]

[ "static", "bool", "rs6000_debug_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "reg_ok_strict", ",", "code_helper", "ch", ")", "{", "bool", "ret", "=", "rs6000_legitimate_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ",", "ch", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\nrs6000_legitimate_address_p: return = %s, mode = %s, ", "<STR_LIT>", "<STR_LIT>", "strict = %d, reload = %s, code = %s\\n", "<STR_LIT>", ",", "ret", "?", "<STR_LIT>", "true", "<STR_LIT>", ":", "<STR_LIT>", "false", "<STR_LIT>", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_ok_strict", ",", "(", "reload_completed", "?", "<STR_LIT>", "after", "<STR_LIT>", ":", "<STR_LIT>", "before", "<STR_LIT>", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "x", ")", ")", ")", ";", "debug_rtx", "(", "x", ")", ";", "return", "ret", ";" ]

[ ";" ]

[ "def", "J4_cmpltu_t_jumpnv_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Ns8", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_b343892a", ",", "TypeNCJ", ">", ",", "Enc_5de85f", ",", "PredRel", "{", "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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "base", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "dst2", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "AMDGPU", "::", "S_SET_GPR_IDX_OFF", ")", ")", ";" ]

[ "if", "(", "!", "STI", ".", "useVGPRIndexMode", "(", ")", ")", "{", "BuildMI", "(", "*", "BB", ",", "&", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "AMDGPU", "::", "M0", ")", ".", "addReg", "(", "IdxReg", ")", ";", "BuildMI", "(", "*", "BB", ",", "&", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AMDGPU", "::", "V_MOVRELS_B32_e32", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Undef", ",", "SubReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Implicit", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AMDGPU", "::", "S_SET_GPR_IDX_ON", ")", ")", ".", "addReg", "(", "IdxReg", ")", ".", "addImm", "(", "AMDGPU", "::", "VGPRIndexMode", "::", "SRC0_ENABLE", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Undef", ",", "SubReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "Implicit", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(" ]

[ ";" ]

[ "return", "NumXMMRegs" ]

[ "<FIXS>", "bool", "updateDefsUses", "(", "ValueType", "V", ",", "bool", "MayStore", ")", ";", "<FIXE>", "<FIXS>", "SmallVectorImpl", "ValueType", ">", "&", "Objects", ")", "const", ";", "<FIXE>", "<FIXS>", "SmallPtrSet", "ValueType", ",", "<NUM_LIT>", ">", "Uses", ",", "Defs", ";", "<FIXE>" ]

[ "MemDefsUses", "(", "const", "MachineFrameInfo", "*", "MFI", ")", ";", "private", ":", "virtual", "bool", "hasHazard_", "(", "const", "MachineInstr", "&", "MI", ")", ";", "<BUGS>", "bool", "updateDefsUses", "(", "const", "Value", "*", "V", ",", "bool", "MayStore", ")", ";", "<BUGE>", "bool", "getUnderlyingObjects", "(", "const", "MachineInstr", "&", "MI", ",", "<BUGS>", "SmallVectorImpl", "const", "Value", "*", ">", "&", "Objects", ")", "const", ";", "<BUGE>", "const", "MachineFrameInfo", "*", "MFI", ";", "<BUGS>", "SmallPtrSet", "const", "Value", "*", ",", "<NUM_LIT>", ">", "Uses", ",", "Defs", ";", "<BUGE>" ]

[ "static", "bool", "rs6000_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "<NUM_LIT>", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "<NUM_LIT>", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "type", ",", "true", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "false", ";", "}", "if", "(", "rs6000_discover_homogeneous_aggregate", "(", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "NULL", ",", "NULL", ")", ")", "return", "false", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", "<=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "aix_struct_return", "||", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "<NUM_LIT>", ")", ")", "return", "true", ";", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", "{", "static", "bool", "warned_for_return_big_vectors", "=", "false", ";", "if", "(", "!", "warned_for_return_big_vectors", ")", "{", "warning", "(", "OPT_Wpsabi", ",", "<STR_LIT>", "GCC vector returned by reference: ", "<STR_LIT>", "<STR_LIT>", "non-standard ABI extension with no compatibility guarantee", "<STR_LIT>", ")", ";", "warned_for_return_big_vectors", "=", "true", ";", "}", "return", "true", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "FLOAT128_IEEE_P", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}" ]

[ "Return", "a", "nonzero", "value", "to", "say", "to", "return", "the", "function", "value", "in", "memory", ",", "just", "as", "large", "structures", "are", "always", "returned", ".", "TYPE", "will", "be", "the", "data", "type", "of", "the", "value", ",", "and", "FNTYPE", "will", "be", "the", "type", "of", "the", "function", "doing", "the", "returning", ",", "or", "@", "code", "{", "NULL", "}", "for", "libcalls", ".", "The", "AIX", "ABI", "for", "the", "RS/6000", "specifies", "that", "all", "structures", "are", "returned", "in", "memory", ".", "The", "Darwin", "ABI", "does", "the", "same", ".", "The", "SVR4", "ABI", "specifies", "that", "structures", "<", "=", "8", "bytes", "are", "returned", "in", "r3/r4", ",", "but", "a", "draft", "put", "them", "in", "memory", ",", "and", "GCC", "used", "to", "implement", "the", "draft", "instead", "of", "the", "final", "standard", ".", "Therefore", ",", "aix_struct_return", "controls", "this", "instead", "of", "DEFAULT_ABI", ";", "V.4", "targets", "needing", "backward", "compatibility", "can", "change", "DRAFT_V4_STRUCT_RET", "to", "override", "the", "default", ",", "and", "-m", "switches", "get", "the", "final", "word", ".", "See", "rs6000_override_options", "for", "more", "details", ".", "The", "PPC32", "SVR4", "ABI", "uses", "IEEE", "double", "extended", "for", "long", "double", ",", "if", "128-bit", "long", "double", "support", "is", "enabled", ".", "These", "values", "are", "returned", "in", "memory", ".", "int_size_in_bytes", "returns", "-1", "for", "variable", "size", "objects", ",", "which", "go", "in", "memory", "always", ".", "The", "cast", "to", "unsigned", "makes", "-1", ">", "8", "." ]

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

[ "if", "(", "I", ".", "getNumMemOperands", "(", ")", ")", "addMemoryOperands", "(", "*", "I", ".", "memoperands_begin", "(", ")", ",", "MIB", ")", ";", "bool", "Result", "=", "MIB", ".", "constrainAllUses", "(", "TII", ",", "TRI", ",", "RBI", ")", ";", "if", "(", "ResVReg", ".", "isValid", "(", ")", "&&", "ResVReg", "!=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "{", "BuildMI", "(", "BB", ",", "I", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResVReg", ")", ".", "addUse", "(", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "}" ]

[ "}" ]

[ "const", "MCInstrDesc", "&", "LastMCID", "=", "LastMI", "->", "getDesc", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "LastMI", "->", "isBarrier", "(", ")", "&&", "!", "(", "TII", ".", "getSubtarget", "(", ")", ".", "isLikeA9", "(", ")", "&&", "(", "LastMI", "->", "mayLoad", "(", ")", "||", "LastMI", "->", "mayStore", "(", ")", ")", ")", "&&", "(", "LastMCID", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "LastMI", ";", "if", "(", "I", "!=", "LastMI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "{", "I", "=", "std", "::", "prev", "(", "I", ")", ";", "DefMI", "=", "&", "*", "I", ";", "}" ]

[ "R1", ";" ]

[ "class", "InstRIEb", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "InstSystemZ", "<", "<NUM_LIT>", ",", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">" ]

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

[ "}", "else", "{", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "high", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "delta", ")", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "high", ")", ";", "src", "=", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "tmpreg", ",", "delta", ")", ")", ";", "}", "emit_move_insn", "(", "dest", "," ]

[ "}" ]

[ "void", "HSAILInstPrinter", "::", "printV2F32", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "O", "<<", "'", "(", "'", ";", "printF32", "(", "MI", ",", "OpNo", "+", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "printF32", "(", "MI", ",", "OpNo", "+", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", ")", "'", ";" ]

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

[ "def", "J4_cmpgti_tp1_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_14d27a", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "bool", "PPCDarwinAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "static", "const", "char", "*", "const", "CPUDirectives", "[", "]", "=", "{", "<STR_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc", "<STR_LIT>", ",", "<STR_LIT>", "ppc601", "<STR_LIT>", ",", "<STR_LIT>", "ppc602", "<STR_LIT>", ",", "<STR_LIT>", "ppc603", "<STR_LIT>", ",", "<STR_LIT>", "ppc7400", "<STR_LIT>", ",", "<STR_LIT>", "ppc750", "<STR_LIT>", ",", "<STR_LIT>", "ppc970", "<STR_LIT>", ",", "<STR_LIT>", "ppc64", "<STR_LIT>", "}", ";", "unsigned", "Directive", "=", "Subtarget", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Subtarget", ".", "isGigaProcessor", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_970", ")", "Directive", "=", "PPC", "::", "DIR_970", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_7400", ")", "Directive", "=", "PPC", "::", "DIR_7400", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_970", ")", "Directive", "=", "PPC", "::", "DIR_64", ";", "assert", "(", "Directive", "<=", "PPC", "::", "DIR_64", "&&", "<STR_LIT>", "Directive out of range.", "<STR_LIT>", ")", ";", "O", "<<", "<STR_LIT>", "\\t.machine ", "<STR_LIT>", "<<", "CPUDirectives", "[", "Directive", "]", "<<", "'", "\\n", "'", ";", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "assert", "(", "MMI", ")", ";", "DW", "=", "getAnalysisIfAvailable", "<", "DwarfWriter", ">", "(", ")", ";", "assert", "(", "DW", "&&", "<STR_LIT>", "DwarfWriter is not available", "<STR_LIT>", ")", ";", "DW", "->", "BeginModule", "(", "&", "M", ",", "MMI", ",", "O", ",", "this", ",", "TAI", ")", ";", "Mang", "->", "setUseQuotes", "(", "true", ")", ";", "SwitchToTextSection", "(", "<STR_LIT>", "\\t.section __TEXT,__textcoal_nt,coalesced,", "<STR_LIT>", "<STR_LIT>", "pure_instructions", "<STR_LIT>", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "SwitchToTextSection", "(", "<STR_LIT>", "\\t.section __TEXT,__picsymbolstub1,symbol_stubs,", "<STR_LIT>", "<STR_LIT>", "pure_instructions,32", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{", "SwitchToTextSection", "(", "<STR_LIT>", "\\t.section __TEXT,__symbol_stub1,symbol_stubs,", "<STR_LIT>", "<STR_LIT>", "pure_instructions,16", "<STR_LIT>", ")", ";", "}", "SwitchToSection", "(", "TAI", "->", "getTextSection", "(", ")", ")", ";", "return", "Result", ";", "}" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]