Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "if", "(", "SDValue", "Res", "=", "LowerDIVREM24", "(", "Op", ",", "DAG", ",", "false", ")", ")", "return", "Res", ";", "<FIXE>" ]

[ "return", "DAG", ".", "getMergeValues", "(", "Results", ",", "DL", ")", ";", "}", "<BUGS>", "SDValue", "Num", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Den", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "<BUGE>", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "{", "<BUGS>", "if", "(", "DAG", ".", "MaskedValueIsZero", "(", "Num", ",", "APInt", "::", "getHighBitsSet", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "&&", "DAG", ".", "MaskedValueIsZero", "(", "Den", ",", "APInt", "::", "getHighBitsSet", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", "{", "return", "LowerDIVREM24", "(", "Op", ",", "DAG", ",", "false", ")", ";", "}", "<BUGE>", "}", "SDValue", "RCP", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Den", ")", ";" ]

[ "return", "expandCopyACC", "(", "MBB", ",", "I", ",", "Opcodes", ".", "first", ",", "Opcodes", ".", "second", ")", ";" ]

[ "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Opcodes", "=", "getMFHiLoOpc", "(", "Src", ")", ";", "if", "(", "!", "Opcodes", ".", "first", ")", "return", "false", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "XB", ";", "let", "Pattern", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XT", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "DCMX", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "}" ]

[ "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "unsigned", "Reg", "=", "IntRegDecoderTable", "[", "RegNo", "]", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Reg", ")", ")", ";", "return", "MCDisassembler", "::", "Success", ";" ]

[ "}" ]

[ "bool", "hasSwiftAsyncContext", "(", ")", "const", "{", "return", "HasSwiftAsyncContext", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "SrcC", "=", "op3", ";", "let", "SrcD", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "hasSrcC", "=", "<NUM_LIT>", ";", "let", "hasSrcD", "=", "<NUM_LIT>", ";", "bit", "HasImm", "=", "!", "isa", "<", "Operand", ">", "(", "Src1", ")", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";", "let", "OperandType", "=", "optype", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred" ]

[ "<FIXS>", "return", "avr_out_plus", "(", "insn", ",", "operands", ")", "<FIXE>", "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "(", "clobber", "(", "match_scratch", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "<BUGS>", "return", "avr_out_minus", "(", "operands", ",", "NULL", ",", "NULL", ")", "<BUGE>", "}", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "baseRegNo", "=", "insn", ".", "hasAdSize", "?", "X86", "::", "EDI", ":", "X86", "::", "RDI", ";", "<FIXE>", "<FIXS>", "baseRegNo", "=", "insn", ".", "hasAdSize", "?", "X86", "::", "DI", ":", "X86", "::", "EDI", ";", "<FIXE>", "<FIXS>", "baseRegNo", "=", "insn", ".", "hasAdSize", "?", "X86", "::", "EDI", ":", "X86", "::", "DI", ";", "<FIXE>" ]

[ "unsigned", "baseRegNo", ";", "if", "(", "insn", ".", "mode", "==", "MODE_64BIT", ")", "<BUGS>", "baseRegNo", "=", "insn", ".", "prefixPresent", "[", "<NUM_LIT>", "]", "?", "X86", "::", "EDI", ":", "X86", "::", "RDI", ";", "<BUGE>", "else", "if", "(", "insn", ".", "mode", "==", "MODE_32BIT", ")", "<BUGS>", "baseRegNo", "=", "insn", ".", "prefixPresent", "[", "<NUM_LIT>", "]", "?", "X86", "::", "DI", ":", "X86", "::", "EDI", ";", "<BUGE>", "else", "{", "assert", "(", "insn", ".", "mode", "==", "MODE_16BIT", ")", ";", "<BUGS>", "baseRegNo", "=", "insn", ".", "prefixPresent", "[", "<NUM_LIT>", "]", "?", "X86", "::", "EDI", ":", "X86", "::", "DI", ";", "<BUGE>", "}", "MCOperand", "baseReg", "=", "MCOperand", "::", "createReg", "(", "baseRegNo", ")", ";", "mcInst", ".", "addOperand", "(", "baseReg", ")", ";" ]

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

[ "def", ":", "InstAlias", "<", "<STR_LIT>", "#", "<STR_LIT>", ",", "(", "FACGTv2f32", "V64", ":", "$", "dst", ",", "V64", ":", "$", "src2", ",", "V64", ":", "$" ]

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

[ "class", "TPCInstVectorNoTypeGen1", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ">", ":", "VectorInstBase", "<", "opc", ",", "asmstr", ">", "{", "bits", "<", "<NUM_LIT>", ">", "RoundMode", "=", "<NUM_LIT>", ";" ]

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

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

[ "<STR_LIT>", ",", "<STR_LIT>", "__trunctfsf2", "<STR_LIT>", ",", "<STR_LIT>", "__unordtf2", "<STR_LIT>", ",", "<STR_LIT>", "ceill", "<STR_LIT>", ",", "<STR_LIT>", "copysignl", "<STR_LIT>", ",", "<STR_LIT>", "cosl", "<STR_LIT>", ",", "<STR_LIT>", "exp2l", "<STR_LIT>", ",", "<STR_LIT>", "expl", "<STR_LIT>", ",", "<STR_LIT>", "floorl", "<STR_LIT>", ",", "<STR_LIT>", "fmal", "<STR_LIT>", ",", "<STR_LIT>", "fmaxl", "<STR_LIT>", ",", "<STR_LIT>", "fmodl", "<STR_LIT>", ",", "<STR_LIT>", "log10l", "<STR_LIT>", ",", "<STR_LIT>", "log2l", "<STR_LIT>", ",", "<STR_LIT>", "logl", "<STR_LIT>", ",", "<STR_LIT>", "nearbyintl", "<STR_LIT>", ",", "<STR_LIT>", "powl", "<STR_LIT>", ",", "<STR_LIT>", "rintl", "<STR_LIT>", ",", "<STR_LIT>", "roundl", "<STR_LIT>", ",", "<STR_LIT>", "sinl", "<STR_LIT>", ",", "<STR_LIT>", "sqrtl", "<STR_LIT>", ",", "<STR_LIT>", "truncl", "<STR_LIT>", "}", ";" ]

[ "static", "bool", "isF128SoftLibCall", "(", "const", "char", "*", "CallSym", ")", "{", "const", "char", "*", "const", "LibCalls", "[", "]", "=", "{", "<STR_LIT>", "__addtf3", "<STR_LIT>", ",", "<STR_LIT>", "__divtf3", "<STR_LIT>", ",", "<STR_LIT>", "__eqtf2", "<STR_LIT>", ",", "<STR_LIT>", "__extenddftf2", "<STR_LIT>", ",", "<STR_LIT>", "__extendsftf2", "<STR_LIT>", ",", "<STR_LIT>", "__fixtfdi", "<STR_LIT>", ",", "<STR_LIT>", "__fixtfsi", "<STR_LIT>", ",", "<STR_LIT>", "__fixtfti", "<STR_LIT>", ",", "<STR_LIT>", "__fixunstfdi", "<STR_LIT>", ",", "<STR_LIT>", "__fixunstfsi", "<STR_LIT>", ",", "<STR_LIT>", "__fixunstfti", "<STR_LIT>", ",", "<STR_LIT>", "__floatditf", "<STR_LIT>", ",", "<STR_LIT>", "__floatsitf", "<STR_LIT>", ",", "<STR_LIT>", "__floattitf", "<STR_LIT>", ",", "<STR_LIT>", "__floatunditf", "<STR_LIT>", ",", "<STR_LIT>", "__floatunsitf", "<STR_LIT>", ",", "<STR_LIT>", "__floatuntitf", "<STR_LIT>", ",", "<STR_LIT>", "__getf2", "<STR_LIT>", ",", "<STR_LIT>", "__gttf2", "<STR_LIT>", ",", "<STR_LIT>", "__letf2", "<STR_LIT>", ",", "<STR_LIT>", "__lttf2", "<STR_LIT>", ",", "<STR_LIT>", "__multf3", "<STR_LIT>", ",", "<STR_LIT>", "__netf2", "<STR_LIT>", ",", "<STR_LIT>", "__powitf2", "<STR_LIT>", ",", "<STR_LIT>", "__subtf3", "<STR_LIT>", ",", "<STR_LIT>", "__trunctfdf2" ]

[ ")", "_", "mm256_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_cvtuqq2ps512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf" ]

[ "static", "void", "ix86_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ",", "const", "bool", "int_registers_saved", ")", "{", "if", "(", "size", "<=", "<NUM_LIT>", "*", "get_probe_interval", "(", ")", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "get_probe_interval", "(", ")", ";", "i", "<", "size", ";", "i", "+=", "get_probe_interval", "(", ")", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "gcc_assert", "(", "int_registers_saved", ")", ";", "HOST_WIDE_INT", "rounded_size", ",", "last", ";", "struct", "scratch_reg", "sr", ";", "get_scratch_register_on_entry", "(", "&", "sr", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "get_probe_interval", "(", ")", ")", ";", "emit_move_insn", "(", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "first", ")", ")", ";", "last", "=", "first", "+", "rounded_size", ";", "emit_insn", "(", "ix86_gen_probe_stack_range", "(", "sr", ".", "reg", ",", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "last", ")", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sr", ".", "reg", ")", ",", "rounded_size", "-", "size", ")", ")", ";", "release_scratch_register_on_entry", "(", "&", "sr", ",", "size", ",", "true", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

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

[ "}", "<BUGS>", "#", "endif", "<BUGE>" ]

[ "IfEntry", "->", "erase", "(", "TI", ")", ";" ]

[ "MachineFunction", "*", "MF", "=", "IfEntry", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "IfEntry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "Branch", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_NON_UNIFORM_BRCOND_PSEUDO", ")", "{", "unsigned", "DstReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstr", "*", "SIIF", "=", "BuildMI", "(", "*", "MF", ",", "Branch", "->", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "SI_IF", ")", ",", "DstReg", ")", ".", "add", "(", "Branch", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "Branch", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MachineInstr", "*", "SIEND", "=", "BuildMI", "(", "*", "MF", ",", "Branch", "->", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "SI_END_CF", ")", ")", ".", "addReg", "(", "DstReg", ")", ";" ]

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

[ "def", "VLD1q64LowQPseudo_UPD", ":", "VLDQQQQWBPseudo", "<", "IIC_VLD1x4", ">", ",", "Sched", "<", "[", "WriteVLD4" ]

[ "}" ]

[ "if", "(", "Desc", ".", "getSize", "(", ")", "==", "<NUM_LIT>", ")", "{", "EmitConstant", "(", "Binary", "&", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "OS", ")", ";", "EmitConstant", "(", "Binary", ">>", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "OS", ")", ";", "}", "else", "EmitConstant", "(", "Binary", ",", "<NUM_LIT>", ",", "OS", ")", ";", "++", "MCNumEmitted", ";" ]

[ "void", "X86TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "assert", "(", "(", "Opc", ">=", "ISD", "::", "BUILTIN_OP_END", "||", "Opc", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_W_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_VOID", ")", "&&", "<STR_LIT>", "Should use MaskedValueIsZero if you don't know whether Op", "<STR_LIT>", "<STR_LIT>", " is a target node!", "<STR_LIT>", ")", ";", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Known", ".", "Zero", ".", "setBitsFrom", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "unsigned", "NumLoBits", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "Known", ".", "Zero", ".", "setBitsFrom", "(", "NumLoBits", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "SrcVT", "=", "Src", ".", "getValueType", "(", ")", ";", "APInt", "DemandedElt", "=", "APInt", "::", "getOneBitSet", "(", "SrcVT", ".", "getVectorNumElements", "(", ")", ",", "Op", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ")", ";", "DAG", ".", "computeKnownBits", "(", "Src", ",", "Known", ",", "DemandedElt", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "Known", "=", "Known", ".", "zextOrTrunc", "(", "BitWidth", ")", ";", "Known", ".", "Zero", ".", "setBitsFrom", "(", "SrcVT", ".", "getScalarSizeInBits", "(", ")", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "if", "(", "auto", "*", "ShiftImm", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "ShiftImm", "->", "getAPIntValue", "(", ")", ".", "uge", "(", "VT", ".", "getScalarSizeInBits", "(", ")", ")", ")", "{", "Known", ".", "setAllZero", "(", ")", ";", "break", ";", "}", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Known", ",", "DemandedElts", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "unsigned", "ShAmt", "=", "ShiftImm", "->", "getZExtValue", "(", ")", ";", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "Known", ".", "Zero", "<<=", "ShAmt", ";", "Known", ".", "One", "<<=", "ShAmt", ";", "Known", ".", "Zero", ".", "setLowBits", "(", "ShAmt", ")", ";", "}", "else", "{", "Known", ".", "Zero", ".", "lshrInPlace", "(", "ShAmt", ")", ";", "Known", ".", "One", ".", "lshrInPlace", "(", "ShAmt", ")", ";", "Known", ".", "Zero", ".", "setHighBits", "(", "ShAmt", ")", ";", "}", "}", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "APInt", "DemandedLHS", ",", "DemandedRHS", ";", "getPackDemandedElts", "(", "VT", ",", "DemandedElts", ",", "DemandedLHS", ",", "DemandedRHS", ")", ";", "Known", ".", "One", "=", "APInt", "::", "getAllOnesValue", "(", "BitWidth", "*", "<NUM_LIT>", ")", ";", "Known", ".", "Zero", "=", "APInt", "::", "getAllOnesValue", "(", "BitWidth", "*", "<NUM_LIT>", ")", ";", "KnownBits", "Known2", ";", "if", "(", "!", "!", "DemandedLHS", ")", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Known2", ",", "DemandedLHS", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "Known", ".", "One", "&=", "Known2", ".", "One", ";", "Known", ".", "Zero", "&=", "Known2", ".", "Zero", ";", "}", "if", "(", "!", "!", "DemandedRHS", ")", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Known2", ",", "DemandedRHS", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "Known", ".", "One", "&=", "Known2", ".", "One", ";", "Known", ".", "Zero", "&=", "Known2", ".", "Zero", ";", "}", "if", "(", "Known", ".", "countMinLeadingZeros", "(", ")", "<", "BitWidth", ")", "Known", ".", "resetAll", "(", ")", ";", "Known", "=", "Known", ".", "trunc", "(", "BitWidth", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Known", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "if", "(", "Known", ".", "isUnknown", "(", ")", ")", "break", ";", "KnownBits", "Known2", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Known2", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "Known", ".", "One", "&=", "Known2", ".", "One", ";", "Known", ".", "Zero", "&=", "Known2", ".", "Zero", ";", "break", ";", "}", "}", "if", "(", "isTargetShuffle", "(", "Opc", ")", ")", "{", "bool", "IsUnary", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "if", "(", "getTargetShuffleMask", "(", "Op", ".", "getNode", "(", ")", ",", "VT", ".", "getSimpleVT", "(", ")", ",", "true", ",", "Ops", ",", "Mask", ",", "IsUnary", ")", ")", "{", "unsigned", "NumOps", "=", "Ops", ".", "size", "(", ")", ";", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "Mask", ".", "size", "(", ")", "==", "NumElts", ")", "{", "SmallVector", "<", "APInt", ",", "<NUM_LIT>", ">", "DemandedOps", "(", "NumOps", ",", "APInt", "(", "NumElts", ",", "<NUM_LIT>", ")", ")", ";", "Known", ".", "Zero", ".", "setAllBits", "(", ")", ";", "Known", ".", "One", ".", "setAllBits", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "{", "if", "(", "!", "DemandedElts", "[", "i", "]", ")", "continue", ";", "int", "M", "=", "Mask", "[", "i", "]", ";", "if", "(", "M", "==", "SM_SentinelUndef", ")", "{", "Known", ".", "resetAll", "(", ")", ";", "break", ";", "}", "else", "if", "(", "M", "==", "SM_SentinelZero", ")", "{", "Known", ".", "One", ".", "clearAllBits", "(", ")", ";", "continue", ";", "}", "assert", "(", "<NUM_LIT>", "<=", "M", "&&", "(", "unsigned", ")", "M", "<", "(", "NumOps", "*", "NumElts", ")", "&&", "<STR_LIT>", "Shuffle index out of range", "<STR_LIT>", ")", ";", "unsigned", "OpIdx", "=", "(", "unsigned", ")", "M", "/", "NumElts", ";", "unsigned", "EltIdx", "=", "(", "unsigned", ")", "M", "%", "NumElts", ";", "if", "(", "Ops", "[", "OpIdx", "]", ".", "getValueType", "(", ")", "!=", "VT", ")", "{", "Known", ".", "resetAll", "(", ")", ";", "break", ";", "}", "DemandedOps", "[", "OpIdx", "]", ".", "setBit", "(", "EltIdx", ")", ";", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumOps", "&&", "!", "Known", ".", "isUnknown", "(", ")", ";", "++", "i", ")", "{", "if", "(", "!", "DemandedOps", "[", "i", "]", ")", "continue", ";", "KnownBits", "Known2", ";", "DAG", ".", "computeKnownBits", "(", "Ops", "[", "i", "]", ",", "Known2", ",", "DemandedOps", "[", "i", "]", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "Known", ".", "One", "&=", "Known2", ".", "One", ";", "Known", ".", "Zero", "&=", "Known2", ".", "Zero", ";", "}", "}", "}", "}", "}" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "}" ]

[ "MemOpChains", ".", "push_back", "(", "ArgStore", ")", ";", "}", "}", "const", "ArgDescriptor", "*", "OutgoingArg", ";", "const", "TargetRegisterClass", "*", "ArgRC", ";", "std", "::", "tie", "(", "OutgoingArg", ",", "ArgRC", ")", "=", "CalleeArgInfo", "->", "getPreloadedValue", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "!", "OutgoingArg", ")", "std", "::", "tie", "(", "OutgoingArg", ",", "ArgRC", ")", "=", "CalleeArgInfo", "->", "getPreloadedValue", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "!", "OutgoingArg", ")", "std", "::", "tie", "(", "OutgoingArg", ",", "ArgRC", ")", "=", "CalleeArgInfo", "->", "getPreloadedValue", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "!", "OutgoingArg", ")", "return", ";", "const", "ArgDescriptor", "*", "IncomingArgX", "=", "CallerArgInfo", ".", "getPreloadedValue", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "first", ";", "const", "ArgDescriptor", "*", "IncomingArgY", "=", "CallerArgInfo", ".", "getPreloadedValue", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "first", ";", "const", "ArgDescriptor", "*", "IncomingArgZ", "=", "CallerArgInfo", ".", "getPreloadedValue", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "first", ";", "SDValue", "InputReg", ";", "SDLoc", "SL", ";", "if", "(", "IncomingArgX", "&&", "!", "IncomingArgX", "->", "isMasked", "(", ")", "&&", "CalleeArgInfo", "->", "WorkItemIDX", ")", "InputReg", "=", "loadInputValue", "(", "DAG", ",", "ArgRC", ",", "MVT", "::", "i32", ",", "DL", ",", "*", "IncomingArgX", ")", ";", "if", "(", "IncomingArgY", "&&", "!", "IncomingArgY", "->", "isMasked", "(", ")", "&&", "CalleeArgInfo", "->", "WorkItemIDY", ")", "{", "SDValue", "Y", "=", "loadInputValue", "(", "DAG", ",", "ArgRC", ",", "MVT", "::", "i32", ",", "DL", ",", "*", "IncomingArgY", ")", ";", "Y", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "SL", ",", "MVT", "::", "i32", ",", "Y", ",", "DAG", ".", "getShiftAmountConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ",", "SL", ")", ")", ";", "InputReg", "=", "InputReg", ".", "getNode", "(", ")", "?", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "SL", ",", "MVT", "::", "i32", ",", "InputReg", ",", "Y", ")", ":", "Y", ";", "}", "if", "(", "IncomingArgZ", "&&", "!", "IncomingArgZ", "->", "isMasked", "(", ")", "&&", "CalleeArgInfo", "->", "WorkItemIDZ", ")", "{", "SDValue", "Z", "=", "loadInputValue", "(", "DAG", ",", "ArgRC", ",", "MVT", "::", "i32", ",", "DL", ",", "*", "IncomingArgZ", ")", ";", "Z", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "SL", ",", "MVT", "::", "i32", ",", "Z", ",", "DAG", ".", "getShiftAmountConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ",", "SL", ")", ")", ";", "InputReg", "=", "InputReg", ".", "getNode", "(", ")", "?", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "SL", ",", "MVT", "::", "i32", ",", "InputReg", ",", "Z", ")", ":", "Z", ";", "}", "if", "(", "!", "InputReg", ".", "getNode", "(", ")", ")", "{", "ArgDescriptor", "IncomingArg", "=", "ArgDescriptor", "::", "createArg", "(", "IncomingArgX", "?", "*", "IncomingArgX", ":", "IncomingArgY", "?", "*", "IncomingArgY", ":", "*", "IncomingArgZ", ",", "~", "<NUM_LIT>", "u", ")", ";", "InputReg", "=", "loadInputValue", "(", "DAG", ",", "ArgRC", ",", "MVT", "::", "i32", ",", "DL", ",", "IncomingArg", ")", ";", "}", "if", "(", "OutgoingArg", "->", "isRegister", "(", ")", ")", "{", "RegsToPass", ".", "emplace_back", "(", "OutgoingArg", "->", "getRegister", "(", ")", ",", "InputReg", ")", ";", "CCInfo", ".", "AllocateReg", "(", "OutgoingArg", "->", "getRegister", "(", ")", ")", ";", "}", "else", "{", "unsigned", "SpecialArgOffset", "=", "CCInfo", ".", "AllocateStack", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "SDValue", "ArgStore", "=", "storeStackInputValue", "(", "DAG", ",", "DL", ",", "Chain", ",", "InputReg", ",", "SpecialArgOffset", ")", ";", "MemOpChains", ".", "push_back", "(", "ArgStore", ")", ";" ]

[ ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_lsx_vftint_l_d", "(", "(", "v2f64", ")", "_", "<NUM_LIT>" ]

[ "static", "rtx", "gen_safe_HIGH64", "(", "rtx", "dest", ",", "HOST_WIDE_INT", "val", ")", "{", "return", "gen_rtx_SET", "(", "dest", ",", "GEN_INT", "(", "val", "&", "~", "(", "HOST_WIDE_INT", ")", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "The", "optimizer", "is", "not", "to", "assume", "anything", "about", "exactly", "which", "bits", "are", "set", "for", "a", "HIGH", ",", "they", "are", "unspecified", ".", "Unfortunately", "this", "leads", "to", "many", "missed", "optimizations", "during", "CSE", ".", "We", "mask", "out", "the", "non-HIGH", "bits", ",", "and", "matches", "a", "plain", "movdi", ",", "to", "alleviate", "this", "problem", "." ]

[ "}" ]

[ "bool", "TL45AsmParser", "::", "ParseSymbolReference", "(", "OperandVector", "&", "Operands", ")", "{", "SMLoc", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "StringRef", "Identifier", ";", "if", "(", "Parser", ".", "parseIdentifier", "(", "Identifier", ")", ")", "return", "true", ";", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "MCSymbol", "*", "Sym", "=", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Identifier", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "getContext", "(", ")", ")", ";", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Res", ",", "S", ",", "E", ")", ")", ";", "return", "false", ";" ]

[ "==", "AMDGPU", "::", "V_MFMA_F64_16X16X4F64_mac_vgprcd_e64", ";" ]

[ "static", "bool", "isDGEMM", "(", "unsigned", "Opcode", ")", "{", "return", "Opcode", "==", "AMDGPU", "::", "V_MFMA_F64_4X4X4F64_e64", "||", "Opcode", "==", "AMDGPU", "::", "V_MFMA_F64_4X4X4F64_vgprcd_e64", "||", "Opcode", "==", "AMDGPU", "::", "V_MFMA_F64_16X16X4F64_e64", "||", "Opcode", "==", "AMDGPU", "::", "V_MFMA_F64_16X16X4F64_vgprcd_e64", "||", "Opcode", "==", "AMDGPU", "::", "V_MFMA_F64_16X16X4F64_mac_e64", "||", "Opcode" ]

[ "let", "Switches", "=", "sw", ";" ]

[ "let", "OutOperandList", "=", "!", "if", "(", "isBoth", ",", "(", "outs", "ZRF", ":", "$", "dest", ")", ",", "(", "outs", "SRF", ":", "$", "dest", ")", ")", ";", "let", "InOperandList", "=", "!", "if", "(", "isBoth", ",", "(", "ins", "SRF", ":", "$", "src1", ",", "SRF", ":", "$", "src2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "BothDivModOp", ":", "$", "bothdiv", ",", "ZRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ",", "(", "ins", "SRF", ":", "$", "src1", ",", "SRF", ":", "$", "src2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ")", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "bothdiv", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src1", ";", "let", "SrcB", "=", "src2", ";" ]

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

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")", ")" ]

[ "return", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "VT", ",", "CmpOp0", ",", "CmpOp1", ")", ";" ]

[ "SDValue", "H1", "=", "expandV4F32ToV2F64", "(", "DAG", ",", "<NUM_LIT>", ",", "DL", ",", "CmpOp1", ")", ";", "SDValue", "L1", "=", "expandV4F32ToV2F64", "(", "DAG", ",", "<NUM_LIT>", ",", "DL", ",", "CmpOp1", ")", ";", "SDValue", "HRes", "=", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "MVT", "::", "v2i64", ",", "H0", ",", "H1", ")", ";", "SDValue", "LRes", "=", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "MVT", "::", "v2i64", ",", "L0", ",", "L1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "HRes", ",", "LRes", ")", ";", "}" ]

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

[ "MVT", "SplitVT", "=", "MVT", "::", "getVectorVT", "(", "ScalarVT", ",", "NumElements", "/", "<NUM_LIT>", ")", ";", "SDValue", "LoV1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "SplitVT", ",", "V1", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "HiV1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "SplitVT", ",", "V1", ",", "DAG", ".", "getIntPtrConstant", "(", "SplitNumElements", ")", ")", ";", "SDValue", "LoV2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "SplitVT", ",", "V2", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "HiV2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "SplitVT", ",", "V2", ",", "DAG", ".", "getIntPtrConstant", "(", "SplitNumElements", ")", ")", ";", "auto", "HalfBlend", "=", "[", "&", "]", "(", "ArrayRef", "<", "int", ">", "HalfMask", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "V1BlendMask", ",", "V2BlendMask", ",", "BlendMask", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "SplitNumElements", ";", "++", "i", ")", "{", "int", "M", "=", "HalfMask", "[", "i", "]", ";", "if", "(", "M", ">=", "NumElements", ")", "{", "V2BlendMask", ".", "push_back", "(", "M", "-" ]

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

[ "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "setKillFlags", "(", "MBB", ")", ";", "const", "unsigned", "Mask", "=", "calcLiveInMask", "(", "&", "MBB", ",", "false", ")", ";", "if", "(", "!" ]

[ "<STR_LIT>", ")" ]

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

[ "getNumFixupKinds", "(", ")", "&&", "<STR_LIT>", "Invalid kind!", "<STR_LIT>", ")", ";" ]

[ "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<" ]

[ "if", "(", "CByte", "&&", "CByte", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", "return", "emitMemMemImm", "(", "DAG", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Chain", ",", "Dst", ",", "Dst", ",", "Bytes", ")", ";" ]

[ "if", "(", "auto", "*", "CSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "{", "uint64_t", "Bytes", "=", "CSize", "->", "getZExtValue", "(", ")", ";", "if", "(", "Bytes", "==", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "if", "(", "CByte", ")", "{", "uint64_t", "ByteVal", "=", "CByte", "->", "getZExtValue", "(", ")", ";", "if", "(", "ByteVal", "==", "<NUM_LIT>", "||", "ByteVal", "==", "<NUM_LIT>", "?", "Bytes", "<=", "<NUM_LIT>", "&&", "llvm", "::", "popcount", "(", "Bytes", ")", "<=", "<NUM_LIT>", ":", "Bytes", "<=", "<NUM_LIT>", ")", "{", "unsigned", "Size1", "=", "Bytes", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "llvm", "::", "bit_floor", "(", "Bytes", ")", ";", "unsigned", "Size2", "=", "Bytes", "-", "Size1", ";", "SDValue", "Chain1", "=", "memsetStore", "(", "DAG", ",", "DL", ",", "Chain", ",", "Dst", ",", "ByteVal", ",", "Size1", ",", "Alignment", ",", "DstPtrInfo", ")", ";", "if", "(", "Size2", "==", "<NUM_LIT>", ")", "return", "Chain1", ";", "Dst", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Dst", ",", "DAG", ".", "getConstant", "(", "Size1", ",", "DL", ",", "PtrVT", ")", ")", ";", "DstPtrInfo", "=", "DstPtrInfo", ".", "getWithOffset", "(", "Size1", ")", ";", "SDValue", "Chain2", "=", "memsetStore", "(", "DAG", ",", "DL", ",", "Chain", ",", "Dst", ",", "ByteVal", ",", "Size2", ",", "std", "::", "min", "(", "Alignment", ",", "Align", "(", "Size1", ")", ")", ",", "DstPtrInfo", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain1", ",", "Chain2", ")", ";", "}", "}", "else", "{", "if", "(", "Bytes", "<=", "<NUM_LIT>", ")", "{", "SDValue", "Chain1", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Byte", ",", "Dst", ",", "DstPtrInfo", ",", "Alignment", ")", ";", "if", "(", "Bytes", "==", "<NUM_LIT>", ")", "return", "Chain1", ";", "SDValue", "Dst2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Dst", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "SDValue", "Chain2", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Byte", ",", "Dst2", ",", "DstPtrInfo", ".", "getWithOffset", "(", "<NUM_LIT>", ")", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain1", ",", "Chain2", ")", ";", "}", "}", "assert", "(", "Bytes", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Should have dealt with 0- and 1-byte cases already", "<STR_LIT>", ")", ";" ]

[ "}" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "SuperClasses", "=", "[", "X86Mem16AsmOperand", "]", ";" ]

[ ".", "getOS", "(", ")", ")", ";" ]

[ "return", "new", "ELFVEAsmBackend", "(", "T", ",", "STI", ".", "getTargetTriple", "(", ")" ]

[ "]", ")" ]

[ "(", "define_code_attr", "sve_fp_op", "[", "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "(", "mult", "<STR_LIT>", ")" ]

[ "}" ]

[ "for", "(", "auto", "&", "MO", ":", "BI", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "return", ";", "}", "}", "if", "(", "!", "MI", ")", "return", ";", "MI", "->", "setDesc", "(", "HII", "->", "get", "(", "HII", "->", "getNonDotCurOp", "(", "*", "MI", ")", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Demoted CUR ", "<STR_LIT>", ";", "MI", "->", "dump", "(", ")", ";", ")", ";" ]

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

[ "(", "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>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "(", "define_code_attr", "vis4_addsub_us_patname" ]

[ "(", "define_code_iterator", "vis4_addsub_us", "[", "us_plus", "us_minus", "]", ")", "(", "define_code_attr", "vis4_addsub_us_insn", "[", "(", "us_plus", "<STR_LIT>", ")", "(", "us_minus", "<STR_LIT>", ")", "]", ")" ]

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

[ "static", "rtx", "aapcs_libcall_value", "(", "machine_mode", "mode", ")", "{", "if", "(", "BYTES_BIG_ENDIAN", "&&", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "<NUM_LIT>", ")", "mode", "=", "SImode", ";", "return", "aapcs_allocate_return_reg", "(", "mode", "," ]

[ "}" ]

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

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

[ "def", "ARM64cmgt", ":", "SDNode", "<" ]

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

[ "void", "ARMBaseInstrInfo", "::", "expandLoadStackGuardBase", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "LoadImmOpc", ",", "unsigned", "LoadOpc", ")", "const", "{", "assert", "(", "!", "Subtarget", ".", "isROPI", "(", ")", "&&", "!", "Subtarget", ".", "isRWPI", "(", ")", "&&", "<STR_LIT>", "ROPI/RWPI not currently supported with stack guard", "<STR_LIT>", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "Register", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "GlobalValue", ">", "(", "(", "*", "MI", "->", "memoperands_begin", "(", ")", ")", "->", "getValue", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "LoadImmOpc", ")", ",", "Reg", ")", ".", "addGlobalAddress", "(", "GV", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "Subtarget", ".", "isGVIndirectSymbol", "(", "GV" ]

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

[ "vcagts_f32", "(", "float32_t", "_", "_", "a", ",", "float32_t", "_" ]

[ "void", "WebAssemblyFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "TODO: implement emitPrologue", "<STR_LIT>", ")", ";", "}" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

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

[ "UNSPEC_DPSQ_SA_L_W", ")", ")", "(", "set", "(", "reg", ":", "CCDSP", "CCDSP_OU_REGNUM", ")", "(", "unspec", ":", "CCDSP", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_DPSQ_SA_L_W", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")" ]

[ "}" ]

[ "if", "(", "mips_noreorder", ".", "nesting_level", ">", "<NUM_LIT>", ")", "return", "<STR_LIT>", "else", "return", "<STR_LIT>" ]

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

[ "if", "(", "!", "isSequentialOrUndefInRange", "(", "Mask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", ";", "++", "i", ")", "if", "(", "Mask", "[", "i", "]", ">=", "<NUM_LIT>", "&&", "(", "Mask", "[", "i", "]", "<", "<NUM_LIT>", "||", "Mask", "[", "i", "]", ">", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ ",", "X86", "::", "MOVZX32rr16", ")", ";", "break", ";" ]

[ "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetSymbolFromOperand", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "switch", "(", "OutMI", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "LEA64_32r", ":", "lower_lea64_32mem", "(", "&", "OutMI", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "X86", "::", "MOVZX16rr8", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOVZX32rr8", ")", ";", "break", ";", "case", "X86", "::", "MOVZX16rm8", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOVZX32rm8", ")", ";", "break", ";", "case", "X86", "::", "MOVSX16rr8", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOVSX32rr8", ")", ";", "break", ";", "case", "X86", "::", "MOVSX16rm8", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOVSX32rm8", ")", ";", "break", ";", "case", "X86", "::", "MOVZX64rr32", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOV32rr", ")", ";", "break", ";", "case", "X86", "::", "MOVZX64rm32", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOV32rm", ")", ";", "break", ";", "case", "X86", "::", "MOV64ri64i32", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOV32ri", ")", ";", "break", ";", "case", "X86", "::", "MOVZX64rr8", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOVZX32rr8", ")", ";", "break", ";", "case", "X86", "::", "MOVZX64rm8", ":", "LowerSubReg32_Op0", "(", "OutMI", ",", "X86", "::", "MOVZX32rm8", ")", ";", "break", ";", "case", "X86", "::", "MOVZX64rr16", ":", "LowerSubReg32_Op0", "(", "OutMI" ]

[ "}" ]

[ "int", "First", "=", "BitVector", "::", "find_first", "(", ")", ";", "if", "(", "First", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "return", "x2v", "(", "First", ")", ";" ]

[ "<FIXS>", "def", ":", "InstAlias", "<STR_LIT>", ",", "(", "tBKPT", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ">", ",", "Requires", "[", "IsThumb", "]", ">", ";", "<FIXE>" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "val", ";", "}", "<BUGS>", "def", ":", "InstAlias", "<STR_LIT>", ",", "(", "tBKPT", "<NUM_LIT>", ")", ">", ",", "Requires", "[", "IsThumb", "]", ">", ";", "<BUGE>", "def", "tHLT", ":", "T1I", "(", "outs", ")", ",", "(", "ins", "imm0_63", ":", "$", "val", ")", ",", "NoItinerary", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "T1Encoding", "<NUM_LIT>", ">", ",", "Requires", "[", "IsThumb", ",", "HasV8", "]", ">", "{" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "BI", "(", "not", ":", "BI", "(", "match_operator", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

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

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

[ "<FIXS>", "switch", "(", "ICA", ".", "getID", "(", ")", ")", "{", "case", "Intrinsic", "::", "fma", ":", "<FIXE>" ]

[ "unsigned", "InstRate", "=", "getQuarterRateInstrCost", "(", "CostKind", ")", ";", "<BUGS>", "if", "(", "ICA", ".", "getID", "(", ")", "==", "Intrinsic", "::", "fma", ")", "{", "<BUGE>", "InstRate", "=", "ST", "->", "hasFastFMAF32", "(", ")", "?", "getHalfRateInstrCost", "(", "CostKind", ")", ":", "getQuarterRateInstrCost", "(", "CostKind", ")", ";", "}", "return", "LT", ".", "first", "*", "NElts", "*", "InstRate", ";" ]

[ "}" ]

[ "unsigned", "getStoreRegOpcode", "(", "unsigned", "SrcReg", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "const", "M680x0Subtarget", "&", "STI", ")", "{", "return", "getLoadStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "TRI", ",", "STI", ",", "false", ")", ";" ]

[ "HI", "QI", "]", ")" ]

[ "(", "define_mode_iterator", "HQI", "[" ]

[ "m128d", "_", "_", "A", ")", "{" ]

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

[ "StringRef", "Annot", ")", "{" ]

[ "void", "TLCS900InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", "," ]

[ "}" ]

[ "int64_t", "ShiftAmt", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "MIB", "->", "removeOperand", "(", "<NUM_LIT>", ")", ";", "MIB", ".", "addReg", "(", "MIB", ".", "getReg", "(", "<NUM_LIT>", ")", ",", "getUndefRegState", "(", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isUndef", "(", ")", ")", ")", ";", "MIB", ".", "addImm", "(", "ShiftAmt", ")", ";", "return", "true", ";" ]

[ ">", ";" ]

[ "def", "HWPort4", ":", "ProcResource", "<", "<NUM_LIT>" ]

[ "(", "OpNum", ")", ".", "getImm", "(", ")", ";" ]

[ "O", "<<", "'", "#", "'", "<<", "Scale", "*", "MI", "->", "getOperand" ]

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

[ "class", "BranchUnaryRRE", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "cls", ">", ":", "InstRRE", "<", "opcode", ",", "(", "outs", "cls", ":", "$", "R1", ")", ",", "(", "ins", "cls", ":", "$", "R1src", ",", "GR64", ":", "$", "R2", ")", ",", "mnemonic", "#", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "if", "(", "change_count", "==", "<NUM_LIT>", ")", "return", "true", ";" ]

[ "curr_val", "=", "(", "unsigned", "int", ")", "(", "(", "m", "&", "(", "unsigned", "int", ")", "(", "<NUM_LIT>", "<<", "shift", ")", ")", ">>", "shift", ")", ";", "if", "(", "curr_val", "!=", "prev_val", ")", "change_count", "++", ";", "prev_val", "=", "curr_val", ";", "}" ]

[ "<FIXS>", "&", "aarch64_simd_builtin_data", "[", "fcode", "-", "AARCH64_SIMD_PATTERN_START", "]", ";", "<FIXE>" ]

[ "rtxaarch64_simd_expand_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "aarch64_simd_builtin_datum", "*", "d", "=", "<BUGS>", "&", "aarch64_simd_builtin_data", "[", "fcode", "-", "(", "AARCH64_SIMD_BUILTIN_BASE", "+", "<NUM_LIT>", ")", "]", ";", "<BUGE>", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_simd_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "@", "@", "-", "<NUM_LIT>", ",", "<NUM_LIT>", "+", "<NUM_LIT>", ",", "<NUM_LIT>", "@", "@", "VAR1", "(", "BINOPP", ",", "crypto_pmull", ",", "<NUM_LIT>", ",", "di", ")", "VAR1", "(", "BINOPP", ",", "crypto_pmull", ",", "<NUM_LIT>", ",", "v2di", ")", "<BUGS>", "VAR1", "(", "BINOPV", ",", "im_lane_bound", ",", "<NUM_LIT>", ",", "si", ")", "<BUGE>" ]

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

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

[ ",", "C", ",", "OS", ")", ";" ]

[ "if", "(", "Printer", ")", "Printer", "(", "get_amd_kernel_code_t_FieldName", "(", "FldIndex", ")" ]

[ ";" ]

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

[ "t", ";" ]

[ "static", "inline", "_", "_", "ev64_opaque__", "_", "_", "internal_ev_mwhsmiaaw", "(", "_", "_", "ev64_opaque__", "a", ",", "_", "_", "ev64_opaque__", "b", ")", "{", "_", "_", "ev64_opaque__" ]

[ "RegisterBankInfo", "::", "InstructionMappings", "AMDGPURegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Size", "=", "getSizeInBits", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "*", "TRI", ")", ";", "InstructionMappings", "AltMappings", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_LOAD", ":", "{", "InstructionMapping", "SSMapping", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "getOperandsMapping", "(", "{", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "Size", ")", ",", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "<NUM_LIT>", ")", "}", ")", ",", "<NUM_LIT>", ")", ";", "AltMappings", ".", "emplace_back", "(", "std", "::", "move", "(", "SSMapping", ")", ")", ";", "InstructionMapping", "VVMapping", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "getOperandsMapping", "(", "{", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "Size", ")", ",", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "<NUM_LIT>", ")", "}", ")", ",", "<NUM_LIT>", ")", ";", "AltMappings", ".", "emplace_back", "(", "std", "::", "move", "(", "VVMapping", ")", ")", ";", "InstructionMapping", "VSMapping", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "getOperandsMapping", "(", "{", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "Size", ")", ",", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "<NUM_LIT>", ")", "}", ")", ",", "<NUM_LIT>", ")", ";", "AltMappings", ".", "emplace_back", "(", "std", "::", "move", "(", "VSMapping", ")", ")", ";", "return", "AltMappings", ";", "}", "default", ":", "break", ";", "}", "return", "RegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "MI", ")", ";", "}" ]

