Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "assert", "(", "MBBI", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Wrong number of operands", "<STR_LIT>", ")", ";", "assert", "(", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Expected operand to be immediate", "<STR_LIT>", ")", ";", "assert", "(", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Expected operand to be a register", "<STR_LIT>", ")", ";", "if", "(", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "SPValue", "-=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "else", "return", "true", ";", "break", ";", "default", ":", "return", "true", ";", "}", "}", "if", "(", "MBBI", "==", "C", ".", "back", "(", ")", ")", "break", ";", "++", "MBBI", ";", "}", "if", "(", "SPValue", ")", "return", "true", ";", "return", "false", ";", "}", ";", "llvm", "::", "erase_if", "(", "RepeatedSequenceLocs", ",", "hasIllegalSPModification", ")", ";", "if", "(", "RepeatedSequenceLocs", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "}", "unsigned", "FlagsSetInAll", "=", "<NUM_LIT>", ";", "std", "::", "for_each", "(", "RepeatedSequenceLocs", ".", "begin", "(", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ",", "[", "&", "FlagsSetInAll", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "FlagsSetInAll", "&=", "C", ".", "Flags", ";", "}", ")", ";", "auto", "CantGuaranteeValueAcrossCall", "=", "[", "&", "TRI", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "if", "(", "C", ".", "Flags", "&", "UnsafeRegsDead", ")", "return", "false", ";", "return", "C", ".", "isAnyUnavailableAcrossOrOutOfSeq", "(", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ",", "TRI", ")", ";", "}", ";", "if", "(", "!", "(", "FlagsSetInAll", "&", "UnsafeRegsDead", ")", ")", "{", "llvm", "::", "erase_if", "(", "RepeatedSequenceLocs", ",", "CantGuaranteeValueAcrossCall", ")", ";", "if", "(", "RepeatedSequenceLocs", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "}", "unsigned", "LastInstrOpcode", "=", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "back", "(", ")", "->", "getOpcode", "(", ")", ";", "auto", "SetCandidateCallInfo", "=", "[", "&", "RepeatedSequenceLocs", "]", "(", "unsigned", "CallID", ",", "unsigned", "NumBytesForCall", ")", "{", "for", "(", "outliner", "::", "Candidate", "&", "C", ":", "RepeatedSequenceLocs", ")", "C", ".", "setCallInfo", "(", "CallID", ",", "NumBytesForCall", ")", ";", "}", ";", "unsigned", "FrameID", "=", "MachineOutlinerDefault", ";", "NumBytesToCreateFrame", "+=", "<NUM_LIT>", ";", "bool", "HasBTI", "=", "any_of", "(", "RepeatedSequenceLocs", ",", "[", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "return", "C", ".", "getMF", "(", ")", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "branchTargetEnforcement", "(", ")", ";", "}", ")", ";", "unsigned", "CFICount", "=", "<NUM_LIT>", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "front", "(", ")", ";", "for", "(", "unsigned", "Loc", "=", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "getStartIdx", "(", ")", ";", "Loc", "<", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "getEndIdx", "(", ")", "+", "<NUM_LIT>", ";", "Loc", "++", ")", "{", "if", "(", "MBBI", "->", "isCFIInstruction", "(", ")", ")", "CFICount", "++", ";", "MBBI", "++", ";", "}", "for", "(", "outliner", "::", "Candidate", "&", "C", ":", "RepeatedSequenceLocs", ")", "{", "std", "::", "vector", "<", "MCCFIInstruction", ">", "CFIInstructions", "=", "C", ".", "getMF", "(", ")", "->", "getFrameInstructions", "(", ")", ";", "if", "(", "CFICount", ">", "<NUM_LIT>", "&&", "CFICount", "!=", "CFIInstructions", ".", "size", "(", ")", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "}", "auto", "IsSafeToFixup", "=", "[", "this", ",", "&", "TRI", "]", "(", "MachineInstr", "&", "MI", ")", "{", "if", "(", "MI", ".", "isCall", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "modifiesRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "TRI", ")", "&&", "!", "MI", ".", "readsRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "TRI", ")", ")", "return", "true", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "TRI", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "mayLoadOrStore", "(", ")", ")", "{", "const", "MachineOperand", "*", "Base", ";", "int64_t", "Offset", ";", "bool", "OffsetIsScalable", ";", "if", "(", "!", "getMemOperandWithOffset", "(", "MI", ",", "Base", ",", "Offset", ",", "OffsetIsScalable", ",", "&", "TRI", ")", "||", "!", "Base", "->", "isReg", "(", ")", "||", "Base", "->", "getReg", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "if", "(", "OffsetIsScalable", ")", "return", "false", ";", "int64_t", "MinOffset", ",", "MaxOffset", ";", "TypeSize", "Scale", "(", "<NUM_LIT>", "U", ",", "false", ")", ";", "unsigned", "DummyWidth", ";", "getMemOpInfo", "(", "MI", ".", "getOpcode", "(", ")", ",", "Scale", ",", "DummyWidth", ",", "MinOffset", ",", "MaxOffset", ")", ";", "Offset", "+=", "<NUM_LIT>", ";", "if", "(", "Offset", "<", "MinOffset", "*", "(", "int64_t", ")", "Scale", ".", "getFixedSize", "(", ")", "||", "Offset", ">", "MaxOffset", "*", "(", "int64_t", ")", "Scale", ".", "getFixedSize", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "bool", "AllStackInstrsSafe", "=", "std", "::", "all_of", "(", "FirstCand", ".", "front", "(", ")", ",", "std", "::", "next", "(", "FirstCand", ".", "back", "(", ")", ")", ",", "IsSafeToFixup", ")", ";", "if", "(", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "back", "(", ")", "->", "isTerminator", "(", ")", ")", "{", "FrameID", "=", "MachineOutlinerTailCall", ";" ]

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

[ "return", "(", "int8x8_t", ")", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "(", "uint8x8_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "tree", "t", "=", "native_interpret_expr", "(", "uint64_type_node", ",", "buf", ",", "len", ")", ";" ]

[ "else", "if", "(", "TREE_CODE", "(", "arg1", ")", "==", "VECTOR_CST", "&&", "CHAR_BIT", "==", "<NUM_LIT>", ")", "{", "unsigned", "char", "buf", "[", "<NUM_LIT>", "]", ";", "int", "len", "=", "native_encode_expr", "(", "arg1", ",", "buf", ",", "<NUM_LIT>", ")", ";", "if", "(", "len", "==", "<NUM_LIT>", ")", "return", "NULL_TREE", ";" ]

[ "(", "clobber", "(", "reg", ":", "CC", "FCC_REGNUM", ")", ")", "]", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "minus", ":", "DF", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "V4HI", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<FIXE>" ]

[ "<STR_LIT>", "*", "mmx_mulv4hi3", "<STR_LIT>", "register_operand", "<STR_LIT>", "=", "y", ",", "x", ",", "Yv", "<STR_LIT>", "register_mmxmem_operand", "<STR_LIT>", "%", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "Yv", "<STR_LIT>", "register_mmxmem_operand", "<STR_LIT>", "ym", ",", "x", ",", "Yv", "<STR_LIT>", "(", "TARGET_MMX", "|", "|", "TARGET_MMX_WITH_SSE", ")", "&", "&", "ix86_binary_operator_ok", "(", "MULT", ",", "V4HImode", ",", "operands", ")", "<STR_LIT>", "@" ]

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "CS", "]", ";" ]

[ "auto", "SelectOpcode", "=", "VT", ".", "isVector", "(", ")", "?", "ISD", "::", "VSELECT", ":", "ISD", "::", "SELECT", ";" ]

[ "static", "SDValue", "performFMinNumFMaxNumCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "const", "X86Subtarget", "&", "Subtarget", ")", "{", "if", "(", "Subtarget", ".", "useSoftFloat", "(", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "(", "(", "Subtarget", ".", "hasSSE1", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "v4f32", ")", ")", "||", "(", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "v2f64", ")", ")", "||", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v8f32", "||", "VT", "==", "MVT", "::", "v4f64", ")", ")", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "SetCCType", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", ";", "auto", "MinMaxOp", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FMAXNUM", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "MinOrMax", "=", "DAG", ".", "getNode", "(", "MinMaxOp", ",", "DL", ",", "VT", ",", "Op1", ",", "Op0", ")", ";", "SDValue", "IsOp0Nan", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "SetCCType", ",", "Op0", ",", "Op0", ",", "ISD", "::", "SETUO", ")", ";" ]

[ "static", "rtx", "c6x_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "unsigned", "regno", ";", "unsigned", "real_regno", ";", "int", "nregs", ";", "int", "i", ";", "rtx", "p", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "nregs", "=", "REG_NREGS", "(", "rtl", ")", ";", "if", "(", "nregs", "==", "<NUM_LIT>", ")", "return", "NULL_RTX", ";", "p", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", ")", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nregs", ";", "i", "++", ")", "{", "if", "(", "TARGET_BIG_ENDIAN", ")", "real_regno", "=", "regno", "+", "nregs", "-", "(", "i", "+", "<NUM_LIT>", ")", ";", "else", "real_regno", "=", "regno", "+", "i", ";", "XVECEXP", "(", "p", ",", "<NUM_LIT>", ",", "i", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "real_regno", ")", ";", "}", "return", "p", ";", "}" ]

[ "We", "save", "pairs", "of", "registers", "using", "a", "DImode", "store", ".", "Describe", "the", "component", "registers", "for", "DWARF", "generation", "code", "." ]

[ "Success", ";" ]

[ "unsigned", "Register", "=", "AArch64MCRegisterClasses", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ".", "getRegister", "(", "RegNo", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Register", ")", ")", ";", "return" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V3", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M5", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m6or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M6", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m6or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M6", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m6or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M6", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m6or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M6", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

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

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

