Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "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>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "->", "isVolatile", "(", ")", ",", "ST", "->", "isNonTemporal", "(", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "unsigned", "ABIAlignment", "=", "getTargetData", "(", ")", "->", "getABITypeAlignment", "(", "ST", "->", "getMemoryVT", "(", ")", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ")", ";", "if", "(", "ST", "->", "getAlignment", "(", ")", ">=", "ABIAlignment", ")", "{", "return", "SDValue", "(", ")", ";", "}", "SDValue", "Chain", "=", "ST", "->", "getChain", "(", ")", ";", "SDValue", "BasePtr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "SDValue", "Value", "=", "ST", "->", "getValue", "(", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "if", "(", "ST", "->", "getAlignment", "(", ")", "==", "<NUM_LIT>", ")", "{", "int", "SVOffset", "=", "ST", "->", "getSrcValueOffset", "(", ")", ";", "SDValue", "Low", "=", "Value", ";", "SDValue", "High", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "MVT", "::", "i32", ",", "Value", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "StoreLow", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "dl", ",", "Low", ",", "BasePtr", ",", "ST", "->", "getSrcValue", "(", ")", ",", "SVOffset", ",", "MVT", "::", "i16", ",", "ST", "->", "isVolatile", "(", ")", ",", "ST", "->", "isNonTemporal", "(", ")", ",", "<NUM_LIT>", ")", ";", "SDValue", "HighAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "StoreHigh", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "dl", ",", "High", ",", "HighAddr", ",", "ST", "->", "getSrcValue", "(", ")", ",", "SVOffset", "+", "<NUM_LIT>", ",", "MVT", "::", "i16", ",", "ST" ]

[ ")", ";" ]

[ "if", "(", "isCheapToExtend", "(", "SetCC", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "isCheapToExtend", "(", "SetCC", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "const", "SDValue", "Ext1", "=", "DAG", ".", "getNode", "(", "ExtType", ",", "SDLoc", "(", "N", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "CCOp0", ")", ";", "const", "SDValue", "Ext2", "=", "DAG", ".", "getNode", "(", "ExtType", ",", "SDLoc", "(", "N", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "CCOp1", ")", ";", "return", "DAG", ".", "getSetCC", "(", "SDLoc", "(", "SetCC", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "Ext1", ",", "Ext2", ",", "cast", "<", "CondCodeSDNode", ">", "(", "SetCC", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "->", "get", "(", ")", ")", ";", "}", "return", "SDValue", "(" ]

[ "VTs", ",", "Ops", ")", ";" ]

[ "int", "CompareOpc", ";", "bool", "isDot", ";", "if", "(", "!", "getVectorCompareInfo", "(", "Op", ",", "CompareOpc", ",", "isDot", ",", "Subtarget", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "isDot", ")", "{", "SDValue", "Tmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "CompareOpc", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Tmp", ")", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "CompareOpc", ",", "dl", ",", "MVT", "::", "i32", ")", "}", ";", "EVT", "VTs", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ",", "MVT", "::", "Glue", "}", ";", "SDValue", "CompNode", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", "," ]

[ "rtx", "shl", "=", "gen_reg_rtx", "(", "SImode", ")", ";" ]

[ "abort", "(", ")", ";", "}", "}", "else", "if", "(", "shift", "<", "<NUM_LIT>", ")", "abort", "(", ")", ";", "switch", "(", "dst_size", ")", "{", "case", "<NUM_LIT>", ":", "maskbits", "=", "(", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "width", "-", "start", ")", ")", ";", "if", "(", "start", ")", "maskbits", "+=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "start", ")", ")", ";", "emit_move_insn", "(", "mask", ",", "GEN_INT", "(", "maskbits", ")", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "maskbits", "=", "(", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "width", "-", "start", ")", ")", ";", "if", "(", "start", ")", "maskbits", "+=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "start", ")", ")", ";", "emit_move_insn", "(", "mask", ",", "GEN_INT", "(", "maskbits", ")", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "{", "unsigned", "char", "arr", "[", "<NUM_LIT>", "]", ";", "int", "i", "=", "start", "/", "<NUM_LIT>", ";", "memset", "(", "arr", ",", "<NUM_LIT>", ",", "sizeof", "(", "arr", ")", ")", ";", "arr", "[", "i", "]", "=", "<NUM_LIT>", ">>", "(", "start", "&", "<NUM_LIT>", ")", ";", "for", "(", "i", "++", ";", "i", "<=", "(", "start", "+", "width", "-", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "i", "++", ")", "arr", "[", "i", "]", "=", "<NUM_LIT>", ";", "arr", "[", "i", "-", "<NUM_LIT>", "]", "&=", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "(", "(", "start", "+", "width", "-", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ")", ";", "emit_move_insn", "(", "mask", ",", "array_to_constant", "(", "TImode", ",", "arr", ")", ")", ";", "}", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "if", "(", "GET_CODE", "(", "ops", "[", "<NUM_LIT>", "]", ")", "==", "MEM", ")", "{", "rtx", "low", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "rotl", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "mask0", "=", "gen_reg_rtx", "(", "TImode", ")", ";", "rtx", "addr", ";", "rtx", "addr0", ";", "rtx", "addr1", ";", "rtx", "mem", ";", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "ops", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", ";", "addr0", "=", "gen_rtx_AND", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "low", ",", "addr", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_negsi2", "(", "rotl", ",", "low", ")", ")", ";", "emit_insn", "(", "gen_rotqby_ti", "(", "shift_reg", ",", "shift_reg", ",", "rotl", ")", ")", ";", "emit_insn", "(", "gen_rotqmby_ti", "(", "mask0", ",", "mask", ",", "rotl", ")", ")", ";", "mem", "=", "change_address", "(", "ops", "[", "<NUM_LIT>", "]", ",", "TImode", ",", "addr0", ")", ";", "set_mem_alias_set", "(", "mem", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "dst", ",", "mem", ")", ";", "emit_insn", "(", "gen_selb", "(", "dst", ",", "dst", ",", "shift_reg", ",", "mask0", ")", ")", ";", "if", "(", "start", "+", "width", ">", "MEM_ALIGN", "(", "ops", "[", "<NUM_LIT>", "]", ")", ")", "{" ]

[ "getTargetStreamer", "(", ")", "->", "emitLocal", "(", "MFI", "->", "getLocals", "(", ")", ")", ";" ]

[ "const", "Function", "&", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "MDNode", "*", "Idx", "=", "F", ".", "getMetadata", "(", "<STR_LIT>", "wasm.index", "<STR_LIT>", ")", ")", "{", "assert", "(", "Idx", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", ";", "getTargetStreamer", "(", ")", "->", "emitIndIdx", "(", "AsmPrinter", "::", "lowerConstant", "(", "cast", "<", "ConstantAsMetadata", ">", "(", "Idx", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ")", ")", ";", "}", "ComputeLegalValueVTs", "(", "F", ",", "TM", ",", "F", ".", "getReturnType", "(", ")", ",", "ResultVTs", ")", ";", "if", "(", "ResultVTs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "getTargetStreamer", "(", ")", "->", "emitResult", "(", "CurrentFnSym", ",", "ResultVTs", ")", ";", "else", "getTargetStreamer", "(", ")", "->", "emitResult", "(", "CurrentFnSym", ",", "ArrayRef", "<", "MVT", ">", "(", ")", ")", ";" ]

[ ":", "{" ]

[ "if", "(", "!", "I", ")", "return", "R", ".", "InsertAcc", "(", "V", ")", ";", "if", "(", "I", "->", "getParent", "(", ")", "!=", "BB", ")", "return", "false", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "PHI", ":", "return", "R", ".", "InsertAcc", "(", "V", ")", ";", "case", "Instruction", "::", "Add", ":", "{", "R", ".", "InsertAdd", "(", "I", ")", ";", "Value", "*", "LHS", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Value", "*", "RHS", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "bool", "ValidLHS", "=", "Search", "(", "LHS", ",", "BB", ",", "R", ")", ";", "bool", "ValidRHS", "=", "Search", "(", "RHS", ",", "BB", ",", "R", ")", ";", "if", "(", "ValidLHS", "&&", "ValidRHS", ")", "return", "true", ";", "return", "R", ".", "InsertAcc", "(", "I", ")", ";", "}", "case", "Instruction", "::", "Mul" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Pg", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Zt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "nregs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zt", ";" ]