[ "Get", "the", "alternative", "mappings", "for", "MI", "." ]

[ "MachineBasicBlock", "*", "MipsTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected instr type to insert", "<STR_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I8", ":", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I8_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "ADDu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I16", ":", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I16_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "ADDu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I32", ":", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I32_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "ADDu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I64", ":", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I64_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "DADDu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_AND_I8", ":", "case", "Mips", "::", "ATOMIC_LOAD_AND_I8_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "AND", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_AND_I16", ":", "case", "Mips", "::", "ATOMIC_LOAD_AND_I16_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "AND", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_AND_I32", ":", "case", "Mips", "::", "ATOMIC_LOAD_AND_I32_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "AND", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_AND_I64", ":", "case", "Mips", "::", "ATOMIC_LOAD_AND_I64_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "AND64", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_OR_I8", ":", "case", "Mips", "::", "ATOMIC_LOAD_OR_I8_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "OR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_OR_I16", ":", "case", "Mips", "::", "ATOMIC_LOAD_OR_I16_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "OR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_OR_I32", ":", "case", "Mips", "::", "ATOMIC_LOAD_OR_I32_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "OR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_OR_I64", ":", "case", "Mips", "::", "ATOMIC_LOAD_OR_I64_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "OR64", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I8", ":", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I8_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "XOR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I16", ":", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I16_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "XOR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I32", ":", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I32_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "XOR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I64", ":", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I64_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "XOR64", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I8", ":", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I8_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I16", ":", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I16_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I32", ":", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I32_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I64", ":", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I64_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I8", ":", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I8_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "SUBu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I16", ":", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I16_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "SUBu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I32", ":", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I32_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "SUBu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I64", ":", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I64_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "Mips", "::", "DSUBu", ")", ";", "case", "Mips", "::", "ATOMIC_SWAP_I8", ":", "case", "Mips", "::", "ATOMIC_SWAP_I8_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_SWAP_I16", ":", "case", "Mips", "::", "ATOMIC_SWAP_I16_P8", ":", "return", "emitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_SWAP_I32", ":", "case", "Mips", "::", "ATOMIC_SWAP_I32_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_SWAP_I64", ":", "case", "Mips", "::", "ATOMIC_SWAP_I64_P8", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I8", ":", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I8_P8", ":", "return", "emitAtomicCmpSwapPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I16", ":", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I16_P8", ":", "return", "emitAtomicCmpSwapPartword", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I32", ":", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I32_P8", ":", "return", "emitAtomicCmpSwap", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ")", ";", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I64", ":", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I64_P8", ":", "return", "emitAtomicCmpSwap", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ")", ";", "}", "}" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "bool", "canMergeStoresTo", "(", "EVT", "MemVT", ")", "const", "override", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "<NUM_LIT>", ")", ";", "}" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "<FIXS>", "&&", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "(", "unsigned", ")", "HARD_FRAME_POINTER_REGNUM", "<FIXE>" ]

