Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "class", "T_LOGICAL_2OP", "<", "string", "MnOp", ",", "bits", "<", "<NUM_LIT>", ">", "OpBits", ",", "bit", "IsNeg", ",", "bit", "Rev", ">", ":", "CRInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps", ",", "PredRegs", ":", "$", "Pt", ")", ",", "<STR_LIT>", "#", "MnOp", "#", "<STR_LIT>", "#", "!", "if", "(", "IsNeg", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "<STR_LIT>", ",", "[", "]", ",", "<STR_LIT>", ",", "CR_tc_2early_SLOT23", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Pd", ";", "bits", "<", "<NUM_LIT>", ">", "Ps", ";" ]

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

[ "std", "::", "vector", "<", "std", "::", "string", ">", "load_movpd", "(", "Imm2" ]

[ "(", "_", "_", "v8hi", ")", "_", "_", "Y", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmaxuw128", "(", "(", "_", "_", "v8hi", ")", "_", "_", "X", "," ]

[ "if", "(", "!", "(", "w", "&", "(", "(", "HWINT", "(", "<NUM_LIT>", ")", ")", "<<", "i", ")", ")", ")", "break", ";" ]

[ "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "ASHIFTRT", ":", "n", "=", "INTVAL_OR_ELSE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "SIGN_EXTRACT", ":", "n", "=", "BITS_PER_WORD", "-", "INTVAL_OR_ELSE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "BITS_PER_WORD", ")", ";", "x", "=", "NULL_RTX", ";", "break", ";", "case", "IOR", ":", "w", "=", "INTVAL_OR_ELSE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "for", "(", "i", "=", "BITS_PER_WORD", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{" ]

[ "]", ";" ]

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

[ "void", "AMDGPUTargetLowering", "::", "analyzeFormalArgumentsCompute", "(", "CCState", "&", "State", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ")", "const", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "MemVT", ";", "unsigned", "NumRegs", "=", "getNumRegisters", "(", "State", ".", "getContext", "(", ")", ",", "In", ".", "ArgVT", ")", ";", "if", "(", "!", "Subtarget", "->", "isAmdHsaOS", "(", ")", "&&", "(", "In", ".", "ArgVT", "==", "MVT", "::", "i16", "||", "In", ".", "ArgVT", "==", "MVT", "::", "i8", "||", "In", ".", "ArgVT", "==", "MVT", "::", "f16", ")", ")", "{", "MemVT", "=", "In", ".", "ArgVT", ".", "isInteger", "(", ")", "?", "MVT", "::", "i32", ":", "MVT", "::", "f32", ";", "}", "else", "if", "(", "NumRegs", "==", "<NUM_LIT>", ")", "{", "assert", "(", "!", "In", ".", "Flags", ".", "isSplit", "(", ")", ")", ";", "if", "(", "In", ".", "ArgVT", ".", "isPow2Size", "(", ")", ")", "{", "MemVT", "=", "In", ".", "ArgVT", ";", "}", "else", "{", "MemVT", "=", "In", ".", "VT", ";", "}", "}", "else", "if", "(", "In", ".", "ArgVT", ".", "isVector", "(", ")", "&&", "In", ".", "VT", ".", "isVector", "(", ")", "&&", "In", ".", "ArgVT", ".", "getScalarType", "(", ")", "==", "In", ".", "VT", ".", "getScalarType", "(", ")", ")", "{", "assert", "(", "In", ".", "ArgVT", ".", "getVectorNumElements", "(", ")", ">", "In", ".", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "MemVT", "=", "In", ".", "VT", ";", "}", "else", "if", "(", "In", ".", "ArgVT", ".", "isVector", "(", ")", "&&", "In", ".", "ArgVT", ".", "getVectorNumElements", "(", ")", "==", "NumRegs", ")", "{", "MemVT", "=", "In", ".", "ArgVT", ".", "getScalarType", "(", ")", ";", "}", "else", "if", "(", "In", ".", "ArgVT", ".", "isExtended", "(", ")", ")", "{", "MemVT", "=", "In", ".", "VT", ";", "}", "else", "{", "unsigned", "MemoryBits", "=", "In", ".", "ArgVT", ".", "getStoreSizeInBits", "(", ")", "/", "NumRegs", ";", "assert", "(", "In", ".", "ArgVT", ".", "getStoreSizeInBits", "(", ")", "%", "NumRegs", "==", "<NUM_LIT>", ")", ";", "if", "(", "In", ".", "VT", ".", "isInteger", "(", ")", ")", "{", "MemVT", "=", "EVT", "::", "getIntegerVT", "(", "State", ".", "getContext", "(", ")", ",", "MemoryBits", ")", ";", "}", "else", "if", "(", "In", ".", "VT", ".", "isVector", "(", ")", ")", "{", "assert", "(", "!", "In", ".", "VT", ".", "getScalarType", "(", ")", ".", "isFloatingPoint", "(", ")", ")", ";", "unsigned", "NumElements", "=", "In", ".", "VT", ".", "getVectorNumElements", "(", ")", ";", "assert", "(", "MemoryBits", "%", "NumElements", "==", "<NUM_LIT>", ")", ";", "EVT", "ScalarVT", "=", "EVT", "::", "getIntegerVT", "(", "State", ".", "getContext", "(", ")", ",", "MemoryBits", "/", "NumElements", ")", ";", "MemVT", "=", "EVT", "::", "getVectorVT", "(", "State", ".", "getContext", "(", ")", ",", "ScalarVT", ",", "NumElements", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "cannot deduce memory type.", "<STR_LIT>", ")", ";", "}", "}", "if", "(", "MemVT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "getVectorNumElements", "(", ")", "==", "<NUM_LIT>", ")", "MemVT", "=", "MemVT", ".", "getScalarType", "(", ")", ";", "if", "(", "MemVT", ".", "isExtended", "(", ")", ")", "{", "assert", "(", "MemVT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "getVectorNumElements", "(", ")", "==", "<NUM_LIT>", ")", ";", "MemVT", "=", "MemVT", ".", "getPow2VectorType", "(", "State", ".", "getContext", "(", ")", ")", ";", "}", "assert", "(", "MemVT", ".", "isSimple", "(", ")", ")", ";", "allocateKernArg", "(", "i", ",", "In", ".", "VT", ",", "MemVT", ".", "getSimpleVT", "(", ")", ",", "CCValAssign", "::", "Full", ",", "In", ".", "Flags", ",", "State", ")", ";", "}", "}" ]

[ "The", "SelectionDAGBuilder", "will", "automatically", "promote", "function", "arguments", "with", "illegal", "types", "." ]

[ "(", "EXTRACT_SUBREG", "(", "INSERT_SUBREG", "(", "v16i8", "(", "IMPLICIT_DEF", ")", ")", ",", "(", "!", "cast", "<", "Instruction", ">", "(", "!", "strconcat", "(", "baseOpc", ",", "<STR_LIT>", ")", ")", "V64", ":", "$", "Rn", ")", ",", "bsub", ")", ",", "ssub", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "and", "(", "i32", "(", "vector_extract", "(", "insert_subvector", "undef", ",", "(", "opNode", "(", "v8i8", "V64", ":", "$", "Rn", ")", ")", ",", "(", "i32", "<NUM_LIT>", ")", ")", ",", "(", "i64", "<NUM_LIT>", ")", ")", ")", ",", "maski8_or_more", ")", ")", ",", "(", "i32" ]

[ "static", "void", "pa_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "<NUM_LIT>", ")", ";", "rtx", "start_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "end_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "line_length", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "r_tramp", ",", "tmp", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "r_tramp", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "fnaddr", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "chain_value", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "r_tramp", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "start_addr", ",", "r_tramp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "TRAMPOLINE_CODE_SIZE", "-", "<NUM_LIT>", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "end_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "emit_move_insn", "(", "line_length", ",", "GEN_INT", "(", "MIN_CACHELINE_SIZE", ")", ")", ";", "emit_insn", "(", "gen_dcacheflushsi", "(", "start_addr", ",", "end_addr", ",", "line_length", ")", ")", ";", "emit_insn", "(", "gen_icacheflushsi", "(", "start_addr", ",", "end_addr", ",", "line_length", ",", "gen_reg_rtx", "(", "Pmode", ")", ",", "gen_reg_rtx", "(", "Pmode", ")", ")", ")", ";", "}", "else", "{", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "fnaddr", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "chain_value", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "<NUM_LIT>", ")", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "start_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "tmp", ",", "TRAMPOLINE_CODE_SIZE", "-", "<NUM_LIT>", ")", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "end_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "emit_move_insn", "(", "line_length", ",", "GEN_INT", "(", "MIN_CACHELINE_SIZE", ")", ")", ";", "emit_insn", "(", "gen_dcacheflushdi", "(", "start_addr", ",", "end_addr", ",", "line_length", ")", ")", ";", "emit_insn", "(", "gen_icacheflushdi", "(", "start_addr", ",", "end_addr", ",", "line_length", ",", "gen_reg_rtx", "(", "Pmode", ")", ",", "gen_reg_rtx", "(", "Pmode", ")", ")", ")", ";", "}", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__enable_execute_stack", "<STR_LIT>", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "XEXP", "(", "m_tramp", ",", "<NUM_LIT>", ")", ",", "Pmode", ")", ";", "}" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "Move", "the", "function", "address", "to", "the", "trampoline", "template", "at", "offset", "36", ".", "Move", "the", "static", "chain", "value", "to", "trampoline", "template", "at", "offset", "40", ".", "Move", "the", "trampoline", "address", "to", "trampoline", "template", "at", "offset", "44", ".", "Move", "r19", "to", "trampoline", "template", "at", "offset", "48", ".", "The", "latter", "two", "words", "create", "a", "plabel", "for", "the", "indirect", "call", "to", "the", "trampoline", ".", "A", "similar", "sequence", "is", "used", "for", "the", "64-bit", "port", "but", "the", "plabel", "is", "at", "the", "beginning", "of", "the", "trampoline", ".", "Finally", ",", "the", "cache", "entries", "for", "the", "trampoline", "code", "are", "flushed", ".", "This", "is", "necessary", "to", "ensure", "that", "the", "trampoline", "instruction", "sequence", "is", "written", "to", "memory", "prior", "to", "any", "attempts", "at", "prefetching", "the", "code", "sequence", "." ]

[ "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "smin", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "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>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "FMOVXDr", "FPR64", ":", "$", "Rd", ",", "XZR", ")" ]

[ "is64Bit", "(", ")", "?", "X86", "::", "RETQ", ":", "X86", "::", "RETL", ")", ")", ";" ]

[ "if", "(", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSExt", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "FastEmitZExtFromI1", "(", "MVT", "::", "i8", ",", "SrcReg", ",", "false", ")", ";", "SrcVT", "=", "MVT", "::", "i8", ";", "}", "unsigned", "Op", "=", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", "?", "ISD", "::", "ZERO_EXTEND", ":", "ISD", "::", "SIGN_EXTEND", ";", "SrcReg", "=", "FastEmit_r", "(", "SrcVT", ".", "getSimpleVT", "(", ")", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "Op", ",", "SrcReg", ",", "false", ")", ";", "}", "unsigned", "DstReg", "=", "VA", ".", "getLocReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "if", "(", "!", "SrcRC", "->", "contains", "(", "DstReg", ")", ")", "return", "false", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "RetRegs", ".", "push_back", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "}", "if", "(", "F", ".", "hasStructRetAttr", "(", ")", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "Subtarget", "->", "isTargetKnownWindowsMSVC", "(", ")", ")", ")", "{", "unsigned", "Reg", "=", "X86MFInfo", "->", "getSRetReturnReg", "(", ")", ";", "assert", "(", "Reg", "&&", "<STR_LIT>", "SRetReturnReg should have been set in LowerFormalArguments()!", "<STR_LIT>", ")", ";", "unsigned", "RetReg", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "RetReg", ")", ".", "addReg", "(", "Reg", ")", ";", "RetRegs", ".", "push_back", "(", "RetReg", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Subtarget", "->" ]

