Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "if", "(", "TARGET_SINGLE_FLOAT", "&&", "TARGET_FLOAT64", ")", "<FIXE>" ]

[ "if", "(", "(", "target_flags_explicit", "&", "MASK_FLOAT64", ")", "!=", "<NUM_LIT>", ")", "{", "<BUGS>", "if", "(", "TARGET_64BIT", "&&", "TARGET_DOUBLE_FLOAT", "&&", "!", "TARGET_FLOAT64", ")", "error", "(", "<STR_LIT>", "unsupported combination: %s", "<STR_LIT>", ",", "<STR_LIT>", "-mgp64 -mfp32 -mdouble-float", "<STR_LIT>", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "TARGET_FLOAT64", "&&", "!", "(", "ISA_HAS_MXHC1", "&&", "mips_abi", "==", "ABI_32", ")", ")", "error", "(", "<STR_LIT>", "-mgp32 and -mfp64 can only be combined if the target", "<STR_LIT>", "<STR_LIT>", " supports the mfhc1 and mthc1 instructions", "<STR_LIT>", ")", ";", "else", "if", "(", "TARGET_SINGLE_FLOAT", "&&", "TARGET_FLOAT64", ")", "<BUGE>", "error", "(", "<STR_LIT>", "unsupported combination: %s", "<STR_LIT>", ",", "<STR_LIT>", "-mfp64 -msingle-float", "<STR_LIT>", ")", ";", "}", "else", "{" ]

[ ")", "{" ]

[ "static", "bool", "isLDSTSIMDSPI", "(", "InsnType", "insn" ]

[ "<STR_LIT>" ]

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

[ ";" ]

[ "if", "(", "MI", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "!", "getLdStOffsetOp", "(", "MI", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "StoreI", ";", "if", "(", "findMatchingStore", "(", "MBBI", ",", "ScanLimit", ",", "StoreI", ")", ")", "{", "++", "NumLoadsFromStoresPromoted", ";", "MBBI", "=", "promoteLoadFromStore", "(", "MBBI", ",", "StoreI", ")", ";", "return", "true", ";", "}", "return", "false" ]

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

[ "if", "(", "!", "DisableHSDR", ")", "addPass", "(", "createHexagonSplitDoubleRegs", "(", ")", ")", ";", "if", "(", "EnableBitSimplify", ")", "addPass", "(", "createHexagonBitSimplify", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "printAndVerify", "(", "<STR_LIT>", "After hexagon peephole pass", "<STR_LIT>", ")", ";", "if", "(", "EnableGenInsert", ")", "addPass", "(" ]

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

[ "const", "MCRegisterInfo", "*", "MRI", "=", "getMRI", "(", ")", ";", "int", "DstAreg", "=", "IsAGPROperand", "(", "Inst", ",", "AMDGPU", "::", "OpName", "::", "vdst", ",", "MRI", ")", ";", "int", "DataAreg", "=", "IsAGPROperand", "(", "Inst", ",", "DataNameIdx", ",", "MRI", ")", ";", "if", "(", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "DataAreg", ">=", "<NUM_LIT>", ")", "{", "int", "Data2Areg", "=", "IsAGPROperand", "(", "Inst", ",", "AMDGPU", "::", "OpName", "::", "data1", ",", "MRI", ")", ";", "if", "(", "Data2Areg", ">=", "<NUM_LIT>", "&&", "Data2Areg", "!=", "DataAreg", ")", "return", "false", ";", "}", "auto", "FB", "=", "getFeatureBits", "(", ")", ";", "if", "(", "FB", "[", "AMDGPU", "::", "FeatureGFX90AInsts", "]", ")", "{", "if", "(", "DataAreg", "<", "<NUM_LIT>", "||", "DstAreg" ]

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

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

[ "<FIXS>", "(", "define_insn", "<STR_LIT>", "[", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "[", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "v4si", ")", "_", "mm_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_prorvd128_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_", "_", "B", ",", "(", "_", "_" ]

[ "ExceptionsType", "=", "ExceptionHandling", "::", "DwarfCFI", ";" ]

[ "PointerSize", "=", "(", "is64Bit", "&&", "!", "isX32", "&&", "!", "isNaCl", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "NaClDontBreakABI", ")", "{", "PointerSize", "=", "(", "is64Bit", "&&", "!", "isX32", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "CalleeSaveStackSlotSize", "=", "is64Bit", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "AssemblerDialect", "=", "AsmWriterFlavor", ";", "TextAlignFillValue", "=", "<NUM_LIT>", ";", "SupportsDebugInformation", "=", "true", ";" ]

[ "}" ]

[ "void", "MipsSEInstrInfo", "::", "expandExtractElementF64", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "bool", "FP64", ")", "const", "{", "unsigned", "DstReg", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcReg", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "N", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "DebugLoc", "dl", "=", "I", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "N", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid immediate", "<STR_LIT>", ")", ";", "unsigned", "SubIdx", "=", "N", "?", "Mips", "::", "sub_hi", ":", "Mips", "::", "sub_lo", ";", "unsigned", "SubReg", "=", "getRegisterInfo", "(", ")", ".", "getSubReg", "(", "SrcReg", ",", "SubIdx", ")", ";", "if", "(", "SubIdx", "==", "Mips", "::", "sub_hi", "&&", "FP64", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "Mips", "::", "MFHC1", ")", ",", "DstReg", ")", ".", "addReg", "(", "SubReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "else", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "Mips", "::", "MFC1", ")", ",", "DstReg", ")", ".", "addReg", "(", "SubReg", ")", ";" ]

[ ")" ]

[ "UNSPEC_SHSUB", "UNSPEC_UHSUB", "UNSPEC_SRHSUB", "UNSPEC_URHSUB", "]" ]

[ "<STR_LIT>" ]

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

[ "A", "/", "(", "_", "_", "v8sf", ")", "_", "_", "B", ")", ";" ]

[ "return", "(", "_", "_", "m256", ")", "(", "(", "_", "_", "v8sf", ")", "_", "_" ]

[ "output_addr_const", "(", "stream", ",", "x", ")", ";" ]

[ "case", "REG", ":", "case", "SUBREG", ":", "{", "int", "base_num", "=", "true_regnum", "(", "base", ")", ";", "int", "index_num", "=", "true_regnum", "(", "index", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "@(r0,%s)", "<STR_LIT>", ",", "reg_names", "[", "MAX", "(", "base_num", ",", "index_num", ")", "]", ")", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@-%s", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@%s+", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "default", ":", "x", "=", "mark_constant_pool_use", "(", "x", ")", ";" ]

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

[ "return", "DAG", ".", "getMemcpy", "(", "Chain", ",", "dl", ",", "Dst", ",", "Src", ",", "SizeNode", ",", "Flags", ".", "getByValAlign", "(", ")", ",", "false" ]