[ "addr", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "REG", "<BUGS>", "&&", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", "<BUGE>", "||", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "STACK_POINTER_REGNUM", ")", "&&", "(", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "!", "SMALL_INT", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ")" ]

[ "return", "cached_can_issue_more", ";" ]

[ "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER6", "&&", "last_scheduled_insn", ")", "return", "power6_sched_reorder2", "(", "ready", ",", "*", "pn_ready", "-", "<NUM_LIT>", ")", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER9", "&&", "last_scheduled_insn", "&&", "recog_memoized", "(", "last_scheduled_insn", ")", ">=", "<NUM_LIT>", ")", "return", "power9_sched_reorder2", "(", "ready", ",", "*", "pn_ready", "-", "<NUM_LIT>", ")", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER10", "&&", "last_scheduled_insn", ")", "return", "power10_sched_reorder", "(", "ready", ",", "*", "pn_ready", "-", "<NUM_LIT>", ")", ";" ]

[ "i", ")", "ShuffleMask", "[", "Idx", "+", "i", "]", "=", "NumElts", "+", "i", ";" ]

[ "assert", "(", "(", "Idx", "+", "Len", ")", "<=", "NumElts", "&&", "<STR_LIT>", "Insertion out of range", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "ShuffleMask", ".", "push_back", "(", "i", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Len", ";", "++" ]

[ "SDValue", "Lo", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "Store", ",", "StackPtr", ",", "NULL", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "VA", ".", "getLocMemOffset", "(", ")", "+", "<NUM_LIT>", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "MVT", "::", "i32", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "Arg", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ")", ")", ";", "}", "static", "const", "unsigned", "ArgRegs", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";", "unsigned", "ArgOffset", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Outs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "Outs", "[", "i", "]", ".", "Val", ";", "EVT", "ObjectVT", "=", "Val", ".", "getValueType", "(", ")", ";", "SDValue", "ValToStore", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "ObjSize", ";", "switch", "(", "ObjectVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled argument type!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i32", ":", "ObjSize", "=", "<NUM_LIT>", ";", "if", "(", "RegsToPass", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "ValToStore", "=", "Val", ";", "}", "else", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ArgRegs", "[", "RegsToPass", ".", "size", "(", ")", "]", ",", "Val", ")", ")", ";", "}", "break", ";", "case", "MVT", "::", "f32", ":", "ObjSize", "=", "<NUM_LIT>", ";", "if", "(", "RegsToPass", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "ValToStore", "=", "Val", ";", "}", "else", "{", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BIT_CONVERT", ",", "dl", ",", "MVT", "::", "i32", ",", "Val", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ArgRegs", "[", "RegsToPass", ".", "size", "(", ")", "]", ",", "Val", ")", ")", ";", "}", "break", ";", "case", "MVT", "::", "f64", ":", "{", "ObjSize", "=", "<NUM_LIT>", ";", "if", "(", "RegsToPass", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "ValToStore", "=", "Val", ";", "break", ";", "}", "SDValue", "StackPtr", "=", "DAG", ".", "CreateStackTemporary", "(", "MVT", "::", "f64", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "Val", ",", "StackPtr", ",", "NULL", ",", "<NUM_LIT>", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "Store", ",", "StackPtr", ",", "NULL", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "StackPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "StackPtr", ".", "getValueType", "(", ")", ",", "StackPtr", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "<FIXS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "llvm", "::", "ARM", "::", "HasV7Ops", "]", "&&", "<FIXE>" ]

[ "static", "bool", "getMCRDeprecationInfo", "(", "MCInst", "&", "MI", ",", "MCSubtargetInfo", "&", "STI", ",", "std", "::", "string", "&", "Info", ")", "{", "<BUGS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "llvm", "::", "ARM", "::", "HasV7Ops", "&&", "<BUGE>", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "&&", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "&&" ]

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

[ "(", "ne", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "ne", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "and", "(", "eq_attr" ]

[ "#", "<STR_LIT>", ")", "V128", ":", "$", "LHS", ",", "V128", ":", "$", "RHS", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4i32", "(", "OpNode", "V128", ":", "$", "LHS", ",", "V128", ":", "$", "RHS", ")", ")", ",", "(", "!", "cast", "<", "Instruction", ">", "(", "inst" ]

[ ")" ]

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

[ "NewI", "->", "addOperand", "(", "CO", ")", ";" ]

[ "if", "(", "F", "==", "PairMap", ".", "end", "(", ")", ")", "{", "SR", "=", "SubR", ";", "}", "else", "{", "const", "UUPair", "&", "P", "=", "F", "->", "second", ";", "R", "=", "(", "SubR", "==", "Hexagon", "::", "isub_lo", ")", "?", "P", ".", "first", ":", "P", ".", "second", ";", "SR", "=", "<NUM_LIT>", ";", "}", "}", "auto", "CO", "=", "MachineOperand", "::", "CreateReg", "(", "R", ",", "Op", ".", "isDef", "(", ")", ",", "Op", ".", "isImplicit", "(", ")", ",", "isKill", ",", "Op", ".", "isDead", "(", ")", ",", "Op", ".", "isUndef", "(", ")", ",", "Op", ".", "isEarlyClobber", "(", ")", ",", "SR", ",", "Op", ".", "isDebug", "(", ")", ",", "Op", ".", "isInternalRead", "(", ")", ")", ";" ]

[ "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", "<<", "<NUM_LIT>", ")", ")", ";" ]

[ "static", "DecodeStatus", "DecodeAddiur2Simm7", "(", "MCInst", "&", "Inst", ",", "unsigned", "Value", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "if", "(", "Value", "==", "<NUM_LIT>", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "Value", "==", "<NUM_LIT>", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "-", "<NUM_LIT>", ")", ")", ";" ]

[ "plus", "ior", "xor", "]", ")" ]

[ "(", "define_code_iterator", "any_or_plus", "[" ]

[ ")", "]" ]

[ "[", "(", "simple_return" ]

[ "if", "(", "Start", "||", "Dec", "||", "End", ")", "{" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Processing ", "<STR_LIT>", "<<", "*", "ML", ")", ";", "auto", "IsLoopStart", "=", "[", "]", "(", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2DoLoopStart", ";", "}", ";", "auto", "SearchForStart", "=", "[", "&", "IsLoopStart", "]", "(", "MachineBasicBlock", "*", "MBB", ")", "->", "MachineInstr", "*", "{", "for", "(", "auto", "&", "MI", ":", "*", "MBB", ")", "{", "if", "(", "IsLoopStart", "(", "MI", ")", ")", "return", "&", "MI", ";", "}", "return", "nullptr", ";", "}", ";", "MachineInstr", "*", "Start", "=", "nullptr", ";", "MachineInstr", "*", "Dec", "=", "nullptr", ";", "MachineInstr", "*", "End", "=", "nullptr", ";", "bool", "Revert", "=", "false", ";", "if", "(", "auto", "*", "Preheader", "=", "ML", "->", "getLoopPreheader", "(", ")", ")", "Start", "=", "SearchForStart", "(", "Preheader", ")", ";", "for", "(", "auto", "*", "MBB", ":", "reverse", "(", "ML", "->", "getBlocks", "(", ")", ")", ")", "{", "for", "(", "auto", "&", "MI", ":", "*", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2LoopDec", ")", "Dec", "=", "&", "MI", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2LoopEnd", ")", "End", "=", "&", "MI", ";", "else", "if", "(", "MI", ".", "getDesc", "(", ")", ".", "isCall", "(", ")", ")", "Revert", "=", "true", ";", "if", "(", "!", "Dec", ")", "continue", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", "||", "MI", ".", "mayStore", "(", ")", ")", "Revert", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "LR", ";", "}", "if", "(", "Dec", "&&", "End", "&&", "Revert", ")", "break", ";", "}" ]

[ "(", "<STR_LIT>", "{@ccnge}", "<STR_LIT>", ",", "X86", "::", "COND_L", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnl}", "<STR_LIT>", ",", "X86", "::", "COND_GE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnle}", "<STR_LIT>", ",", "X86", "::", "COND_G", ")", ".", "Case", "(", "<STR_LIT>", "{@ccno}", "<STR_LIT>", ",", "X86", "::", "COND_NO", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnp}", "<STR_LIT>", ",", "X86", "::", "COND_NP", ")", ".", "Case", "(", "<STR_LIT>", "{@ccns}", "<STR_LIT>", ",", "X86", "::", "COND_NS", ")", ".", "Case", "(", "<STR_LIT>", "{@cco}", "<STR_LIT>", ",", "X86", "::", "COND_O", ")", ".", "Case", "(", "<STR_LIT>", "{@ccp}", "<STR_LIT>", ",", "X86", "::", "COND_P", ")", ".", "Case", "(", "<STR_LIT>", "{@ccs}", "<STR_LIT>", ",", "X86", "::", "COND_S", ")", ".", "Default", "(", "X86", "::", "COND_INVALID", ")", ";" ]