[ "(", ")", ",", "Load", ",", "VecIndex", ")", ";" ]

[ "SDLoc", "DL", "(", "ML", ")", ";", "EVT", "VT", "=", "ML", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "EVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "EltVT", ",", "DL", ",", "ML", "->", "getChain", "(", ")", ",", "Addr", ",", "ML", "->", "getPointerInfo", "(", ")", ",", "Alignment", ",", "ML", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "Insert", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "DL", ",", "VT", ",", "ML", "->", "getSrc0" ]

[ "::", "i32", ",", "Op", ",", "Mask11", ")", ";" ]

[ "if", "(", "ShiftedActiveBits", "<=", "<NUM_LIT>", "&&", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "MVT", "::", "i64", ")", ")", "{", "SDValue", "LUT", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "ULL", ",", "DL", ",", "MVT", "::", "i64", ")", ";", "if", "(", "ActiveBits", ">", "<NUM_LIT>", ")", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "VT", ",", "Op", ",", "DAG", ".", "getShiftAmountConstant", "(", "TZ", ",", "VT", ",", "DL", ")", ")", ";", "Op", "=", "DAG", ".", "getZExtOrTrunc", "(", "Op", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "DL", ",", "MVT", "::", "i32", ",", "Op", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i64", ",", "LUT", ",", "DAG", ".", "getShiftAmountOperand", "(", "MVT", "::", "i64", ",", "Op", ")", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i64", ",", "Op", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "return", "DAG", ".", "getZExtOrTrunc", "(", "Op", ",", "DL", ",", "VT", ")", ";", "}", "if", "(", "ShiftedActiveBits", "<=", "<NUM_LIT>", ")", "{", "SDValue", "Mask11", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "U", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "if", "(", "ActiveBits", ">", "<NUM_LIT>", ")", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "VT", ",", "Op", ",", "DAG", ".", "getShiftAmountConstant", "(", "TZ", ",", "VT", ",", "DL", ")", ")", ";", "Op", "=", "DAG", ".", "getZExtOrTrunc", "(", "Op", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "DL", ",", "MVT", "::", "i32", ",", "Op", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "U", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "Op", ",", "DAG", ".", "getShiftAmountConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ",", "DL", ")", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lo_sum", ":", "SF", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "Inst", ")", "&&", "<STR_LIT>", "Hexagon relaxInstruction only works on bundles", "<STR_LIT>", ")", ";", "Res", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "bool", "Update", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "Inst", ")", ")", "{", "MCInst", "&", "CrntHMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "if", "(", "*", "RelaxTarget", "==", "&", "CrntHMI", ")", "{", "Update", "=", "true", ";", "assert", "(", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Res", ")", "<", "HEXAGON_PACKET_SIZE", ")", "&&", "<STR_LIT>", "No room to insert extender for relaxation", "<STR_LIT>", ")", ";", "MCInst", "*", "HMIx", "=", "takeExtender", "(", ")", ";", "*", "HMIx", "=", "HexagonMCInstrInfo", "::", "deriveExtender", "(", "*", "MCII", ",", "CrntHMI", ",", "HexagonMCInstrInfo", "::", "getExtendableOperand", "(", "*", "MCII", ",", "CrntHMI", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "HMIx", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "}", "Res", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "I", ".", "getInst", "(", ")", ")", ")", ";", "}", "(", "void", ")", "Update", ";", "assert", "(", "Update", "&&", "<STR_LIT>", "Didn't find relaxation target", "<STR_LIT>", ")", ";", "}" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

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

[ "def", "V_ADD_F64", ":", "VOP3_64", "<", "<NUM_LIT>" ]

[ "(", "set", "(", "attr", "<STR_LIT>", ")" ]

[ "<STR_LIT>", "{", "return", "output_plussi", "(", "operands", ")", "}", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "symbol_ref", "<STR_LIT>", ")", ")" ]

[ "<FIXS>", "SWaitInst", "=", "BuildMI", "(", "Block", ",", "Block", ".", "getFirstNonPHI", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WAITCNT", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "if", "(", "ScoreBrackets", "->", "getScoreUB", "(", "T", ")", ">", "ScoreBrackets", "->", "getScoreLB", "(", "T", ")", ")", "{", "ScoreBrackets", "->", "setScoreLB", "(", "T", ",", "ScoreBrackets", "->", "getScoreUB", "(", "T", ")", ")", ";", "HasPending", "=", "true", ";", "}", "}", "if", "(", "HasPending", ")", "{", "if", "(", "!", "SWaitInst", ")", "{", "<BUGS>", "SWaitInst", "=", "Block", ".", "getParent", "(", ")", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "AMDGPU", "::", "S_WAITCNT", ")", ",", "DebugLoc", "(", ")", ")", ";", "<BUGE>", "TrackedWaitcntSet", ".", "insert", "(", "SWaitInst", ")", ";", "<BUGS>", "const", "MachineOperand", "&", "Op", "=", "MachineOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ";", "SWaitInst", "->", "addOperand", "(", "MF", ",", "Op", ")", ";", "<BUGE>", "#", "if", "<NUM_LIT>", "OutputTransformBanner", "(", "<STR_LIT>", "insertWaitcntInBlock", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "Create:", "<STR_LIT>", ",", "context", ")", ";", "OutputTransformAdd", "(", "SWaitInst", ",", "context", ")", ";" ]

[ "<NUM_LIT>", ";" ]

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

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

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

[ ")", "]" ]

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

[ "}" ]

[ "AtomicExpansionKind", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "override", "{", "return", "AtomicExpansionKind", "::", "LLSC", ";" ]

[ "emitRR", "(", "Mips", "::", "CTC1", ",", "Mips", "::", "RA", ",", "ThirdReg", ",", "IDLoc", ",", "Instructions", ")", ";" ]

[ "createNop", "(", "false", ",", "IDLoc", ",", "Instructions", ")", ";", "emitRRI", "(", "Mips", "::", "ORi", ",", "ATReg", ",", "ThirdReg", ",", "<NUM_LIT>", ",", "IDLoc", ",", "Instructions", ")", ";", "emitRRI", "(", "Mips", "::", "XORi", ",", "ATReg", ",", "ATReg", ",", "<NUM_LIT>", ",", "IDLoc", ",", "Instructions", ")", ";", "emitRR", "(", "Mips", "::", "CTC1", ",", "Mips", "::", "RA", ",", "ATReg", ",", "IDLoc", ",", "Instructions", ")", ";", "createNop", "(", "false", ",", "IDLoc", ",", "Instructions", ")", ";", "emitRR", "(", "IsDouble", "?", "(", "Is64FPU", "?", "Mips", "::", "CVT_W_D64", ":", "Mips", "::", "CVT_W_D32", ")", ":", "Mips", "::", "CVT_W_S", ",", "FirstReg", ",", "SecondReg", ",", "IDLoc", ",", "Instructions", ")", ";" ]

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

[ "}", "if", "(", "!", "isImmTy", "(", "ImmTyNone", ")", ")", "{", "return", "false", ";", "}", "APInt", "Literal", "(", "<NUM_LIT>", ",", "Imm", ".", "Val", ")", ";", "if", "(", "Imm", ".", "IsFPImm", ")", "{", "if", "(", "type", "==", "MVT", "::", "f64", "||", "type", "==", "MVT", "::", "i64", ")", "{", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "Imm", ".", "Val", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "APFloat", "FPLiteral", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "APInt", "(", "<NUM_LIT>", ",", "Imm", ".", "Val", ")", ")", ";", "if", "(", "!", "canLosslesslyConvertToFPType", "(", "FPLiteral", ",", "type", ")", ")", "return", "false", ";", "if", "(", "type", ".", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "return", "isInlineableLiteralOp16", "(", "static_cast", "<", "int16_t", ">", "(", "FPLiteral", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ")", ",", "type", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "AMDGPU", "::", "isInlinableLiteral32", "(", "static_cast", "<", "int32_t", ">", "(", "FPLiteral", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ")", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "if", "(", "type", "==", "MVT", "::", "f64", "||", "type", "==", "MVT", "::", "i64", ")", "{", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "Imm", ".", "Val", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "if", "(", "!", "isSafeTruncation", "(", "Imm", ".", "Val", ",", "type", ".", "getScalarSizeInBits", "(", ")", ")", ")", "{" ]

[ "MVT", "::", "i32", ")", ";" ]

[ "Reloc", "::", "Model", "RelocM", "=", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", ";", "SDValue", "CPAddr", ";", "unsigned", "PCAdj", "=", "(", "RelocM", "!=", "Reloc", "::", "PIC_", ")", "?", "<NUM_LIT>", ":", "(", "Subtarget", "->", "isThumb", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "ARMConstantPoolValue", "*", "CPV", "=", "ARMConstantPoolConstant", "::", "Create", "(", "MF", ".", "getFunction", "(", ")", ",", "ARMPCLabelIndex", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "PCAdj", ")", ";", "CPAddr", "=", "DAG", ".", "getTargetConstantPool", "(", "CPV", ",", "PtrVT", ",", "<NUM_LIT>", ")", ";", "CPAddr", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "CPAddr", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "CPAddr", ",", "MachinePointerInfo", "::", "getConstantPool", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "if", "(", "RelocM", "==", "Reloc", "::", "PIC_", ")", "{", "SDValue", "PICLabel", "=", "DAG", ".", "getConstant", "(", "ARMPCLabelIndex", "," ]

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

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

[ "}" ]

[ "delta", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_args", ";", "reg", "=", "SP_REGNUM", ";", "}", "if", "(", "TARGET_THUMB1", "&&", "TARGET_BACKTRACE", ")", "delta", "-=", "<NUM_LIT>", ";", "delta", "-=", "<NUM_LIT>", ";", "addr", "=", "gen_rtx_REG", "(", "SImode", ",", "reg", ")", ";", "if", "(", "delta", ">", "limit", ")", "{", "emit_insn", "(", "gen_movsi", "(", "scratch", ",", "GEN_INT", "(", "delta", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "scratch", ",", "scratch", ",", "stack_pointer_rtx", ")", ")", ";", "addr", "=", "scratch", ";", "}", "else", "addr", "=", "plus_constant", "(", "Pmode", ",", "addr", ",", "delta", ")", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "true", ";", "emit_move_insn", "(", "mem", ",", "source", ")", ";" ]

[ ")", ";" ]

[ "rtx", "x", ";", "v2mode", "=", "GET_MODE_2XWIDER_MODE", "(", "GET_MODE", "(", "op0", ")", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "v2mode", ",", "op0", ",", "op1" ]

[ "Parser", ".", "Lex", "(", ")", ";" ]

[ "Parser", ".", "Lex", "(", ")", ";", "return", "parseOperand", "(", "Operands", ",", "false", ",", "false", ")", ";", "}", "case", "AsmToken", "::", "LCurly", ":", "return", "parseNeonVectorList", "(", "Operands", ")", ";", "case", "AsmToken", "::", "Identifier", ":", "{", "if", "(", "isCondCode", ")", "return", "parseCondCode", "(", "Operands", ",", "invertCondCode", ")", ";", "if", "(", "!", "parseRegister", "(", "Operands", ")", ")", "return", "false", ";", "if", "(", "!", "parseOptionalMulOperand", "(", "Operands", ")", ")", "return", "false", ";", "OperandMatchResultTy", "GotShift", "=", "tryParseOptionalShiftExtend", "(", "Operands", ")", ";", "if", "(", "GotShift", "!=", "MatchOperand_NoMatch", ")", "return", "GotShift", ";", "const", "MCExpr", "*", "IdVal", ";", "S", "=", "getLoc", "(", ")", ";", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "IdVal", ")", ")", "return", "true", ";", "E", "=", "SMLoc", "::", "getFromPointer", "(", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateImm", "(", "IdVal", ",", "S", ",", "E", ",", "getContext", "(", ")", ")", ")", ";", "return", "false", ";", "}", "case", "AsmToken", "::", "Integer", ":", "case", "AsmToken", "::", "Real", ":", "case", "AsmToken", "::", "Hash", ":", "{", "S", "=", "getLoc", "(", ")", ";", "parseOptionalToken", "(", "AsmToken", "::", "Hash", ")", ";", "bool", "isNegative", "=", "false", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Minus", ")", ")", "{", "isNegative", "=", "true", ";", "if", "(", "Parser", ".", "getLexer", "(", ")", ".", "peekTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Real", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "}", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Real", ")", ")", "{", "APFloat", "RealVal", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "Tok", ".", "getString", "(", ")", ")", ";", "uint64_t", "IntVal", "=", "RealVal", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ";", "if", "(", "Mnemonic", "!=", "<STR_LIT>", "fcmp", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmpe", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmeq", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmge", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmgt", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmle", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmlt", "<STR_LIT>", ")", "return", "TokError", "(", "<STR_LIT>", "unexpected floating point literal", "<STR_LIT>", ")", ";", "else", "if", "(", "IntVal", "!=", "<NUM_LIT>", "||", "isNegative", ")", "return", "TokError", "(", "<STR_LIT>", "expected floating-point constant #0.0", "<STR_LIT>", ")", ";" ]

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

[ "}", "assert", "(", "LSB", "+", "Width", "+", "<NUM_LIT>", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Shouldn't create an invalid ubfx", "<STR_LIT>", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "LSB", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "Width", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "Reg0", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opc", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "unsigned", "Shl_imm", "=", "<NUM_LIT>", ";", "if", "(", "isOpcWithIntImmediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ",", "ISD", "::", "SHL", ",", "Shl_imm", ")", ")", "{", "assert", "(", "Shl_imm", ">", "<NUM_LIT>", "&&", "Shl_imm", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "bad amount in shift node!", "<STR_LIT>", ")", ";", "unsigned", "Srl_imm", "=", "<NUM_LIT>", ";", "if", "(", "isInt32Immediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Srl_imm", ")", ")", "{", "assert", "(", "Srl_imm", ">", "<NUM_LIT>", "&&", "Srl_imm", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "bad amount in shift node!", "<STR_LIT>", ")", ";", "unsigned", "Width", "=", "<NUM_LIT>", "-", "Srl_imm", "-", "<NUM_LIT>", ";", "int", "LSB", "=", "Srl_imm", "-", "Shl_imm", ";", "if", "(", "LSB", "<", "<NUM_LIT>", ")", "return", "false", ";", "SDValue", "Reg0", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "assert", "(", "LSB", "+", "Width", "+", "<NUM_LIT>", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Shouldn't create an invalid ubfx", "<STR_LIT>", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "LSB", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "Width", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "Reg0", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opc", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "return", "true", ";", "}", "}", "if", "(", "isOpcWithIntImmediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ",", "ISD", "::", "AND", ",", "And_imm", ")", "&&", "isShiftedMask_32", "(", "And_imm", ")", ")", "{" ]

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

[ "DenseSet", "<", "unsigned", ">", "*", "LiveOuts", "=", "InnerRegion", "->", "getLiveOuts", "(", ")", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "OldLiveOuts", ";", "bool", "IsSingleBB", "=", "InnerRegion", "->", "getEntry", "(", ")", "==", "InnerRegion", "->", "getExit", "(", ")", ";", "for", "(", "auto", "OLI", ":", "*", "LiveOuts", ")", "{", "OldLiveOuts", ".", "push_back", "(", "OLI", ")", ";", "}", "for", "(", "auto", "LI", ":", "OldLiveOuts", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "LiveOut: ", "<STR_LIT>", "<<", "printReg", "(", "LI", ",", "TRI", ")", ")", ";", "if", "(", "!", "containsDef", "(", "CodeBB", ",", "InnerRegion", ",", "LI", ")", "||", "(", "!", "IsSingleBB", "&&", "(", "getDefInstr", "(", "LI", ")", "->", "getParent", "(", ")", "==", "LRegion", "->", "getExit", "(", ")", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "- through", "<STR_LIT>", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "unsigned", "Reg", "=", "LI", ";", "if", "(", "Reg", "!=", "InnerRegion", "->", "getBBSelectRegOut", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RegClass", "=", "MRI", "->", "getRegClass", "(", "Reg", ")", ";", "unsigned", "PHIDestReg", "=", "MRI", "->", "createVirtualRegister", "(", "RegClass", ")", ";", "unsigned", "IfSourceReg", "=", "MRI", "->", "createVirtualRegister", "(", "RegClass", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Initializer for reg: ", "<STR_LIT>", "<<", "printReg", "(", "Reg", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "TII", "->", "materializeImmediate", "(", "*", "IfBB", ",", "IfBB", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "IfSourceReg", ",", "<NUM_LIT>", ")", ";", "InnerRegion", "->", "replaceRegisterOutsideRegion", "(", "Reg", ",", "PHIDestReg", ",", "true", ",", "MRI", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Insert Non-Chained Live out PHI\\n", "<STR_LIT>", ")", ";", "insertMergePHI", "(", "IfBB", ",", "InnerRegion", "->", "getExit", "(", ")", ",", "MergeBB", ",", "PHIDestReg", ",", "IfSourceReg", ",", "Reg", ",", "true", ")", ";", "}", "}", "SmallVector", "<", "unsigned", "," ]

[ ")" ]

[ "(", "TEXASR_SPR", "\t", "\t", "<NUM_LIT>", ")", "(", "TEXASRU_SPR", "\t", "\t", "<NUM_LIT>" ]

[ "(", "NewPR", ".", "R", ",", "<NUM_LIT>", ",", "NewPR", ".", "S", ")", ";" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "_", "_", "func__", "<<", "<STR_LIT>", ": ", "<STR_LIT>", "<<", "MI", "<<", "<STR_LIT>", "<STR_LIT>", "<<", "*", "MI", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "assert", "(", "isConvertibleToPredForm", "(", "MI", ")", ")", ";", "unsigned", "NumOps", "=", "MI", "->", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumOps", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isUse", "(", ")", ")", "continue", ";", "Register", "Reg", "(", "MO", ")", ";", "if", "(", "Reg", ".", "S", "&&", "Reg", ".", "S", "!=", "Hexagon", "::", "isub_lo", ")", "return", "false", ";", "if", "(", "!", "PredGPRs", ".", "count", "(", "Reg", ")", ")", "return", "false", ";", "}", "MachineBasicBlock", "&", "B", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "NewOpc", "=", "getPredForm", "(", "Opc", ")", ";", "if", "(", "NewOpc", "==", "<NUM_LIT>", ")", "{", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeqi", ":", "NewOpc", "=", "Hexagon", "::", "C2_not", ";", "break", ";", "case", "Hexagon", "::", "C4_cmpneqi", ":", "NewOpc", "=", "TargetOpcode", "::", "COPY", ";", "break", ";", "default", ":", "return", "false", ";", "}", "Register", "PR", "=", "getPredRegFor", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "isScalarPred", "(", "PR", ")", ")", "return", "false", ";", "NumOps", "=", "<NUM_LIT>", ";", "}", "MachineOperand", "&", "Op0", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "Op0", ".", "isDef", "(", ")", ")", ";", "Register", "OutR", "(", "Op0", ")", ";", "const", "TargetRegisterClass", "*", "PredRC", "=", "&", "Hexagon", "::", "PredRegsRegClass", ";", "Register", "NewPR", "=", "MRI", "->", "createVirtualRegister", "(", "PredRC", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "NewOpc", ")", ",", "NewPR", ".", "R", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumOps", ";", "++", "i", ")", "{", "Register", "GPR", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "Register", "Pred", "=", "getPredRegFor", "(", "GPR", ")", ";", "MIB", ".", "addReg", "(", "Pred", ".", "R", ",", "<NUM_LIT>", ",", "Pred", ".", "S", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "generated: ", "<STR_LIT>", "<<", "*", "MIB", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", "->", "getRegClass", "(", "OutR", ".", "R", ")", ";", "unsigned", "NewOutR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewOutR", ")", ".", "addReg" ]

[ "and", "_", "operation", ";" ]

[ "FOR_EACH_INSN_INFO_USE", "(", "src_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "src_use", ")", ",", "src_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "src_use", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "XEXP", "(", "mem", ",", "<NUM_LIT>", ")", "=" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "if", "(", "PPCInstrInfo", "::", "hasTLSFlag", "(", "MO", ".", "getTargetFlags", "(", ")", ")", ")", "<FIXE>" ]

