Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "unsigned", "getSRetReturnReg", "(", ")", "const", "{", "return", "SRetReturnReg", ";" ]

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

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

[ "<FIXS>", "handle_reg_adjust", "(", "operands", "[", "<NUM_LIT>", "]", ",", "-", "size", ")", ";", "<FIXE>" ]

[ "if", "(", "optype0", "==", "PUSHOP", "&&", "optype1", "==", "POPOP", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "<BUGS>", "if", "(", "size", "==", "<NUM_LIT>", ")", "output_asm_insn", "(", "<STR_LIT>", "sub%.l #12,%0", "<STR_LIT>", ",", "operands", ")", ";", "elseoutput_asm_insn", "(", "<STR_LIT>", "subq%.l #8,%0", "<STR_LIT>", ",", "operands", ")", ";", "<BUGE>", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "XFmode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_MEM", "(", "XFmode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "else", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "DFmode", ")" ]

[ "void", "M680x0AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "{", "if", "(", "MI", "->", "isPseudo", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Pseudo opcode(", "<STR_LIT>", "<<", "MI", "->", "getOpcode", "(", ")", "<<", "<STR_LIT>", ") found in EmitInstruction()\\n", "<STR_LIT>", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Cannot proceed", "<STR_LIT>", ")", ";", "}", "break", ";", "}", "case", "M680x0", "::", "TAILJMPj", ":", "case", "M680x0", "::", "TAILJMPq", ":", "OutStreamer", "->", "AddComment", "(", "<STR_LIT>", "TAILCALL", "<STR_LIT>", ")", ";", "break", ";", "}", "MCInst", "TmpInst0", ";", "MCInstLowering", "->", "Lower", "(", "MI", ",", "TmpInst0", ")", ";", "OutStreamer", "->", "EmitInstruction", "(", "TmpInst0", ",", "getSubtargetInfo", "(", ")", ")", ";", "}" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "}" ]

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

[ "'", "'", ";" ]

[ "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_MULTIPLE", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "m", "'", ";", "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_INDEXED", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "i", "'", ";", "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_QUAD_OFFSET", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "O", "'", ";", "else", "if", "(", "(", "mask", "&", "RELOAD_REG_OFFSET", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "o", "'", ";", "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=" ]

[ "<FIXS>", "gmask", "&", "~", "(", "HARD_FRAME_POINTER_MASK", "|", "RETURN_ADDR_MASK", ")", ",", "<FIXE>" ]

[ "offset", "+=", "<NUM_LIT>", ";", "}", "sparc_flat_save_restore", "(", "file", ",", "sp_str", ",", "offset", ",", "<BUGS>", "gmask", "&", "~", "(", "FRAME_POINTER_MASK", "|", "RETURN_ADDR_MASK", ")", ",", "<BUGE>", "current_frame_info", ".", "fmask", ",", "<STR_LIT>", "st", "<STR_LIT>", ",", "<STR_LIT>", "std", "<STR_LIT>", ",", "-", "size1", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tset\\t", "<STR_LIT>", ")", ";" ]