[ "X86", "::", "CondCode", "Cond", "=", "StringSwitch", "<", "X86", "::", "CondCode", ">", "(", "Constraint", ")", ".", "Case", "(", "<STR_LIT>", "{@cca}", "<STR_LIT>", ",", "X86", "::", "COND_A", ")", ".", "Case", "(", "<STR_LIT>", "{@ccae}", "<STR_LIT>", ",", "X86", "::", "COND_AE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccb}", "<STR_LIT>", ",", "X86", "::", "COND_B", ")", ".", "Case", "(", "<STR_LIT>", "{@ccbe}", "<STR_LIT>", ",", "X86", "::", "COND_BE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccc}", "<STR_LIT>", ",", "X86", "::", "COND_B", ")", ".", "Case", "(", "<STR_LIT>", "{@cce}", "<STR_LIT>", ",", "X86", "::", "COND_E", ")", ".", "Case", "(", "<STR_LIT>", "{@ccz}", "<STR_LIT>", ",", "X86", "::", "COND_E", ")", ".", "Case", "(", "<STR_LIT>", "{@ccg}", "<STR_LIT>", ",", "X86", "::", "COND_G", ")", ".", "Case", "(", "<STR_LIT>", "{@ccge}", "<STR_LIT>", ",", "X86", "::", "COND_GE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccl}", "<STR_LIT>", ",", "X86", "::", "COND_L", ")", ".", "Case", "(", "<STR_LIT>", "{@ccle}", "<STR_LIT>", ",", "X86", "::", "COND_LE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccna}", "<STR_LIT>", ",", "X86", "::", "COND_BE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnae}", "<STR_LIT>", ",", "X86", "::", "COND_B", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnb}", "<STR_LIT>", ",", "X86", "::", "COND_AE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnbe}", "<STR_LIT>", ",", "X86", "::", "COND_A", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnc}", "<STR_LIT>", ",", "X86", "::", "COND_AE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccne}", "<STR_LIT>", ",", "X86", "::", "COND_NE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccnz}", "<STR_LIT>", ",", "X86", "::", "COND_NE", ")", ".", "Case", "(", "<STR_LIT>", "{@ccng}", "<STR_LIT>", ",", "X86", "::", "COND_LE", ")", ".", "Case" ]

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