[ "const", "MCInstrDesc", "&", "D", "=", "HII", "->", "get", "(", "Opc", ")", ";", "if", "(", "const", "MCPhysReg", "*", "R", "=", "D", ".", "ImplicitDefs", ")", "while", "(", "*", "R", ")", "expandReg", "(", "*", "R", "++", ",", "Defs", ")", ";", "if", "(", "const", "MCPhysReg", "*", "R", "=", "D", ".", "ImplicitUses", ")", "while", "(", "*", "R", ")", "expandReg", "(", "*", "R", "++", ",", "Uses", ")", ";", "for", "(", "ConstMIOperands", "Mo", "(", "MI", ")", ";", "Mo", ".", "isValid", "(", ")", ";", "++", "Mo", ")", "{", "if", "(", "!", "Mo", "->", "isReg", "(", ")", "||", "Mo", "->", "isImplicit", "(", ")" ]

[ "<FIXS>", "if", "(", "!", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", ")", "return", "false", ";", "int64_t", "NewOffset", "=", "Offset", "+", "getMUBUFInstrOffset", "(", "MI", ")", ";", "return", "isUInt", "<NUM_LIT>", ">", "(", "NewOffset", ")", ";", "<FIXE>" ]

[ "bool", "SIRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "<BUGS>", "return", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", "&&", "isUInt", "<NUM_LIT>", ">", "(", "Offset", ")", ";", "<BUGE>", "}", "const", "TargetRegisterClass", "*", "SIRegisterInfo", "::", "getPointerRegClass", "(" ]

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

[ "}", "def", ":", "InstRW", "[", "SKXWriteResGroup31", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKXWriteResGroup31", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKXWriteResGroup31", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKXWriteResGroup31", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKXWriteResGroup31", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKXWriteResGroup31", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

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

[ "int64_t", "Off", "=", "PostInc", "?", "<NUM_LIT>", ":", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "LowI", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "S2_storeri_io", ")", ")", ".", "addReg", "(", "AdrOp", ".", "getReg", "(", ")", ",", "RSA", "&", "~", "RegState", "::", "Kill", ",", "AdrOp", ".", "getSubReg", "(", ")", ")", ".", "addImm", "(", "Off", ")", ".", "addReg", "(", "P", ".", "first", ")", ";", "HighI", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "S2_storeri_io", ")", ")", ".", "addReg", "(", "AdrOp", ".", "getReg", "(", ")", ",", "RSA", "&", "~", "RegState", "::", "Kill", ",", "AdrOp", ".", "getSubReg", "(", ")", ")", ".", "addImm", "(", "Off", "+", "<NUM_LIT>", ")", ".", "addReg", "(", "P", ".", "second", ")", ";", "}", "if", "(", "PostInc", ")", "{", "int64_t", "Inc", "=", "Load", "?", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ":", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "MachineOperand", "&", "UpdOp", "=", "Load", "?", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ":", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", "->", "getRegClass", "(", "UpdOp", ".", "getReg", "(", ")", ")", ";", "unsigned", "NewR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "!", "UpdOp", ".", "getSubReg", "(", ")", "&&", "<STR_LIT>", "Def operand with subreg", "<STR_LIT>", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_addi", ")", ",", "NewR", ")", ".", "addReg", "(", "AdrOp", ".", "getReg", "(", ")", ",", "RSA", ")", ".", "addImm", "(", "Inc", ")", ";", "MRI", "->", "replaceRegWith", "(", "UpdOp", ".", "getReg", "(", ")", ",", "NewR", ")", ";", "}", "MachineFunction", "&", "MF", "=", "*", "B", ".", "getParent", "(", ")", ";", "for", "(", "auto", "&", "MO", ":", "MI", "->", "memoperands", "(", ")", ")", "{", "const", "MachinePointerInfo", "&", "Ptr", "=", "MO" ]

[ "assert", "(", "Width", "&&", "<STR_LIT>", "Expected non-zero bitfield width", "<STR_LIT>", ")", ";" ]

[ "else", "return", "SDValue", "(", ")", ";", "SDValue", "RHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "RHS", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", ")", "return", "SDValue", "(", ")", ";", "uint64_t", "RHSMask", ";", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "RHSMask", "=", "RHS", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "else", "return", "SDValue", "(", ")", ";", "if", "(", "LHSMask", "&", "RHSMask", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Bitfield", "=", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "getLSBForBFI", "(", "DAG", ",", "DL", ",", "VT", ",", "Bitfield", ",", "LHSMask", ")", "!=", "-", "<NUM_LIT>", ")", "{", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "std", "::", "swap", "(", "LHSMask", ",", "RHSMask", ")", ";", "}", "Bitfield", "=", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "int32_t", "LSB", "=", "getLSBForBFI", "(", "DAG", ",", "DL", ",", "VT", ",", "Bitfield", ",", "RHSMask", ")", ";", "if", "(", "LSB", "==", "-", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "uint32_t", "Width", "=", "CountPopulation_64", "(", "RHSMask", ")", ";" ]

[ "<FIXS>", "static", "cl", "::", "opt", "bool", ">", "EnableExactSolver", "(", "<STR_LIT>", "amdgpu-igrouplp-exact-solver", "<STR_LIT>", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "Whether to use the exponential time solver to fit ", "<STR_LIT>", "<STR_LIT>", "the instructions to the pipeline as closely as ", "<STR_LIT>", "<STR_LIT>", "possible.", "<STR_LIT>", ")", ",", "cl", "::", "init", "(", "false", ")", ")", ";", "static", "cl", "::", "opt", "unsigned", ">", "CutoffForExact", "(", "<STR_LIT>", "amdgpu-igrouplp-exact-solver-cutoff", "<STR_LIT>", ",", "cl", "::", "init", "(", "<NUM_LIT>", ")", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "The maximum number of scheduling group conflicts ", "<STR_LIT>", "<STR_LIT>", "which we attempt to solve with the exponential time ", "<STR_LIT>", "<STR_LIT>", "exact solver. Problem sizes greater than this will", "<STR_LIT>", "<STR_LIT>", "be solved by the less accurate greedy algorithm. Selecting ", "<STR_LIT>", "<STR_LIT>", "solver by size is superseded by manually selecting ", "<STR_LIT>", "<STR_LIT>", "the solver (e.g. by amdgpu-igrouplp-exact-solver", "<STR_LIT>", ")", ")", ";", "static", "cl", "::", "opt", "uint64_t", ">", "MaxBranchesExplored", "(", "<STR_LIT>", "amdgpu-igrouplp-exact-solver-max-branches", "<STR_LIT>", ",", "cl", "::", "init", "(", "<NUM_LIT>", ")", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "The amount of branches that we are willing to explore with", "<STR_LIT>", "<STR_LIT>", "the exact algorithm before giving up.", "<STR_LIT>", ")", ")", ";", "static", "cl", "::", "opt", "bool", ">", "UseCostHeur", "(", "<STR_LIT>", "amdgpu-igrouplp-exact-solver-cost-heur", "<STR_LIT>", ",", "cl", "::", "init", "(", "true", ")", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "Whether to use the cost heuristic to make choices as we ", "<STR_LIT>", "<STR_LIT>", "traverse the search space using the exact solver. Defaulted ", "<STR_LIT>", "<STR_LIT>", "to on, and if turned off, we will use the node order -- ", "<STR_LIT>", "<STR_LIT>", "attempting to put the later nodes in the later sched groups. ", "<STR_LIT>", "<STR_LIT>", "Experimentally, results are mixed, so this should be set on a ", "<STR_LIT>", "<STR_LIT>", "case-by-case basis.", "<STR_LIT>", ")", ")", ";", "<FIXE>" ]

[ "<STR_LIT>", "their ordering for scheduling", "<STR_LIT>", ")", ",", "cl", "::", "init", "(", "false", ")", ")", ";", "<BUGS>", "static", "cl", "::", "opt", "Optional", "unsigned", ">>", "VMEMGroupMaxSize", "(", "<STR_LIT>", "amdgpu-igrouplp-vmem-group-size", "<STR_LIT>", ",", "cl", "::", "init", "(", "None", ")", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "The maximum number of instructions to include ", "<STR_LIT>", "<STR_LIT>", "in VMEM group.", "<STR_LIT>", ")", ")", ";", "static", "cl", "::", "opt", "Optional", "unsigned", ">>", "MFMAGroupMaxSize", "(", "<STR_LIT>", "amdgpu-igrouplp-mfma-group-size", "<STR_LIT>", ",", "cl", "::", "init", "(", "None", ")", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "The maximum number of instructions to include ", "<STR_LIT>", "<STR_LIT>", "in MFMA group.", "<STR_LIT>", ")", ")", ";", "static", "cl", "::", "opt", "Optional", "unsigned", ">>", "LDRGroupMaxSize", "(", "<STR_LIT>", "amdgpu-igrouplp-ldr-group-size", "<STR_LIT>", ",", "cl", "::", "init", "(", "None", ")", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "The maximum number of instructions to include ", "<STR_LIT>", "<STR_LIT>", "in lds/gds read group.", "<STR_LIT>", ")", ")", ";", "static", "cl", "::", "opt", "Optional", "unsigned", ">>", "LDWGroupMaxSize", "(", "<STR_LIT>", "amdgpu-igrouplp-ldw-group-size", "<STR_LIT>", ",", "cl", "::", "init", "(", "None", ")", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "The maximum number of instructions to include ", "<STR_LIT>", "<STR_LIT>", "in lds/gds write group.", "<STR_LIT>", ")", ")", ";", "<BUGE>" ]

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

[ "static", "void", "m32r_option_override", "(" ]

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

[ "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VSX_SET", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "bool", "CanDown", "=", "canMoveOver", "(", "DefI", ",", "Defs", ",", "Uses", ")", ";" ]

[ "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "std", "::", "next", "(", "DefIt", ")", ";", "I", "!=", "TfrIt", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "I", ";", "unsigned", "Exec", "=", "Exec_Then", "|", "Exec_Else", ";", "if", "(", "PredValid", "&&", "HII", "->", "isPredicated", "(", "*", "MI", ")", "&&", "MI", "->", "readsRegister", "(", "PredR", ")", ")", "Exec", "=", "(", "Cond", "==", "HII", "->", "isPredicatedTrue", "(", "*", "MI", ")", ")", "?", "Exec_Then", ":", "Exec_Else", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "RegisterRef", "RR", "=", "Op", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "RR", ".", "Reg", ")", ")", "return", "false", ";", "ReferenceMap", "&", "Map", "=", "Op", ".", "isDef", "(", ")", "?", "Defs", ":", "Uses", ";", "addRefToMap", "(", "RR", ",", "Map", ",", "Exec", ")", ";", "}", "}", "if", "(", "isRefInMap", "(", "RT", ",", "Defs", ",", "Exec_Then", ")", "||", "isRefInMap", "(", "RT", ",", "Uses", ",", "Exec_Else", ")", ")", "return", "false", ";", "RegisterRef", "RD", "=", "MD", ";", "bool", "CanUp", "=", "canMoveOver", "(", "TfrI", ",", "Defs", ",", "Uses", ")", ";" ]