[ "TPCII", "::", "HasCompositeImmMask", ";" ]

[ "return", "(", "MCInstD", ".", "TSFlags", ">>", "HasCompositeImmStart", ")", "&" ]

[ "mm_sub_pd", "(", "_", "_", "m128d", "_", "_", "A", ",", "_", "_", "m128d", "_", "_", "B", ")", "{" ]

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

[ "return", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";" ]

[ "case", "TLSModel", "::", "GeneralDynamic", ":", "case", "TLSModel", "::", "LocalDynamic", ":", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "LowerToTLSGeneralDynamicModel64", "(", "GA", ",", "DAG", ",", "getPointerTy", "(", ")", ")", ";", "return", "LowerToTLSGeneralDynamicModel32", "(", "GA", ",", "DAG", ",", "getPointerTy", "(", ")", ")", ";", "case", "TLSModel", "::", "InitialExec", ":", "case", "TLSModel", "::", "LocalExec", ":", "return", "LowerToTLSExecModel", "(", "GA", ",", "DAG", ",", "getPointerTy", "(", ")", ",", "model", ",", "Subtarget", "->", "is64Bit", "(", ")", ")", ";", "}", "}", "else", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "{", "unsigned", "char", "OpFlag", "=", "<NUM_LIT>", ";", "unsigned", "WrapperKind", "=", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "bool", "PIC32", "=", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", ";", "if", "(", "PIC32", ")", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "DebugLoc", "DL", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "DL", ",", "GA", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "GA", "->", "getOffset", "(", ")", ",", "OpFlag", ")", ";", "SDValue", "Offset", "=", "DAG", ".", "getNode", "(", "WrapperKind", ",", "DL", ",", "getPointerTy", "(", ")", ",", "Result", ")", ";", "if", "(", "PIC32", ")", "Offset", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "getPointerTy", "(", ")", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DebugLoc", "(", ")", ",", "getPointerTy", "(", ")", ")", ",", "Offset", ")", ";", "SDValue", "Chain", "=", "DAG", ".", "getEntryNode", "(", ")", ";", "SDVTList", "NodeTys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Flag", ")", ";", "SDValue", "Args", "[", "]", "=", "{", "Chain", ",", "Offset", "}", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "NodeTys", ",", "Args", ",", "<NUM_LIT>", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MFI", "->", "setAdjustsStack", "(", "true", ")", ";", "unsigned", "Reg", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";" ]

[ "static", "rtx", "rs6000_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "extra", ";", "if", "(", "!", "reg_offset_addressing_ok_p", "(", "mode", ")", "||", "mode_supports_vsx_dform_quad", "(", "mode", ")", ")", "{", "if", "(", "virtual_stack_registers_memory_p", "(", "x", ")", ")", "return", "x", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", "==", "const0_rtx", ")", "return", "force_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "(", "mode", "!=", "TImode", "||", "!", "TARGET_VSX_TIMODE", ")", ")", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ",", "force_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", ";", "else", "return", "force_reg", "(", "Pmode", ",", "x", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "enum", "tls_model", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ";", "if", "(", "model", "!=", "<NUM_LIT>", ")", "return", "rs6000_legitimize_tls_address", "(", "x", ",", "model", ")", ";", "}", "extra", "=", "<NUM_LIT>", ";", "switch", "(", "mode", ")", "{", "case", "E_TFmode", ":", "case", "E_TDmode", ":", "case", "E_TImode", ":", "case", "E_PTImode", ":", "case", "E_IFmode", ":", "case", "E_KFmode", ":", "extra", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "+", "<NUM_LIT>", ")", ">=", "<NUM_LIT>", "-", "extra", ")", "&&", "!", "(", "SPE_VECTOR_MODE", "(", "mode", ")", "||", "(", "TARGET_E500_DOUBLE", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", ")", ")", "{", "HOST_WIDE_INT", "high_int", ",", "low_int", ";", "rtx", "sum", ";", "low_int", "=", "(", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "if", "(", "low_int", ">=", "<NUM_LIT>", "-", "extra", ")", "low_int", "=", "<NUM_LIT>", ";", "high_int", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "-", "low_int", ";", "sum", "=", "force_operand", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "high_int", ")", ")", ",", "<NUM_LIT>", ")", ";", "return", "plus_constant", "(", "Pmode", ",", "sum", ",", "low_int", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "!=", "CONST_INT", "&&", "GET_MODE_NUNITS", "(", "mode", ")", "==", "<NUM_LIT>", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "||", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "TARGET_DOUBLE_FLOAT", ")", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DDmode", ")", ")", ")", "&&", "!", "avoiding_indexed_address_p", "(", "mode", ")", ")", "{", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "force_reg", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", ";", "}", "else", "if", "(", "SPE_VECTOR_MODE", "(", "mode", ")", "||", "(", "TARGET_E500_DOUBLE", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", ")", "{", "if", "(", "mode", "==", "DImode", ")", "return", "x", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "op1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "op2", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "y", ";", "op1", "=", "force_reg", "(", "Pmode", ",", "op1", ")", ";", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "!", "SPE_CONST_OFFSET_OK", "(", "INTVAL", "(", "op2", ")", ")", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "<NUM_LIT>", "&&", "!", "SPE_CONST_OFFSET_OK", "(", "INTVAL", "(", "op2", ")", "+", "<NUM_LIT>", ")", ")", ")", ")", "op2", "=", "force_reg", "(", "Pmode", ",", "op2", ")", ";", "y", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "op1", ",", "op2", ")", ";", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "<NUM_LIT>", "||", "mode", "==", "DDmode", ")", "&&", "REG_P", "(", "op2", ")", ")", "return", "force_reg", "(", "Pmode", ",", "y", ")", ";", "else", "return", "y", ";", "}", "return", "force_reg", "(", "Pmode", ",", "x", ")", ";", "}", "else", "if", "(", "(", "TARGET_ELF", "||", "!", "MACHO_DYNAMIC_NO_PIC_P", ")", "&&", "TARGET_32BIT", "&&", "TARGET_NO_TOC", "&&", "!", "flag_pic", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_WIDE_INT", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "&&", "CONSTANT_P", "(", "x", ")", "&&", "GET_MODE_NUNITS", "(", "mode", ")", "==", "<NUM_LIT>", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "||", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "TARGET_DOUBLE_FLOAT", ")", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DDmode", ")", ")", ")", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_ELF", ")", "emit_insn", "(", "gen_elf_high", "(", "reg", ",", "x", ")", ")", ";", "else", "emit_insn", "(", "gen_macho_high", "(", "reg", ",", "x", ")", ")", ";", "return", "gen_rtx_LO_SUM", "(", "Pmode", ",", "reg", ",", "x", ")", ";", "}", "else", "if", "(", "TARGET_TOC", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "constant_pool_expr_p", "(", "x", ")", "&&", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "get_pool_constant", "(", "x", ")", ",", "Pmode", ")", ")", "return", "create_TOC_reference", "(", "x", ",", "NULL_RTX", ")", ";", "else", "return", "x", ";", "}" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "This", "is", "used", "from", "only", "one", "place", ":", "`", "memory_address", "'", "in", "explow.c", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "passed", "so", "that", "this", "function", "can", "use", "GO_IF_LEGITIMATE_ADDRESS", ".", "It", "is", "always", "safe", "for", "this", "function", "to", "do", "nothing", ".", "It", "exists", "to", "recognize", "opportunities", "to", "optimize", "the", "output", ".", "On", "RS/6000", ",", "first", "check", "for", "the", "sum", "of", "a", "register", "with", "a", "constant", "integer", "that", "is", "out", "of", "range", ".", "If", "so", ",", "generate", "code", "to", "add", "the", "constant", "with", "the", "low-order", "16", "bits", "masked", "to", "the", "register", "and", "force", "this", "result", "into", "another", "register", "(", "this", "can", "be", "done", "with", "`", "cau", "'", ")", ".", "Then", "generate", "an", "address", "of", "REG+", "(", "CONST", "&", "0xffff", ")", ",", "allowing", "for", "the", "possibility", "of", "bit", "16", "being", "a", "one", ".", "Then", "check", "for", "the", "sum", "of", "a", "register", "and", "something", "not", "constant", ",", "try", "to", "load", "the", "other", "things", "into", "a", "register", "and", "return", "the", "sum", "." ]