[ "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "IV", "=", "AMDGPU", "::", "IsaInfo", "::", "getIsaVersion", "(", "ST", "->", "getFeatureBits", "(", ")", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "AMDGPUASI", "=", "ST", "->", "getAMDGPUAS", "(", ")", ";", "ForceEmitZeroWaitcnts", "=", "ForceEmitZeroFlag", ";", "for", "(", "enum", "InstCounterType", "T", "=", "VM_CNT", ";", "T", "<", "NUM_INST_CNTS", ";", "T", "=", "(", "enum", "InstCounterType", ")", "(", "T", "+", "<NUM_LIT>", ")", ")", "ForceEmitWaitcnt", "[", "T", "]", "=", "false", ";", "HardwareLimits", ".", "VmcntMax", "=", "AMDGPU", "::", "getVmcntBitMask", "(", "IV", ")", ";", "HardwareLimits", ".", "ExpcntMax", "=", "AMDGPU", "::", "getExpcntBitMask", "(", "IV", ")", ";", "HardwareLimits", ".", "LgkmcntMax", "=", "AMDGPU", "::", "getLgkmcntBitMask", "(", "IV", ")", ";", "HardwareLimits", ".", "NumVGPRsMax", "=", "ST", "->", "getAddressableNumVGPRs", "(", ")", ";", "HardwareLimits", ".", "NumSGPRsMax", "=", "ST", "->", "getAddressableNumSGPRs", "(", ")", ";", "assert", "(", "HardwareLimits", ".", "NumVGPRsMax", "<=", "SQ_MAX_PGM_VGPRS", ")", ";", "assert", "(", "HardwareLimits", ".", "NumSGPRsMax", "<=", "SQ_MAX_PGM_SGPRS", ")", ";", "RegisterEncoding", ".", "VGPR0", "=", "TRI", "->", "getEncodingValue", "(", "AMDGPU", "::", "VGPR0", ")", ";", "RegisterEncoding", ".", "VGPRL", "=", "RegisterEncoding", ".", "VGPR0", "+", "HardwareLimits", ".", "NumVGPRsMax", "-", "<NUM_LIT>", ";", "RegisterEncoding", ".", "SGPR0", "=", "TRI", "->", "getEncodingValue", "(", "AMDGPU", "::", "SGPR0", ")", ";", "RegisterEncoding", ".", "SGPRL", "=", "RegisterEncoding", ".", "SGPR0", "+", "HardwareLimits", ".", "NumSGPRsMax", "-", "<NUM_LIT>", ";", "TrackedWaitcntSet", ".", "clear", "(", ")", ";", "BlockVisitedSet", ".", "clear", "(", ")", ";", "VCCZBugHandledSet", ".", "clear", "(", ")", ";", "LoopWaitcntDataMap", ".", "clear", "(", ")", ";", "BlockWaitcntProcessedSet", ".", "clear", "(", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "::", "rpo_iterator", "I", "=", "RPOT", ".", "begin", "(", ")", ",", "E", "=", "RPOT", ".", "end", "(", ")", ",", "J", "=", "RPOT", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "*", "I", ";", "BlockVisitedSet", ".", "insert", "(", "&", "MBB", ")", ";", "BlockWaitcntBrackets", "*", "ScoreBrackets", "=", "BlockWaitcntBracketsMap", "[", "&", "MBB", "]", ".", "get", "(", ")", ";", "if", "(", "!", "ScoreBrackets", ")", "{", "BlockWaitcntBracketsMap", "[", "&", "MBB", "]", "=", "llvm", "::", "make_unique", "<", "BlockWaitcntBrackets", ">", "(", "ST", ")", ";", "ScoreBrackets", "=", "BlockWaitcntBracketsMap", "[", "&", "MBB", "]", ".", "get", "(", ")", ";", "}", "ScoreBrackets", "->", "setPostOrder", "(", "MBB", ".", "getNumber", "(", ")", ")", ";", "MachineLoop", "*", "ContainingLoop", "=", "MLI", "->", "getLoopFor", "(", "&", "MBB", ")", ";", "if", "(", "ContainingLoop", "&&", "LoopWaitcntDataMap", "[", "ContainingLoop", "]", "==", "nullptr", ")", "LoopWaitcntDataMap", "[", "ContainingLoop", "]", "=", "llvm", "::", "make_unique", "<", "LoopWaitcntData", ">", "(", ")", ";", "if", "(", "ContainingLoop", "&&", "ContainingLoop", "->", "getHeader", "(", ")", "==", "&", "MBB", ")", "{", "unsigned", "Count", "=", "countNumBottomBlocks", "(", "ContainingLoop", ")", ";", "if", "(", "(", "std", "::", "count", "(", "BlockWaitcntProcessedSet", ".", "begin", "(", ")", ",", "BlockWaitcntProcessedSet", ".", "end", "(", ")", ",", "&", "MBB", ")", "<", "Count", ")", ")", "{", "BlockWaitcntBracketsMap", "[", "&", "MBB", "]", "->", "setRevisitLoop", "(", "true", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "set-revisit1: Block", "<STR_LIT>", "<<", "ContainingLoop", "->", "getHeader", "(", ")", "->", "getNumber", "(", ")", "<<", "'", "\\n", "'", ";", ")", ";", "}", "}", "insertWaitcntInBlock", "(", "MF", ",", "MBB", ")", ";", "BlockWaitcntProcessedSet", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "ContainingLoop", "&&", "isLoopBottom", "(", "ContainingLoop", ",", "&", "MBB", ")", "&&", "std", "::", "count", "(", "BlockWaitcntProcessedSet", ".", "begin", "(", ")", ",", "BlockWaitcntProcessedSet", ".", "end", "(", ")", ",", "&", "MBB", ")", "==", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "*", "EntryBB", "=", "ContainingLoop" ]

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

[ "{" ]

[ "ChainOfDependences", "&", "getChain", "(", ")" ]

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

[ "class", "Enc_3d5b28", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Rss32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rss32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "if", "(", "CI", ".", "BaseOff", ")", "{" ]

[ "MachineBasicBlock", "*", "MBB", "=", "CI", ".", "I", "->", "getParent", "(", ")", ";", "const", "MachineOperand", "*", "AddrReg", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", ";", "const", "MachineOperand", "*", "Data0", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "data0", ")", ";", "const", "MachineOperand", "*", "Data1", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "Paired", ",", "AMDGPU", "::", "OpName", "::", "data0", ")", ";", "unsigned", "NewOffset0", "=", "CI", ".", "Offset0", ";", "unsigned", "NewOffset1", "=", "CI", ".", "Offset1", ";", "unsigned", "Opc", "=", "CI", ".", "UseST64", "?", "write2ST64Opcode", "(", "CI", ".", "EltSize", ")", ":", "write2Opcode", "(", "CI", ".", "EltSize", ")", ";", "if", "(", "NewOffset0", ">", "NewOffset1", ")", "{", "std", "::", "swap", "(", "NewOffset0", ",", "NewOffset1", ")", ";", "std", "::", "swap", "(", "Data0", ",", "Data1", ")", ";", "}", "assert", "(", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "NewOffset0", ")", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "NewOffset1", ")", ")", "&&", "(", "NewOffset0", "!=", "NewOffset1", ")", "&&", "<STR_LIT>", "Computed offset doesn't fit", "<STR_LIT>", ")", ";", "const", "MCInstrDesc", "&", "Write2Desc", "=", "TII", "->", "get", "(", "Opc", ")", ";", "DebugLoc", "DL", "=", "CI", ".", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "BaseReg", "=", "AddrReg", "->", "getReg", "(", ")", ";", "unsigned", "BaseSubReg", "=", "AddrReg", "->", "getSubReg", "(", ")", ";", "unsigned", "BaseRegFlags", "=", "<NUM_LIT>", ";" ]