[ "WDrr", ")", "VR128", ":", "$", "src", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4i32", "(", "ExtOp", "(", "v8i16", "VR128", ":", "$", "src", ")", ")", ")", ",", "(", "!", "cast", "<", "I", ">", "(", "OpcPrefix", "#" ]

[ "<", "nunits", ">", ",", "true", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "<", "VWIDE", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "ANY_EXTEND", ":", "<", "VWIDE", ">", "(", "match_operand", ":", "VQ_HSI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "<", "VCOND", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "p", "=", "aarch64_simd_vect_par_cnst_half", "(", "<", "MODE", ">", "mode", "," ]

[ ")", "]" ]

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

[ "(", "vec_duplicate", ":", "<", "VWIDE", ">" ]

[ "(", "mult", ":", "<", "VWIDE", ">", "(", "sign_extend", ":", "<", "VWIDE", ">", "(", "vec_select", ":", "<", "VHALF", ">", "(", "match_operand", ":", "VQ_HSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VQ_HSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

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

[ "MachineInstr", "*", "Def", "=", "getDefIgnoringCopies", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "!", "Def", ")", "return", ";", "Register", "DefDstReg", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "LLT", "DefDstTy", "=", "MRI", ".", "getType", "(", "DefDstReg", ")", ";", "Register", "StoreSrcReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "LLT", "StoreSrcTy", "=", "MRI", ".", "getType", "(", "StoreSrcReg", ")", ";", "if", "(", "!", "DefDstTy", ".", "isValid" ]

[ "U", ",", "_", "_", "m256i", "_", "_", "A", ",", "unsigned", "int", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_slli_epi64", "(", "_", "_", "m256i", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_" ]

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

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

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

[ "addPass", "(", "createX86RetpolineThunksPass", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSWindows", "(", ")", "&&", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "addPass", "(", "createX86AvoidTrailingCallPass", "(", ")", ")", ";", "if", "(", "!", "TT", ".", "isOSDarwin", "(", ")", "&&", "(", "!", "TT", ".", "isOSWindows", "(", ")", "||", "MAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "DwarfCFI", ")", ")", "addPass", "(", "createCFIInstrInserter" ]

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

[ "static", "bool", "usesFrameIndex", "(", "const", "MachineInstr", "&", "MI", ")", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "uses", "(", ")", ")", "if", "(", "MO", ".", "isFI", "(", ")" ]

[ "return", ";" ]

[ "tree", "lhs", "=", "gimple_get_lhs", "(", "stmt_info", "->", "stmt", ")", ";", "bool", "is_float", "=", "FLOAT_TYPE_P", "(", "TREE_TYPE", "(", "lhs", ")", ")", ";", "unsigned", "int", "basic_cost", "=", "is_float", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "m_reduc_factor", "=", "MAX", "(", "basic_cost", "*", "or", "ig_count", ",", "m_reduc_factor", ")", ";", "}", "if", "(", "kind", "==", "vec_construct", "&&", "stmt_info", "&&", "STMT_VINFO_TYPE", "(", "stmt_info", ")", "==", "load_vec_info_type", "&&", "(", "STMT_VINFO_MEMORY_ACCESS_TYPE", "(", "stmt_info", ")", "==", "VMAT_ELEMENTWISE", "||", "STMT_VINFO_MEMORY_ACCESS_TYPE", "(", "stmt_info", ")", "==", "VMAT_STRIDED_SLP", ")", ")", "{", "tree", "vectype", "=", "STMT_VINFO_VECTYPE", "(", "stmt_info", ")", ";", "unsigned", "int", "nunits", "=", "vect_nunits_for_cost", "(", "vectype", ")", ";", "if", "(", "nunits", "==", "<NUM_LIT>", ")" ]

[ "<FIXS>", "gcc_assert", "(", "call_used_or_fixed_reg_p", "(", "tmp", ")", ")", ";", "<FIXE>" ]

[ "fputs", "(", "<STR_LIT>", "\\tstrd r0,[sp,-1]\\n", "<STR_LIT>", ",", "file", ")", ";", "elsetmp", "=", "GPR_16", ";", "<BUGS>", "gcc_assert", "(", "call_used_regs", "[", "tmp", "]", ")", ";", "<BUGE>", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tmov r%d,%%low(", "<STR_LIT>", ",", "tmp", ")", ";", "assemble_name", "(", "file", ",", "dst_name", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", ")\\n", "<STR_LIT>" ]

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

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

[ "{" ]

[ "(", "compare", ":", "CCFPE", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "if", "(", "isDarwin", "(", ")", ")", "HasLazyResolverStubs", "=", "true", ";" ]

[ "std", "::", "string", "FullFS", "=", "FS", ";", "if", "(", "IsPPC64", ")", "{", "Has64BitSupport", "=", "true", ";", "Use64BitRegs", "=", "true", ";", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "<STR_LIT>", "+64bit,", "<STR_LIT>", "+", "FullFS", ";", "else", "FullFS", "=", "<STR_LIT>", "+64bit", "<STR_LIT>", ";", "}", "if", "(", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ")", "{", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "<STR_LIT>", "+crbits,", "<STR_LIT>", "+", "FullFS", ";", "else", "FullFS", "=", "<STR_LIT>", "+crbits", "<STR_LIT>", ";", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "FullFS", ")", ";", "if", "(", "use64BitRegs", "(", ")", "&&", "!", "has64BitSupport", "(", ")", ")", "Use64BitRegs", "=", "false", ";" ]

[ "else", "Ret", "+=", "<STR_LIT>", "-S128", "<STR_LIT>", ";" ]

[ "if", "(", "ST", ".", "isTarget64BitILP32", "(", ")", "||", "!", "ST", ".", "is64Bit", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-p:32:32", "<STR_LIT>", ";", "if", "(", "ST", ".", "is64Bit", "(", ")", "||", "ST", ".", "isTargetCygMing", "(", ")", "||", "ST", ".", "isTargetWindows", "(", ")", "||", "ST", ".", "isTargetNaCl", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-i64:64", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-f64:32:64", "<STR_LIT>", ";", "if", "(", "ST", ".", "isTargetNaCl", "(", ")", ")", ";", "else", "if", "(", "ST", ".", "is64Bit", "(", ")", "||", "ST", ".", "isTargetDarwin", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-f80:128", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-f80:32", "<STR_LIT>", ";", "if", "(", "ST", ".", "is64Bit", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-n8:16:32:64", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-n8:16:32", "<STR_LIT>", ";", "if", "(", "!", "ST", ".", "is64Bit", "(", ")", "&&", "(", "ST", ".", "isTargetCygMing", "(", ")", "||", "ST", ".", "isTargetWindows", "(", ")", ")", ")", "Ret", "+=", "<STR_LIT>", "-S32", "<STR_LIT>", ";" ]

[ "return", "LowerSampleIntrinsic", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "Op", ",", "DAG", ")", ";" ]

[ "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "LOCAL_SIZE_X", ",", "false", ")", ";", "case", "Intrinsic", "::", "r600_read_local_size_y", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "LOCAL_SIZE_Y", ",", "false", ")", ";", "case", "Intrinsic", "::", "r600_read_local_size_z", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "LOCAL_SIZE_Z", ",", "false", ")", ";", "case", "Intrinsic", "::", "AMDGPU_read_workdim", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "ABIArgOffset", ",", "false", ")", ";", "case", "Intrinsic", "::", "r600_read_tgid_x", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "SReg_32RegClass", ",", "TRI", "->", "getPreloadedValue", "(", "MF", ",", "SIRegisterInfo", "::", "TGID_X", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tgid_y", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "SReg_32RegClass", ",", "TRI", "->", "getPreloadedValue", "(", "MF", ",", "SIRegisterInfo", "::", "TGID_Y", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tgid_z", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "SReg_32RegClass", ",", "TRI", "->", "getPreloadedValue", "(", "MF", ",", "SIRegisterInfo", "::", "TGID_Z", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tidig_x", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "TRI", "->", "getPreloadedValue", "(", "MF", ",", "SIRegisterInfo", "::", "TIDIG_X", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tidig_y", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "TRI", "->", "getPreloadedValue", "(", "MF", ",", "SIRegisterInfo", "::", "TIDIG_Y", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tidig_z", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "TRI", "->", "getPreloadedValue", "(", "MF", ",", "SIRegisterInfo", "::", "TIDIG_Z", ")", ",", "VT", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Ops", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", ")", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOInvariant", ",", "VT", ".", "getStoreSize", "(", ")", ",", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Ops", ",", "VT", ",", "MMO", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "LowerSampleIntrinsic", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "Op", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "LowerSampleIntrinsic", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "Op", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "startswith", "(", "<STR_LIT>", ".arch", "<STR_LIT>", ")", ")", "return", "parseDirectiveArch", "(", ")", ";", "if", "(", "IDVal", ".", "startswith", "(", "<STR_LIT>", ".code", "<STR_LIT>", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "<STR_LIT>", ".att_syntax", "<STR_LIT>", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "<STR_LIT>", "prefix", "<STR_LIT>", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "<STR_LIT>", "noprefix", "<STR_LIT>", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "'.att_syntax noprefix' is not ", "<STR_LIT>", "<STR_LIT>", "supported: registers must have a ", "<STR_LIT>", "<STR_LIT>", "'%' prefix in .att_syntax", "<STR_LIT>", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "<NUM_LIT>", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "<STR_LIT>", ".intel_syntax", "<STR_LIT>", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "<NUM_LIT>", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "<STR_LIT>", "noprefix", "<STR_LIT>", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "<STR_LIT>", "prefix", "<STR_LIT>", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "'.intel_syntax prefix' is not ", "<STR_LIT>", "<STR_LIT>", "supported: registers must not have ", "<STR_LIT>", "<STR_LIT>", "a '%' prefix in .intel_syntax", "<STR_LIT>", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".nops", "<STR_LIT>", ")", "return", "parseDirectiveNops", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".even", "<STR_LIT>", ")", "return", "parseDirectiveEven", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cv_fpo_proc", "<STR_LIT>", ")", "return", "parseDirectiveFPOProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cv_fpo_setframe", "<STR_LIT>", ")", "return", "parseDirectiveFPOSetFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cv_fpo_pushreg", "<STR_LIT>", ")", "return", "parseDirectiveFPOPushReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cv_fpo_stackalloc", "<STR_LIT>", ")", "return", "parseDirectiveFPOStackAlloc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cv_fpo_stackalign", "<STR_LIT>", ")", "return", "parseDirectiveFPOStackAlign", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cv_fpo_endprologue", "<STR_LIT>", ")", "return", "parseDirectiveFPOEndPrologue", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cv_fpo_endproc", "<STR_LIT>", ")", "return", "parseDirectiveFPOEndProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".seh_pushreg", "<STR_LIT>", "||", "(", "Parser", ".", "isParsingMasm", "(", ")", "&&", "IDVal", ".", "equals_insensitive", "(", "<STR_LIT>", ".pushreg", "<STR_LIT>", ")", ")", ")", "return", "parseDirectiveSEHPushReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".seh_setframe", "<STR_LIT>", "||", "(", "Parser", ".", "isParsingMasm", "(", ")", "&&", "IDVal", ".", "equals_insensitive", "(", "<STR_LIT>", ".setframe", "<STR_LIT>", ")", ")", ")", "return", "parseDirectiveSEHSetFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".seh_savereg", "<STR_LIT>", "||", "(", "Parser", ".", "isParsingMasm", "(", ")", "&&", "IDVal", ".", "equals_insensitive", "(", "<STR_LIT>", ".savereg", "<STR_LIT>", ")", ")", ")", "return", "parseDirectiveSEHSaveReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".seh_savexmm", "<STR_LIT>", "||", "(", "Parser", ".", "isParsingMasm", "(", ")", "&&", "IDVal", ".", "equals_insensitive", "(", "<STR_LIT>", ".savexmm128", "<STR_LIT>", ")", ")", ")", "return", "parseDirectiveSEHSaveXMM", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".seh_pushframe", "<STR_LIT>", "||", "(", "Parser", ".", "isParsingMasm", "(", ")", "&&", "IDVal", ".", "equals_insensitive", "(", "<STR_LIT>", ".pushframe", "<STR_LIT>", ")", ")", ")", "return", "parseDirectiveSEHPushFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

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

[ "def", "VLD3LNd32", ":", "VLD3LN", "<", "<NUM_LIT>", ",", "{", "?", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "<STR_LIT>", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

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

[ "class", "sve_fp_3op_p_zds_b", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asm", ",", "ZPRRegOp", "zprty", ">", ":", "I", "<", "(", "outs", "zprty", ":", "$", "Zdn", ")", ",", "(", "ins", "PPR3bAny", ":", "$", "Pg", ",", "zprty", ":", "$", "_Zdn", ",", "zprty", ":", "$", "Zm", ",", "zprty", ":", "$", "Za", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Pg", ";", "bits", "<", "<NUM_LIT>", ">", "Za", ";", "bits", "<", "<NUM_LIT>", ">", "Zdn", ";", "bits", "<", "<NUM_LIT>", ">", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "imm", ";", "bits", "<", "<NUM_LIT>", ">", "shift", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "high", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "match_scratch", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "high", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "high", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "lo_sum", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashift", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "mips_unspec_address", "(", "operands", "[", "<NUM_LIT>", "]" ]

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

[ "def", "A2_subh_h16_sat_lh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_bd6011", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

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

[ "let", "BaseOpcode", "=", "<STR_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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";" ]

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

[ "def", "DMB", ":", "CRmSystemI", "<", "barrier_op" ]

[ "<FIXS>", "&&", "GET_CODE", "(", "MOVA_LABELREF", "(", "insn", ")", ")", "==", "LABEL_REF", ")", ";", "<FIXE>", "<FIXS>", "SET_SRC", "(", "PATTERN", "(", "mova", ")", ")", "=", "MOVA_LABELREF", "(", "mova", ")", ";", "<FIXE>" ]

[ "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_MOVA", "<BUGS>", "&&", "GET_CODE", "(", "XVECEXP", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", ")", ";", "<BUGE>", "}", "static", "voidfixup_mova", "(", "rtx", "mova", ")", "{", "if", "(", "!", "flag_pic", ")", "{", "<BUGS>", "SET_SRC", "(", "PATTERN", "(", "mova", ")", ")", "=", "XVECEXP", "(", "SET_SRC", "(", "PATTERN", "(", "mova", ")", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "INSN_CODE", "(", "mova", ")", "=", "-", "<NUM_LIT>", ";", "}", "else" ]

[ ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask3_fnmadd_ps", "(", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ",", "_", "_", "m128", "_", "_", "C", ",", "_", "_", "mmask8", "_", "_", "U", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_vfmaddps128_mask3", "(", "-", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_", "v4sf", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8" ]

[ "CurrentIdxReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Offset", ")", ";" ]

[ "BuildMI", "(", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "PHI", ")", ",", "PhiReg", ")", ".", "addReg", "(", "InitReg", ")", ".", "addMBB", "(", "&", "OrigBB", ")", ".", "addReg", "(", "ResultReg", ")", ".", "addMBB", "(", "&", "LoopBB", ")", ";", "BuildMI", "(", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "PHI", ")", ",", "PhiExec", ")", ".", "addReg", "(", "InitSaveExecReg", ")", ".", "addMBB", "(", "&", "OrigBB", ")", ".", "addReg", "(", "NewExec", ")", ".", "addMBB", "(", "&", "LoopBB", ")", ";", "BuildMI", "(", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "CurrentIdxReg", ")", ".", "addReg", "(", "IdxReg", ".", "getReg", "(", ")", ",", "getUndefRegState", "(", "IdxReg", ".", "isUndef", "(", ")", ")", ")", ";", "BuildMI", "(", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_CMP_EQ_U32_e64", ")", ",", "CondReg", ")", ".", "addReg", "(", "CurrentIdxReg", ")", ".", "addReg", "(", "IdxReg", ".", "getReg", "(", ")", ",", "<NUM_LIT>", ",", "IdxReg", ".", "getSubReg", "(", ")", ")", ";", "BuildMI", "(", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_AND_SAVEEXEC_B32", ":", "AMDGPU", "::", "S_AND_SAVEEXEC_B64", ")", ",", "NewExec", ")", ".", "addReg", "(", "CondReg", ",", "RegState", "::", "Kill", ")", ";", "MRI", ".", "setSimpleHint", "(", "NewExec", ",", "CondReg", ")", ";", "if", "(", "UseGPRIdxMode", ")", "{", "unsigned", "IdxReg", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "{", "IdxReg", "=", "CurrentIdxReg", ";", "}", "else", "{", "IdxReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ";", "BuildMI", "(", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_I32", ")", ",", "IdxReg", ")", ".", "addReg", "(" ]

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

[ "class", "MVE_mod_imm", "<", "string", "iname", ",", "string", "suffix", ",", "bits", "<", "<NUM_LIT>", ">", "cmode", ",", "bit", "op", ",", "dag", "iops", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVE_p", "<", "(", "outs", "MQPR", ":", "$", "Qd", ")", ",", "iops", ",", "NoItinerary", ",", "iname", ",", "suffix", ",", "<STR_LIT>", ",", "vpred_r", ",", "<STR_LIT>", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";", "bits", "<", "<NUM_LIT>", ">", "Qd", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "return", "NULL", ";" ]

[ "Value", "*", "X86IREmitter", "::", "visitTLSBASEADDR", "(", "const", "SDNode", "*", "N", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "visitTLSBASEADDR Unimplemented X86 visit...", "<STR_LIT>", ")", ";" ]

[ "break", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: Not a v8.1m.main+mve target.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "BasicBlock", "*", "Preheader", "=", "L", "->", "getLoopPreheader", "(", ")", ";", "if", "(", "!", "Preheader", ")", "return", "false", ";", "auto", "FindLoopIterations", "=", "[", "]", "(", "BasicBlock", "*", "BB", ")", "->", "IntrinsicInst", "*", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "auto", "*", "Call", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "Call", ")", "continue", ";", "Intrinsic", "::", "ID", "ID", "=", "Call", "->", "getIntrinsicID", "(", ")", ";", "if", "(", "ID", "==", "Intrinsic", "::", "set_loop_iterations", "||", "ID", "==", "Intrinsic", "::", "test_set_loop_iterations", ")", "return", "cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "}", "return", "nullptr", ";", "}", ";", "IntrinsicInst", "*", "Setup", "=", "FindLoopIterations", "(", "Preheader", ")", ";", "if", "(", "!", "Setup", ")", "{", "if", "(", "!", "Preheader", "->", "getSinglePredecessor", "(", ")", ")", "return", "false", ";", "Setup", "=", "FindLoopIterations", "(", "Preheader", "->", "getSinglePredecessor", "(", ")", ")", ";", "if", "(", "!", "Setup", ")", "return", "false", ";", "}", "IntrinsicInst", "*", "Decrement", "=", "nullptr", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "IsDecrement", "(", "I", ")", ")", "{", "Decrement", "=", "cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";" ]

[ "false", ";" ]

[ "bool", "isSelectSupported", "(", "SelectSupportKind", ")", "const", "override", "{", "return" ]

[ ")", ";" ]

[ "Stubs", "=", "MMIMacho", ".", "GetFnStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "const", "MCSection", "*", "TheSection", "=", "OutContext", ".", "getMachOSection", "(", "<STR_LIT>", "__IMPORT", "<STR_LIT>", ",", "<STR_LIT>", "__jump_table", "<STR_LIT>", ",", "MachO", "::", "S_SYMBOL_STUBS", "|", "MachO", "::", "S_ATTR_SELF_MODIFYING_CODE", "|", "MachO", "::", "S_ATTR_PURE_INSTRUCTIONS", ",", "<NUM_LIT>", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "TheSection", ")", ";", "for", "(", "const", "auto", "&", "Stub", ":", "Stubs", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stub", ".", "first", ")", ";", "OutStreamer", ".", "EmitSymbolAttribute", "(", "Stub", ".", "second", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "const", "char", "HltInsts", "[", "]", "=", "<STR_LIT>", "\\xf4\\xf4\\xf4\\xf4\\xf4", "<STR_LIT>", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "HltInsts", ",", "<NUM_LIT>", ")", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "const", "MCSection", "*", "TheSection", "=", "OutContext", ".", "getMachOSection", "(", "<STR_LIT>", "__IMPORT", "<STR_LIT>", ",", "<STR_LIT>", "__pointers", "<STR_LIT>", ",", "MachO", "::", "S_NON_LAZY_SYMBOL_POINTERS", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "TheSection", ")", ";", "for", "(", "auto", "&", "Stub", ":", "Stubs", ")", "emitNonLazySymbolPointer", "(", "OutStreamer", ",", "Stub", ".", "first", ",", "Stub", ".", "second", ")", ";", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetHiddenGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "const", "MCSection", "*", "TheSection", "=", "OutContext", ".", "getMachOSection", "(", "<STR_LIT>", "__IMPORT", "<STR_LIT>", ",", "<STR_LIT>", "__pointers", "<STR_LIT>", ",", "MachO", "::", "S_NON_LAZY_SYMBOL_POINTERS", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "TheSection", ")", ";", "for", "(", "auto", "&", "Stub", ":", "Stubs", ")", "emitNonLazySymbolPointer", "(", "OutStreamer", ",", "Stub", ".", "first", ",", "Stub", ".", "second", ")", ";", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "SM", ".", "serializeToStackMapSection", "(", ")", ";", "OutStreamer", ".", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "}", "if", "(", "Subtarget", "->", "isTargetKnownWindowsMSVC", "(", ")", "&&", "MMI", "->", "usesVAFloatArgument", "(", ")", ")", "{", "StringRef", "SymbolName", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "<STR_LIT>", "_fltused", "<STR_LIT>", ":", "<STR_LIT>", "__fltused", "<STR_LIT>", ";", "MCSymbol", "*", "S", "=", "MMI", "->", "getContext", "(", ")", ".", "GetOrCreateSymbol", "(", "SymbolName", ")", ";", "OutStreamer", ".", "EmitSymbolAttribute", "(", "S", ",", "MCSA_Global", ")", ";", "}", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "std", "::", "vector", "<", "const", "MCSymbol", "*", ">", "DLLExportedFns", ",", "DLLExportedGlobals", ";", "for", "(", "const", "auto", "&", "Function", ":", "M", ")", "if", "(", "Function", ".", "hasDLLExportStorageClass", "(", ")", ")", "DLLExportedFns", ".", "push_back", "(", "getSymbol", "(", "&", "Function", ")", ")", ";", "for", "(", "const", "auto", "&", "Global", ":", "M", ".", "globals", "(", ")", ")", "if", "(", "Global", ".", "hasDLLExportStorageClass", "(", ")", ")", "DLLExportedGlobals", ".", "push_back", "(", "getSymbol", "(", "&", "Global", ")", ")", ";", "for", "(", "const", "auto", "&", "Alias", ":", "M", ".", "aliases", "(", ")", ")", "{", "if", "(", "!", "Alias", ".", "hasDLLExportStorageClass", "(", ")", ")", "continue", ";", "if", "(", "Alias", ".", "getType", "(", ")", "->", "getElementType", "(", ")", "->", "isFunctionTy", "(", ")", ")", "DLLExportedFns", ".", "push_back", "(", "getSymbol", "(", "&", "Alias", ")", ")", ";", "else", "DLLExportedGlobals", ".", "push_back", "(", "getSymbol", "(", "&", "Alias", ")", ")", ";", "}", "if", "(", "!", "DLLExportedGlobals", ".", "empty", "(", ")", "||", "!", "DLLExportedFns", ".", "empty", "(", ")", ")", "{", "const", "TargetLoweringObjectFileCOFF", "&", "TLOFCOFF", "=", "static_cast", "<", "const", "TargetLoweringObjectFileCOFF", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "TLOFCOFF", ".", "getDrectveSection", "(", ")", ")", ";", "for", "(", "auto", "&", "Symbol", ":", "DLLExportedGlobals", ")", "GenerateExportDirective", "(", "Symbol", ",", "true", ")", ";", "for", "(", "auto", "&", "Symbol", ":", "DLLExportedFns", ")", "GenerateExportDirective", "(", "Symbol", ",", "false", ")", ";", "}", "}", "if", "(", "Subtarget", "->", "isTargetELF", "(", ")", ")", "{", "const", "TargetLoweringObjectFileELF", "&", "TLOFELF", "=", "static_cast", "<", "const", "TargetLoweringObjectFileELF", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoELF", "&", "MMIELF", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MachineModuleInfoELF", "::", "SymbolListTy", "Stubs", "=", "MMIELF", ".", "GetGVStubList", "(" ]

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

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

[ "<FIXS>", "extern", "void", "mmix_encode_section_info", "PARAMS", "(", "(", "tree", ",", "int", ")", ")", ";", "<FIXE>" ]

[ "extern", "void", "mmix_setup_incoming_varargsPARAMS", "(", "(", "CUMULATIVE_ARGS", "*", ",", "enum", "machine_mode", ",", "tree", ",", "int", "*", ",", "int", ")", ")", ";", "extern", "void", "mmix_select_section", "PARAMS", "(", "(", "tree", ",", "int", ",", "int", ")", ")", ";", "<BUGS>", "extern", "void", "mmix_encode_section_info", "PARAMS", "(", "(", "tree", ")", ")", ";", "<BUGE>", "extern", "void", "mmix_unique_section", "PARAMS", "(", "(", "tree", ",", "int", ")", ")", ";", "extern", "void", "mmix_asm_output_pool_prologuePARAMS", "(", "(", "FILE", "*", ",", "const", "char", "*", ",", "tree", ",", "int", ")", ")", ";" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "True", ",", "False", ",", "ARMcc", ",", "CCR", ",", "Cmp", ")", ";" ]

[ "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "SelectTrue", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "SelectFalse", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Cond", ".", "hasOneUse", "(", ")", ")", "{", "const", "ConstantSDNode", "*", "CMOVTrue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "const", "ConstantSDNode", "*", "CMOVFalse", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "CMOVTrue", "&&", "CMOVFalse", ")", "{", "unsigned", "CMOVTrueVal", "=", "CMOVTrue", "->", "getZExtValue", "(", ")", ";", "unsigned", "CMOVFalseVal", "=", "CMOVFalse", "->", "getZExtValue", "(", ")", ";", "SDValue", "True", ";", "SDValue", "False", ";", "if", "(", "CMOVTrueVal", "==", "<NUM_LIT>", "&&", "CMOVFalseVal", "==", "<NUM_LIT>", ")", "{", "True", "=", "SelectTrue", ";", "False", "=", "SelectFalse", ";", "}", "else", "if", "(", "CMOVTrueVal", "==", "<NUM_LIT>", "&&", "CMOVFalseVal", "==", "<NUM_LIT>", ")", "{", "True", "=", "SelectFalse", ";", "False", "=", "SelectTrue", ";", "}", "if", "(", "True", ".", "getNode", "(", ")", "&&", "False", ".", "getNode", "(", ")", ")", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDValue", "ARMcc", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "CCR", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Cmp", "=", "duplicateCmp", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "assert", "(", "True", ".", "getValueType", "(", ")", "==", "VT", ")", ";" ]

[ "_", "m1", ",", "(", "_", "_", "v4hi", ")", "_", "_", "m2", ")", ";" ]

[ "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_pcmpeqw", "(", "(", "_", "_", "v4hi", ")", "_" ]

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

[ "vreinterpretq_bf16_p64", "(", "poly64x2_t", "_", "_" ]

[ "(", "v2i64", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_lsx_vmskltz_d", "(" ]

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

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

[ "unsigned", "Lanes", "=", "cast", "<", "VectorType", ">", "(", "Insert", "->", "getType", "(", ")", ")", "->", "getNumElements", "(", ")", ";" ]

[ "if", "(", "!", "match", "(", "Shuffle", ",", "m_ShuffleVector", "(", "m_Instruction", "(", "Insert", ")", ",", "m_Undef", "(", ")", ",", "m_Zero", "(", ")", ")", ")", ")", "return", "false", ";", "Instruction", "*", "BECount", "=", "nullptr", ";", "if", "(", "!", "match", "(", "Insert", ",", "m_InsertElement", "(", "m_Undef", "(", ")", ",", "m_Instruction", "(", "BECount", ")", ",", "m_Zero", "(", ")", ")", ")", ")", "return", "false", ";", "Value", "*", "TripCount", "=", "nullptr", ";", "if", "(", "!", "match", "(", "BECount", ",", "m_Add", "(", "m_Value", "(", "TripCount", ")", ",", "m_AllOnes", "(", ")", ")", ")", ")", "return", "false", ";", "if", "(", "TripCount", "!=", "NumElements", ")", "return", "false", ";", "Instruction", "*", "BroadcastSplat", "=", "nullptr", ";", "Constant", "*", "Const", "=", "nullptr", ";", "if", "(", "!", "match", "(", "Induction", ",", "m_Add", "(", "m_Instruction", "(", "BroadcastSplat", ")", ",", "m_Constant", "(", "Const", ")", ")", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "CDS", "=", "dyn_cast", "<", "ConstantDataSequential", ">", "(", "Const", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "CDS", "->", "getNumElements", "(", ")", ";", "++", "i", ")", "{", "if", "(", "CDS", "->", "getElementAsInteger", "(", "i", ")", "!=", "i", ")", "return", "false", ";", "}", "}", "else", "return", "false", ";", "if", "(", "!", "match", "(", "BroadcastSplat", ",", "m_ShuffleVector", "(", "m_Instruction", "(", "Insert", ")", ",", "m_Undef", "(", ")", ",", "m_Zero", "(", ")", ")", ")", ")", "return", "false", ";", "Instruction", "*", "IV", "=", "nullptr", ";", "if", "(", "!", "match", "(", "Insert", ",", "m_InsertElement", "(", "m_Undef", "(", ")", ",", "m_Instruction", "(", "IV", ")", ",", "m_Zero", "(", ")", ")", ")", ")", "return", "false", ";", "auto", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "IV", ")", ";", "if", "(", "!", "Phi", ")", "return", "false", ";", "Value", "*", "OnEntry", "=", "Phi", "->", "getIncomingValueForBlock", "(", "L", "->", "getLoopPreheader", "(", ")", ")", ";", "if", "(", "!", "match", "(", "OnEntry", ",", "m_Zero", "(", ")", ")", ")", "return", "false", ";", "Value", "*", "InLoop", "=", "Phi", "->", "getIncomingValueForBlock", "(", "L", "->", "getLoopLatch", "(", ")", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "VF_128", "(", "multdiv", ":", "VF_128", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<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>" ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "XF", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "}", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "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", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>" ]

[ "}" ]

[ "static", "const", "MCPhysReg", "XMMArgRegs", "[", "]", "=", "{", "X86", "::", "XMM0", ",", "X86", "::", "XMM1", ",", "X86", "::", "XMM2", ",", "X86", "::", "XMM3", ",", "X86", "::", "XMM4", ",", "X86", "::", "XMM5", ",", "X86", "::", "XMM6", ",", "X86", "::", "XMM7", "}", ";", "unsigned", "GPRIdx", "=", "<NUM_LIT>", ";", "unsigned", "FPRIdx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "MVT", "VT", "=", "TLI", ".", "getSimpleValueType", "(", "DL", ",", "Arg", ".", "getType", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "unsigned", "SrcReg", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected value type.", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i32", ":", "SrcReg", "=", "GPR32ArgRegs", "[", "GPRIdx", "++", "]", ";", "break", ";", "case", "MVT", "::", "i64", ":", "SrcReg", "=", "GPR64ArgRegs", "[", "GPRIdx", "++", "]", ";", "break", ";", "case", "MVT", "::", "f32", ":", "LLVM_FALLTHROUGH", ";", "case", "MVT", "::", "f64", ":", "SrcReg", "=", "XMMArgRegs", "[", "FPRIdx", "++", "]", ";", "break", ";", "}", "unsigned", "DstReg", "=", "FuncInfo", ".", "MF", "->", "addLiveIn", "(", "SrcReg", ",", "RC", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ";", "updateValueMap", "(", "&", "Arg", ",", "ResultReg", ")", ";" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "ior", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CRIS_CC0_REGNUM", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

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

[ "def", ":", "VFP2MnemonicAlias", "<", "<STR_LIT>", "," ]

[ ";" ]

[ "else", "if", "(", "MO1", ".", "isImm", "(", ")", ")", "O", "<<", "<STR_LIT>", "[pc, #", "<STR_LIT>", "<<", "MO1", ".", "getImm", "(", ")", "<<", "<STR_LIT>", "]", "<STR_LIT>", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unknown LDR label operand?", "<STR_LIT>", ")" ]

[ "<FIXS>", "emit_insn", "(", "gen_subdi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "adjustment_rtx", ")", ")", ";", "<FIXE>", "<FIXS>", "emit_insn", "(", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "adjustment_rtx", ")", ")", ";", "<FIXE>", "<FIXS>", "mips_set_frame_expr", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "-", "tsize", ")", ")", ")", ";", "<FIXE>" ]

[ "adjustment_rtx", "=", "tsize_rtx", ";", "if", "(", "Pmode", "==", "DImode", ")", "<BUGS>", "insn", "=", "emit_insn", "(", "gen_subdi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "adjustment_rtx", ")", ")", ";", "<BUGE>", "else", "<BUGS>", "insn", "=", "emit_insn", "(", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "adjustment_rtx", ")", ")", ";", "dwarf_pattern", "=", "gen_rtx_SET", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "-", "tsize", ")", ")", ";", "<BUGE>", "<BUGS>", "mips_annotate_frame_insn", "(", "insn", ",", "dwarf_pattern", ")", ";", "<BUGE>", "}", "if", "(", "!", "mips_entry", ")" ]

[ "CodeGenOpt", "::", "Level", "OptLevel", ")", "const", "{" ]

[ "bool", "AArch64TargetLowering", "::", "generateFMAsInMachineCombiner", "(", "EVT", "VT", "," ]

[ "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SISubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "<STR_LIT>", "should not see multiple frame indices", "<STR_LIT>", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "<STR_LIT>", "frame index must be address operand", "<STR_LIT>", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", ")", ";", "assert", "(", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", "->", "getReg", "(", ")", "==", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "getFrameOffsetReg", "(", ")", "&&", "<STR_LIT>", "should only be seeing frame offset relative FrameIndex", "<STR_LIT>", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "assert", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "NewOffset", ")", "&&", "<STR_LIT>", "offset should be legal", "<STR_LIT>", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "}" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

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

[ "def", "A2_vsubw", ":", "T_VectALU_64", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "float", ")", "a1", ")", ";" ]

[ "return", "(", "vector", "float", ")", "_", "_", "builtin_altivec_vrefp", "(", "(", "vector" ]

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

[ "(", "truncate", ":", "HI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "truncate", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "R_FLAGS", ")", ")", "]", ")", "]", "<STR_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", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>" ]

[ "}" ]

[ "InitSystemZMCRegisterInfo", "(", "X", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "X", ";" ]

[ "}", "=", "R2", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "R2", ";", "bits", "<", "<NUM_LIT>", ">", "R3", ";", "bits", "<", "<NUM_LIT>", ">", "M4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

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

[ "def", "Z28", ":", "AArch64Reg", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "Q28", ",", "Z28_HI", "]", ">", ",", "DwarfRegNum" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_permutex2var_epi8", "(", "_", "_", "mmask64", "_", "_", "U", ",", "_", "_", "m512i", "_", "_", "A", ",", "_", "_", "m512i", "_", "_", "I", ",", "_", "_", "m512i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_vpermt2varqi512_maskz", "(", "(", "_", "_", "v64qi", ")", "_", "_", "I", ",", "(", "_", "_", "v64qi", ")", "_", "_", "A", ",", "(", "_", "_", "v64qi", ")", "_", "_", "B", ",", "(", "_", "_", "mmask64", ")", "_", "_", "U", ")", ";" ]

[ ">", ";" ]

[ "def", "ARMUmlal", ":", "SDNode", "<", "<STR_LIT>", ",", "SDT_ARM64bitmlal" ]

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

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

[ "}" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "aarch64_split_atomic_op", "(", "NOT", ",", "NULL", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "DONE" ]

[ "}" ]

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

[ ")", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ",", "<NUM_LIT>", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ",", "<NUM_LIT>", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "||", "reg_overlap_mentioned_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_INT", ")", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "<NUM_LIT>", ")", ";", "else", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "==", "POST_INC", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_MEM", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]" ]

[ "<", "addsub_shifted_imm32", ">", ";" ]

[ "def", "gi_addsub_shifted_imm32", ":", "GIComplexOperandMatcher", "<", "s32", ",", "<STR_LIT>", ">", ",", "GIComplexPatternEquiv" ]

[ ")", "]" ]

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

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

[ "[", "(", "set", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "GPR", "(", "plus", ":", "GPR", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "reg", ":", "GPR", "CA_REGNO", ")", ")", ")", "(", "clobber", "(", "reg", ":", "GPR", "CA_REGNO" ]

[ "}" ]

[ "const", "uint64_t", "F", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "return", "(", "Tile64Type", ")", "(", "(", "F", ">>", "TypePos", ")", "&", "TypeMask", ")", ";" ]

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

[ "def", "VLD1q32LowQPseudo_UPD", ":", "VLDQQQQWBPseudo", "<", "IIC_VLD1x4", ">", ",", "Sched", "<", "[" ]

[ "}" ]

[ "auto", "*", "ST", "=", "dyn_cast", "<", "StructType", ">", "(", "Ty", ")", ";", "if", "(", "!", "ST", ")", "return", "memVTFromLoadIntrData", "(", "TLI", ",", "DL", ",", "Ty", ",", "MaxNumLanes", ")", ";", "assert", "(", "ST", "->", "getNumContainedTypes", "(", ")", "==", "<NUM_LIT>", "&&", "ST", "->", "getContainedType", "(", "<NUM_LIT>", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", ";", "return", "memVTFromLoadIntrData", "(", "TLI", ",", "DL", ",", "ST", "->", "getContainedType", "(", "<NUM_LIT>", ")", ",", "MaxNumLanes", ")", ";" ]

[ "SYMBOL_REF_FLAGS", "(", "s390_tls_symbol", ")", "|=", "SYMBOL_FLAG_FUNCTION", ";" ]

[ "rtx", "insn", ";", "if", "(", "!", "flag_pic", ")", "emit_insn", "(", "s390_load_got", "(", ")", ")", ";", "if", "(", "!", "s390_tls_symbol", ")", "{", "s390_tls_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__tls_get_offset", "<STR_LIT>", ")", ";" ]

[ "bool", "ARMCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallingConv", "::", "ID", "CallConv", ",", "const", "MachineOperand", "&", "Callee", ",", "const", "ArgInfo", "&", "OrigRet", ",", "ArrayRef", "<", "ArgInfo", ">", "OrigArgs", ",", "const", "MDNode", "*", "KnownCallees", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "const", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "auto", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "STI", ".", "genLongCalls", "(", ")", ")", "return", "false", ";", "if", "(", "STI", ".", "isThumb1Only", "(", ")", ")", "return", "false", ";", "auto", "CallSeqStart", "=", "MIRBuilder", ".", "buildInstr", "(", "ARM", "::", "ADJCALLSTACKDOWN", ")", ";", "bool", "IsDirect", "=", "!", "Callee", ".", "isReg", "(", ")", ";", "auto", "CallOpcode", "=", "getCallOpcode", "(", "STI", ",", "IsDirect", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "CallOpcode", ")", ";", "bool", "IsThumb", "=", "STI", ".", "isThumb", "(", ")", ";", "if", "(", "IsThumb", ")", "MIB", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MIB", ".", "add", "(", "Callee", ")", ";", "if", "(", "!", "IsDirect", ")", "{", "auto", "CalleeReg", "=", "Callee", ".", "getReg", "(", ")", ";", "if", "(", "CalleeReg", "&&", "!", "TRI", "->", "isPhysicalRegister", "(", "CalleeReg", ")", ")", "{", "unsigned", "CalleeIdx", "=", "IsThumb", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "MIB", "->", "getOperand", "(", "CalleeIdx", ")", ".", "setReg", "(", "constrainOperandRegClass", "(", "MF", ",", "*", "TRI", ",", "MRI", ",", "*", "STI", ".", "getInstrInfo", "(", ")", ",", "*", "STI", ".", "getRegBankInfo", "(", ")", ",", "*", "MIB", ".", "getInstr", "(", ")", ",", "MIB", "->", "getDesc", "(", ")", ",", "Callee", ",", "CalleeIdx", ")", ")", ";", "}", "}", "MIB", ".", "addRegMask", "(", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallConv", ")", ")", ";", "bool", "IsVarArg", "=", "false", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "ArgInfos", ";", "for", "(", "auto", "Arg", ":", "OrigArgs", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "Ty", ")", ")", "return", "false", ";", "if", "(", "!", "Arg", ".", "IsFixed", ")", "IsVarArg", "=", "true", ";", "if", "(", "Arg", ".", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "splitToValueTypes", "(", "Arg", ",", "ArgInfos", ",", "MF", ")", ";", "}", "auto", "ArgAssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "CallConv", ",", "IsVarArg", ")", ";", "OutgoingValueHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "ArgAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "if", "(", "!", "OrigRet", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "OrigRet", ".", "Ty", ")", ")", "return", "false", ";", "ArgInfos", ".", "clear", "(", ")", ";", "splitToValueTypes", "(", "OrigRet", ",", "ArgInfos", ",", "MF", ")", ";", "auto", "RetAssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "CallConv", ",", "IsVarArg", ")", ";", "CallReturnHandler", "RetHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "RetHandler", ")", ")", "return", "false", ";", "}", "CallSeqStart", ".", "addImm", "(", "ArgHandler", ".", "StackSize", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "ARM", "::", "ADJCALLSTACKUP", ")", ".", "addImm", "(", "ArgHandler", ".", "StackSize", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "return", "true", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "if", "(", "(", "VT", "==", "MVT", "::", "v32i16", "||", "VT", "==", "MVT", "::", "v64i8", ")", "&&", "!", "EnableOldKNLABI", "&&", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v16i32", ";" ]

[ "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v32i8", ";", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "!", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "<NUM_LIT>", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "<NUM_LIT>", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", ")", "return", "MVT", "::", "i8", ";" ]

[ ")", "{" ]

[ "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".unreq", "<STR_LIT>", ")", "parseDirectiveUnreq", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".inst", "<STR_LIT>", ")", "parseDirectiveInst", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cfi_negate_ra_state", "<STR_LIT>", ")", "parseDirectiveCFINegateRAState", "(", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cfi_b_key_frame", "<STR_LIT>", ")", "parseDirectiveCFIBKeyFrame", "(", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".arch_extension", "<STR_LIT>", ")", "parseDirectiveArchExtension", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".variant_pcs", "<STR_LIT>", ")", "parseDirectiveVariantPCS", "(", "Loc", ")", ";", "else", "if", "(", "IsMachO" ]

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

[ "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_PCMP", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "<", "V48H_AVX512VL", ":", "avx512fmaskmode", ">", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_PCMP", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "<", "V48H_AVX512VL", ":", "MODE", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "operands", "[", "<NUM_LIT>", "]", "=", "lowpart_subreg", "(", "<", "V48H_AVX512VL", ":", "avx512fmaskmode", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<", "SWI248x", ":", "MODE", ">", "mode", ")", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "and", "(" ]

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

[ "def", "A2_tfrpfnew", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_1ae57e39", ",", "TypeALU32_2op", ">", ",", "PredNewRel", "{", "let", "isPredicated", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "unsigned", "HOST_WIDE_INT", "size", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "return", "data_section", ";", "}", "<BUGS>", "<BUGE>", "static", "boolmips_in_small_data_p", "(", "const_tree", "decl", ")", "{", "<BUGS>", "HOST_WIDE_INT", "size", ";", "<BUGE>", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "<BUGS>", "<BUGE>", "if", "(", "TARGET_ABICALLS", "||", "TARGET_VXWORKS_RTP", ")", "return", "false", ";" ]

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

[ "PTXMachineFunctionInfo", "(", "MachineFunction", "&", "MF", ")", ":", "IsKernel", "(", "false", ")", "{", "UsedRegs", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "RegisterList", "(", ")", ";", "UsedRegs", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "RegisterList", "(", ")", ";", "UsedRegs", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "RegisterList", "(", ")", ";", "UsedRegs", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "RegisterList", "(", ")", ";", "UsedRegs", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "RegisterList", "(", ")", ";", "UsedRegs", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=" ]

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

[ "unsigned", "getNumberOfRegisters", "(", "unsigned", "ClassID", ")", "const", "{", "bool", "Vector", "=", "(", "ClassID", "==", "<NUM_LIT>", ")", ";", "if", "(", "Vector", ")", "{", "return", "<NUM_LIT>", ";", "}" ]