[ "MachineInstr", "*", "Z80InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "MachineInstr", "&", "LoadMI", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "return", "nullptr", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented", "<STR_LIT>", ")", ";", "}" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "_", "_", "artificial__", ")", ")", "_", "mm_cvtusepi32_epi8", "(", "_", "_", "m128i", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", "," ]

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

[ "extern", "_", "_", "inline", "long", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "TM_end" ]

[ "<FIXS>", "&&", "AM", ".", "Base_Reg", ".", "getNode", "(", ")", "==", "<NUM_LIT>", ")", "{", "<FIXE>", "<FIXS>", "AM", ".", "Base_FrameIndex", "=", "cast", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "<FIXE>" ]

[ "case", "ISD", "::", "FrameIndex", ":", "if", "(", "AM", ".", "BaseType", "==", "X86ISelAddressMode", "::", "RegBase", "<BUGS>", "&&", "AM", ".", "Base", ".", "Reg", ".", "getNode", "(", ")", "==", "<NUM_LIT>", ")", "{", "<BUGE>", "AM", ".", "BaseType", "=", "X86ISelAddressMode", "::", "FrameIndexBase", ";", "<BUGS>", "AM", ".", "Base", ".", "FrameIndex", "=", "cast", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "<BUGE>", "return", "false", ";", "}", "break", ";" ]

[ "return", "NULL_RTX", ";" ]

[ "if", "(", "crtl", "->", "is_leaf", "&&", "!", "sh_pr_n_sets", "(", ")", ")", "return", "hard_reg", ";", "else", "return", "gen_frame_mem", "(", "Pmode", ",", "return_address_pointer_rtx", ")", ";", "}" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_reservation", "<STR_LIT>" ]

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

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

[ "<STR_LIT>" ]

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

[ "case", "PPC", "::", "fixup_ppc_br24", ":" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown fixup kind!", "<STR_LIT>", ")", ";", "case", "FK_Data_1", ":", "case", "FK_Data_2", ":", "case", "FK_Data_4", ":", "case", "FK_Data_8", ":", "case", "PPC", "::", "fixup_ppc_toc", ":", "return", "Value", ";", "case", "PPC", "::", "fixup_ppc_lo14", ":", "case", "PPC", "::", "fixup_ppc_toc16_ds", ":", "return", "(", "Value", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "case", "PPC", "::", "fixup_ppc_brcond14", ":", "return", "Value", "&", "<NUM_LIT>", ";" ]

[ "_", "_", "a", ";" ]

[ "return", "(", "poly16x8_t", ")" ]

[ "if", "(", "GVKind", ".", "isBSS", "(", ")", ")", "TS", "->", "emitBlock", "(", "Size", ")", ";" ]

[ "if", "(", "GVSym", "->", "isDefined", "(", ")", "||", "GVSym", "->", "isVariable", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "symbol '", "<STR_LIT>", "+", "Twine", "(", "GVSym", "->", "getName", "(", ")", ")", "+", "<STR_LIT>", "' is already defined", "<STR_LIT>", ")", ";", "SectionKind", "GVKind", "=", "TargetLoweringObjectFile", "::", "getKindForGlobal", "(", "GV", ",", "TM", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "unsigned", "Align", "=", "DL", ".", "getPreferredAlignment", "(", "GV", ")", ";", "MCSection", "*", "TheSection", "=", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", ",", "TM", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "TheSection", ")", ";", "TS", "->", "emitAlign", "(", "Align", ")", ";", "if", "(", "!", "GV", "->", "hasLocalLinkage", "(", ")", ")", "TS", "->", "emitGlobal", "(", "GVSym", ")", ";", "OutStreamer", "->", "EmitLabel", "(", "GVSym", ")", ";" ]

[ "Register", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "for", "(", "auto", "*", "Pred", ":", "MBB", "->", "predecessors", "(", ")", ")", "{" ]

[ "for", "(", "auto", "*", "MBB", ":", "Blocks", ")", "{", "if", "(", "MBB", "!=", "Entry", ")", "{" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Unexpected value type", "<STR_LIT>", ")", ";" ]

[ "SDNode", "*", "Result_3", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "COMBINE_rr", ",", "dl", ",", "MVT", "::", "i64", ",", "MVT", "::", "Other", ",", "SDValue", "(", "Result_2", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "Result_1", ",", "<NUM_LIT>", ")", ")", ";", "ReplaceUses", "(", "N", ",", "Result_3", ")", ";", "return", "Result_3", ";", "}", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i32", ")", "{", "SDNode", "*", "RsPd", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "TFR_RsPd", ",", "dl", ",", "MVT", "::", "i32", ",", "SDValue", "(", "IsIntrinsic", ",", "<NUM_LIT>", ")", ")", ";", "ReplaceUses", "(", "N", ",", "RsPd", ")", ";", "return", "RsPd", ";", "}" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "VReg32OrOffClass", ";" ]

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

[ "def", ":", "InstRW", "<", "[", "WriteAdr", ",", "KryoWrite_1cyc_LS_Y_XY_LS_Y_LS_Y_366ln", "]", ",", "(", "instregex" ]

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

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

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "t0", ",", "x", ")", ")", "<FIXE>" ]

[ "x", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "const1_rtx", ",", "const0_rtx", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "const2_rtx", ")", ")", "x", "=", "gen_rtx_VEC_SELECT", "(", "V4HImode", ",", "op1h", ",", "x", ")", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "t0", ",", "x", ")", ")", "<BUGE>", "emit_insn", "(", "gen_mulv4hi3", "(", "t1", ",", "op1h", ",", "op2h", ")", ")" ]

[ "a", ",", "_", "_", "b", ",", "_", "_", "p", ")", ";" ]

[ "return", "_", "_", "builtin_mve_vhsubq_m_n_sv4si", "(", "_", "_", "inactive", ",", "_", "_" ]

[ "(", "any_extend", ":", "V2DI" ]

[ "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "V2DI", "(", "mult", ":", "V2DI", "(", "any_extend", ":", "V2DI", "(", "vec_select", ":", "V2SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "any_extend", ":", "V2DI", "(", "vec_select", ":", "V2SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "(", "mult", ":", "V2DI", "(", "any_extend", ":", "V2DI", "(", "vec_select", ":", "V2SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")" ]

[ "<FIXS>", "MergeLDR_STR", "(", "MBB", ",", "<NUM_LIT>", ",", "CurrBase", ",", "CurrOpc", ",", "CurrSize", ",", "Scratch", ",", "MemOps", ")", ";", "<FIXE>", "<FIXS>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumMemOps", ";", "++", "i", ")", "if", "(", "!", "MemOps", "[", "i", "]", ".", "Merged", ")", "if", "(", "mergeBaseUpdateLoadStore", "(", "MBB", ",", "MemOps", "[", "i", "]", ".", "MBBI", ",", "TII", ")", ")", "NumMerges", "++", ";", "RS", "->", "skipTo", "(", "prior", "(", "MBBI", ")", ")", ";", "RSI", "=", "MBBI", ";", "}", "<FIXE>" ]

[ "if", "(", "TryMerge", ")", "{", "if", "(", "NumMemOps", ">", "<NUM_LIT>", ")", "{", "SmallVector", "MachineBasicBlock", "::", "iterator", ",", "<NUM_LIT>", ">", "MBBII", "=", "<BUGS>", "MergeLDR_STR", "(", "MBB", ",", "<NUM_LIT>", ",", "CurrBase", ",", "CurrOpc", ",", "CurrSize", ",", "MemOps", ")", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MBBII", ".", "size", "(", ")", ";", "i", "e", ";", "++", "i", ")", "if", "(", "mergeBaseUpdateLSMultiple", "(", "MBB", ",", "MBBII", "[", "i", "]", ")", ")", "NumMerges", "++", ";", "NumMerges", "+=", "MBBII", ".", "size", "(", ")", ";", "<BUGS>", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumMemOps", ";", "++", "i", ")", "if", "(", "!", "MemOps", "[", "i", "]", ".", "Merged", ")", "if", "(", "mergeBaseUpdateLoadStore", "(", "MBB", ",", "MemOps", "[", "i", "]", ".", "MBBI", ",", "TII", ")", ")", "NumMerges", "++", ";", "<BUGE>", "CurrBase", "=", "<NUM_LIT>", ";", "CurrOpc", "=", "-", "<NUM_LIT>", ";" ]

[ ";" ]

[ "++", "Idx", ";", "if", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "ByVal", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "InReg", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "StructRet", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "Nest", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "EVT", "ArgVT", "=", "TLI", ".", "getValueType", "(", "ArgTy", ")", ";", "if", "(", "!", "ArgVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "ArgVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "++", "GPRCnt", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "false", ";", "++", "FPRCnt", ";", "break", ";", "}", "if", "(", "GPRCnt", ">", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "FPRCnt", ">", "<NUM_LIT>", ")", "return", "false", ";", "}", "static", "const", "MCPhysReg", "GPR32ArgRegs", "[", "]", "=", "{", "X86", "::", "EDI", ",", "X86", "::", "ESI", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "X86", "::", "R8D", ",", "X86", "::", "R9D", "}", ";", "static", "const", "MCPhysReg", "GPR64ArgRegs", "[", "]", "=", "{", "X86", "::", "RDI", ",", "X86", "::", "RSI", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "R8", ",", "X86", "::", "R9", "}", ";", "static", "const", "MCPhysReg", "XMMArgRegs", "[", "]", "=", "{", "X86", "::", "XMM0", ",", "X86", "::", "XMM1", ",", "X86", "::", "XMM2", ",", "X86", "::", "XMM3", ",", "X86", "::", "XMM4", ",", "X86", "::", "XMM5", ",", "X86", "::", "XMM6", ",", "X86", "::", "XMM7", "}", ";", "unsigned", "GPRIdx", "=", "<NUM_LIT>", ";", "unsigned", "FPRIdx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "MVT", "VT", "=", "TLI", ".", "getSimpleValueType", "(", "Arg", ".", "getType", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "unsigned", "SrcReg", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected value type.", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i32", ":", "SrcReg", "=", "GPR32ArgRegs", "[", "GPRIdx", "++", "]", ";", "break", ";", "case", "MVT", "::", "i64", ":", "SrcReg", "=", "GPR64ArgRegs", "[", "GPRIdx", "++", "]", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "SrcReg", "=", "XMMArgRegs", "[", "FPRIdx", "++", "]", ";", "break", ";", "}", "unsigned", "DstReg", "=", "FuncInfo", ".", "MF", "->", "addLiveIn", "(", "SrcReg", ",", "RC", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ";", "UpdateValueMap", "(", "&", "Arg", ",", "ResultReg", ")", ";", "}", "return", "true" ]

[ "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "<NUM_LIT>", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "while", "(", "Result", "==", "Success", "&&", "!", "Complete", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "os", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "HexagonMCChecker", "Checker", "(", "*", "MCII", ",", "STI", ",", "MI", ",", "MI", ",", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "Checker", ".", "check", "(", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "return", "MCDisassembler", "::", "Success", ";", "}" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "TREE_NOTHROW", "(", "t", ")", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "type", "==", "NULL_TREE", ")", "return", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "(", "int", ")", "code", ",", "<NUM_LIT>", ",", "(", "int", ")", "RS6000_BUILTIN_COUNT", ")", ")", ";", "if", "(", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", ")", "fatal_error", "(", "input_location", ",", "<STR_LIT>", "internal error: builtin function %qs already processed", "<STR_LIT>", ",", "name", ")", ";", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", "=", "t", "=", "add_builtin_function", "(", "name", ",", "type", ",", "(", "int", ")", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "if", "(", "(", "classify", "&", "RS6000_BTC_CONST", ")", "!=", "<NUM_LIT>", ")", "{", "TREE_READONLY", "(", "t", ")", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "emit_insn", "(", "gen_fsca", "(", "operands", "[", "<NUM_LIT>", "]", ",", "x", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<FIXE>" ]

[ "gcc_assert", "(", "GET_CODE", "(", "x", ")", "=", "=", "FIX", "|", "|", "GET_CODE", "(", "x", ")", "=", "=", "FLOAT", ")", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", "}", "gcc_assert", "(", "x", "!", "=", "NULL_RTX", "&", "&", "fpul_operand", "(", "x", ",", "SImode", ")", ")", "<BUGS>", "emit_insn", "(", "gen_fsca", "(", "operands", "[", "<NUM_LIT>", "]", ",", "x", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<BUGE>", "DONE", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashift", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "R_FLAGS", ")", ")", "]", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "lshiftrt", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "R_FLAGS", ")", ")", "]", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_SUBREG", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", "}", "[", "(", "set_attr", "<STR_LIT>" ]

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

[ "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "words", "=", "ia64_function_arg_words", "(", "arg", ".", "type", ",", "arg", ".", "mode", ")", ";", "int", "offset", "=", "ia64_function_arg_offset", "(", "cum", ",", "arg", ".", "type", ",", "words", ")", ";", "if", "(", "cum", "->", "words", "+", "offset", ">=", "MAX_ARGUMENT_SLOTS", ")", "return", "<NUM_LIT>", ";", "if", "(", "words", "+", "cum", "->", "words", "+", "offset", "<=" ]

[ "rA", ")", ">", ";" ]

[ "class", "LRRegInst", "<", "RegisterClass", "rclass", ">", ":", "LRInst", "<", "(", "outs", "rclass", ":", "$", "rT", ")", ",", "(", "ins", "rclass", ":", "$" ]

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

[ "class", "TestBranch", "<", "bit", "op", ",", "string", "asm", ",", "SDNode", "node", ">", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "GPR64", ":", "$", "Rt", ",", "imm0_63", ":", "$", "bit_off", ",", "am_tbrcond", ":", "$", "target", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "node", "GPR64", ":", "$", "Rt", ",", "imm0_63", ":", "$", "bit_off", ",", "bb", ":", "$", "target", ")", "]", ">", ",", "Sched", "<", "[", "WriteBr", "]", ">", "{", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";" ]

[ ")", "_", "mm512_i64gather_epi32", "(", "_", "_", "m512i", "_", "_", "index", ",", "void", "const", "*", "_", "_", "addr", ",", "int", "_", "_", "scale", ")", "{" ]

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

[ "if", "(", "OffImm", "!=", "<NUM_LIT>", "&&", "UseMarkup", ")", "O", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";" ]

[ "assert", "(", "(", "(", "OffImm", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Not a valid immediate!", "<STR_LIT>", ")", ";", "if", "(", "OffImm", "!=", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "if", "(", "OffImm", "!=", "<NUM_LIT>", "&&", "UseMarkup", ")", "O", "<<", "<STR_LIT>", "<imm:", "<STR_LIT>", ";", "if", "(", "OffImm", "==", "INT32_MIN", ")", "O", "<<", "<STR_LIT>", "#-0", "<STR_LIT>", ";", "else", "if", "(", "OffImm", "<", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", "#-", "<STR_LIT>", "<<", "-", "OffImm", ";", "else", "if", "(", "OffImm", ">", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", "#", "<STR_LIT>", "<<", "OffImm", ";" ]

[ "}" ]

[ "class", "VOP3be_gfx6_gfx7", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "VOPProfile", "p", ">", ":", "VOP3be", "<", "p", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";" ]

[ "else", "emit_move_insn", "(", "dst", ",", "src", ")", ";" ]

[ "rtx", "tmp", "=", "assign_386_stack_local", "(", "smode", ",", "SLOT_STV_TEMP", ")", ";", "emit_move_insn", "(", "tmp", ",", "src", ")", ";", "if", "(", "!", "TARGET_64BIT", "&&", "smode", "==", "DImode", ")", "{", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "<NUM_LIT>", ")", ",", "adjust_address", "(", "tmp", ",", "SImode", ",", "<NUM_LIT>", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "<NUM_LIT>", ")", ",", "adjust_address", "(", "tmp", ",", "SImode", ",", "<NUM_LIT>", ")", ")", ";", "}", "else", "emit_move_insn", "(", "dst", ",", "copy_rtx", "(", "tmp", ")", ")", ";", "}", "else", "if", "(", "!", "TARGET_64BIT", "&&", "smode", "==", "DImode", ")", "{", "if", "(", "TARGET_SSE4_1", ")", "{", "rtx", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "<NUM_LIT>", ")", ",", "gen_rtx_VEC_SELECT", "(", "SImode", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "src", ",", "<NUM_LIT>", ")", ",", "tmp", ")", ")", ")", ";", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "<NUM_LIT>", ")", ",", "gen_rtx_VEC_SELECT", "(", "SImode", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "src", ",", "<NUM_LIT>", ")", ",", "tmp", ")", ")", ")", ";", "}", "else", "{", "rtx", "vcopy", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "emit_move_insn", "(", "vcopy", ",", "gen_rtx_SUBREG", "(", "V2DImode", ",", "src", ",", "<NUM_LIT>", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "<NUM_LIT>", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "vcopy", ",", "<NUM_LIT>", ")", ")", ";", "emit_move_insn", "(", "vcopy", ",", "gen_rtx_LSHIFTRT", "(", "V2DImode", ",", "vcopy", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "<NUM_LIT>", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "vcopy", ",", "<NUM_LIT>", ")", ")", ";", "}", "}" ]

[ "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", "<<", "<NUM_LIT>", ")", ";" ]

[ "void", "PPCInstPrinter", "::", "printBranchOperand", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "return", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "<STR_LIT>", ".", "<STR_LIT>", ";", "int32_t", "Imm", "=", "SignExtend32", "<", "<NUM_LIT>", ">", "(", "(", "unsigned", ")", "MI", "->" ]

[ "}" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "Absolute", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ ":", "{" ]

[ "OptimizeListAgain", "|=", "(", "CI", ".", "Width", "+", "Paired", ".", "Width", ")", "<", "<NUM_LIT>", ";", "break", ";", "}", "case", "BUFFER_LOAD", ":", "{", "MachineBasicBlock", "::", "iterator", "NewMI", "=", "mergeBufferLoadPair", "(", "CI", ",", "Paired", ")", ";", "CI", ".", "setMI", "(", "NewMI", ",", "*", "TII", ",", "*", "STM", ")", ";", "OptimizeListAgain", "|=", "(", "CI", ".", "Width", "+", "Paired", ".", "Width", ")", "<", "<NUM_LIT>", ";", "break", ";", "}", "case", "BUFFER_STORE", ":", "{", "MachineBasicBlock", "::", "iterator", "NewMI", "=", "mergeBufferStorePair", "(", "CI", ",", "Paired", ")", ";", "CI", ".", "setMI", "(", "NewMI", ",", "*", "TII", ",", "*", "STM", ")", ";", "OptimizeListAgain", "|=", "(", "CI", ".", "Width", "+", "Paired", ".", "Width", ")", "<", "<NUM_LIT>", ";", "break", ";", "}", "case", "MIMG", ":", "{", "MachineBasicBlock", "::", "iterator", "NewMI", "=", "mergeImagePair", "(", "CI", ",", "Paired", ")", ";", "CI", ".", "setMI", "(", "NewMI", ",", "*", "TII", ",", "*", "STM", ")", ";", "OptimizeListAgain", "|=", "(", "CI", ".", "Width", "+", "Paired", ".", "Width", ")", "<", "<NUM_LIT>", ";", "break", ";", "}", "case", "TBUFFER_LOAD" ]

[ "getRegisterName", "(", "RegNo", ")", ")", ";" ]

[ "void", "M680x0InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "<STR_LIT>", "%", "<STR_LIT>", "<<", "StringRef", "(" ]

[ "}" ]

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

[ "cast", "<", "MachineSDNode", ">", "(", "VLdDup", ")", "->", "setMemRefs", "(", "MemOp", ",", "MemOp", "+", "<NUM_LIT>", ")", ";" ]

[ "SDValue", "Inc", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "Inc", ".", "getNode", "(", ")", ")", ")", "Opc", "=", "getVLDSTRegisterUpdateOpcode", "(", "Opc", ")", ";", "Ops", ".", "push_back", "(", "Inc", ")", ";", "}", "Ops", ".", "push_back", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SmallVector", "<", "EVT", ",", "<NUM_LIT>", ">", "ResTys", ";", "if", "(", "NumVecs", "==", "<NUM_LIT>", ")", "ResTys", ".", "push_back", "(", "MVT", "::", "Untyped", ")", ";", "else", "{", "EVT", "ResTy", "=", "EVT", "::", "getVectorVT", "(", "*", "CurDAG", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "is64BitVector", "?", "NumVecs", ":", "NumVecs", "*", "<NUM_LIT>", ")", ";", "ResTys", ".", "push_back", "(", "ResTy", ")", ";", "}", "if", "(", "isUpdating", ")", "ResTys", ".", "push_back", "(", "MVT", "::", "i64", ")", ";", "ResTys", ".", "push_back", "(", "MVT", "::", "Other", ")", ";", "SDNode", "*", "VLdDup", "=", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "dl", ",", "ResTys", ",", "Ops", ")", ";", "MachineSDNode", "::", "mmo_iterator", "MemOp", "=", "MF", "->", "allocateMemRefsArray", "(", "<NUM_LIT>", ")", ";", "MemOp", "[", "<NUM_LIT>", "]", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";" ]

[ "}" ]

[ "SDValue", "GprIndexPlusOne", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "GprIndex", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "GprIndex", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "dl", ",", "MVT", "::", "i32", ",", "CC64", ",", "GprIndexPlusOne", ",", "GprIndex", ")", ";", "}", "SDValue", "FprPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "VAListPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "FprIndex", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "ZEXTLOAD", ",", "dl", ",", "MVT", "::", "i32", ",", "InChain", ",", "FprPtr", ",", "MachinePointerInfo", "(", "SV", ")", ",", "MVT", "::", "i8", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "FprIndex", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "RegSaveAreaPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "VAListPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "OverflowAreaPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "VAListPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "OverflowArea", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "InChain", ",", "OverflowAreaPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "OverflowArea", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "RegSaveArea", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "InChain", ",", "RegSaveAreaPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "RegSaveArea", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "CC", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "MVT", "::", "i32", ",", "VT", ".", "isInteger", "(", ")", "?", "GprIndex", ":", "FprIndex", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "ISD", "::", "SETLT", ")", ";", "SDValue", "RegConstant", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "MVT", "::", "i32", ",", "VT", ".", "isInteger", "(", ")", "?", "GprIndex", ":", "FprIndex", ",", "DAG", ".", "getConstant", "(", "VT", ".", "isInteger", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "OurReg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "RegSaveArea", ",", "RegConstant", ")", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", "OurReg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "OurReg", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "IndexPlus1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "VT", ".", "isInteger", "(", ")", "?", "GprIndex", ":", "FprIndex", ",", "DAG", ".", "getConstant", "(", "VT", "==", "MVT", "::", "i64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "InChain", "=", "DAG", ".", "getTruncStore", "(", "InChain", ",", "dl", ",", "IndexPlus1", ",", "VT", ".", "isInteger", "(", ")", "?", "VAListPtr", ":", "FprPtr", ",", "MachinePointerInfo", "(", "SV", ")", ",", "MVT", "::", "i8", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "dl", ",", "PtrVT", ",", "CC", ",", "OurReg", ",", "OverflowArea", ")", ";", "SDValue", "OverflowAreaPlusN", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "OverflowArea", ",", "DAG", ".", "getConstant", "(", "VT", ".", "isInteger", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "OverflowArea", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "dl", ",", "MVT", "::", "i32", ",", "CC", ",", "OverflowArea", ",", "OverflowAreaPlusN", ")", ";", "InChain", "=", "DAG", ".", "getTruncStore", "(", "InChain", ",", "dl", ",", "OverflowArea", ",", "OverflowAreaPtr", ",", "MachinePointerInfo", "(", ")", ",", "MVT", "::", "i32", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getLoad", "(", "VT", ",", "dl", ",", "InChain", ",", "Result", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";" ]

[ "DL", ",", "PtrVT", ",", "Hi", ")", ";" ]

[ "SDValue", "Lo", "=", "DAG", ".", "getTargetConstantPool", "(", "GV", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "LoFlags", ")", ";", "SDValue", "PoolAddr", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "ADRP", ",", "Lo", ")", ";", "SDValue", "GlobalAddr", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "PoolAddr", ",", "MachinePointerInfo", "::", "getConstantPool", "(", ")", ",", "false", ",", "true", ",", "true", ",", "<NUM_LIT>", ")", ";", "if", "(", "GN", "->", "getOffset", "(", ")", "!=", "<NUM_LIT>", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "GlobalAddr", ",", "DAG", ".", "getConstant", "(", "GN", "->", "getOffset", "(", ")", ",", "PtrVT", ")", ")", ";", "return", "GlobalAddr", ";", "}", "if", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "{", "const", "unsigned", "char", "MO_NC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "|", "MO_NC", ")", ",", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "|", "MO_NC", ")", ",", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "|", "MO_NC", ")", ")", ";", "}", "else", "{", "SDValue", "Hi", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "OpFlags", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "unsigned", "char", "LoFlags", "=", "OpFlags", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "Lo", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "LoFlags", ")", ";", "SDValue", "ADRP", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", "," ]

[ ")", "!=", "<NUM_LIT>", ")", "return", "Dims", ";" ]

[ "msgpack", "::", "ArrayDocNode", "MetadataStreamerMsgPackV4", "::", "getWorkGroupDimensions", "(", "MDNode", "*", "Node", ")", "const", "{", "auto", "Dims", "=", "HSAMetadataDoc", "->", "getArrayNode", "(", ")", ";", "if", "(", "Node", "->", "getNumOperands", "(" ]

[ "long", "val", ";" ]

[ "fprintf", "(", "stream", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "nds32_intrinsic_register_names", "[", "op_value", "-", "<NUM_LIT>", "]", ")", ";", "}", "return", ";", "case", "'", "R", "'", ":", "if", "(", "op_value", "<", "<NUM_LIT>", "||", "op_value", ">", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "CCTL intrinsic function subtype out of range", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "nds32_cctl_names", "[", "op_value", "]", ")", ";", "return", ";", "case", "'", "T", "'", ":", "if", "(", "op_value", "<", "<NUM_LIT>", "||", "op_value", ">", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "CCTL intrinsic function subtype out of range", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "nds32_cctl_names", "[", "op_value", "+", "<NUM_LIT>", "]", ")", ";", "return", ";", "case", "'", "U", "'", ":", "if", "(", "op_value", "<", "<NUM_LIT>", "||", "op_value", ">", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "CCTL intrinsic function subtype out of range", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "nds32_cctl_names", "[", "op_value", "+", "<NUM_LIT>", "]", ")", ";", "return", ";", "case", "'", "X", "'", ":", "if", "(", "op_value", "<", "<NUM_LIT>", "||", "op_value", ">", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "CCTL intrinsic function subtype out of range", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "nds32_cctl_names", "[", "op_value", "+", "<NUM_LIT>", "]", ")", ";", "return", ";", "case", "'", "W", "'", ":", "if", "(", "op_value", "<", "<NUM_LIT>", "||", "op_value", ">", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "CCTL intrinsic function subtype out of range", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "nds32_cctl_names", "[", "op_value", "+", "<NUM_LIT>", "]", ")", ";", "return", ";", "case", "'", "Z", "'", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "nds32_dpref_names", "[", "op_value", "]", ")", ";", "return", ";", "default", ":", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand output code", "<STR_LIT>", ")", ";", "break", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "stream", ",", "x", ")", ";", "if", "(", "!", "TARGET_LINUX_ABI", "&&", "nds32_indirect_call_referenced_p", "(", "x", ")", ")", "fprintf", "(", "stream", ",", "<STR_LIT>", "@ICT", "<STR_LIT>", ")", ";", "break", ";", "case", "REG", ":", "if", "(", "(", "GET_MODE", "(", "x", ")", "==", "DImode", "||", "GET_MODE", "(", "x", ")", "==", "DFmode", ")", "&&", "NDS32_IS_FPR_REGNUM", "(", "REGNO", "(", "x", ")", ")", ")", "{", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "!", "NDS32_FPR_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for code '%c'", "<STR_LIT>", ",", "code", ")", ";", "break", ";", "}", "fprintf", "(", "stream", ",", "<STR_LIT>", "$fd%d", "<STR_LIT>", ",", "(", "regno", "-", "NDS32_FIRST_FPR_REGNUM", ")", ">>", "<NUM_LIT>", ")", ";", "break", ";", "}", "if", "(", "(", "GET_MODE", "(", "x", ")", "==", "DImode", "||", "GET_MODE", "(", "x", ")", "==", "DFmode", ")", "&&", "NDS32_IS_GPR_REGNUM", "(", "REGNO", "(", "x", ")", ")", ")", "{", "if", "(", "(", "pick_lsb_p", "&&", "WORDS_BIG_ENDIAN", ")", "||", "(", "pick_msb_p", "&&", "!", "WORDS_BIG_ENDIAN", ")", ")", "{", "regno", "=", "REGNO", "(", "x", ")", ";", "regno", "++", ";", "fputs", "(", "reg_names", "[", "regno", "]", ",", "stream", ")", ";", "break", ";", "}", "}", "if", "(", "TARGET_REDUCED_REGS", "&&", "REGNO", "(", "x", ")", "==", "STATIC_CHAIN_REGNUM", ")", "sorry", "(", "<STR_LIT>", "a nested function is not supported for reduced registers", "<STR_LIT>", ")", ";", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "stream", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "HIGH", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "CONST_DOUBLE", ")", "{", "const", "REAL_VALUE_TYPE", "*", "rv", ";", "long", "val", ";", "gcc_assert", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", ";", "rv", "=", "CONST_DOUBLE_REAL_VALUE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "rv", ",", "val", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "hi20(0x%lx)", "<STR_LIT>", ",", "val", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "const", "REAL_VALUE_TYPE", "*", "rv", ";" ]

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

[ "(", "match_operand", ":", "ADDSUB", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "CCDSP", "CCDSP_OU_REGNUM", ")", "(", "unspec", ":", "CCDSP", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_SUBQ_S", ")", ")", "]", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "unsigned", "OpNum", ",", "raw_ostream", "&", "O", ")", "{" ]

[ "void", "printMemoryRegOffset", "(", "const", "MCInst", "*", "MI", "," ]

[ ")", ")" ]

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

[ "Optional", "<", "Instruction", "*", ">", "AArch64TTIImpl", "::", "instCombineIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ")", "const", "{", "Intrinsic", "::", "ID", "IID", "=", "II", ".", "getIntrinsicID", "(", ")", ";", "switch", "(", "IID", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_sve_convert_from_svbool", ":", "return", "instCombineConvertFromSVBool", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup", ":", "return", "instCombineSVEDup", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup_x", ":", "return", "instCombineSVEDupX", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpne", ":", "case", "Intrinsic", "::", "aarch64_sve_cmpne_wide", ":", "return", "instCombineSVECmpNE", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_rdffr", ":", "return", "instCombineRDFFR", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_lasta", ":", "case", "Intrinsic", "::", "aarch64_sve_lastb", ":", "return", "instCombineSVELast", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntd", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "<NUM_LIT>", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntw", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "<NUM_LIT>", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cnth", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "<NUM_LIT>", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntb", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "<NUM_LIT>", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ptest_any", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_first", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_last", ":", "return", "instCombineSVEPTest", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mul", ":", "case", "Intrinsic", "::", "aarch64_sve_fmul", ":", "return", "instCombineSVEVectorMul", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tbl", ":", "return", "instCombineSVETBL", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_uunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_uunpklo", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpklo", ":", "return", "instCombineSVEUnpack", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tuple_get", ":", "return", "instCombineSVETupleGet", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_zip1", ":", "case", "Intrinsic", "::", "aarch64_sve_zip2", ":", "return", "instCombineSVEZip", "(", "IC", ",", "II", ")", ";", "}", "return", "None", ";", "}" ]

[ "Targets", "can", "implement", "their", "own", "combinations", "for", "target-specific", "intrinsics", "." ]

[ "SHOWNEWINSTR", "(", "NewInstr", ")", ";" ]

[ "MachineFunction", "*", "MF", "=", "blk", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewInstr", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "NewOpcode", ")", ",", "DL", ")", ";", "blk", "->", "insert", "(", "I", ",", "NewInstr", ")", ";", "MachineInstrBuilder", "(", "*", "MF", ",", "NewInstr", ")", ".", "addReg", "(", "RegNum", ",", "false", ")", ";" ]

[ "{" ]

[ "vreinterpret_u64_f64", "(", "float64x1_t", "_", "_", "a", ")" ]

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

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

[ "false", ";" ]

[ "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".set", "<STR_LIT>", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".fmask", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".mask", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "<STR_LIT>", ".gpword", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return" ]

[ "static", "void", "mips_epilogue_set_cfa", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx_insn", "*", "insn", ";", "insn", "=", "mips_epilogue_emit_cfa_restores", "(", ")", ";", "if", "(", "reg", "!=", "mips_epilogue", ".", "cfa_reg", "||", "offset", "!=", "mips_epilogue", ".", "cfa_offset", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "reg", ",", "offset", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "mips_epilogue", ".", "cfa_reg", "=", "reg", ";", "mips_epilogue", ".", "cfa_offset", "=", "offset", ";", "}", "}" ]

[ "Like", "mips_epilogue_emit_cfa_restores", ",", "but", "also", "record", "that", "the", "CFA", "is", "now", "at", "REG", "+", "OFFSET", "." ]

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

[ "def", "simm5_32b", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "Imm", ">", "=", "-", "<NUM_LIT>", "&", "&", "Imm", "<" ]

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

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

[ "}" ]

[ "def", "_B_fixed", ":", "STN_WBFx_Lane", "<", "r", ",", "<NUM_LIT>", ",", "op0", ",", "!", "cast", "<", "RegisterOperand", ">", "(", "List", "#", "<STR_LIT>", ")", ",", "uimm_b", ",", "neon_uimm4_bare", ",", "asmop", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "}", ";" ]

[ "_", "v32qi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask8", ")", "_", "_", "M", ")", ";" ]

[ "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_cmpb256_mask", "(", "(", "_", "_", "v32qi", ")", "_", "_", "X", ",", "(", "_" ]

[ "Invalid u6imm argument!", "<STR_LIT>", ")", ";" ]

[ "void", "VideocoreInstPrinter", "::", "printU6ImmOperand", "(", "const", "MCInst", "*", "MI", ",", "int", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "unsigned", "int", "Value", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ";", "assert", "(", "Value", "<=", "<NUM_LIT>", "&&", "<STR_LIT>" ]

[ "make_unique", "<", "R600SchedStrategy", ">", "(", ")", ")", ";" ]

[ "return", "new", "ScheduleDAGMILive", "(", "C", ",", "llvm", "::" ]

[ "}", "else", "if", "(", "int32_t", "Num", ";" ]

[ "std", "::", "ssub_match", "SMatch", "=", "Match", "[", "i", "]", ";", "std", "::", "string", "Item", "=", "SMatch", ".", "str", "(", ")", ";", "if", "(", "Item", ".", "length", "(", ")", "==", "<NUM_LIT>", ")", "break", ";", "if", "(", "Item", "[", "<NUM_LIT>", "]", "==", "'", "<STR_LIT>", "'", ")", "{", "Item", "=", "Item", ".", "substr", "(", "<NUM_LIT>", ",", "Item", ".", "length", "(", ")", "-", "<NUM_LIT>", ")", ";", "static", "const", "std", "::", "regex", "RStr", "(", "<STR_LIT>", "^(\\\\d+)(?:,(\\\\d+))*$", "<STR_LIT>", ")", ";", "if", "(", "std", "::", "smatch", "MatchStr", ";", "std", "::", "regex_match", "(", "Item", ",", "MatchStr", ",", "RStr", ")", ")", "{", "for", "(", "std", "::", "size_t", "SubIdx", "=", "<NUM_LIT>", ";", "SubIdx", "<", "MatchStr", ".", "size", "(", ")", ";", "++", "SubIdx", ")", "if", "(", "std", "::", "string", "SubStr", "=", "MatchStr", "[", "SubIdx", "]", ".", "str", "(", ")", ";", "SubStr", ".", "length", "(", ")", ")", "MDsItem", ".", "push_back", "(", "ConstantAsMetadata", "::", "get", "(", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "std", "::", "stoi", "(", "SubStr", ")", ")", ")", ")", ";", "}", "else", "{", "MDsItem", ".", "push_back", "(", "MDString", "::", "get", "(", "Ctx", ",", "Item", ")", ")", ";", "}" ]

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

[ "let", "PrintMethod" ]

[ "static", "void", "rs6000_xcoff_asm_init_sections", "(", "void", ")", "{", "read_only_data_section", "=", "get_unnamed_section", "(", "<NUM_LIT>", ",", "rs6000_xcoff_output_readonly_section_asm_op", ",", "&", "xcoff_read_only_section_name", ")", ";", "private_data_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", ",", "rs6000_xcoff_output_readwrite_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "tls_data_section", "=", "get_unnamed_section", "(", "SECTION_TLS", ",", "rs6000_xcoff_output_tls_section_asm_op", ",", "&", "xcoff_tls_data_section_name", ")", ";", "tls_private_data_section", "=", "get_unnamed_section", "(", "SECTION_TLS", ",", "rs6000_xcoff_output_tls_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "read_only_private_data_section", "=", "get_unnamed_section", "(", "<NUM_LIT>", ",", "rs6000_xcoff_output_readonly_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "toc_section", "=", "get_unnamed_section", "(", "<NUM_LIT>", ",", "rs6000_xcoff_output_toc_section_asm_op", ",", "NULL", ")", ";", "readonly_data_section", "=", "read_only_data_section", ";", "}" ]

[ "Implement", "TARGET_ASM_INIT_SECTIONS", "." ]

[ "<FIXS>", "bool", "emitREXPrefix", "(", "unsigned", "&", "CurByte", ",", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<FIXE>" ]

[ "bool", "emitOpcodePrefix", "(", "unsigned", "&", "CurByte", ",", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<BUGS>", "uint8_t", "determineREXPrefix", "(", "const", "MCInst", "&", "MI", ",", "int", "MemOperand", ")", "const", ";", "<BUGE>", "}", ";", "}" ]

[ ";" ]

[ "bool", "isV2", "(", ")", "const", "{", "return", "IsV2" ]

[ ",", "T", ")", ";" ]

[ "Constant", "*", "CVal", "=", "nullptr", ";", "bool", "isVTi1Type", "=", "false", ";", "if", "(", "auto", "*", "CV", "=", "dyn_cast", "<", "ConstantVector", ">", "(", "CPN", "->", "getConstVal", "(", ")", ")", ")", "{", "if", "(", "CV", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "{", "IRBuilder", "<", ">", "IRB", "(", "CV", "->", "getContext", "(", ")", ")", ";", "SmallVector", "<", "Constant", "*", ",", "<NUM_LIT>", ">", "NewConst", ";", "unsigned", "VecLen", "=", "CV", "->", "getNumOperands", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "VecLen", ")", "&&", "<STR_LIT>", "conversion only supported for pow2 VectorSize", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "VecLen", ";", "++", "i", ")", "NewConst", ".", "push_back", "(", "IRB", ".", "getInt8", "(", "CV", "->", "getOperand", "(", "i", ")", "->", "isZeroValue", "(", ")", ")", ")", ";", "CVal", "=", "ConstantVector", "::", "get", "(", "NewConst", ")", ";", "isVTi1Type", "=", "true", ";", "}", "}", "unsigned", "Align", "=", "CPN", "->", "getAlignment", "(", ")", ";", "bool", "IsPositionIndependent", "=", "isPositionIndependent", "(", ")", ";", "unsigned", "char", "TF", "=", "IsPositionIndependent", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "unsigned", "Offset", "=", "<NUM_LIT>", ";", "SDValue", "T", ";", "if", "(", "CPN", "->", "isMachineConstantPoolEntry", "(", ")", ")", "T", "=", "DAG", ".", "getTargetConstantPool", "(", "CPN", "->", "getMachineCPVal", "(", ")", ",", "ValTy", ",", "Align", ",", "Offset", ",", "TF", ")", ";", "else", "if", "(", "isVTi1Type", ")", "T", "=", "DAG", ".", "getTargetConstantPool", "(", "CVal", ",", "ValTy", ",", "Align", ",", "Offset", ",", "TF", ")", ";", "else", "T", "=", "DAG", ".", "getTargetConstantPool", "(", "CPN", "->", "getConstVal", "(", ")", ",", "ValTy", ",", "Align", ",", "Offset", ",", "TF", ")", ";", "assert", "(", "cast", "<", "ConstantPoolSDNode", ">", "(", "T", ")", "->", "getTargetFlags", "(", ")", "==", "TF", "&&", "<STR_LIT>", "Inconsistent target flag encountered", "<STR_LIT>", ")", ";", "if", "(", "IsPositionIndependent", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "Op", ")", ",", "ValTy", ",", "T", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "Op", ")", ",", "ValTy" ]

[ "for", "(", "auto", "&", "It", ":", "PreviousRegSeqByUndefCount", ")", "{" ]

[ "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "MIs", "=", "It", ".", "second", ";", "MIs", ".", "erase", "(", "llvm", "::", "find", "(", "MIs", ",", "MI", ")", ",", "MIs", ".", "end", "(", ")", ")", ";", "}" ]

[ "}" ]

[ "_", "_", "arm_vsliq", "(", "int32x4_t", "_", "_", "a", ",", "int32x4_t", "_", "_", "b", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "_", "_", "arm_vsliq_n_s32", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "imm", ")", ";" ]

[ "outliner", "::", "OutlinedFunction", "AArch64InstrInfo", "::", "getOutliningCandidateInfo", "(", "std", "::", "vector", "<", "outliner", "::", "Candidate", ">", "&", "RepeatedSequenceLocs", ")", "const", "{", "unsigned", "SequenceSize", "=", "std", "::", "accumulate", "(", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "front", "(", ")", ",", "std", "::", "next", "(", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "back", "(", ")", ")", ",", "<NUM_LIT>", ",", "[", "this", "]", "(", "unsigned", "Sum", ",", "const", "MachineInstr", "&", "MI", ")", "{", "return", "Sum", "+", "getInstSizeInBytes", "(", "MI", ")", ";", "}", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "getRegisterInfo", "(", ")", ";", "std", "::", "for_each", "(", "RepeatedSequenceLocs", ".", "begin", "(", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ",", "[", "&", "TRI", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "C", ".", "initLRU", "(", "TRI", ")", ";", "}", ")", ";", "auto", "CantGuaranteeValueAcrossCall", "=", "[", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "LiveRegUnits", "LRU", "=", "C", ".", "LRU", ";", "return", "(", "!", "LRU", ".", "available", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "!", "LRU", ".", "available", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "!", "LRU", ".", "available", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "}", ";", "RepeatedSequenceLocs", ".", "erase", "(", "std", "::", "remove_if", "(", "RepeatedSequenceLocs", ".", "begin", "(", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ",", "CantGuaranteeValueAcrossCall", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ")", ";", "if", "(", "RepeatedSequenceLocs", ".", "empty", "(", ")", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "unsigned", "LastInstrOpcode", "=", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "back", "(", ")", "->", "getOpcode", "(", ")", ";", "auto", "SetCandidateCallInfo", "=", "[", "&", "RepeatedSequenceLocs", "]", "(", "unsigned", "CallID", ",", "unsigned", "NumBytesForCall", ")", "{", "for", "(", "outliner", "::", "Candidate", "&", "C", ":", "RepeatedSequenceLocs", ")", "C", ".", "setCallInfo", "(", "CallID", ",", "NumBytesForCall", ")", ";", "}", ";", "unsigned", "FrameID", "=", "MachineOutlinerDefault", ";", "unsigned", "NumBytesToCreateFrame", "=", "<NUM_LIT>", ";", "bool", "HasBTI", "=", "any_of", "(", "RepeatedSequenceLocs", ",", "[", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "return", "C", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "<STR_LIT>", "branch-target-enforcement", "<STR_LIT>", ")", ";", "}", ")", ";", "if", "(", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "back", "(", ")", "->", "isTerminator", "(", ")", ")", "{", "FrameID", "=", "MachineOutlinerTailCall", ";", "NumBytesToCreateFrame", "=", "<NUM_LIT>", ";", "SetCandidateCallInfo", "(", "MachineOutlinerTailCall", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "LastInstrOpcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "(", "LastInstrOpcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "!", "HasBTI", ")", ")", "{", "FrameID", "=", "MachineOutlinerThunk", ";", "NumBytesToCreateFrame", "=", "<NUM_LIT>", ";", "SetCandidateCallInfo", "(", "MachineOutlinerThunk", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "std", "::", "all_of", "(", "RepeatedSequenceLocs", ".", "begin", "(", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ",", "[", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "return", "C", ".", "LRU", ".", "available", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", ")", ")", "{", "FrameID", "=", "MachineOutlinerNoLRSave", ";", "NumBytesToCreateFrame", "=", "<NUM_LIT>", ";", "SetCandidateCallInfo", "(", "MachineOutlinerNoLRSave", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "if", "(", "all_of", "(", "RepeatedSequenceLocs", ",", "[", "this", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "return", "findRegisterToSaveLRTo", "(", "C", ")", ";", "}", ")", ")", "{", "FrameID", "=", "MachineOutlinerRegSave", ";", "NumBytesToCreateFrame", "=", "<NUM_LIT>", ";", "SetCandidateCallInfo", "(", "MachineOutlinerRegSave", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "FrameID", "=", "MachineOutlinerDefault", ";", "NumBytesToCreateFrame", "=", "<NUM_LIT>", ";", "SetCandidateCallInfo", "(", "MachineOutlinerDefault", ",", "<NUM_LIT>", ")", ";", "}", "}", "if", "(", "std", "::", "any_of", "(", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "front", "(", ")", ",", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "back", "(", ")", ",", "[", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "isCall", "(", ")", ";", "}", ")", ")", "NumBytesToCreateFrame", "+=", "<NUM_LIT>", ";", "else", "if", "(", "FrameID", "!=", "MachineOutlinerThunk", "&&", "FrameID", "!=", "MachineOutlinerTailCall", "&&", "RepeatedSequenceLocs", "[", "<NUM_LIT>", "]", ".", "back", "(", ")", "->", "isCall", "(", ")", ")", "NumBytesToCreateFrame", "+=", "<NUM_LIT>", ";", "return", "outliner", "::", "OutlinedFunction", "(", "RepeatedSequenceLocs", ",", "SequenceSize", ",", "NumBytesToCreateFrame", ",", "FrameID", ")", ";", "}" ]

[ "Returns", "a", "outliner", ":", ":OutlinedFunction", "struct", "containing", "target-specific", "information", "for", "a", "set", "of", "outlining", "candidates", "." ]

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

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

[ ",", "<NUM_LIT>", ")", ",", "(", "STIWX", "(", "XSCVDPUXWS", "f64", ":", "$", "src", ")", ",", "xoaddr", ":", "$", "dst", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "PPCstore_scal_int_from_vsr", "(", "f64", "(", "PPCcv_fp_to_uint_in_vsr", "f64", ":", "$", "src", ")", ")", ",", "xoaddr", ":", "$", "dst" ]