[ "if", "(", "!", "isRelocatable", ")", "return", "false", ";" ]

[ "MCValue", "Value", ";", "bool", "isRelocatable", "=", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "Value", ",", "nullptr", ",", "nullptr", ")", ";" ]

[ ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "true" ]

[ "NAME", "#", "<STR_LIT>", ")", ",", "GPR64", ">", ";" ]

[ "def", ":", "LogicalRegAlias", "<", "mnemonic", ",", "!", "cast", "<", "Instruction", ">", "(" ]

[ "static", "void", "ix86_emit_save_regs", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "rtx", "insn", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", ";", "regno", "--", ">", "<NUM_LIT>", ";", ")", "if", "(", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_push", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "}" ]

[ "Emit", "code", "to", "save", "registers", "in", "the", "prologue", "." ]

[ "<STR_LIT>", ")" ]

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

[ ".", "addImm", "(", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "DestSub1", ")", ".", "addImm", "(", "AMDGPU", "::", "sub1", ")", ";" ]

[ "const", "TargetRegisterClass", "*", "Src1SubRC", "=", "RI", ".", "getSubRegClass", "(", "Src1RC", ",", "AMDGPU", "::", "sub0", ")", ";", "MachineOperand", "SrcReg0Sub0", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub0", ",", "Src0SubRC", ")", ";", "MachineOperand", "SrcReg1Sub0", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src1", ",", "Src1RC", ",", "AMDGPU", "::", "sub0", ",", "Src1SubRC", ")", ";", "MachineOperand", "SrcReg0Sub1", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub1", ",", "Src0SubRC", ")", ";", "MachineOperand", "SrcReg1Sub1", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src1", ",", "Src1RC", ",", "AMDGPU", "::", "sub1", ",", "Src1SubRC", ")", ";", "unsigned", "LoOpc", "=", "IsAdd", "?", "AMDGPU", "::", "V_ADD_I32_e64", ":", "AMDGPU", "::", "V_SUB_I32_e64", ";", "MachineInstr", "*", "LoHalf", "=", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "get", "(", "LoOpc", ")", ",", "DestSub0", ")", ".", "addReg", "(", "CarryReg", ",", "RegState", "::", "Define", ")", ".", "add", "(", "SrcReg0Sub0", ")", ".", "add", "(", "SrcReg1Sub0", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "unsigned", "HiOpc", "=", "IsAdd", "?", "AMDGPU", "::", "V_ADDC_U32_e64", ":", "AMDGPU", "::", "V_SUBB_U32_e64", ";", "MachineInstr", "*", "HiHalf", "=", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "get", "(", "HiOpc", ")", ",", "DestSub1", ")", ".", "addReg", "(", "DeadCarryReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "add", "(", "SrcReg0Sub1", ")", ".", "add", "(", "SrcReg1Sub1", ")", ".", "addReg", "(", "CarryReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "REG_SEQUENCE", ")", ",", "FullDestReg", ")", ".", "addReg", "(", "DestSub0", ")" ]

[ "<FIXS>", "const", "GCNSubtarget", "&", "STI", ")", "{", "<FIXE>" ]

[ "static", "unsigned", "getBufferFormatWithCompCount", "(", "unsigned", "OldFormat", ",", "unsigned", "ComponentCount", ",", "<BUGS>", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "<BUGE>", "if", "(", "ComponentCount", ">", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";" ]

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

[ "if", "(", "DCI", ".", "isAfterLegalizeVectorOps", "(", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "PPCSubTarget", ".", "hasFRES", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "f64", "&&", "PPCSubTarget", ".", "hasFRE", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "PPCSubTarget", ".", "hasAltivec", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v2f64", "&&", "PPCSubTarget", ".", "hasVSX", "(", ")", ")", ")", "{", "int", "Iterations", "=", "PPCSubTarget", ".", "hasRecipPrec", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "VT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "f64", ")", "++", "Iterations", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "FPOne", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "VT", ".", "getScalarType", "(", ")", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "assert", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unknown vector type", "<STR_LIT>", ")", ";", "FPOne", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "VT", ",", "FPOne", ",", "FPOne", ",", "FPOne", ",", "FPOne", ")", ";", "}", "SDValue", "Est", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Op", ")", ";", "DCI", ".", "AddToWorklist", "(", "Est", ".", "getNode", "(", ")", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "Iterations", ";", "++", "i", ")", "{", "SDValue", "NewEst", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "dl", ",", "VT", ",", "Op", ",", "Est", ")", ";", "DCI", ".", "AddToWorklist", "(", "NewEst", ".", "getNode", "(", ")", ")", ";", "NewEst", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "VT", ",", "FPOne", ",", "NewEst", ")", ";", "DCI", ".", "AddToWorklist", "(", "NewEst", ".", "getNode", "(", ")", ")", ";", "NewEst", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "dl", ",", "VT", ",", "Est", ",", "NewEst", ")", ";", "DCI", ".", "AddToWorklist", "(", "NewEst", ".", "getNode", "(" ]