[ "}", "}", "<BUGS>", "static", "bool", "hasTLSFlag", "(", "const", "MachineOperand", "&", "MO", ")", "{", "unsigned", "Flags", "=", "MO", ".", "getTargetFlags", "(", ")", ";", "if", "(", "Flags", "&", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "&", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "&", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "true", ";", "if", "(", "Flags", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "true", ";", "return", "false", ";", "}", "<BUGE>", "static", "PPCAsmPrinter", "::", "TOCEntryTypegetTOCEntryTypeForMO", "(", "const", "MachineOperand", "&", "MO", ")", "{", "<BUGS>", "if", "(", "hasTLSFlag", "(", "MO", ")", ")", "<BUGE>", "return", "PPCAsmPrinter", "::", "TOCType_ThreadLocal", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{" ]

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

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

[ "f16", "||", "VT", "==", "MVT", "::", "bf16", ")", ")", ";" ]

[ "bool", "AMDGPUTargetLowering", "::", "isFAbsFree", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", ";", "return", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", "||", "(", "Subtarget", "->", "has16BitInsts", "(", ")", "&&", "(", "VT", "==", "MVT", "::" ]

[ "const", "char", "*", "output_64bit_ior", "(", "rtx", "*", "operands", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "int", "bs0", ",", "bs1", ",", "p", ",", "len", ";", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "copy %1,%0", "<STR_LIT>", ";", "for", "(", "bs0", "=", "<NUM_LIT>", ";", "bs0", "<", "HOST_BITS_PER_WIDE_INT", ";", "bs0", "++", ")", "if", "(", "(", "mask", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "bs0", ")", ")", "!=", "<NUM_LIT>", ")", "break", ";", "for", "(", "bs1", "=", "bs0", ";", "bs1", "<", "HOST_BITS_PER_WIDE_INT", ";", "bs1", "++", ")", "if", "(", "(", "mask", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "bs1", ")", ")", "==", "<NUM_LIT>", ")", "break", ";", "gcc_assert", "(", "bs1", "==", "HOST_BITS_PER_WIDE_INT", "||", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "bs1", ")", ">", "mask", ")", ";", "p", "=", "<NUM_LIT>", "-", "bs0", ";", "len", "=", "bs1", "-", "bs0", ";", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "p", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "len", ")", ";", "return", "<STR_LIT>", "depdi -1,%2,%3,%0", "<STR_LIT>", ";", "}" ]

[ "Return", "a", "string", "to", "perform", "a", "bitwise-and", "of", "operands", "[", "1", "]", "with", "operands", "[", "2", "]", "storing", "the", "result", "in", "operands", "[", "0", "]", "." ]

[ "}" ]

[ "class", "TMemImm7ShiftOffsetAsmOperand", "<", "int", "shift", ">", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

[ ")", ";" ]

[ "return", "isAISrc_1024B16", "(" ]

[ ";" ]

[ "bool", "isStreaming", "(", ")", "const", "{", "return", "IsStreaming" ]

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

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

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

[ "(", "define_insn_reservation" ]

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

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "cond", "[", "(", "and" ]

[ "<FIXS>", "defm", "_e32", ":", "VOP2_m", "op", ",", "outs", ",", "ins32", ",", "asm32", ",", "pat32", ",", "opName", ",", "revOp", ">", ";", "<FIXE>" ]

[ "dag", "ins64", ",", "string", "asm64", ",", "list", "dag", ">", "pat64", ",", "string", "revOp", ",", "bit", "HasMods", ">", "{", "<BUGS>", "defm", "_e32", ":", "VOP2_m", "op", ",", "outs", ",", "ins32", ",", "asm32", ",", "pat32", ",", "opName", ",", "revOp", ",", "revOp", ">", ";", "<BUGE>", "defm", "_e64", ":", "VOP3b_2_m", "op", ",", "outs", ",", "ins64", ",", "opName", "#", "<STR_LIT>", "#", "asm64", ",", "pat64", ",", "opName", ",", "revOp", ",", "HasMods" ]

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

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

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

[ "const", "ImmTLSOp", "getImmTLS", "(" ]

[ ":" ]

[ "switch", "(", "type", ")", "{", "case", "SYMBOL_GOT_DISP", ":", "if", "(", "mode", "!=", "MAX_MACHINE_MODE", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "case", "SYMBOL_TLSGD" ]

[ "lo_half", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "SImode", ",", "lo_half", "[", "<NUM_LIT>", "]", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "any_logical", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "rtx", "hi_half", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", "enum", "insn_code", "icode", "=", "CODE_FOR_", "<", "optab", ">", "si3", "if", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_clobber", "(", "operands", "[", "<NUM_LIT>", "]", ")", "split_di", "(", "operands", ",", "<NUM_LIT>", ",", "lo_half", ",", "hi_half", ")", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "lo_half", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")" ]

[ "SDValue", "rbit", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "ST", "->", "hasV6T2Ops", "(", ")", ")", "return", "SDValue", "(", ")", ";" ]

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

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

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

[ "[", "(", "V4DI", "<STR_LIT>", ")", "(", "V8SI", "<STR_LIT>", ")" ]

[ "_", "i", ";" ]

[ "union", "{", "int", "_", "_", "i", ";", "float", "_", "_", "f", ";", "}", "_", "_", "tmp", ";", "_", "_", "tmp", ".", "_", "_", "f", "=", "_", "_", "builtin_ia32_vec_ext_v4sf", "(", "(", "_", "_", "v4sf", ")", "_", "_", "X", ",", "_", "_", "N", ")", ";", "return", "_", "_", "tmp", ".", "_" ]

[ "if", "(", "callee_opts", "->", "x_aarch64_override_tune_string", "!=", "NULL", "&&", "caller_opts", "->", "x_aarch64_override_tune_string", "==", "NULL", ")", "return", "false", ";" ]

[ "if", "(", "always_inline", ")", "return", "true", ";", "if", "(", "caller_opts", "->", "x_aarch64_cmodel_var", "!=", "callee_opts", "->", "x_aarch64_cmodel_var", ")", "return", "false", ";", "if", "(", "caller_opts", "->", "x_aarch64_tls_dialect", "!=", "callee_opts", "->", "x_aarch64_tls_dialect", ")", "return", "false", ";", "if", "(", "!", "aarch64_tribools_ok_for_inlining_p", "(", "caller_opts", "->", "x_aarch64_fix_a53_err835769", ",", "callee_opts", "->", "x_aarch64_fix_a53_err835769", ",", "<NUM_LIT>", ",", "TARGET_FIX_ERR_A53_835769_DEFAULT", ")", ")", "return", "false", ";", "if", "(", "!", "aarch64_tribools_ok_for_inlining_p", "(", "caller_opts", "->", "x_aarch64_fix_a53_err843419", ",", "callee_opts", "->", "x_aarch64_fix_a53_err843419", ",", "<NUM_LIT>", ",", "TARGET_FIX_ERR_A53_843419", ")", ")", "return", "false", ";", "if", "(", "!", "aarch64_tribools_ok_for_inlining_p", "(", "caller_opts", "->", "x_flag_omit_leaf_frame_pointer", ",", "callee_opts", "->", "x_flag_omit_leaf_frame_pointer", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ "<STR_LIT>" ]

[ "(", "plus", ":", "DI", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "sign_extend", ":", "DI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_rsqrt14_pd", "(", "_", "_", "m256d", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_" ]

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

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

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

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

[ "}" ]

[ "unsigned", "Reg", "=", "ScopedHT", ".", "lookup", "(", "Entry", ")", ".", "second", ";", "assert", "(", "Reg", ")", ";", "return", "Reg", ";" ]

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

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

[ "let", "PrintMethod", "=", "<STR_LIT>", "#", "Reg", "#", "<STR_LIT>", "#", "Width", "#", "<STR_LIT>", ";" ]

[ "class", "ro_extend", "<", "AsmOperandClass", "ParserClass", ",", "string", "Reg", ",", "int", "Width", ">", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "ParserClass", ";" ]

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

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

[ "Reg", ";" ]

[ "if", "(", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "||", "(", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", ")", "Reg", "=", "<NUM_LIT>", ";", "if", "(", "Reg", ")", "return" ]

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

[ "class", "BaseIntegerToFPUnscaled", "<", "bit", "isUnsigned", ",", "RegisterClass", "srcType", ",", "RegisterClass", "dstType", ",", "ValueType", "dvt", ",", "string", "asm", ",", "SDPatternOperator", "node", ">", ":", "I", "<", "(", "outs", "dstType", ":", "$", "Rd", ")", ",", "(", "ins", "srcType", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "dvt", "dstType", ":", "$", "Rd", ")", ",", "(", "node", "srcType", ":", "$", "Rn", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteFCvt", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "scale", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "switch", "(", "class", ")", "{", "case", "BR_REGS", ":", "if", "(", "BR_REGNO_P", "(", "regno", ")", ")", "return", "GR_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "return", "GR_REGS", ";", "break", ";", "case", "FR_REGS", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "||", "GET_MODE", "(", "x", ")", "==", "HImode", "||", "GET_MODE", "(", "x", ")", "==", "QImode", ")", ")", "return", "GR_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "return", "GR_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "GR_REGS", ";", "break", ";", "case", "PR_REGS", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "return", "GR_REGS", ";", "break", ";", "default", ":", "break", ";", "}", "<FIXE>" ]

[ "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "||", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "regno", "=", "true_regnum", "(", "x", ")", ";", "<BUGS>", "if", "(", "class", "==", "BR_REGS", "&&", "BR_REGNO_P", "(", "regno", ")", ")", "return", "GR_REGS", ";", "if", "(", "class", "==", "BR_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "return", "GR_REGS", ";", "if", "(", "class", "==", "FR_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "||", "GET_MODE", "(", "x", ")", "==", "HImode", "||", "GET_MODE", "(", "x", ")", "==", "QImode", ")", ")", "return", "GR_REGS", ";", "if", "(", "class", "==", "FR_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "return", "GR_REGS", ";", "if", "(", "class", "==", "PR_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "return", "GR_REGS", ";", "<BUGE>", "return", "NO_REGS", ";", "}" ]

[ "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__enable_execute_stack", "<STR_LIT>", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "XEXP", "(", "m_tramp", ",", "<NUM_LIT>", ")", ",", "Pmode", ")", ";" ]

[ "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "<NUM_LIT>", ")", ",", "fnaddr", ")", ";", "emit_insn", "(", "gen_flush", "(", "DImode", ",", "validize_mem", "(", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "if", "(", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC", "&&", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC3", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA2", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA3", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA4", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA7", "&&", "sparc_cpu", "!=", "PROCESSOR_M8", ")", "emit_insn", "(", "gen_flush", "(", "DImode", ",", "validize_mem", "(", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "<NUM_LIT>", ")", ")", ")", ")", ";" ]

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

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

[ "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup210", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup210", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "}", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup210", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup210", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup210", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup210", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "(", "VEXvml_v", "v256f64", ":", "$", "vz", ",", "v256i1", ":", "$", "vm", ",", "i32", ":", "$", "vl", ",", "v256f64", ":", "$", "pt", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vex_vvmvl", "v256f64", ":", "$", "vz", ",", "v256i1", ":", "$", "vm", ",", "v256f64", ":", "$", "pt", ",", "i32", ":", "$", "vl", ")", "," ]

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

[ "return", "_", "_", "builtin_ia32_divph256_mask", "(", "_", "_", "B", ",", "_", "_", "C", ",", "_", "mm256_setzero_ph" ]

[ "}" ]

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

[ "<FIXS>", "IV", ",", "(", "ForceSwaitcnt", "[", "VM_CNT", "]", ">", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "CntVal", "[", "VM_CNT", "]", ",", "(", "ForceSwaitcnt", "[", "EXP_CNT", "]", ">", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "CntVal", "[", "EXP_CNT", "]", ",", "(", "ForceSwaitcnt", "[", "LGKM_CNT", "]", ">", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "CntVal", "[", "LGKM_CNT", "]", ")", ")", ";", "<FIXE>" ]

[ "CompilerGeneratedWaitcntSet", ".", "insert", "(", "SWaitInst", ")", ";", "}", "const", "MachineOperand", "&", "Op", "=", "MachineOperand", "::", "CreateImm", "(", "AMDGPU", "::", "encodeWaitcnt", "(", "<BUGS>", "IV", ",", "CntVal", "[", "VM_CNT", "]", ",", "CntVal", "[", "EXP_CNT", "]", ",", "CntVal", "[", "LGKM_CNT", "]", ")", ")", ";", "<BUGE>", "SWaitInst", "->", "addOperand", "(", "MF", ",", "Op", ")", ";", "if", "(", "CntVal", "[", "EXP_CNT", "]", "==", "<NUM_LIT>", ")", "{", "ScoreBrackets", "->", "setMixedExpTypes", "(", "false", ")", ";", "}" ]

[ "<FIXS>", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "<FIXE>" ]

[ "voidneon_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "<BUGS>", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "enum", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "<BUGE>", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_var", "=", "<NUM_LIT>", ",", "one_var", "=", "-", "<NUM_LIT>", ";", "bool", "all_same", "=", "true", ";" ]

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

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

[ "Value", "*", "Args", "[", "]", "=", "{", "FunctionName", ",", "ConstantInt", "::", "get", "(", "I16", ",", "F", ".", "arg_size", "(", ")", ")", "}", ";" ]

[ "Constant", "*", "Fn", "=", "F", ".", "getParent", "(", ")", "->", "getOrInsertFunction", "(", "SymName", ",", "FnType", ")", ";", "Value", "*", "FunctionName", "=", "CreateStringPtr", "(", "BB", ",", "F", ".", "getName", "(", ")", ")", ";" ]

[ "}" ]

[ "def", "v2i32_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V64", ",", "V128", ",", "VectorIndexS", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v2i64", "V128", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "v2i32", "V64", ":", "$", "Rn", ")", ",", "(", "v2i32", "(", "ARM64duplane32", "(", "v4i32", "V128", ":", "$", "Rm", ")", ",", "VectorIndexS", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";" ]

[ "if", "(", "isThumb2", ")", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "NewDestReg", ")", ".", "addReg", "(", "DestReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "const", "TargetRegisterClass", "*", "RC", "=", "isThumb2", "?", "&", "ARM", "::", "rGPRRegClass", ":", "&", "ARM", "::", "GPRRegClass", ";", "unsigned", "DestReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "GlobalVariable", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "bool", "IsThreadLocal", "=", "GVar", "&&", "GVar", "->", "isThreadLocal", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "isTargetMachO", "(", ")", "&&", "IsThreadLocal", ")", "return", "<NUM_LIT>", ";", "bool", "IsPositionIndependent", "=", "isPositionIndependent", "(", ")", ";", "if", "(", "Subtarget", "->", "useMovt", "(", "*", "FuncInfo", ".", "MF", ")", "&&", "(", "Subtarget", "->", "isTargetMachO", "(", ")", "||", "!", "IsPositionIndependent", ")", ")", "{", "unsigned", "Opc", ";", "unsigned", "char", "TF", "=", "<NUM_LIT>", ";", "if", "(", "Subtarget", "->", "isTargetMachO", "(", ")", ")", "TF", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "IsPositionIndependent", ")", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2MOV_ga_pcrel", ":", "ARM", "::", "MOV_ga_pcrel", ";", "else", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2MOVi32imm", ":", "ARM", "::", "MOVi32imm", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addGlobalAddress", "(", "GV", ",", "<NUM_LIT>", ",", "TF", ")", ")", ";", "}", "else", "{", "unsigned", "Align", "=", "DL", ".", "getPrefTypeAlignment", "(", "GV", "->", "getType", "(", ")", ")", ";", "if", "(", "Align", "==", "<NUM_LIT>", ")", "{", "Align", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", ")", ";", "}", "if", "(", "Subtarget", "->", "isTargetELF", "(", ")", "&&", "IsPositionIndependent", ")", "return", "ARMLowerPICELF", "(", "GV", ",", "Align", ",", "VT", ")", ";", "unsigned", "PCAdj", "=", "IsPositionIndependent", "?", "(", "Subtarget", "->", "isThumb", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ":", "<NUM_LIT>", ";", "unsigned", "Id", "=", "AFI", "->", "createPICLabelUId", "(", ")", ";", "ARMConstantPoolValue", "*", "CPV", "=", "ARMConstantPoolConstant", "::", "Create", "(", "GV", ",", "Id", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "PCAdj", ")", ";", "unsigned", "Idx", "=", "MCP", ".", "getConstantPoolIndex", "(", "CPV", ",", "Align", ")", ";", "MachineInstrBuilder", "MIB", ";", "if", "(", "isThumb2", ")", "{", "unsigned", "Opc", "=", "IsPositionIndependent", "?", "ARM", "::", "t2LDRpci_pic", ":", "ARM", "::", "t2LDRpci", ";", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "if", "(", "IsPositionIndependent", ")", "MIB", ".", "addImm", "(", "Id", ")", ";", "AddOptionalDefs", "(", "MIB", ")", ";", "}", "else", "{", "DestReg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ",", "DestReg", ",", "<NUM_LIT>", ")", ";", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "AddOptionalDefs", "(", "MIB", ")", ";", "if", "(", "IsPositionIndependent", ")", "{", "unsigned", "Opc", "=", "IsIndirect", "?", "ARM", "::", "PICLDR", ":", "ARM", "::", "PICADD", ";", "unsigned", "NewDestReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ")", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "NewDestReg", ")", ".", "addReg", "(", "DestReg", ")", ".", "addImm", "(", "Id", ")", ";", "AddOptionalDefs", "(", "MIB", ")", ";", "return", "NewDestReg", ";", "}", "}", "}", "if", "(", "IsIndirect", ")", "{", "MachineInstrBuilder", "MIB", ";", "unsigned", "NewDestReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ")", ")", ";" ]

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

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

[ "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "X86MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "<NUM_LIT>", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "void", "msp430_output_labelref", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ")", "{", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "helper_function_name_mappings", "[", "i", "]", ".", "gcc_name", ";", "i", "++", ")", "if", "(", "strcmp", "(", "helper_function_name_mappings", "[", "i", "]", ".", "gcc_name", ",", "name", ")", "==", "<NUM_LIT>", ")", "{", "name", "=", "helper_function_name_mappings", "[", "i", "]", ".", "ti_name", ";", "break", ";", "}", "if", "(", "user_label_prefix", "[", "<NUM_LIT>", "]", "!=", "<NUM_LIT>", ")", "fputs", "(", "user_label_prefix", ",", "file", ")", ";", "fputs", "(", "name", ",", "file", ")", ";", "}" ]

[ "This", "function", "does", "the", "same", "as", "the", "default", ",", "but", "it", "will", "replace", "GCC", "function", "names", "with", "the", "MSPABI-specified", "ones", "." ]

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

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

[ "IC", ".", "Builder", ".", "setFastMathFlags", "(", "II", ".", "getFastMathFlags", "(", ")", ")", ";" ]

[ "if", "(", "II", ".", "isStrictFP", "(", ")", ")", "return", "std", "::", "nullopt", ";", "auto", "*", "OpPredicate", "=", "II", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "auto", "BinOpCode", "=", "intrinsicIDToBinOpCode", "(", "II", ".", "getIntrinsicID", "(", ")", ")", ";", "if", "(", "BinOpCode", "==", "Instruction", "::", "BinaryOpsEnd", "||", "!", "match", "(", "OpPredicate", ",", "m_Intrinsic", "<", "Intrinsic", "::", "aarch64_sve_ptrue", ">", "(", "m_ConstantInt", "<", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", ")", ")", ")", ")", "return", "std", "::", "nullopt", ";", "IRBuilderBase", "::", "FastMathFlagGuard", "FMFGuard", "(", "IC", ".", "Builder", ")", ";" ]

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

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ ")", ";" ]

[ "AlphaTargetMachine", "::", "AlphaTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "DataLayout", "(", "<STR_LIT>", "e-f128:128:128", "<STR_LIT>", ")", ",", "FrameInfo", "(", "TargetFrameInfo", "::", "StackGrowsDown", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "JITInfo", "(", "*", "this", ")", ",", "Subtarget", "(", "TT", ",", "FS", ")", ",", "TLInfo", "(", "*", "this", ")", "{", "setRelocationModel", "(", "Reloc", "::", "PIC_" ]

[ ";" ]

[ "def", "L2_ploadrht_zomap", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5ef37dc4", ",", "TypeMAPPING", ">", "{", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>" ]

[ "<FIXS>", "def", "uimm2", ":", "Operand", "GRLenVT", ">", ",", "ImmLeaf", "GRLenVT", ",", "[", "{", "return", "isUInt", "<NUM_LIT>", ">", "(", "Imm", ")", ";", "}", "]", ">", "{", "<FIXE>" ]

[ "let", "ParserMatchClass", "=", "ImmAsmOperand", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "}", "<BUGS>", "def", "uimm2", ":", "Operand", "GRLenVT", ">", "{", "<BUGE>", "let", "ParserMatchClass", "=", "UImmAsmOperand", "<NUM_LIT>", ">", ";", "}" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "class", "Enc_53dca9", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs16", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs16", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rd16", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd16", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<FIXS>", "TREE_UNSIGNED", "(", "num_field", ")", ",", "false_label", ")", ";", "<FIXE>" ]

[ "OPTAB_LIB_WIDEN", ")", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "GE", ",", "const0_rtx", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "num_field", ")", ")", ",", "<BUGS>", "TREE_UNSIGNED", "(", "num_field", ")", ",", "<NUM_LIT>", ",", "false_label", ")", ";", "<BUGE>", "inreg", "=", "fold", "(", "build", "(", "MULT_EXPR", ",", "integer_type_node", ",", "num_field", ",", "build_int_2", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";" ]

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

[ "class", "InstRIS", "<", "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>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "I2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";" ]

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

[ "if", "(", "Stage", "==", "InitialSchedule", "&&", "S", ".", "HasClusteredNodes", ")", "RegionsWithClusters", "[", "RegionIdx", "]", "=", "true", ";", "if", "(", "S", ".", "HasExcessPressure", ")", "RegionsWithHighRP", "[", "RegionIdx", "]", "=", "true", ";", "if", "(", "!", "LIS", ")", "return", ";", "auto", "PressureAfter", "=", "getRealRegPressure", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Pressure after scheduling: ", "<STR_LIT>", ";", "PressureAfter", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "if", "(", "PressureAfter", ".", "getSGPRNum", "(", ")", "<=", "S", ".", "SGPRCriticalLimit", "&&", "PressureAfter", ".", "getVGPRNum", "(", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "<=", "S", ".", "VGPRCriticalLimit", ")", "{", "Pressure", "[", "RegionIdx", "]", "=", "PressureAfter", ";", "RegionsWithMinOcc", "[", "RegionIdx", "]", "=", "PressureAfter", ".", "getOccupancy", "(", "ST", ")", "==", "MinOccupancy", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Pressure in desired limits, done.\\n", "<STR_LIT>", ")", ";", "return", ";", "}", "unsigned", "WavesAfter", "=", "std", "::", "min", "(", "S", ".", "TargetOccupancy", ",", "PressureAfter", ".", "getOccupancy", "(", "ST", ")", ")", ";", "unsigned", "WavesBefore", "=", "std", "::", "min", "(", "S", ".", "TargetOccupancy", ",", "PressureBefore", ".", "getOccupancy", "(", "ST", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Occupancy before scheduling: ", "<STR_LIT>", "<<", "WavesBefore", "<<", "<STR_LIT>", ", after ", "<STR_LIT>", "<<", "WavesAfter", "<<", "<STR_LIT>", ".\\n", "<STR_LIT>", ")", ";", "unsigned", "NewOccupancy", "=", "std", "::", "max", "(", "WavesAfter", ",", "WavesBefore", ")", ";", "if", "(", "WavesAfter", "<", "WavesBefore", "&&", "WavesAfter", "<", "MinOccupancy", "&&", "WavesAfter", ">=", "MFI", ".", "getMinAllowedOccupancy", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Function is memory bound, allow occupancy drop up to ", "<STR_LIT>", "<<", "MFI", ".", "getMinAllowedOccupancy", "(", ")", "<<", "<STR_LIT>", " waves\\n", "<STR_LIT>", ")", ";", "NewOccupancy", "=", "WavesAfter", ";", "}", "if", "(", "NewOccupancy", "<", "MinOccupancy", ")", "{", "MinOccupancy", "=", "NewOccupancy", ";", "MFI", ".", "limitOccupancy", "(", "MinOccupancy", ")", ";", "RegionsWithMinOcc", ".", "reset", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Occupancy lowered for the function to ", "<STR_LIT>", "<<", "MinOccupancy", "<<", "<STR_LIT>", ".\\n", "<STR_LIT>", ")", ";", "}", "unsigned", "MaxVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "MaxSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "if", "(", "PressureAfter", ".", "getVGPRNum", "(", "false", ")", ">", "MaxVGPRs", "||", "PressureAfter", ".", "getAGPRNum", "(", ")", ">", "MaxVGPRs", "||", "PressureAfter", ".", "getSGPRNum", "(", ")", ">", "MaxSGPRs", ")", "{", "RescheduleRegions", "[", "RegionIdx", "]", "=", "true", ";", "RegionsWithHighRP", "[", "RegionIdx", "]", "=", "true", ";", "}", "if", "(", "WavesAfter", ">=", "MinOccupancy", ")", "{", "if", "(", "Stage", "==", "UnclusteredReschedule", "&&", "!", "PressureAfter", ".", "less", "(", "ST", ",", "PressureBefore", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Unclustered reschedule did not help.\\n", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "WavesAfter", ">", "MFI", ".", "getMinWavesPerEU", "(", ")", "||", "PressureAfter", ".", "less", "(", "ST", ",", "PressureBefore", ")", "||", "!", "RescheduleRegions", "[", "RegionIdx", "]", ")", "{", "Pressure", "[", "RegionIdx", "]", "=", "PressureAfter", ";", "RegionsWithMinOcc", "[", "RegionIdx", "]", "=", "PressureAfter", ".", "getOccupancy", "(", "ST", ")", "==", "MinOccupancy", ";", "if", "(", "!", "RegionsWithClusters", "[", "RegionIdx", "]", "&&", "(", "Stage", "+", "<NUM_LIT>", ")", "==", "UnclusteredReschedule", ")", "RescheduleRegions", "[", "RegionIdx", "]", "=", "false", ";", "return", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "New pressure will result in more spilling.\\n", "<STR_LIT>", ")", ";", "}", "}", "RegionsWithMinOcc", "[", "RegionIdx", "]", "=", "PressureBefore", ".", "getOccupancy", "(", "ST", ")", "==", "MinOccupancy", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Attempting to revert scheduling.\\n", "<STR_LIT>", ")", ";", "RescheduleRegions", "[", "RegionIdx", "]", "=", "RegionsWithClusters", "[", "RegionIdx", "]", "||", "(", "Stage", "+", "<NUM_LIT>", ")", "!=", "UnclusteredReschedule", ";", "RegionEnd", "=", "RegionBegin", ";" ]

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

[ "if", "(", "MaskScalarSizeInBits", "==", "<NUM_LIT>", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "RepeatedMask", ";", "if", "(", "is128BitLaneRepeatedShuffleMask", "(", "MaskEltVT", ",", "Mask", ",", "RepeatedMask", ")", ")", "{", "ArrayRef", "<", "int", ">", "LoMask", "(", "Mask", ".", "data", "(", ")", "+", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "ArrayRef", "<", "int", ">", "HiMask", "(", "Mask", ".", "data", "(", ")", "+", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "isUndefOrInRange", "(", "LoMask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "&&", "isSequentialOrUndefInRange", "(", "HiMask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "ShuffleVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i16", ",", "InputSizeInBits", "/", "<NUM_LIT>", ")", ";", "PermuteImm", "=", "getV4X86ShuffleImm", "(", "LoMask", ")", ";", "return", "true", ";", "}", "if", "(", "isUndefOrInRange", "(", "HiMask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "&&", "isSequentialOrUndefInRange", "(", "LoMask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "int", "OffsetHiMask", "[", "<NUM_LIT>", "]", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", ";", "++", "i", ")", "OffsetHiMask", "[", "i", "]", "=", "(", "HiMask", "[", "i", "]", "<", "<NUM_LIT>", "?", "HiMask", "[", "i", "]", ":", "HiMask", "[", "i", "]", "-", "<NUM_LIT>", ")", ";", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "ShuffleVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i16", ",", "InputSizeInBits", "/", "<NUM_LIT>", ")", ";", "PermuteImm", "=", "getV4X86ShuffleImm", "(", "OffsetHiMask", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "return", "false", ";", "}", "if", "(", "MaskScalarSizeInBits", "!=", "<NUM_LIT>", "&&", "MaskScalarSizeInBits", "!=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "FloatDomain", "&&", "!", "Subtarget", ".", "hasAVX", "(", ")", ")", "return", "false", ";", "if", "(", "MaskVT", ".", "is256BitVector", "(", ")", "&&", "!", "Subtarget", ".", "hasAVX2", "(", ")", ")", "FloatDomain", "=", "true", ";", "if", "(", "is128BitLaneCrossingShuffleMask", "(", "MaskEltVT", ",", "Mask", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "MaskVT", ".", "is256BitVector", "(", ")", "&&", "Mask", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "ShuffleVT", "=", "(", "FloatDomain", "?", "MVT", "::", "v4f64", ":", "MVT", "::", "v4i64", ")", ";", "PermuteImm", "=", "getV4X86ShuffleImm", "(", "Mask", ")", ";", "return", "true", ";", "}", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "MaskVT", ".", "is512BitVector", "(", ")", "&&", "Mask", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "RepeatedMask", ";", "if", "(", "is256BitLaneRepeatedShuffleMask", "(", "MVT", "::", "v8f64", ",", "Mask", ",", "RepeatedMask", ")", ")", "{", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "ShuffleVT", "=", "(", "FloatDomain", "?", "MVT", "::", "v8f64", ":", "MVT", "::", "v8i64", ")", ";", "PermuteImm", "=", "getV4X86ShuffleImm", "(", "RepeatedMask", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "if", "(", "FloatDomain", "&&", "MaskScalarSizeInBits", "==", "<NUM_LIT>", ")", "{", "Shuffle", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "ShuffleVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "f64", ",", "Mask", ".", "size", "(", ")", ")", ";", "PermuteImm", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "Mask", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "M", "=", "Mask", "[", "i", "]", ";", "if", "(", "M", "==", "SM_SentinelUndef" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=" ]

[ "}" ]

[ "void", "X86AvoidSFBPass", "::", "findPotentiallylBlockedCopies", "(", "MachineFunction", "&", "MF", ")", "{", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isPotentialBlockedMemCpyLd", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "int", "DefVR", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "MRI", "->", "hasOneUse", "(", "DefVR", ")", ")", "continue", ";", "for", "(", "auto", "UI", "=", "MRI", "->", "use_nodbg_begin", "(", "DefVR", ")", ",", "UE", "=", "MRI", "->", "use_nodbg_end", "(", ")", ";", "UI", "!=", "UE", ";", ")", "{", "MachineOperand", "&", "StoreMO", "=", "*", "UI", "++", ";", "MachineInstr", "&", "StoreMI", "=", "*", "StoreMO", ".", "getParent", "(", ")", ";", "if", "(", "StoreMI", ".", "getParent", "(", ")", "==", "MI", ".", "getParent", "(", ")", "&&", "isPotentialBlockedMemCpyPair", "(", "MI", ".", "getOpcode", "(", ")", ",", "StoreMI", ".", "getOpcode", "(", ")", ")", "&&", "isRelevantAddressingMode", "(", "&", "MI", ")", "&&", "isRelevantAddressingMode", "(", "&", "StoreMI", ")", ")", "{", "assert", "(", "MI", ".", "hasOneMemOperand", "(", ")", "&&", "<STR_LIT>", "Expected one memory operand for load instruction", "<STR_LIT>", ")", ";", "assert", "(", "StoreMI", ".", "hasOneMemOperand", "(", ")", "&&", "<STR_LIT>", "Expected one memory operand for store instruction", "<STR_LIT>", ")", ";", "if", "(", "!", "alias", "(", "*", "*", "MI", ".", "memoperands_begin", "(", ")", ",", "*", "*", "StoreMI", ".", "memoperands_begin", "(", ")", ")", ")", "BlockedLoadsStoresPairs", ".", "push_back", "(", "std", "::", "make_pair", "(", "&", "MI", ",", "&", "StoreMI", ")", ")", ";" ]

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

[ "static", "_", "_", "inline", "vec_double2", "spu_nand", "(", "vec_double2", "a", ",", "vec_double2", "b", ")", "{", "return", "(", "(", "vec_double2", ")", "(", "si_nand", "(", "(", "qword", ")", "(", "a", ")", ",", "(", "qword" ]

[ "}" ]

[ "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "<NUM_LIT>", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "case", "<NUM_LIT>", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "<NUM_LIT>", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", "->", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "<NUM_LIT>", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "return", ";", "}", "if", "(", "(", "Node", "->", "hasNUsesOfValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "isMachineOpcode", "(", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "EXTRACT_SUBREG", "&&", "!", "Node", "->", "use_begin", "(", ")", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", ")", ")", "{", "unsigned", "Def", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "Def", ")", ";" ]

[ "<FIXS>", "rtx", "l", "=", "gen_reg_rtx", "(", "V4HImode", ")", "rtx", "h", "=", "gen_reg_rtx", "(", "V4HImode", ")", "emit_insn", "(", "gen_mulv4hi3", "(", "l", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_insn", "(", "gen_pmpyshr2_u", "(", "h", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", "ia64_unpack_assemble", "(", "operands", "[", "<NUM_LIT>", "]", ",", "l", ",", "h", ",", "true", ")", "<FIXE>" ]

[ "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "<BUGS>", "ia64_expand_widen_mul_v4hi", "(", "operands", ",", "true", ",", "true", ")", "<BUGE>", "DONE", "}", ")" ]

[ "<FIXS>", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unknown branch operand.", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "raw_ostream", "&", "O", ")", "const", "{", "<BUGS>", "assert", "(", "<STR_LIT>", "Unknown branch operand.", "<STR_LIT>", ")", ";", "<BUGE>", "}", "void", "HexagonInstPrinter", "::", "printCallOperand", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", "," ]

[ ";" ]

[ "if", "(", "max_skip", "<=", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "rx_cpu_type", "==", "RX100", "||", "rx_cpu_type", "==", "RX200", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "<NUM_LIT>", ";" ]

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

[ "<STR_LIT>", ")" ]

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