[ "<FIXS>", "template", "typename", "T", ">", "void", "PipelineSolver", "::", "greedyFind", "(", "std", "::", "vector", "std", "::", "pair", "SUnit", "*", ",", "SUnit", "*", ">>", "&", "AddedEdges", ",", "T", "I", ",", "T", "E", ")", "{", "SUToCandSGsPair", "CurrSU", "=", "PipelineInstrs", "[", "CurrSyncGroupIdx", "]", "[", "CurrConflInstNo", "]", ";", "int", "BestNodeCost", "=", "-", "<NUM_LIT>", ";", "int", "TempCost", ";", "SchedGroup", "*", "BestGroup", "=", "nullptr", ";", "int", "BestGroupID", "=", "-", "<NUM_LIT>", ";", "auto", "&", "SyncPipeline", "=", "CurrPipeline", "[", "CurrSyncGroupIdx", "]", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Fitting SU(", "<STR_LIT>", "<<", "CurrSU", ".", "first", "->", "NodeNum", "<<", "<STR_LIT>", ") in Pipeline # ", "<STR_LIT>", "<<", "CurrSyncGroupIdx", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "<FIXE>", "<FIXS>", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "std", "::", "vector", "std", "::", "pair", "SUnit", "*", ",", "SUnit", "*", ">>", "AddedEdges", ";", "int", "CandSGID", "=", "*", "I", ";", "SchedGroup", "*", "Match", ";", "for", "(", "auto", "&", "SG", ":", "SyncPipeline", ")", "{", "if", "(", "SG", ".", "getSGID", "(", ")", "==", "CandSGID", ")", "Match", "=", "&", "SG", ";", "}", "<FIXE>", "<FIXS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Trying SGID # ", "<STR_LIT>", "<<", "CandSGID", "<<", "<STR_LIT>", " with Mask ", "<STR_LIT>", "<<", "(", "int", ")", "Match", "->", "getMask", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "<FIXE>", "<FIXS>", "if", "(", "Match", "->", "isFull", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "SGID # ", "<STR_LIT>", "<<", "CandSGID", "<<", "<STR_LIT>", " is full\\n", "<STR_LIT>", ")", ";", "continue", ";", "<FIXE>", "<FIXS>", "if", "(", "BestGroupID", "!=", "-", "<NUM_LIT>", ")", "{", "BestGroup", "->", "add", "(", "*", "CurrSU", ".", "first", ")", ";", "addEdges", "(", "SyncPipeline", ",", "CurrSU", ".", "first", ",", "BestGroupID", ",", "AddedEdges", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Best Group has ID: ", "<STR_LIT>", "<<", "BestGroupID", "<<", "<STR_LIT>", " and Mask", "<STR_LIT>", "<<", "(", "int", ")", "BestGroup", "->", "getMask", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "BestCost", "+=", "TempCost", ";", "}", "elseBestCost", "+=", "MissPenalty", ";", "<FIXE>", "<FIXS>", "CurrPipeline", "[", "CurrSyncGroupIdx", "]", "=", "SyncPipeline", ";", "}", "bool", "PipelineSolver", "::", "solveGreedy", "(", ")", "{", "BestCost", "=", "<NUM_LIT>", ";", "std", "::", "vector", "std", "::", "pair", "SUnit", "*", ",", "SUnit", "*", ">>", "AddedEdges", ";", "while", "(", "static_cast", "size_t", ">", "(", "CurrSyncGroupIdx", ")", "PipelineInstrs", ".", "size", "(", ")", ")", "{", "SUToCandSGsPair", "CurrSU", "=", "PipelineInstrs", "[", "CurrSyncGroupIdx", "]", "[", "CurrConflInstNo", "]", ";", "IsBottomUp", "?", "greedyFind", "(", "AddedEdges", ",", "CurrSU", ".", "second", ".", "rbegin", "(", ")", ",", "CurrSU", ".", "second", ".", "rend", "(", ")", ")", ":", "greedyFind", "(", "AddedEdges", ",", "CurrSU", ".", "second", ".", "begin", "(", ")", ",", "CurrSU", ".", "second", ".", "end", "(", ")", ")", ";", "<FIXE>" ]

[ "return", "FinishedExploring", ";", "}", "<BUGS>", "bool", "PipelineSolver", "::", "solveGreedy", "(", ")", "{", "BestCost", "=", "<NUM_LIT>", ";", "std", "::", "vector", "std", "::", "pair", "SUnit", "*", ",", "SUnit", "*", ">>", "AddedEdges", ";", "<BUGE>", "<BUGS>", "while", "(", "static_cast", "size_t", ">", "(", "CurrSyncGroupIdx", ")", "PipelineInstrs", ".", "size", "(", ")", ")", "{", "SUToCandSGsPair", "CurrSU", "=", "PipelineInstrs", "[", "CurrSyncGroupIdx", "]", "[", "CurrConflInstNo", "]", ";", "int", "BestNodeCost", "=", "-", "<NUM_LIT>", ";", "int", "TempCost", ";", "SchedGroup", "*", "BestGroup", "=", "nullptr", ";", "int", "BestGroupID", "=", "-", "<NUM_LIT>", ";", "auto", "&", "SyncPipeline", "=", "CurrPipeline", "[", "CurrSyncGroupIdx", "]", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Fitting SU(", "<STR_LIT>", "<<", "CurrSU", ".", "first", "->", "NodeNum", "<<", "<STR_LIT>", ") in Pipeline # ", "<STR_LIT>", "<<", "CurrSyncGroupIdx", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "auto", "I", "=", "CurrSU", ".", "second", ".", "rbegin", "(", ")", ";", "auto", "E", "=", "CurrSU", ".", "second", ".", "rend", "(", ")", ";", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "std", "::", "vector", "std", "::", "pair", "SUnit", "*", ",", "SUnit", "*", ">>", "AddedEdges", ";", "int", "CandSGID", "=", "*", "I", ";", "SchedGroup", "*", "Match", ";", "for", "(", "auto", "&", "SG", ":", "SyncPipeline", ")", "{", "if", "(", "SG", ".", "getSGID", "(", ")", "==", "CandSGID", ")", "Match", "=", "&", "SG", ";", "}", "<BUGE>", "<BUGS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Trying SGID # ", "<STR_LIT>", "<<", "CandSGID", "<<", "<STR_LIT>", " with Mask ", "<STR_LIT>", "<<", "(", "int", ")", "Match", "->", "getMask", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "<BUGE>", "<BUGS>", "if", "(", "Match", "->", "isFull", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "SGID # ", "<STR_LIT>", "<<", "CandSGID", "<<", "<STR_LIT>", " is full\\n", "<STR_LIT>", ")", ";", "continue", ";", "}", "TempCost", "=", "addEdges", "(", "SyncPipeline", ",", "CurrSU", ".", "first", ",", "CandSGID", ",", "AddedEdges", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Cost of Group ", "<STR_LIT>", "<<", "TempCost", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "TempCost", "BestNodeCost", "||", "BestNodeCost", "==", "-", "<NUM_LIT>", ")", "{", "BestGroup", "=", "Match", ";", "BestNodeCost", "=", "TempCost", ";", "BestGroupID", "=", "CandSGID", ";", "}", "removeEdges", "(", "AddedEdges", ")", ";", "if", "(", "BestNodeCost", "==", "<NUM_LIT>", ")", "break", ";", "<BUGE>", "}", "<BUGS>", "if", "(", "BestGroupID", "!=", "-", "<NUM_LIT>", ")", "{", "BestGroup", "->", "add", "(", "*", "CurrSU", ".", "first", ")", ";", "addEdges", "(", "SyncPipeline", ",", "CurrSU", ".", "first", ",", "BestGroupID", ",", "AddedEdges", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Best Group has ID: ", "<STR_LIT>", "<<", "BestGroupID", "<<", "<STR_LIT>", " and Mask", "<STR_LIT>", "<<", "(", "int", ")", "BestGroup", "->", "getMask", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "BestCost", "+=", "TempCost", ";", "}", "elseBestCost", "+=", "MissPenalty", ";", "<BUGE>", "<BUGS>", "CurrPipeline", "[", "CurrSyncGroupIdx", "]", "=", "SyncPipeline", ";", "<BUGE>", "advancePosition", "(", ")", ";", "}", "BestPipeline", "=", "CurrPipeline", ";" ]

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

[ "(", "define_reservation" ]

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

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

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

[ "[", "(", "set", "(", "match_operand", ":", "V8FI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "V8FI", "(", "match_operand", ":", "V8FI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "}" ]

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

[ ")", ",", "LoadVal", "->", "getOffset", "(", ")", ",", "LoadVT", ",", "LoadVal", "->", "getMemOperand", "(", ")", ")", ";" ]

[ "EVT", "MemVT", "=", "LoadVal", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "N", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "EVT", "LoadVT", "=", "getEquivalentMemType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MemVT", ")", ";", "SDValue", "NewLoad", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "ISD", "::", "NON_EXTLOAD", ",", "LoadVT", ",", "SL", ",", "LoadVal", "->", "getChain", "(", ")", ",", "LoadVal", "->", "getBasePtr", "(" ]

[ "Vec", ",", "ShiftVec", ")", ";" ]

[ "Value", "*", "Amt", "=", "II", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "auto", "*", "VT", "=", "cast", "<", "FixedVectorType", ">", "(", "Vec", "->", "getType", "(", ")", ")", ";", "Type", "*", "SVT", "=", "VT", "->", "getElementType", "(", ")", ";", "Type", "*", "AmtVT", "=", "Amt", "->", "getType", "(", ")", ";", "unsigned", "VWidth", "=", "VT", "->", "getNumElements", "(", ")", ";", "unsigned", "BitWidth", "=", "SVT", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "IsImm", ")", "{", "assert", "(", "AmtVT", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Unexpected shift-by-immediate type", "<STR_LIT>", ")", ";", "KnownBits", "KnownAmtBits", "=", "llvm", "::", "computeKnownBits", "(", "Amt", ",", "II", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "KnownAmtBits", ".", "getMaxValue", "(", ")", ".", "ult", "(", "BitWidth", ")", ")", "{", "Amt", "=", "Builder", ".", "CreateZExtOrTrunc", "(", "Amt", ",", "SVT", ")", ";", "Amt", "=", "Builder", ".", "CreateVectorSplat", "(", "VWidth", ",", "Amt", ")", ";", "return", "(", "LogicalShift", "?", "(", "ShiftLeft", "?", "Builder", ".", "CreateShl", "(", "Vec", ",", "Amt", ")", ":", "Builder", ".", "CreateLShr", "(", "Vec", ",", "Amt", ")", ")", ":", "Builder", ".", "CreateAShr", "(", "Vec", ",", "Amt", ")", ")", ";", "}", "if", "(", "KnownAmtBits", ".", "getMinValue", "(", ")", ".", "uge", "(", "BitWidth", ")", ")", "{", "if", "(", "LogicalShift", ")", "return", "ConstantAggregateZero", "::", "get", "(", "VT", ")", ";", "Amt", "=", "ConstantInt", "::", "get", "(", "SVT", ",", "BitWidth", "-", "<NUM_LIT>", ")", ";", "return", "Builder", ".", "CreateAShr", "(", "Vec", ",", "Builder", ".", "CreateVectorSplat", "(", "VWidth", ",", "Amt", ")", ")", ";", "}", "}", "else", "{", "assert", "(", "AmtVT", "->", "isVectorTy", "(", ")", "&&", "AmtVT", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "cast", "<", "VectorType", ">", "(", "AmtVT", ")", "->", "getElementType", "(", ")", "==", "SVT", "&&", "<STR_LIT>", "Unexpected shift-by-scalar type", "<STR_LIT>", ")", ";", "unsigned", "NumAmtElts", "=", "cast", "<", "FixedVectorType", ">", "(", "AmtVT", ")", "->", "getNumElements", "(", ")", ";", "APInt", "DemandedLower", "=", "APInt", "::", "getOneBitSet", "(", "NumAmtElts", ",", "<NUM_LIT>", ")", ";", "APInt", "DemandedUpper", "=", "APInt", "::", "getBitsSet", "(", "NumAmtElts", ",", "<NUM_LIT>", ",", "NumAmtElts", "/", "<NUM_LIT>", ")", ";", "KnownBits", "KnownLowerBits", "=", "llvm", "::", "computeKnownBits", "(", "Amt", ",", "DemandedLower", ",", "II", ".", "getDataLayout", "(", ")", ")", ";", "KnownBits", "KnownUpperBits", "=", "llvm", "::", "computeKnownBits", "(", "Amt", ",", "DemandedUpper", ",", "II", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "KnownLowerBits", ".", "getMaxValue", "(", ")", ".", "ult", "(", "BitWidth", ")", "&&", "(", "DemandedUpper", ".", "isZero", "(", ")", "||", "KnownUpperBits", ".", "isZero", "(", ")", ")", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ZeroSplat", "(", "VWidth", ",", "<NUM_LIT>", ")", ";", "Amt", "=", "Builder", ".", "CreateShuffleVector", "(", "Amt", ",", "ZeroSplat", ")", ";", "return", "(", "LogicalShift", "?", "(", "ShiftLeft", "?", "Builder", ".", "CreateShl", "(", "Vec", ",", "Amt", ")", ":", "Builder", ".", "CreateLShr", "(", "Vec", ",", "Amt", ")", ")", ":", "Builder", ".", "CreateAShr", "(", "Vec", ",", "Amt", ")", ")", ";", "}", "}", "auto", "*", "CDV", "=", "dyn_cast", "<", "ConstantDataVector", ">", "(", "Amt", ")", ";", "if", "(", "!", "CDV", ")", "return", "nullptr", ";", "assert", "(", "AmtVT", "->", "isVectorTy", "(", ")", "&&", "AmtVT", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "cast", "<", "VectorType", ">", "(", "AmtVT", ")", "->", "getElementType", "(", ")", "==", "SVT", "&&", "<STR_LIT>", "Unexpected shift-by-scalar type", "<STR_LIT>", ")", ";", "APInt", "Count", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "NumSubElts", "=", "<NUM_LIT>", "/", "BitWidth", ";", "i", "!=", "NumSubElts", ";", "++", "i", ")", "{", "unsigned", "SubEltIdx", "=", "(", "NumSubElts", "-", "<NUM_LIT>", ")", "-", "i", ";", "auto", "*", "SubElt", "=", "cast", "<", "ConstantInt", ">", "(", "CDV", "->", "getElementAsConstant", "(", "SubEltIdx", ")", ")", ";", "Count", "<<=", "BitWidth", ";", "Count", "|=", "SubElt", "->", "getValue", "(", ")", ".", "zextOrTrunc", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "Count", ".", "isZero", "(", ")", ")", "return", "Vec", ";", "if", "(", "Count", ".", "uge", "(", "BitWidth", ")", ")", "{", "if", "(", "LogicalShift", ")", "return", "ConstantAggregateZero", "::", "get", "(", "VT", ")", ";", "Count", "=", "APInt", "(", "<NUM_LIT>", ",", "BitWidth", "-", "<NUM_LIT>", ")", ";", "}", "auto", "ShiftAmt", "=", "ConstantInt", "::", "get", "(", "SVT", ",", "Count", ".", "zextOrTrunc", "(", "BitWidth", ")", ")", ";", "auto", "ShiftVec", "=", "Builder", ".", "CreateVectorSplat", "(", "VWidth", ",", "ShiftAmt", ")", ";", "if", "(", "ShiftLeft", ")", "return", "Builder", ".", "CreateShl", "(", "Vec", ",", "ShiftVec", ")", ";", "if", "(", "LogicalShift", ")", "return", "Builder", ".", "CreateLShr", "(", "Vec", ",", "ShiftVec", ")", ";", "return", "Builder", ".", "CreateAShr", "(" ]

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

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

[ "Unexpected relocation", "<STR_LIT>", ")", ";" ]

[ "GotEntryKey", "key", ";", "key", ".", "m_GOTPage", "=", "m_CurrentGOTPart", ";", "key", ".", "m_pInfo", "=", "pInfo", ";", "key", ".", "m_Addend", "=", "<NUM_LIT>", ";", "GotEntryMapType", "::", "iterator", "it", "=", "m_GotTLSGdEntriesMap", ".", "find", "(", "key", ")", ";", "return", "it", "==", "m_GotTLSGdEntriesMap", ".", "end", "(", ")", "?", "nullptr", ":", "it", "->", "second", ";", "}", "if", "(", "pType", "==", "llvm", "::", "ELF", "::", "R_MIPS_TLS_GOTTPREL", ")", "{", "GotEntryKey", "key", ";", "key", ".", "m_GOTPage", "=", "m_CurrentGOTPart", ";", "key", ".", "m_pInfo", "=", "pInfo", ";", "key", ".", "m_Addend", "=", "<NUM_LIT>", ";", "GotEntryMapType", "::", "iterator", "it", "=", "m_GotTLSGotEntriesMap", ".", "find", "(", "key", ")", ";", "return", "it", "==", "m_GotTLSGotEntriesMap", ".", "end", "(", ")", "?", "nullptr", ":", "it", "->", "second", ";", "}", "llvm_unreachable", "(", "<STR_LIT>" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "extend", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";" ]

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

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

[ "int", "lm32_return_in_memory", "(", "tree", "type", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "return", "<NUM_LIT>", ";", "}", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", ">=", "<NUM_LIT>", "&&", "size", "<=", "UNITS_PER_WORD", ")", "{", "return", "<NUM_LIT>", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "non-zero", "if", "the", "given", "return", "type", "should", "be", "returned", "in", "memory", "." ]

[ "=", "base", ";" ]

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

[ "static", "void", "ix86_emit_restore_reg_using_pop", "(", "rtx", "reg", ",", "bool", "ppx_p", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_pop", "(", "reg", ",", "ppx_p", ")", ")", ";", "ix86_add_cfa_restore_note", "(", "insn", ",", "reg", ",", "m", "->", "fs", ".", "sp_offset", ")", ";", "m", "->", "fs", ".", "sp_offset", "-=", "UNITS_PER_WORD", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "crtl", "->", "drap_reg", "&&", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "m", "->", "fs", ".", "drap_valid", "=", "true", ";", "return", ";", "}", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "stack_pointer_rtx", ")", "{", "rtx", "x", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ";", "x", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "x", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "x", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "m", "->", "fs", ".", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "reg", "==", "hard_frame_pointer_rtx", ")", "{", "m", "->", "fs", ".", "fp_valid", "=", "false", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "hard_frame_pointer_rtx", ")", "{", "m", "->", "fs", ".", "cfa_reg", "=", "stack_pointer_rtx", ";", "m", "->", "fs", ".", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "m", "->", "fs", ".", "cfa_offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "}", "}" ]

[ "Emit", "code", "to", "restore", "REG", "using", "a", "POP", "insn", "." ]

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

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

[ ";" ]

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

[ "\t", "<STR_LIT>" ]

[ "(", "mem", ":", "QIHI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "QIHI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "mem", ":", "QIHI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "unspec", ":", "QIHI", "[", "(", "FETCHOP", ":", "QIHI", "(", "mem", ":", "QIHI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "UNSPEC_ATOMIC", ")", ")", "(", "set", "(", "reg", ":", "SI", "T_REG", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R0_REG", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "return", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t" ]

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

[ "rtvec", "v", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "if", "(", "!", "ISA_HAS_MSA", ")", "return", "false", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "d", "->", "nelt", ";", "i", "++", ")", "elts", "[", "i", "]", "=", "GEN_INT", "(", "d", "->", "perm", "[", "i", "]", ")", ";", "v", "=", "gen_rtvec_v", "(", "d", "->", "nelt", ",", "elts", ")", ";", "x", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "v", ")", ";", "if", "(", "!", "mips_const_vector_shuffle_set_p", "(", "x", ",", "d", "->", "vmode", ")", ")", "return", "false", ";", "x", "=", "gen_rtx_VEC_SELECT", "(", "d", "->", "vmode", ",", "d", "->", "op0", "," ]

[ "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "assert", "(", "MF", "&&", "<STR_LIT>", "MachineFunction required", "<STR_LIT>", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "default", ":", "break", ";", "}", "bool", "IsNaCl", "=", "Subtarget", ".", "isTargetNaCl", "(", ")", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "IsNaCl", ")", "{", "if", "(", "CallsEHReturn", ")", "return", "CSR_NaCl64EHRet_SaveList", ";", "return", "CSR_NaCl64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "}" ]

[ "if", "(", "mips_symbol_insns", "(", "symbol_type", ",", "mode", ")", "==", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "mips_lo_relocs", "[", "symbol_type", "]", "==", "NULL", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "return", "true", ";" ]

[ "<FIXS>", "N", "-", ">", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "<FIXE>", "<FIXS>", "N", "-", ">", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "<FIXE>" ]

[ "def", "bitcast_fpimm_to_i32", ":", "SDNodeXForm", "fpimm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "<BUGS>", "N", "-", ">", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ",", "MVT", ":", ":", "i32", ")", ";", "<BUGE>", "}", "]", ">", ";", "def", "bitcast_fpimm_to_i64", ":", "SDNodeXForm", "fpimm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "<BUGS>", "N", "-", ">", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ",", "MVT", ":", ":", "i64", ")", ";", "<BUGE>", "}", "]", ">", ";" ]

[ "<FIXS>", "output_asm_insn", "(", "<STR_LIT>", "brasl\\t0,%2%K2", "<STR_LIT>", ",", "op", ")", ";", "<FIXE>" ]

[ "warning", "(", "OPT_Wcannot_profile", ",", "<STR_LIT>", "nested functions cannot be profiled ", "<STR_LIT>", "<STR_LIT>", "with %<-mfentry%> on s390", "<STR_LIT>", ")", ";", "else", "<BUGS>", "output_asm_insn", "(", "<STR_LIT>", "brasl\\t0,%2", "<STR_LIT>", ",", "op", ")", ";", "<BUGE>", "}", "else", "if", "(", "TARGET_64BIT", ")", "{" ]

[ "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "NumBytes", "-", "<NUM_LIT>", "-", "i", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "Idx", "*", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";", "}", "}" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "<NUM_LIT>", ";" ]

[ "def", "Wrs", ":", "BaseAddSubSReg", "<", "isSub", ",", "<NUM_LIT>", ",", "GPR32", ",", "arith_shifted_reg32", ",", "mnemonic", ",", "OpNode", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "}" ]

[ "SDValue", "V2", "=", "SVOp", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VT", "=", "SVOp", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "unsigned", "NumElems", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "V1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "CONCAT_VECTORS", "&&", "V2", ".", "getOpcode", "(", ")", "==", "ISD", "::", "CONCAT_VECTORS", ")", "{", "if", "(", "V2", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "BUILD_VECTOR", "||", "V2", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "UNDEF", "||", "V1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "UNDEF", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "ISD", "::", "isBuildVectorAllZeros", "(", "V2", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", "/", "<NUM_LIT>", ";", "++", "i", ")", "if", "(", "!", "isUndefOrEqual", "(", "SVOp", "->", "getMaskElt", "(", "i", ")", ",", "i", ")", "||", "!", "isUndefOrEqual", "(", "SVOp", "->", "getMaskElt", "(", "i", "+", "NumElems", "/", "<NUM_LIT>", ")", ",", "NumElems", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "LoadSDNode", "*", "Ld", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "V1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "Ld", "->", "hasNUsesOfValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "v4i64", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Ld", "->", "getChain", "(", ")", ",", "Ld", "->", "getBasePtr", "(", ")", "}", ";", "SDValue", "ResNode", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Ops", ",", "array_lengthof", "(", "Ops", ")", ",", "Ld", "->", "getMemoryVT", "(", ")", ",", "Ld", "->", "getPointerInfo", "(", ")", ",", "Ld", "->", "getAlignment", "(", ")", ",", "false", ",", "true", ",", "false", ")", ";", "if", "(", "Ld", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", ")", "{", "SDValue", "NewChain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "SDValue", "(", "Ld", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "ResNode", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "Ld", ",", "<NUM_LIT>", ")", ",", "NewChain", ")", ";", "DAG", ".", "UpdateNodeOperands", "(", "NewChain", ".", "getNode", "(", ")", ",", "SDValue", "(", "Ld", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "ResNode", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "MachineInstr", "*", "LanaiInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", ")", "const", "{", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "unknown select instruction", "<STR_LIT>", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "PreviousClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "PreviousClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "add", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "getOppositeCondition", "(", "LPCC", "::", "CondCode", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "copyImplicitOps", "(", "MI", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "add", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "<NUM_LIT>", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "if", "(", "DefMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", ")", "NewMI", "->", "clearKillInfo", "(", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ ";" ]

[ "SDValue", "Cpu0TargetLowering", "::", "LowerBRCOND", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "Op" ]

[ "<NUM_LIT>", ";" ]

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

[ "<STR_LIT>" ]

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

[ "ArrayRef", "<", "Register", ">", "OrigArgRegs", "=", "VRegs", "[", "i", "]", ";" ]

[ "const", "DataLayout", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "allocateHSAUserSGPRs", "(", "CCInfo", ",", "MIRBuilder", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "const", "unsigned", "KernArgBaseAlign", "=", "<NUM_LIT>", ";", "const", "unsigned", "BaseOffset", "=", "Subtarget", "->", "getExplicitKernelArgOffset", "(", "F", ")", ";", "uint64_t", "ExplicitArgOffset", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "unsigned", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "ArgTy", ")", ";", "if", "(", "AllocSize", "==", "<NUM_LIT>", ")", "continue", ";", "unsigned", "ABIAlign", "=", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ";", "uint64_t", "ArgOffset", "=", "alignTo", "(", "ExplicitArgOffset", ",", "ABIAlign", ")", "+", "BaseOffset", ";", "ExplicitArgOffset", "=", "alignTo", "(", "ExplicitArgOffset", ",", "ABIAlign", ")", "+", "AllocSize", ";" ]

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

[ "def", "J4_jumpseti", ":", "HInst", "<", "(", "outs", "GeneralSubRegs", ":", "$", "Rd16", ")", ",", "(", "ins", "u6_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_0663f615", ",", "TypeCJ", ">", ",", "Enc_9e4c3f", "{", "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", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "if", "(", "Idx", "==", "AMDGPU", "::", "RegisterPressureSets", "::", "VGPR_32", "||", "Idx", "==", "AMDGPU", "::", "RegisterPressureSets", "::", "AGPR_32", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "if", "(", "Idx", "==", "AMDGPU", "::", "RegisterPressureSets", "::", "SReg_32", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected register pressure set!", "<STR_LIT>", ")", ";", "}" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ ")", "==", "ISD", "::", "ZEXTLOAD", ")", "{" ]

[ "bool", "zextval", "=", "(", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "ZEXTLOAD", ")", ";", "const", "HexagonInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "LoadedVT", "==", "MVT", "::", "i64", ")", "{", "if", "(", "TII", "->", "isValidAutoIncImm", "(", "LoadedVT", ",", "Val", ")", ")", "Opcode", "=", "Hexagon", "::", "POST_LDrid", ";", "else", "Opcode", "=", "Hexagon", "::", "LDrid", ";", "}", "else", "if", "(", "LoadedVT", "==", "MVT", "::", "i32", ")", "{", "if", "(", "TII", "->", "isValidAutoIncImm", "(", "LoadedVT", ",", "Val", ")", ")", "Opcode", "=", "Hexagon", "::", "POST_LDriw", ";", "else", "Opcode", "=", "Hexagon", "::", "LDriw", ";", "}", "else", "if", "(", "LoadedVT", "==", "MVT", "::", "i16", ")", "{", "if", "(", "TII", "->", "isValidAutoIncImm", "(", "LoadedVT", ",", "Val", ")", ")", "Opcode", "=", "zextval", "?", "Hexagon", "::", "POST_LDriuh", ":", "Hexagon", "::", "POST_LDrih", ";", "else", "Opcode", "=", "zextval", "?", "Hexagon", "::", "LDriuh", ":", "Hexagon", "::", "LDrih", ";", "}", "else", "if", "(", "LoadedVT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "TII", "->", "isValidAutoIncImm", "(", "LoadedVT", ",", "Val", ")", ")", "Opcode", "=", "zextval", "?", "Hexagon", "::", "POST_LDriub", ":", "Hexagon", "::", "POST_LDrib", ";", "else", "Opcode", "=", "zextval", "?", "Hexagon", "::", "LDriub", ":", "Hexagon", "::", "LDrib", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "unknown memory type", "<STR_LIT>", ")", ";", "if", "(", "LD", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i64", "&&", "LD", "->", "getExtensionType", "(" ]

[ "isSymbolPreemptible", "(", "pSym", ")", ")", "return", "false", ";" ]

[ "if", "(", "pSym", ".", "isDyn", "(", ")", "||", "pSym", ".", "isUndef", "(", ")", "||", "pFactory", ".", "getTarget", "(", ")", "." ]

[ "unsigned", "TMS320C64XInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "TargetInstrDesc", "desc", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", "&&", "!", "(", "desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MachineOperand", "op", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "op", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "op", ".", "getIndex", "(", ")", ";", "return", "true", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Found load-from-stack sans ", "<STR_LIT>", "<STR_LIT>", "frame index operand", "<STR_LIT>", ")", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ ";" ]

[ "bool", "AMDGPUAsmParser", "::", "ParseDirectiveMajorMinor", "(", "uint32_t", "&", "Major", ",", "uint32_t", "&", "Minor", ")", "{", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Integer", ")", ")", "return", "TokError", "(", "<STR_LIT>", "invalid major version", "<STR_LIT>", ")", ";", "Major", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getIntVal", "(", ")", ";", "Lex", "(", ")" ]

[ ",", "ORRvi_lsl_4S", ",", "VPR128", ">", ";" ]

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

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

[ "def", "p_imm", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "CoprocNumAsmOperand", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "\t", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ ";" ]

[ "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "StringRef", "Value", "=", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "Value", "!=", "<STR_LIT>", "xx", "<STR_LIT>", ")", "{", "reportParseError", "(", "<STR_LIT>", "unsupported value, expected 'xx', '32' or '64'", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "!", "isABI_O32", "(", ")", ")", "{", "reportParseError", "(", "<STR_LIT>", "'", "<STR_LIT>", "+", "Directive", "+", "<STR_LIT>", " fp=xx' requires the O32 ABI", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "FpABI", "=", "<STR_LIT>", "::", "<STR_LIT>", "::", "XX", ";", "return", "true" ]

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

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";", "}", "<BUGS>", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SBWriteResGroup0", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", "SBWriteResGroup1", ":", "SchedWriteRes", "[", "SBPort1", "]", ">", "{" ]

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

[ "(", "define_attr", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "(", "const", "(", "symbol_ref", "<STR_LIT>", ")", ")", ")" ]

[ "<FIXS>", "string", "opc", ",", "string", "asm", ",", "string", "cstr", ",", "list", "dag", ">", "pattern", ">", "<FIXE>", "<FIXS>", "let", "InOperandList", "=", "!", "con", "(", "iops", ",", "(", "ops", "pred", ":", "$", "p", ")", ")", ";", "let", "AsmString", "=", "!", "strconcat", "(", "opc", ",", "!", "strconcat", "(", "<STR_LIT>", ",", "asm", ")", ")", ";", "<FIXE>", "<FIXS>", "class", "NI", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "string", "opc", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ">", ":", "NeonI", "oops", ",", "iops", ",", "AddrModeNone", ",", "IndexModeNone", ",", "itin", ",", "opc", ",", "asm", ",", "<STR_LIT>", ",", "pattern", ">", "{", "<FIXE>", "<FIXS>", "class", "NI4", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "string", "opc", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ">", ":", "NeonI", "oops", ",", "iops", ",", "AddrMode4", ",", "IndexModeNone", ",", "itin", ",", "opc", ",", "asm", ",", "<STR_LIT>", ",", "pattern", ">", "{", "<FIXE>", "<FIXS>", "string", "opc", ",", "string", "asm", ",", "string", "cstr", ",", "list", "dag", ">", "pattern", ">", ":", "NeonI", "oops", ",", "iops", ",", "AddrMode6", ",", "IndexModeNone", ",", "itin", ",", "opc", ",", "asm", ",", "cstr", ",", "pattern", ">", "{", "<FIXE>" ]

[ "class", "NeonI", "dag", "oops", ",", "dag", "iops", ",", "AddrMode", "am", ",", "IndexMode", "im", ",", "InstrItinClass", "itin", ",", "<BUGS>", "string", "asm", ",", "string", "cstr", ",", "list", "dag", ">", "pattern", ">", "<BUGE>", ":", "InstARM", "am", ",", "Size4Bytes", ",", "im", ",", "NEONFrm", ",", "NeonDomain", ",", "cstr", ",", "itin", ">", "{", "let", "OutOperandList", "=", "oops", ";", "<BUGS>", "let", "InOperandList", "=", "iops", ";", "let", "AsmString", "=", "asm", ";", "<BUGE>", "let", "Pattern", "=", "pattern", ";", "list", "Predicate", ">", "Predicates", "=", "[", "HasNEON", "]", ";", "}", "<BUGS>", "class", "NI", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ">", ":", "NeonI", "oops", ",", "iops", ",", "AddrModeNone", ",", "IndexModeNone", ",", "itin", ",", "asm", ",", "<STR_LIT>", ",", "pattern", ">", "{", "<BUGE>", "}", "<BUGS>", "class", "NI4", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ">", ":", "NeonI", "oops", ",", "iops", ",", "AddrMode4", ",", "IndexModeNone", ",", "itin", ",", "asm", ",", "<STR_LIT>", ",", "pattern", ">", "{", "<BUGE>", "}", "class", "NLdSt", "bit", "op23", ",", "bits", "<NUM_LIT>", ">", "op21_20", ",", "bits", "<NUM_LIT>", ">", "op11_8", ",", "bits", "<NUM_LIT>", ">", "op7_4", ",", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "<BUGS>", "string", "asm", ",", "string", "cstr", ",", "list", "dag", ">", "pattern", ">", ":", "NeonI", "oops", ",", "iops", ",", "AddrMode6", ",", "IndexModeNone", ",", "itin", ",", "asm", ",", "cstr", ",", "pattern", ">", "{", "<BUGE>", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op23", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op21_20", ";" ]

[ "if", "(", "isCN", ")", "{" ]

[ "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Ptr", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Val", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Base", ",", "Scale", ",", "Index", ",", "Disp", ",", "Segment", ";", "if", "(", "!", "SelectAddr", "(", "Node", ",", "Ptr", ",", "Base", ",", "Scale", ",", "Index", ",", "Disp", ",", "Segment", ")", ")", "return", "nullptr", ";", "enum", "AtomicOpc", "Op", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "nullptr", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "Op", "=", "OR", ";", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "Op", "=", "AND", ";", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "Op", "=", "XOR", ";", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "Op", "=", "ADD", ";", "break", ";", "}", "Val", "=", "getAtomicLoadArithTargetConstant", "(", "CurDAG", ",", "dl", ",", "Op", ",", "NVT", ",", "Val", ",", "Subtarget", ")", ";", "bool", "isUnOp", "=", "!", "Val", ".", "getNode", "(", ")", ";", "bool", "isCN", "=", "Val", ".", "getNode", "(", ")", "&&", "(", "Val", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetConstant", ")", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "switch", "(", "NVT", ".", "SimpleTy", ")", "{", "default", ":", "return", "nullptr", ";", "case", "MVT", "::", "i8", ":", "if", "(", "isCN", ")", "Opc", "=", "AtomicOpcTbl", "[", "Op", "]", "[", "ConstantI8", "]", ";", "else", "Opc", "=", "AtomicOpcTbl", "[", "Op", "]", "[", "I8", "]", ";", "break", ";", "case", "MVT", "::", "i16", ":", "if", "(", "isCN", ")", "{", "if", "(", "immSext8", "(", "Val", ".", "getNode", "(", ")", ")", ")", "Opc", "=", "AtomicOpcTbl", "[", "Op", "]", "[", "SextConstantI16", "]", ";", "else", "Opc", "=", "AtomicOpcTbl", "[", "Op", "]", "[", "ConstantI16", "]", ";", "}", "else", "Opc", "=", "AtomicOpcTbl", "[", "Op", "]", "[", "I16", "]", ";", "break", ";", "case", "MVT", "::", "i32", ":" ]

[ "<STR_LIT>" ]

[ "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "CC_FP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "clobber", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>" ]

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

[ "}", "]", ">", ";", "def", "NonDSFormSextLoadi32", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "sextloadi32", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "LoadSDNode", ">", "(", "N", ")", "-", ">", "getAlignment", "(", ")", "<", "<NUM_LIT>", "&", "&", "!", "isOffsetMultipleOf", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "quadwOffsetLoad", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "load", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "isOffsetMultipleOf", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "quadwOffsetStore", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "(", "store", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "isOffsetMultipleOf", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "nonQuadwOffsetLoad", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "load", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "!", "isOffsetMultipleOf", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "nonQuadwOffsetStore", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "(", "store", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "!", "isOffsetMultipleOf", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "class", "BinOpWithoutSImm16Operand", "<", "SDNode", "opcode", ">", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "left", ",", "node", ":", "$", "right", ")", ",", "(", "opcode", "node", ":", "$", "left", ",", "node", ":", "$", "right", ")", ",", "[", "{", "int16_t", "Imm", ";", "return", "!", "isIntS16Immediate", "(", "N", "-", ">", "getOperand", "(", "<NUM_LIT>", ")", ",", "Imm", ")", "&", "&", "!", "isIntS16Immediate", "(", "N", "-", ">", "getOperand", "(", "<NUM_LIT>", ")", ",", "Imm", ")", ";" ]

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

[ "class", "MVE_VCMPqr", "<", "string", "suffix", ",", "bit", "bit_28", ",", "bits", "<", "<NUM_LIT>", ">", "bits_21_20", ",", "VCMPPredicateOperand", "predtype", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVE_p", "<", "(", "outs", "VCCR", ":", "$", "P0", ")", ",", "(", "ins", "MQPR", ":", "$", "Qn", ",", "GPRwithZR", ":", "$", "Rm", ",", "predtype", ":", "$", "fc", ")", ",", "NoItinerary", ",", "<STR_LIT>", ",", "suffix", ",", "<STR_LIT>", ",", "vpred_n", ",", "<STR_LIT>", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "fc", ";" ]

[ "<FIXS>", "if", "(", "!", "bif_is_mma", "(", "rs6000_builtin_info", "[", "fncode", "]", ")", ")", "<FIXE>", "<FIXS>", "if", "(", "rs6000_builtin_info", "[", "fncode", "]", ".", "assoc_bif", "==", "RS6000_BIF_NONE", "<FIXE>", "<FIXS>", "bifdata", "*", "bd", "=", "&", "rs6000_builtin_info", "[", "fncode", "]", ";", "<FIXE>" ]

[ "gimple", "*", "stmt", "=", "gsi_stmt", "(", "*", "gsi", ")", ";", "size_t", "fncode", "=", "(", "size_t", ")", "fn_code", ";", "<BUGS>", "if", "(", "!", "bif_is_mma", "(", "rs6000_builtin_info_x", "[", "fncode", "]", ")", ")", "<BUGE>", "return", "false", ";", "<BUGS>", "if", "(", "rs6000_builtin_info_x", "[", "fncode", "]", ".", "assoc_bif", "==", "RS6000_BIF_NONE", "<BUGE>", "&&", "fncode", "!=", "RS6000_BIF_LXVP", "&&", "fncode", "!=", "RS6000_BIF_STXVP", ")", "return", "false", ";", "<BUGS>", "bifdata", "*", "bd", "=", "&", "rs6000_builtin_info_x", "[", "fncode", "]", ";", "<BUGE>", "unsigned", "nopnds", "=", "bd", "->", "nargs", ";", "gimple_seq", "new", "_", "seq", "=", "NULL", ";", "gimple", "*", "new", "_", "call", ";" ]

[ "}" ]

[ "unsigned", "ARMFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "unsigned", "Op1", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "<NUM_LIT>", ")", ";", "Op1", "=", "constrainOperandRegClass", "(", "II", ",", "Op1", ",", "<NUM_LIT>", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "<NUM_LIT>", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "<NUM_LIT>", "]", ")", ")", ";", "}", "return", "ResultReg", ";" ]

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

[ "class", "BSETI_D_ENC", ":", "MSA_BIT_D_FMT", "<", "<NUM_LIT>", "," ]

[ "NumBBsPadded", "++", ";" ]

[ "if", "(", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ")", "{", "return", "false", ";", "}", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "!", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "MF", ".", "begin", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "<NUM_LIT>", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "<NUM_LIT>", "&&", "<STR_LIT>", "Basic block should contain at least a RET but is empty", "<STR_LIT>", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "<STR_LIT>", "Basic block does not end with RET", "<STR_LIT>", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";" ]

[ "}" ]

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

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

[ "def", "SNEScallseq_end", ":", "SDNode", "<", "<STR_LIT>", ",", "SDT_SNESCallSeqEnd", ",", "[", "SDNPHasChain", ",", "SDNPOptInGlue", "," ]

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

[ "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "cond_exec", "(", "match_dup", "<NUM_LIT>", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_op_dup", ":", "SI", "<NUM_LIT>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "cond_exec", "(", "match_dup", "<NUM_LIT>", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_op_dup", ":", "SI", "<NUM_LIT>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "NE", "?", "EQ", ":", "NE", ",", "VOIDmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "const0_rtx", ")", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "InternalInstruction", "&", "insn", ",", "const", "MCDisassembler", "*", "Dis", ")", "{", "<FIXE>" ]

[ "static", "bool", "translateInstruction", "(", "MCInst", "&", "mcInst", ",", "<BUGS>", "InternalInstruction", "&", "insn", ")", "{", "<BUGE>", "if", "(", "!", "insn", ".", "spec", ")", "{", "debug", "(", "<STR_LIT>", "Instruction has no specification", "<STR_LIT>", ")", ";", "return", "true", ";" ]

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

[ "while", "(", "I", "->", "isDebugValue", "(", ")", "||", "!", "I", "->", "isTerminator", "(", ")", ")", "{", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "!", "FBB", "&&", "<STR_LIT>", "FBB should have been null.", "<STR_LIT>", ")", ";", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "if", "(", "I", "->", "isReturn", "(", ")", ")", "{", "CantAnalyze", "=", "!", "isPredicated", "(", "I", ")", ";", "}", "else", "{", "return", "true", ";", "}", "if", "(", "!", "isPredicated", "(", "I", ")", "&&", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "I", "->", "isReturn", "(", ")", ")", ")", "{", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "<NUM_LIT>", ";", "if", "(", "AllowModify", ")", "{", "MachineBasicBlock", "::", "iterator", "DI", "=", "std", "::", "next", "(", "I", ")", ";", "while", "(", "DI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineInstr", "*", "InstToDelete", "=", "DI", ";", "++", "DI", ";", "InstToDelete", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "if", "(", "CantAnalyze", ")", "return", "true", ";", "if", "(", "I", "==", "MBB", ".", "begin" ]

[ "]", ")" ]

[ "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC_FP", "CCFP_REGNUM", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "!", "Subtarget", "->", "isThumb1Only", "(", ")", "&&", "ST", "->", "isVolatile", "(", ")", "&&", "ST", "->", "getAlign", "(", ")", ">=", "Subtarget", "->", "getDualLoadStoreAlignment", "(", ")", ")", "{", "<FIXE>" ]

[ "assert", "(", "ST", "->", "isUnindexed", "(", ")", "&&", "<STR_LIT>", "Stores should be unindexed at this point.", "<STR_LIT>", ")", ";", "if", "(", "MemVT", "==", "MVT", "::", "i64", "&&", "Subtarget", "->", "hasV5TEOps", "(", ")", "&&", "<BUGS>", "!", "Subtarget", "->", "isThumb1Only", "(", ")", "&&", "ST", "->", "isVolatile", "(", ")", ")", "{", "<BUGE>", "SDNode", "*", "N", "=", "Op", ".", "getNode", "(", ")", ";", "SDLoc", "dl", "(", "N", ")", ";" ]

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "USR", "]", ";" ]

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

[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "I2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "SmallVector", "<", "const", "ValueMapping", "*", ",", "<NUM_LIT>", ">", "OpdsMapping", "(", "MI", ".", "getNumOperands", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "SrcOp", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "!", "SrcOp", ".", "isReg", "(", ")" ]

[ "(", "next_parm_info_bit", "-", "<NUM_LIT>", ")", ")", ";" ]

[ "else", "optional_tbtab", "=", "!", "optimize_size", "&&", "!", "TARGET_ELF", ";", "if", "(", "optional_tbtab", ")", "{", "fname", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "while", "(", "*", "fname", "==", "'", ".", "'", ")", "fname", "++", ";", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "file", ",", "<STR_LIT>", "LT", "<STR_LIT>", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "fname", ")", ";", "}", "fputs", "(", "<STR_LIT>", "\\t.long 0\\n", "<STR_LIT>", ",", "file", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.byte 0,", "<STR_LIT>", ",", "file", ")", ";", "if", "(", "lang_GNU_C", "(", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU GIMPLE", "<STR_LIT>", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Go", "<STR_LIT>", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "libgccjit", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU F77", "<STR_LIT>", ")", "||", "lang_GNU_Fortran", "(", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Pascal", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Ada", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "lang_GNU_CXX", "(", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Objective-C++", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Java", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Objective-C", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "gcc_unreachable", "(", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "i", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "optional_tbtab", "<<", "<NUM_LIT>", ")", "|", "(", "(", "info", "->", "first_fp_reg_save", "!=", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "(", "optional_tbtab", "<<", "<NUM_LIT>", ")", "|", "(", "(", "optional_tbtab", "&", "frame_pointer_needed", ")", "<<", "<NUM_LIT>", ")", "|", "(", "info", "->", "cr_save_p", "<<", "<NUM_LIT>", ")", "|", "(", "info", "->", "lr_save_p", ")", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "info", "->", "push_p", "<<", "<NUM_LIT>", ")", "|", "(", "<NUM_LIT>", "-", "info", "->", "first_fp_reg_save", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "<NUM_LIT>", "-", "first_reg_to_save", "(", ")", ")", ")", ";", "if", "(", "optional_tbtab", ")", "{", "tree", "decl", ";", "int", "next_parm_info_bit", "=", "<NUM_LIT>", ";", "for", "(", "decl", "=", "DECL_ARGUMENTS", "(", "current_function_decl", ")", ";", "decl", ";", "decl", "=", "DECL_CHAIN", "(", "decl", ")", ")", "{", "rtx", "parameter", "=", "DECL_INCOMING_RTL", "(", "decl", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "parameter", ")", ";", "if", "(", "GET_CODE", "(", "parameter", ")", "==", "REG", ")", "{", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", ")", "{", "int", "bits", ";", "float_parms", "++", ";", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "case", "E_SDmode", ":", "bits", "=", "<NUM_LIT>", ";", "break", ";", "case", "E_DFmode", ":", "case", "E_DDmode", ":", "case", "E_TFmode", ":", "case", "E_TDmode", ":", "case", "E_IFmode", ":", "case", "E_KFmode", ":", "bits", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "next_parm_info_bit", ">", "<NUM_LIT>", ")", "parm_info", "|=", "(", "bits", "<<" ]

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

[ "class", "SpuInstJmpU", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "ScalarInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", ")", ";", "let", "InOperandList", "=", "(", "ins", "brtarget", ":", "$", "target", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";" ]

[ "}" ]

[ "JITCompilerFunction", "=", "F", ";", "return", "AlphaCompilationCallback", ";" ]

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

[ "(", "plus", ":", "P", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "P", "CA_REGNO", ")", "(", "ltu", ":", "P", "(", "plus", ":", "P", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

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

[ "(", "abs", ":", "IEEE128", "(", "match_operand", ":", "IEEE128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "use", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";" ]

[ "assert", "(", "Kind", "==", "Expression", "&&" ]

[ "}" ]

[ "static", "void", "emitReservedArgRegCallError", "(", "const", "MachineFunction", "&", "MF", ")", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "F", ".", "getContext", "(", ")", ".", "diagnose", "(", "DiagnosticInfoUnsupported", "{", "F", ",", "(", "<STR_LIT>", "SPARC doesn't support", "<STR_LIT>", "<STR_LIT>", " function calls if any of the argument registers is reserved.", "<STR_LIT>", ")", "}", ")", ";" ]

[ "MIB", ".", "addReg", "(", "PPC", "::", "X2", ",", "RegState", "::", "Implicit", ")", ";" ]

[ "if", "(", "ArgVT", ".", "isVector", "(", ")", ")", "return", "false", ";", "unsigned", "Arg", "=", "getRegForValue", "(", "ArgValue", ")", ";", "if", "(", "Arg", "==", "<NUM_LIT>", ")", "return", "false", ";", "Args", ".", "push_back", "(", "ArgValue", ")", ";", "ArgRegs", ".", "push_back", "(", "Arg", ")", ";", "ArgVTs", ".", "push_back", "(", "ArgVT", ")", ";", "ArgFlags", ".", "push_back", "(", "Flags", ")", ";", "}", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "RegArgs", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "Args", ",", "ArgRegs", ",", "ArgVTs", ",", "ArgFlags", ",", "RegArgs", ",", "CC", ",", "NumBytes", ",", "IsVarArg", ")", ")", "return", "false", ";", "MachineInstrBuilder", "MIB", ";", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "Callee", ")", ";", "if", "(", "!", "GV", ")", "{", "if", "(", "CLI", ".", "IsPatchPoint", ")", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "NOP", ")", ")", ";", "else", "return", "false", ";", "}", "else", "{", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "BL8_NOP", ")", ")", ";", "MIB", ".", "addGlobalAddress", "(", "GV", ")", ";", "}", "for", "(", "unsigned", "II", "=", "<NUM_LIT>", ",", "IE", "=", "RegArgs", ".", "size", "(", ")", ";", "II", "!=", "IE", ";", "++", "II", ")", "MIB", ".", "addReg", "(", "RegArgs", "[", "II", "]", ",", "RegState", "::", "Implicit", ")", ";", "PPCFuncInfo", "->", "setUsesTOCBasePtr", "(", ")", ";" ]

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

[ "if", "(", "!", "ShlCst", ")", "return", "false", ";", "uint64_t", "ShAmt", "=", "ShlCst", "->", "getZExtValue", "(", ")", ";", "uint64_t", "RemovedBitsMask", "=", "(", "<NUM_LIT>", "ULL", "<<", "ShAmt", ")", "-", "<NUM_LIT>", ";", "if", "(", "Opcode", "!=", "ISD", "::", "AND", "&&", "(", "Val", "&", "RemovedBitsMask", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "auto", "CanShrinkImmediate", "=", "[", "&", "]", "(", "int64_t", "&", "ShiftedVal", ")", "{", "if", "(", "Opcode", "==", "ISD", "::", "AND", ")", "{", "ShiftedVal", "=", "(", "uint64_t", ")", "Val", ">>", "ShAmt", ";", "if", "(", "NVT", "==", "MVT", "::", "i64", "&&", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "ShiftedVal", ")", ")", "return", "true", ";", "if", "(", "ShiftedVal", "==", "UINT8_MAX", "||", "ShiftedVal", "==", "UINT16_MAX", ")", "return", "true", ";", "}", "ShiftedVal", "=", "Val", ">>", "ShAmt", ";", "if", "(", "(", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "ShiftedVal", ")", ")", "||", "(", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "ShiftedVal", ")", ")", ")", "return", "true", ";", "if", "(", "Opcode", "!=", "ISD", "::", "AND", ")", "{", "ShiftedVal", "=", "(", "uint64_t", ")", "Val", ">>", "ShAmt", ";", "if", "(", "NVT", "==", "MVT", "::", "i64", "&&", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "ShiftedVal", ")", ")", "return", "true", ";", "}" ]

[ "}" ]

[ "MachineOperand", "MO", "=", "MI", "->", "getOperand", "(", "oper", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getMinimalPhysRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "RC", "==", "Hexagon", "::", "PredRegsRegisterClass", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "return", "true", ";" ]

[ "<FIXS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " #", "<STR_LIT>", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", ": ", "<STR_LIT>", ";", "<FIXE>" ]

[ "if", "(", "DMI", "->", "definesRegister", "(", "reg", ")", ")", "{", "assert", "(", "DMI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", ";", "ReturnInfoInsts", ".", "insert", "(", "DMI", ")", ";", "<BUGS>", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " #", "<STR_LIT>", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", ": ", "<STR_LIT>", ";", "<BUGE>", "DMI", "->", "dump", "(", ")", ")", ";", "found", "=", "true", ";", "break", ";" ]

[ "(", "*", "I", ")", "->", "eraseFromParent", "(", ")", ";" ]

[ "unsigned", "int", "cnt", "=", "Removables", ".", "size", "(", ")", ";", "for", "(", "std", "::", "set", "<", "MachineInstr", "*", ">", "::", "iterator", "I", "=", "Removables", ".", "begin", "(", ")", ",", "E", "=", "Removables", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", "<<", "*", "*", "I", ")", ";" ]

[ "}", ";" ]

[ "class", "VST1D3", "<", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "Operand", "AddrMode", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ",", "VecListThreeD", ":", "$", "Vd", ")", ",", "IIC_VST1x3", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVST3", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>" ]

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

[ "class", "Enc_0cb018", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Cs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Cs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rd32", ";" ]

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

[ "SDValue", "Result", ";", "if", "(", "expandFP_TO_SINT", "(", "N", ",", "Result", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "case", "ISD", "::", "SDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "SDValue", "RES", "=", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "RES", ")", ";", "Results", ".", "push_back", "(", "RES", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "UDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", "," ]

[ "}" ]

[ "inline", "vector", "signed", "int", "vec_cmple", "(", "vector", "float", "a1", ",", "vector", "float", "a2", ")", "{", "return", "(", "vector", "signed", "int", ")", "_", "_", "builtin_altivec_vcmpgefp", "(", "(", "vector", "float", ")", "a1", ",", "(", "vector", "float", ")", "a2", ")", ";" ]

[ "bool", "X86PartialReduction", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "auto", "&", "TM", "=", "TPC", "->", "getTM", "<", "X86TargetMachine", ">", "(", ")", ";", "ST", "=", "TM", ".", "getSubtargetImpl", "(", "F", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "auto", "*", "EE", "=", "dyn_cast", "<", "ExtractElementInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "EE", ")", "continue", ";", "bool", "ReduceInOneBB", ";", "Value", "*", "Root", "=", "matchAddReduction", "(", "*", "EE", ",", "ReduceInOneBB", ")", ";", "if", "(", "!", "Root", ")", "continue", ";", "SmallVector", "<", "Instruction", "*", ",", "<NUM_LIT>", ">", "Leaves", ";", "collectLeaves", "(", "Root", ",", "Leaves", ")", ";", "for", "(", "Instruction", "*", "I", ":", "Leaves", ")", "{", "if", "(", "tryMAddReplacement", "(", "I", ",", "ReduceInOneBB", ")", ")", "{", "MadeChange", "=", "true", ";", "continue", ";", "}", "if", "(", "I", "!=", "Root", "&&", "trySADReplacement", "(", "I", ")", ")", "MadeChange", "=", "true", ";", "}", "}", "}", "return", "MadeChange", ";", "}" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "}" ]

[ "bool", "empty", "(", ")", "const", "{", "return", "Units", ".", "none", "(", ")", ";" ]

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

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

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

[ "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "RegInfo", "||", "!", "FI", ")", "return", "false", ";", "if", "(", "!", "Subtarget", ".", "isELFv2ABI", "(", ")", "||", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "false", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "FrameSize", "||", "FrameSize", ">", "Subtarget", ".", "getRedZoneSize", "(", ")", ")", "return", "false", ";", "if", "(", "hasFP", "(", "MF", ")", "||", "RegInfo", "->", "hasBasePointer", "(", "MF" ]

[ "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "Value", ",", "StackSlot", "}", ";" ]

[ "int", "SSFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "MemSize", ",", "MemSize", ",", "false", ")", ";", "SDValue", "StackSlot", "=", "DAG", ".", "getFrameIndex", "(", "SSFI", ",", "PtrVT", ")", ";", "Chain", "=", "IsStrict", "?", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ":", "DAG", ".", "getEntryNode", "(", ")", ";", "SDValue", "Adjust", ";", "if", "(", "UnsignedFixup", ")", "{", "APFloat", "Thresh", "(", "APFloat", "::", "IEEEsingle", "(", ")", ",", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "LLVM_ATTRIBUTE_UNUSED", "APFloat", "::", "opStatus", "Status", "=", "APFloat", "::", "opOK", ";", "bool", "LosesInfo", "=", "false", ";", "if", "(", "TheVT", "==", "MVT", "::", "f64", ")", "Status", "=", "Thresh", ".", "convert", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "APFloat", "::", "rmNearestTiesToEven", ",", "&", "LosesInfo", ")", ";", "else", "if", "(", "TheVT", "==", "MVT", "::", "f80", ")", "Status", "=", "Thresh", ".", "convert", "(", "APFloat", "::", "x87DoubleExtended", "(", ")", ",", "APFloat", "::", "rmNearestTiesToEven", ",", "&", "LosesInfo", ")", ";", "assert", "(", "Status", "==", "APFloat", "::", "opOK", "&&", "!", "LosesInfo", "&&", "<STR_LIT>", "FP conversion should have been exact", "<STR_LIT>", ")", ";", "SDValue", "ThreshVal", "=", "DAG", ".", "getConstantFP", "(", "Thresh", ",", "DL", ",", "TheVT", ")", ";", "EVT", "ResVT", "=", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "TheVT", ")", ";", "SDValue", "Cmp", ";", "if", "(", "IsStrict", ")", "{", "Cmp", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "ResVT", ",", "Value", ",", "ThreshVal", ",", "ISD", "::", "SETLT", ",", "Chain", ",", "true", ")", ";", "Chain", "=", "Cmp", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "Cmp", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "ResVT", ",", "Value", ",", "ThreshVal", ",", "ISD", "::", "SETLT", ")", ";", "}", "Adjust", "=", "DAG", ".", "getSelect", "(", "DL", ",", "MVT", "::", "i64", ",", "Cmp", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ",", "DAG", ".", "getConstant", "(", "APInt", "::", "getSignMask", "(", "<NUM_LIT>", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "SDValue", "FltOfs", "=", "DAG", ".", "getSelect", "(", "DL", ",", "TheVT", ",", "Cmp", ",", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "DL", ",", "TheVT", ")", ",", "ThreshVal", ")", ";", "if", "(", "IsStrict", ")", "{", "Value", "=", "DAG", ".", "getNode", "(", "ISD", "::", "STRICT_FSUB", ",", "DL", ",", "{", "TheVT", ",", "MVT", "::", "Other", "}", ",", "{", "Chain", ",", "Value", ",", "FltOfs", "}", ")", ";", "Chain", "=", "Value", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "else", "Value", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "DL", ",", "TheVT", ",", "Value", ",", "FltOfs", ")", ";", "}", "MachinePointerInfo", "MPI", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "SSFI", ")", ";", "if", "(", "isScalarFPTypeInSSEReg", "(", "TheVT", ")", ")", "{", "assert", "(", "DstTy", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Invalid FP_TO_SINT to lower!", "<STR_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Value", ",", "StackSlot", ",", "MPI", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "f80", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "StackSlot", "}", ";", "unsigned", "FLDSize", "=", "TheVT", ".", "getStoreSize", "(", ")", ";", "assert", "(", "FLDSize", "<=", "MemSize", "&&", "<STR_LIT>", "Stack slot not big enough", "<STR_LIT>", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPI", ",", "MachineMemOperand", "::", "MOLoad", ",", "FLDSize", ",", "FLDSize", ")", ";", "Value", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Tys", ",", "Ops", ",", "TheVT", ",", "MMO", ")", ";", "Chain", "=", "Value", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPI", ",", "MachineMemOperand", "::", "MOStore", ",", "MemSize", ",", "MemSize", ")", ";" ]

[ "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "vselect", "(", "Ty", "Mask", ":", "$", "m", ")", ",", "(", "Ty", "ROWD", ":", "$", "ws", ")", ",", "ROWS", ":", "$", "wd_in", ")", ")", "]", ";" ]

[ "dag", "OutOperandList", "=", "(", "outs", "ROWD", ":", "$", "wd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROWD", ":", "$", "wd_in", ",", "ROWS", ":", "$", "ws", ",", "vsplat_uimm8", ":", "$", "m", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";" ]

[ "<FIXS>", "if", "(", "set", "==", "NULL_RTX", "<FIXE>" ]

[ "elsereturn", "false", ";", "}", "<BUGS>", "if", "(", "set", "==", "<NUM_LIT>", "<BUGE>", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "this_insn", ")", ")", ")", "return", "false", ";", "}" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_xor_pd", "(", "_", "_", "m128d", "_", "_", "A", ",", "_", "_", "m128d", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_xorpd", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ",", "(", "_", "_", "v2df", ")", "_", "_", "B", ")", ";" ]

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

[ "(", "define_function_unit", "<STR_LIT>", "<NUM_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "<NUM_LIT>", "<NUM_LIT>", ")" ]

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

[ "class", "LoadLiteral", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bit", "V", ",", "RegisterOperand", "regtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pat", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rt", ")", ",", "(", "ins", "am_ldrlit", ":", "$", "label", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pat", ">", ",", "Sched", "<", "[", "WriteLD", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "label", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "gcc_assert", "(", "cc_prev_status", ".", "flags", "&", "CC_IN_68881", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "ungt", "(", "cc0", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "{" ]

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

[ "}", "XtensaRegisterInfo", "::", "XtensaRegisterInfo", "(", ")", ":", "XtensaGenRegisterInfo", "(" ]