[ ")", ";" ]

[ "return", "true", ";", "case", "<NUM_LIT>", ":", "fprintf", "(", "asm_out_file", ",", "TARGET_UNIX_ASM", "?", "<STR_LIT>", "\\t", "<STR_LIT>", ":", "<STR_LIT>", "\\t.word\\t", "<STR_LIT>", ")", ";", "output_addr_const_pdp11", "(", "asm_out_file", ",", "x", ")", ";", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", " /* short */\\n", "<STR_LIT>" ]

[ ";" ]

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>" ]

[ "override", "{" ]

[ "bool", "isMemUseUpRegs", "(", ")", "const" ]

[ "<FIXS>", "unsigned", "subreg", "=", "WORDS_BIG_ENDIAN", "?", "i", ":", "(", "nregs", "-", "reg_mode_nregs", "-", "i", ")", ";", "<FIXE>" ]

[ "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "nregs", ";", "i", "+=", "reg_mode_nregs", ")", "{", "<BUGS>", "unsigned", "subreg", "=", "(", "WORDS_BIG_ENDIAN", ")", "?", "i", ":", "(", "nregs", "-", "reg_mode_nregs", "-", "i", ")", ";", "<BUGE>", "rtx", "dst2", "=", "gen_rtx_REG", "(", "reg_mode", ",", "reg", "+", "subreg", ")", ";", "rtx", "src2", "=", "adjust_address", "(", "src", ",", "reg_mode", ",", "offset", ")", ";", "offset", "+=", "size", ";" ]

[ ";" ]

[ "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "op1", ",", "TPCImm", "<", "Isrc", ">", ":", "$", "op2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}" ]

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

[ "uint64_t", "SizeInBits", "=", "DL", "->", "getTypeSizeInBits", "(", "StoredVal", "->", "getType", "(", ")", ")", ";", "if", "(", "(", "SizeInBits", "&", "<NUM_LIT>", ")", "||", "(", "SizeInBits", ">>", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "auto", "*", "StoreEv", "=", "dyn_cast", "<", "SCEVAddRecExpr", ">", "(", "SE", "->", "getSCEV", "(", "StorePtr", ")", ")", ";", "if", "(", "!", "StoreEv", "||", "StoreEv", "->", "getLoop", "(", ")", "!=", "CurLoop", "||", "!", "StoreEv", "->", "isAffine", "(", ")", ")", "return", "false", ";", "int", "Stride", "=", "getSCEVStride", "(", "StoreEv", ")", ";", "if", "(", "Stride", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "StoreSize", "=", "DL", "->", "getTypeStoreSize", "(", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", ")", ";", "if", "(", "StoreSize", "!=", "unsigned", "(", "std", "::" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "bool", "aarch64_bti_enabled", "(", "void", ")", "{", "return", "(", "aarch64_enable_bti", "==", "<NUM_LIT>", ")", ";", "}" ]

[ "Return", "TRUE", "if", "Branch", "Target", "Identification", "Mechanism", "is", "enabled", "." ]

[ "<FIXS>", "emit_move_insn", "(", "reg3", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", "<FIXE>" ]

[ "emit_label", "(", "label1", ")", "emit_move_insn", "(", "reg2", ",", "gen_rtx", "(", "MINUS", ",", "SFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "reg1", ")", ")", "<BUGS>", "emit_move_insn", "(", "reg3", ",", "gen_rtx", "(", "CONST_INT", ",", "VOIDmode", ",", "<NUM_LIT>", ")", ")", "<BUGE>", "emit_insn", "(", "gen_ashldi3", "(", "reg3", ",", "reg3", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", "emit_insn", "(", "gen_fix_truncsfdi2", "(", "operands", "[", "<NUM_LIT>", "]", ",", "reg2", ")", ")" ]

[ ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_cvtps_pd", "(", "_", "_", "m128d", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_cvtps2pd128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v2df" ]

[ "Val", ";" ]

[ "unsigned", "getSysCR", "(", ")", "const", "{", "assert", "(", "Kind", "==", "k_SysCR", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "return", "SysCRImm", "." ]

[ ",", "Srl", ")", ";" ]

[ "SDValue", "Srl", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "XVT", ",", "X", ",", "Eight", ")", ";", "SDValue", "And", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "XVT", ",", "Srl", ",", "NewMask", ")", ";", "SDValue", "Ext", "=", "DAG", ".", "getZExtOrTrunc", "(", "And", ",", "DL", ",", "VT", ")", ";", "SDValue", "ShlCount", "=", "DAG", ".", "getConstant", "(", "ScaleLog", ",", "DL", ",", "MVT", "::", "i8", ")", ";", "SDValue", "Shl", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "Ext", ",", "ShlCount", ")", ";", "insertDAGNode", "(", "DAG", ",", "N", ",", "Eight", ")", ";", "insertDAGNode", "(", "DAG", ",", "N", ",", "NewMask", ")", ";", "insertDAGNode", "(", "DAG", ",", "N" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cmple_ss", "(", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_cmpless", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ")", ";" ]

[ "_", "A", ",", "(", "const", "_", "_", "v2sf", "*", ")", "_", "_", "P", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_loadh_pi", "(", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m64", "const", "*", "_", "_", "P", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_loadhps", "(", "(", "_", "_", "v4sf", ")", "_" ]

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

[ "def", "_4S", ":", "N2VShiftIns", "<", "<NUM_LIT>", ",", "u", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "VPR128", ",", "v4i32", ",", "shr_imm32", ",", "int_aarch64_neon_vsri", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

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

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

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

[ "def", "FPImmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";" ]

[ "_", "v16si", ")", "_", "mm512_undefined_epi32", "(", ")", ",", "(", "_", "_", "mmask16", ")", "-", "<NUM_LIT>", ",", "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_cvtt_roundps_epu32", "(", "_", "_", "m512", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_cvttps2udq512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_" ]

[ "}" ]

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

[ "}" ]

[ "write_count", "=", "rws_sum", "[", "regno", "]", ".", "write_count", ";", "switch", "(", "write_count", ")", "{", "case", "<NUM_LIT>", ":", "if", "(", "!", "in_safe_group_barrier", ")", "rws_update", "(", "regno", ",", "flags", ",", "pred", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "flags", ".", "is_and", "&&", "rws_sum", "[", "regno", "]", ".", "written_by_and", ")", ";", "else", "if", "(", "flags", ".", "is_or", "&&", "rws_sum", "[", "regno", "]", ".", "written_by_or", ")", ";", "else", "need_barrier", "=", "<NUM_LIT>", ";", "if", "(", "!", "in_safe_group_barrier", ")", "rws_update", "(", "regno", ",", "flags", ",", "pred", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "flags", ".", "is_and", "&&", "rws_sum", "[", "regno", "]", ".", "written_by_and", ")", ";", "else", "if", "(", "flags", ".", "is_or", "&&", "rws_sum", "[", "regno", "]", ".", "written_by_or", ")", ";", "else", "need_barrier", "=", "<NUM_LIT>", ";", "if", "(", "!", "in_safe_group_barrier", ")", "{", "rws_sum", "[", "regno", "]", ".", "written_by_and", "=", "flags", ".", "is_and", ";", "rws_sum", "[", "regno", "]", ".", "written_by_or", "=", "flags", ".", "is_or", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "if", "(", "flags", ".", "is_branch", ")", "{", "if", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "BR_REGS", "||", "regno", "==", "AR_PFS_REGNUM", ")", "return", "<NUM_LIT>", ";", "if", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "PR_REGS", "&&", "!", "rws_sum", "[", "regno", "]", ".", "written_by_fp", ")", "return", "<NUM_LIT>", ";", "}", "if", "(", "flags", ".", "is_and", "&&", "rws_sum", "[", "regno", "]", ".", "written_by_and", ")", "return", "<NUM_LIT>", ";", "if", "(", "flags", ".", "is_or", "&&", "rws_sum", "[", "regno", "]", ".", "written_by_or", ")", "return", "<NUM_LIT>", ";", "switch", "(", "rws_sum", "[", "regno", "]", ".", "write_count", ")", "{", "case", "<NUM_LIT>", ":", "break", ";", "case", "<NUM_LIT>", ":", "need_barrier", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "need_barrier", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}" ]

[ "if", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", "||", "(", "regno", ">=", "<NUM_LIT>", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";" ]

[ "if", "(", "TARGET_ELF", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "MACHOPIC_INDIRECT", ")", ")", "{", "if", "(", "rclass", "!=", "BASE_REGS", "&&", "(", "GET_CODE", "(", "in", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "in", ")", "==", "HIGH", "||", "GET_CODE", "(", "in", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "in", ")", "==", "CONST", ")", ")", "return", "BASE_REGS", ";", "}", "if", "(", "GET_CODE", "(", "in", ")", "==", "REG", ")", "{", "regno", "=", "REGNO", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "in", ")", "==", "SUBREG", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "<NUM_LIT>", ";", "}", "else", "regno", "=", "-", "<NUM_LIT>", ";", "if", "(", "TARGET_VSX", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "<NUM_LIT>", "&&", "!", "mode_supports_vmx_dform", "(", "mode", ")", "&&", "(", "(", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", "&&", "(", "regno", ">=", "<NUM_LIT>", "&&", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", ")", "||", "(", "(", "rclass", "==", "VSX_REGS", "||", "rclass", "==", "ALTIVEC_REGS", ")", "&&", "(", "regno", ">=", "<NUM_LIT>", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", ")", ")", "return", "FLOAT_REGS", ";" ]

[ "$", "vm", ",", "i32", ":", "$", "vl", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vstu2dnc_vssml", "v256f64", ":", "$", "vx", ",", "i64", ":", "$", "sy", ",", "i64", ":", "$", "sz", ",", "v256i1", ":", "$", "vm", ",", "i32", ":", "$", "vl", ")", ",", "(", "VSTU2DNCrrvml", "i64", ":", "$", "sy", ",", "i64", ":", "$", "sz", ",", "v256f64", ":", "$", "vx", ",", "v256i1", ":" ]

[ ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "symbol_ref", "<STR_LIT>", ")" ]

[ ")" ]

[ "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")" ]

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

[ "(", "vec_merge", ":", "V48_AVX512VL", "(", "match_operand", ":", "V48_AVX512VL", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "let", "ParserMatchClass", "=", "VEMEMzriAsmOperand", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "i32imm", ",", "ptr_rc", ",", "i32imm", ")", ";" ]

[ "}" ]

[ "class", "VST1D4", "<", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "Operand", "AddrMode", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ",", "VecListFourD", ":", "$", "Vd", ")", ",", "IIC_VST1x4", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVST4", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

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

[ "bool", "BackChain", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "<STR_LIT>", "backchain", "<STR_LIT>", ")", ";", "bool", "SoftFloat", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ".", "hasSoftFloat", "(", ")", ";", "unsigned", "Offset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "if", "(", "usePackedStack", "(", "MF", ")", "&&", "!", "(", "IsVarArg", "&&", "!", "SoftFloat" ]

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

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

[ "static", "bool", "loongarch_hard_regno_mode_ok_uncached", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "size", ";", "enum", "mode_class", "mclass", ";", "if", "(", "mode", "==", "FCCmode", ")", "return", "FCC_REG_P", "(", "regno", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", ")", "return", "(", "(", "regno", "-", "GP_REG_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "||", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "{", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", "||", "mclass", "==", "MODE_VECTOR_FLOAT", ")", "return", "size", "<=", "UNITS_PER_FPVALUE", ";", "if", "(", "mclass", "==", "MODE_INT", ")", "return", "size", ">=", "MIN_UNITS_PER_WORD", "&&", "size", "<=", "UNITS_PER_FPREG", ";", "}", "return", "false", ";", "}" ]

[ "Return", "true", "if", "register", "REGNO", "can", "store", "a", "value", "of", "mode", "MODE", ".", "The", "result", "of", "this", "function", "is", "cached", "in", "loongarch_hard_regno_mode_ok", "." ]

[ ",", "_", "_", "m128", "_", "_", "B", ",", "const", "int", "_", "_", "R", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_max_round_ss", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "A" ]

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

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "}", "<BUGS>", "def", ":", "InstRW", "[", "SKXWriteResGroup229", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKXWriteResGroup229", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKXWriteResGroup229", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKXWriteResGroup229", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", "SKXWriteResGroup230", ":", "SchedWriteRes", "[", "SKXPort0", ",", "SKXPort23", ",", "SKXPort015", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "vreinterpretq_s64_s32", "(", "int32x4_t", "_", "_", "a", ")", "{", "return", "(", "int64x2_t", ")", "_", "_", "a", ";" ]

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

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

[ "c", ")", ";" ]

[ "vqdmlsl_s32", "(", "int64x2_t", "_", "_", "a", ",", "int32x2_t", "_", "_", "b", ",", "int32x2_t", "_", "_", "c", ")", "{", "return", "_", "_", "builtin_aarch64_sqdmlslv2si", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_" ]

[ "c", ")", ":", ")", ";" ]

[ "_", "_", "asm__", "(", "<STR_LIT>", "sabal %0.8h,%2.8b,%3.8b", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "(", "a", ")", ",", "<STR_LIT>", "w", "<STR_LIT>", "(", "b", ")", ",", "<STR_LIT>", "w", "<STR_LIT>", "(" ]

[ "<STR_LIT>" ]

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

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

[ "def", "A2_aslh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_57890846", ",", "TypeALU32_2op", ">", ",", "Enc_5e2823", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "<FIXS>", "readonly_data_section", "(", ")", ";", "<FIXE>" ]

[ "&&", "(", "TREE_CODE", "(", "decl", ")", "!=", "STRING_CST", "||", "!", "flag_writable_strings", ")", ")", ")", "&&", "!", "(", "flag_pic", "&&", "reloc", ")", ")", "<BUGS>", "READONLY_DATA_SECTION", "(", ")", ";", "<BUGE>", "else", "if", "(", "size", ">", "<NUM_LIT>", "&&", "size", "<=", "mips_section_threshold", ")", "SMALL_DATA_SECTION", "(", ")", ";", "else" ]

[ ";" ]

[ "case", "AMDGPU", "::", "SReg_1_XEXECRegClassID", ":", "return", "isWave32", "?", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ":", "&", "AMDGPU", "::", "SReg_64_XEXECRegClass", ";", "case", "-", "<NUM_LIT>", ":", "return", "nullptr" ]

[ "<STR_LIT>" ]

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

[ "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";" ]

[ "}" ]

[ "vaddq_u8", "(", "uint8x16_t", "_", "_", "a", ",", "uint8x16_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "+", "_", "_", "b", ";" ]

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

[ "def", "A4_pzxthtnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_1ae57e39", ",", "TypeALU32_2op", ">", ",", "Enc_fb6577", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "MachineOperand", "*", "Data", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "data", ")", ";", "if", "(", "Data", "&&", "Op", ".", "isIdenticalTo", "(", "*", "Data", ")", ")", "return", "true", ";", "MachineOperand", "*", "Data0", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "data0", ")", ";", "if", "(", "Data0", "&&", "Op", ".", "isIdenticalTo", "(", "*", "Data0", ")", ")", "return", "true", ";", "MachineOperand", "*", "Data1", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "data1", ")", ";", "if", "(", "Data1", "&&", "Op", ".", "isIdenticalTo", "(", "*", "Data1", ")", ")", "return", "true", ";", "return", "false", ";", "}", "for", "(", "MachineInstr", "::", "mop_iterator", "I", "=", "MI", ".", "operands_begin", "(", ")", ",", "E", "=", "MI", ".", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReg", "(", ")", "&&", "I", "->", "isUse", "(", ")", ")", "return", "Op", ".", "isIdenticalTo", "(", "*", "I", ")", ";", "}", "return", "false" ]

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

[ "class", "BaseSIMDVectorShiftTied", "<", "bit", "Q", ",", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bits", "<", "<NUM_LIT>", ">", "fixed_imm", ",", "RegisterOperand", "vectype1", ",", "RegisterOperand", "vectype2", ",", "Operand", "immtype", ",", "string", "asm", ",", "string", "dst_kind", ",", "string", "src_kind", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "vectype1", ":", "$", "dst", ")", ",", "(", "ins", "vectype1", ":", "$", "Rd", ",", "vectype2", ":", "$", "Rn", ",", "immtype", ":", "$", "imm", ")", ",", "asm", ",", "<STR_LIT>", "#", "dst_kind", "#", "<STR_LIT>", "#", "src_kind", "#", "<STR_LIT>", "#", "<STR_LIT>", "#", "dst_kind", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteV", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "fixed_imm", ";" ]

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

[ "bool", "KudeyarTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "KudeyarSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "KudeyarSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isLinux", "(", ")", ")", "return", "false", ";", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")" ]

[ "if", "(", "isUndef", "(", "Ops", "[", "<NUM_LIT>", "]", ")", ")", "return", "Ops", "[", "<NUM_LIT>", "]", ";" ]

[ "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "Ops", "[", "<NUM_LIT>", "]", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SPLAT_VECTOR", ")", "{", "if", "(", "const", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Ops", "[", "<NUM_LIT>", "]", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "C", "->", "isZero", "(", ")", "?", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ty", "(", "Op", ")", ")", ":", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ty", "(", "Op", ")", ")", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "Ops", "[", "<NUM_LIT>", "]", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SPLAT_VECTOR", ",", "dl", ",", "ty", "(", "Op", ")", ",", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "if", "(", "Ops", "[", "<NUM_LIT>", "]", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "getZero", "(", "dl", ",", "ty", "(", "Op", ")", ",", "DAG", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "}" ]

[ "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "unsigned", "Opc", "=", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "if", "(", "X86", "::", "VR256RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "XReg", "=", "TRI", "->", "getSubReg", "(", "Reg", ",", "X86", "::", "sub_xmm", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "X86", "::", "VXORPSrr", ")", ",", "XReg", ")", ".", "addReg", "(", "XReg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "XReg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "else", "return", ";", "MI", "->", "addRegisterKilled", "(", "Reg", ",", "TRI", ",", "true", ")", ";" ]

[ "dag", "InOperandList", "=", "(", "ins", "ROWS", ":", "$", "ws", ",", "vsplat_uimm5", ":", "$", "m", ")", ";" ]

[ "class", "MSA_BIT_W_DESC_BASE", "<", "string", "instr_asm", ",", "SDPatternOperator", "OpNode", ",", "ComplexPattern", "Imm", ",", "RegisterOperand", "ROWD", ",", "RegisterOperand", "ROWS", "=", "ROWD", ",", "InstrItinClass", "itin", "=", "NoItinerary", ">", "{", "dag", "OutOperandList", "=", "(", "outs", "ROWD", ":", "$", "wd", ")", ";" ]

[ ";" ]

[ "return", "new", "HexagonRemoveExtendArgs", "(", ")" ]

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

[ "class", "NeonI_Scalar2SameMisc_cmpz_D_size", "<", "bit", "u", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "string", "asmop", ">", ":", "NeonI_Scalar2SameMisc", "<", "u", ",", "<NUM_LIT>", ",", "opcode", ",", "(", "outs", "FPR64", ":", "$", "Rd", ")", ",", "(", "ins", "FPR64", ":", "$", "Rn", ",", "neon_uimm0", ":", "$", "Imm", ")", ",", "!", "strconcat", "(" ]

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

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "cond", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", "(", "and", "(", "ge", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", "(", "lt", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", "(", "and", "(", "ge", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", "(", "lt", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

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

[ "(", "define_mode_iterator", "DIFD", "[", "DI", "(", "DF", "<STR_LIT>", ")" ]

[ "<STR_LIT>", ";" ]

[ "class", "addsub_shifted_imm_neg", "<", "ValueType", "Ty", ">", ":", "Operand", "<", "Ty", ">", "{", "let", "EncoderMethod", "=" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DSPV", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "DSPV", "(", "match_operand", ":", "DSPV", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DSPV", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "CCDSP", "CCDSP_OU_REGNUM", ")", "(", "unspec", ":", "CCDSP", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_SUBQ" ]

[ "<FIXS>", "const", "int", "*", "or", "der", "=", "(", "TARGET_ORDER_1", "?", "(", "AVR_TINY", "?", "tiny_order_1", ":", "or", "der_1", ")", ":", "TARGET_ORDER_2", "?", "(", "AVR_TINY", "?", "tiny_order_0", ":", "or", "der_2", ")", ":", "(", "AVR_TINY", "?", "tiny_order_0", ":", "or", "der_0", ")", ")", ";", "<FIXE>" ]

[ "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "<BUGS>", "const", "int", "*", "or", "der", "=", "(", "TARGET_ORDER_1", "?", "or", "der_1", ":", "TARGET_ORDER_2", "?", "or", "der_2", ":", "or", "der_0", ")", ";", "<BUGE>", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "ARRAY_SIZE", "(", "or", "der_0", ")", ";", "++", "i", ")", "reg_alloc_order", "[", "i", "]", "=", "or", "der", "[", "i", "]", ";", "}" ]

[ "ALU_MASK", ";" ]

[ "unsigned", "const", "ALU_MASK", "=", "<NUM_LIT>", ";", "return", "AluOp", "&" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "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_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

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

[ "}" ]

[ "static", "_", "_", "inline", "_", "_", "m64", "_", "mm_unpackel_pi32", "(", "_", "_", "m64", "_", "_", "m1", ")", "{", "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_arm_wunpckelsw", "(", "(", "_", "_", "v2si", ")", "_", "_", "m1", ")", ";" ]

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

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

[ "<NUM_LIT>", ")" ]

[ "(", "MACH_REG", "\t", "<NUM_LIT>", ")", "(", "MACL_REG", "\t", "<NUM_LIT>", ")", "(", "FPUL_REG", "\t", "<NUM_LIT>", ")", "(", "RAP_REG", "\t" ]

[ "}" ]

[ "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Hard", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "ps", ".", "has_sdst", ",", "sdst", ",", "?", ")", ";" ]

[ "let", "SchedRW", "=", "ps", ".", "SchedRW", ";", "let", "mayLoad", "=", "ps", ".", "mayLoad", ";", "let", "mayStore", "=", "ps", ".", "mayStore", ";", "bits", "<", "<NUM_LIT>", ">", "sdst", ";", "bits", "<", "<NUM_LIT>", ">", "src0", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "ps", ".", "has_src0", ",", "src0", ",", "?", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";" ]

[ "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";" ]

[ "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "<NUM_LIT>", "ULL", "<<", "Lg2", ")", "-", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ";", "SDValue", "CCVal", ";", "SDValue", "Cmp", "=", "getAArch64Cmp", "(", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ",", "CCVal", ",", "DAG", ",", "DL", ")", ";" ]

[ "}" ]

[ "}", "else", "{", "rtx", "reguse", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tlsoff_hilo", "(", "reguse", ",", "addr", ",", "GEN_INT", "(", "R_FRV_GOTTLSDESCHI", ")", ")", ")", ";", "emit_insn", "(", "gen_tls_tlsdesc_ldd", "(", "dest", ",", "picreg", ",", "reguse", ",", "addr", ")", ")", ";" ]

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

[ "[", "(", "set", "(", "cc0", ")", "(", "compare", "(", "match_operand", ":", "ALL1", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ALL1", "<NUM_LIT>", "<STR_LIT>" ]

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

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "B", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "B", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setIfReturnsVoid", "(", "!", "Val", ")", ";", "assert", "(", "!", "Val", "==", "VRegs", ".", "empty", "(", ")", "&&", "<STR_LIT>", "Return value without a vreg", "<STR_LIT>", ")", ";", "CallingConv", "::", "ID", "CC", "=", "B", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "bool", "IsShader", "=", "AMDGPU", "::", "isShader", "(", "CC", ")", ";", "const", "bool", "IsWaveEnd", "=", "(", "IsShader", "&&", "MFI", "->", "returnsVoid", "(", ")", ")", "||", "AMDGPU", "::", "isKernel", "(", "CC", ")", ";", "if", "(", "IsWaveEnd", ")", "{", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "auto", "const", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "ReturnOpc", "=", "<NUM_LIT>", ";", "if", "(", "IsShader", ")", "ReturnOpc", "=", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ";", "else", "if", "(", "CC", "==", "CallingConv", "::", "AMDGPU_Gfx", ")", "ReturnOpc", "=", "AMDGPU", "::", "S_SETPC_B64_return_gfx", ";", "else", "ReturnOpc", "=", "AMDGPU", "::", "S_SETPC_B64_return", ";", "auto", "Ret", "=", "B", ".", "buildInstrNoInsert", "(", "ReturnOpc", ")", ";", "Register", "ReturnAddrVReg", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "ReturnAddrVReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "CCR_SGPR_64RegClass", ")", ";", "Ret", ".", "addUse", "(", "ReturnAddrVReg", ")", ";", "}", "else", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return_gfx", ")", "{", "ReturnAddrVReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "Gfx_CCR_SGPR_64RegClass", ")", ";", "Ret", ".", "addUse", "(", "ReturnAddrVReg", ")", ";", "}", "if", "(", "!", "FLI", ".", "CanLowerReturn", ")", "insertSRetStores", "(", "B", ",", "Val", "->", "getType", "(", ")", ",", "VRegs", ",", "FLI", ".", "DemoteRegister", ")", ";", "else", "if", "(", "!", "lowerReturnVal", "(", "B", ",", "Val", ",", "VRegs", ",", "Ret", ")", ")", "return", "false", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", "||", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return_gfx", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "Register", "LiveInReturn", "=", "MF", ".", "addLiveIn", "(", "TRI", "->", "getReturnAddressReg", "(", "MF", ")", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "B", ".", "buildCopy", "(", "ReturnAddrVReg", ",", "LiveInReturn", ")", ";", "}", "B", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "->", "index", ")", "||", "(", "e", "->", "flags", "&", "EDGE_COMPLEX", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";" ]

[ "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "!", "single_succ_p", "(", "e", "->", "src", ")", "||", "!", "bitmap_bit_p", "(", "protected_bbs", ",", "e", "->", "src" ]

[ "RegInterval", "Interval", "=", "ScoreBrackets", "->", "getRegInterval", "(", "&", "MI", ",", "TII", ",", "MRI", ",", "TRI", ",", "I", ",", "true", ")", ";" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "RETURN", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ")", "{", "for", "(", "enum", "InstCounterType", "T", "=", "VM_CNT", ";", "T", "<", "NUM_INST_CNTS", ";", "T", "=", "(", "enum", "InstCounterType", ")", "(", "T", "+", "<NUM_LIT>", ")", ")", "{", "if", "(", "ScoreBrackets", "->", "getScoreUB", "(", "T", ")", ">", "ScoreBrackets", "->", "getScoreLB", "(", "T", ")", ")", "{", "ScoreBrackets", "->", "setScoreLB", "(", "T", ",", "ScoreBrackets", "->", "getScoreUB", "(", "T", ")", ")", ";", "EmitSwaitcnt", "|=", "CNT_MASK", "(", "T", ")", ";", "}", "}", "}", "else", "if", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_SENDMSG", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_SENDMSGHALT", ")", "&&", "(", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "&", "AMDGPU", "::", "SendMsg", "::", "ID_MASK_", ")", "==", "AMDGPU", "::", "SendMsg", "::", "ID_GS_DONE", ")", ")", "{", "if", "(", "ScoreBrackets", "->", "getScoreUB", "(", "VM_CNT", ")", ">", "ScoreBrackets", "->", "getScoreLB", "(", "VM_CNT", ")", ")", "{", "ScoreBrackets", "->", "setScoreLB", "(", "VM_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "VM_CNT", ")", ")", ";", "EmitSwaitcnt", "|=", "CNT_MASK", "(", "VM_CNT", ")", ";", "}", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SC_FENCE", ")", "{", "const", "unsigned", "int", "group_size", "=", "context", "->", "shader_info", "->", "GetMaxThreadGroupSize", "(", ")", ";", "const", "bool", "group_is_multi_wave", "=", "(", "group_size", "==", "<NUM_LIT>", "||", "group_size", ">", "target_info", "->", "GetWaveFrontSize", "(", ")", ")", ";", "const", "bool", "fence_is_global", "=", "!", "(", "(", "SCInstInternalMisc", "*", ")", "Inst", ")", "->", "IsGroupFence", "(", ")", ";", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "Inst", "->", "NumSrcOperands", "(", ")", ";", "i", "++", ")", "{", "SCRegType", "src_type", "=", "Inst", "->", "GetSrcType", "(", "i", ")", ";", "switch", "(", "src_type", ")", "{", "case", "SCMEM_LDS", ":", "if", "(", "group_is_multi_wave", "||", "context", "->", "OptFlagIsOn", "(", "OPT_R1100_LDSMEM_FENCE_CHICKEN_BIT", ")", ")", "{", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "LGKM_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "LGKM_CNT", ")", ")", ";", "if", "(", "target_info", "->", "HasBufferLoadToLDS", "(", ")", ")", "{", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "VM_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "VM_CNT", ")", ")", ";", "}", "}", "break", ";", "case", "SCMEM_GDS", ":", "if", "(", "group_is_multi_wave", "||", "fence_is_global", ")", "{", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "EXP_CNT", ")", ")", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "LGKM_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "LGKM_CNT", ")", ")", ";", "}", "break", ";", "case", "SCMEM_UAV", ":", "case", "SCMEM_TFBUF", ":", "case", "SCMEM_RING", ":", "case", "SCMEM_SCATTER", ":", "if", "(", "group_is_multi_wave", "||", "fence_is_global", ")", "{", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "EXP_CNT", ")", ")", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "VM_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "VM_CNT", ")", ")", ";", "}", "break", ";", "case", "SCMEM_SCRATCH", ":", "default", ":", "break", ";", "}", "}", "}", "else", "{", "if", "(", "MI", ".", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "{", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getEventUB", "(", "EXP_GPR_LOCK", ")", ")", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getEventUB", "(", "EXP_PARAM_ACCESS", ")", ")", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getEventUB", "(", "EXP_POS_ACCESS", ")", ")", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getEventUB", "(", "GDS_GPR_LOCK", ")", ")", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SC_CALL", ")", "{", "if", "(", "ScoreBrackets", "->", "getScoreUB", "(", "EXP_CNT", ")", ">", "ScoreBrackets", "->", "getScoreLB", "(", "EXP_CNT", ")", ")", "{", "ScoreBrackets", "->", "setScoreLB", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "EXP_CNT", ")", ")", ";", "EmitSwaitcnt", "|=", "CNT_MASK", "(", "EXP_CNT", ")", ";", "}", "}", "for", "(", "const", "MachineMemOperand", "*", "Memop", ":", "MI", ".", "memoperands", "(", ")", ")", "{", "unsigned", "AS", "=", "Memop", "->", "getAddrSpace", "(", ")", ";", "if", "(", "AS", "!=", "AMDGPUASI", ".", "LOCAL_ADDRESS", ")", "continue", ";", "unsigned", "RegNo", "=", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "VM_CNT", ",", "ScoreBrackets", "->", "getRegScore", "(", "RegNo", ",", "VM_CNT", ")", ")", ";", "}", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "const", "MachineRegisterInfo", "&", "MRIA", "=", "*", "MRI", ";", "RegInterval", "Interval", "=", "ScoreBrackets", "->", "getRegInterval", "(", "&", "MI", ",", "TII", ",", "MRI", ",", "TRI", ",", "I", ",", "false", ")", ";", "for", "(", "signed", "RegNo", "=", "Interval", ".", "first", ";", "RegNo", "<", "Interval", ".", "second", ";", "++", "RegNo", ")", "{", "if", "(", "TRI", "->", "isVGPR", "(", "MRIA", ",", "Op", ".", "getReg", "(", ")", ")", ")", "{", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "VM_CNT", ",", "ScoreBrackets", "->", "getRegScore", "(", "RegNo", ",", "VM_CNT", ")", ")", ";", "}", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "LGKM_CNT", ",", "ScoreBrackets", "->", "getRegScore", "(", "RegNo", ",", "LGKM_CNT", ")", ")", ";", "}", "}", "if", "(", "MI", ".", "mayStore", "(", ")", ")", "{", "for", "(", "const", "MachineMemOperand", "*", "Memop", ":", "MI", ".", "memoperands", "(", ")", ")", "{", "unsigned", "AS", "=", "Memop", "->", "getAddrSpace", "(", ")", ";", "if", "(", "AS", "!=", "AMDGPUASI", ".", "LOCAL_ADDRESS", ")", "continue", ";", "unsigned", "RegNo", "=", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "VM_CNT", ",", "ScoreBrackets", "->", "getRegScore", "(", "RegNo", ",", "VM_CNT", ")", ")", ";", "EmitSwaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getRegScore", "(", "RegNo", ",", "EXP_CNT", ")", ")", ";", "}", "}", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "const", "MachineRegisterInfo", "&", "MRIA", "=", "*", "MRI", ";" ]