[ "return", "AArch64_AM", ":", ":", "getFP16Imm", "(", "Imm", ")", "!", "=", "-", "<NUM_LIT>", ";" ]

[ "}", "]", ">", ";", "def", "fpimm64XForm", ":", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "InVal", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "uint32_t", "enc", "=", "AArch64_AM", ":", ":", "getFP64Imm", "(", "InVal", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "fpimm16", ":", "Operand", "<", "f16", ">", ",", "FPImmLeaf", "<", "f16", ",", "[", "{" ]

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

[ "def", "J4_cmpgtn1_f_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "n1Const", ":", "$", "n1", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_bd8382d1", ",", "TypeNCJ", ">", ",", "Enc_3694bd", ",", "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", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "override", "{", "switch", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "<STR_LIT>", "Not yet implemented.", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "break", ";", "}", "makeLive", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "}" ]

[ "++", "NumOpsAdded", ";", "}", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Base", ")", ")", ";", "++", "NumOpsAdded", ";", "if", "(", "B", "->", "DoPredicateOperands", "(", "MI", ",", "Opcode", ",", "insn", ",", "NumOps", ")", ")", "{", "NumOpsAdded", "+=", "<NUM_LIT>", ";", "}", "else", "{", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "Expected predicate operands not found.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "unsigned", "RegListBits", "=", "insn", "&", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "if", "(", "(", "RegListBits", ">>", "i", ")", "&", "<NUM_LIT>", ")", "{", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "getRegisterEnum", "(", "B", ",", "ARM", "::", "GPRRegClassID", ",", "i", ")", ")", ")", ";", "++", "NumOpsAdded", ";" ]

[ ":", "AsmOperandClass", "{" ]

[ "def", "PSBHintOperand" ]

[ "<FIXS>", "extern", "cl", "::", "opt", "bool", ">", "WasmEnableEmException", ";", "extern", "cl", "::", "opt", "bool", ">", "WasmEnableEmSjLj", ";", "<FIXE>" ]

[ "<STR_LIT>", " instruction output for test purposes only.", "<STR_LIT>", ")", ",", "cl", "::", "init", "(", "false", ")", ")", ";", "<BUGS>", "extern", "cl", "::", "opt", "bool", ">", "EnableEmException", ";", "extern", "cl", "::", "opt", "bool", ">", "EnableEmSjLj", ";", "<BUGE>", "static", "void", "removeRegisterOperands", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", ";" ]

[ "const", "{" ]

[ "bool", "isThumb2Function", "(", ")" ]

[ ",", "<STR_LIT>", "backToBool", "<STR_LIT>", ",", "I", ")", ";" ]

[ "++", "NumBoolToIntPromotion", ";", "for", "(", "Value", "*", "V", ":", "Defs", ")", "if", "(", "!", "BoolToIntMap", ".", "count", "(", "V", ")", ")", "BoolToIntMap", "[", "V", "]", "=", "translate", "(", "V", ")", ";", "for", "(", "auto", "&", "Pair", ":", "BoolToIntMap", ")", "{", "User", "*", "First", "=", "dyn_cast", "<", "User", ">", "(", "Pair", ".", "first", ")", ";", "User", "*", "Second", "=", "dyn_cast", "<", "User", ">", "(", "Pair", ".", "second", ")", ";", "assert", "(", "(", "!", "First", "||", "Second", ")", "&&", "<STR_LIT>", "translated from user to non-user!?", "<STR_LIT>", ")", ";", "if", "(", "First", "&&", "!", "isa", "<", "CallInst", ">", "(", "First", ")", ")", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "First", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "Second", "->", "setOperand", "(", "i", ",", "BoolToIntMap", "[", "First", "->", "getOperand", "(", "i", ")", "]", ")", ";", "}", "Value", "*", "IntRetVal", "=", "BoolToIntMap", "[", "U", "]", ";", "Type", "*", "Int1Ty", "=", "Type", "::", "getInt1Ty", "(", "U", "->", "getContext", "(", ")", ")", ";", "Instruction", "*", "I", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "Value", "*", "BackToBool", "=", "new", "TruncInst", "(", "IntRetVal", ",", "Int1Ty" ]

[ "void", "SIScheduleBlock", "::", "addPred", "(", "SIScheduleBlock", "*", "Pred", ")", "{", "unsigned", "PredID", "=", "Pred", "->", "getID", "(", ")", ";", "for", "(", "SIScheduleBlock", "*", "P", ":", "Preds", ")", "{", "if", "(", "PredID", "==", "P", "->", "getID", "(", ")", ")", "return", ";", "}", "Preds", ".", "push_back", "(", "Pred", ")", ";", "assert", "(", "none_of", "(", "Succs", ",", "[", "=", "]", "(", "std", "::", "pair", "<", "SIScheduleBlock", "*", ",", "SIScheduleBlockLinkKind", ">", "S", ")", "{", "return", "PredID", "==", "S", ".", "first", "->", "getID", "(", ")", ";", "}", ")", "&&", "<STR_LIT>", "Loop in the Block Graph!", "<STR_LIT>", ")", ";", "}" ]

[ "Adds", "the", "specified", "edge", "as", "a", "pred", "of", "the", "current", "node", "if", "not", "already", "." ]

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

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