Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "{" ]

[ "vreinterpret_s32_s16", "(", "int16x4_t", "_", "_", "a", ")" ]

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

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";" ]

[ "bool", "MSP430FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "I", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "rtx", "get_unaligned_address", "(", "rtx", "ref", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "offset", "=", "<NUM_LIT>", ";", "gcc_assert", "(", "MEM_P", "(", "ref", ")", ")", ";", "if", "(", "reload_in_progress", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "<NUM_LIT>", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "offset", "+=", "INTVAL", "(", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ";", "return", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "}" ]

[ "Similar", ",", "but", "just", "get", "the", "address", ".", "Handle", "the", "two", "reload", "cases", ".", "Add", "EXTRA_OFFSET", "to", "the", "address", "we", "return", "." ]

[ "<FIXS>", "static", "bool", "sparc_handle_option", "(", "struct", "gcc_options", "*", ",", "struct", "gcc_options", "*", ",", "const", "struct", "cl_decoded_option", "*", ",", "location_t", ")", ";", "<FIXE>" ]

[ "int", "sparc_indent_opcode", "=", "<NUM_LIT>", ";", "<BUGS>", "static", "bool", "sparc_handle_option", "(", "size_t", ",", "const", "char", "*", ",", "int", ")", ";", "<BUGE>", "static", "void", "sparc_option_override", "(", "void", ")", ";", "static", "void", "sparc_init_modes", "(", "void", ")", ";", "static", "void", "scan_record_type", "(", "const_tree", ",", "int", "*", ",", "int", "*", ",", "int", "*", ")", ";" ]

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

[ "return", "new", "TVMLoadStoreReplace" ]

[ "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";" ]

[ "unsigned", "DMask", "=", "cast", "<", "ConstantInt", ">", "(", "CI", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "DMaskLanes", "=", "DMask", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "countPopulation", "(", "DMask", ")", ";", "}", "Info", ".", "memVT", "=", "memVTFromImageReturn", "(", "CI", ".", "getType", "(", ")", ",", "DMaskLanes", ")", ";", "}", "else", "Info", ".", "memVT", "=", "EVT", "::", "getEVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "}", "else", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "WriteOnly", ")", ")", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Type", "*", "DataTy", "=", "CI", ".", "getArgOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ";", "if", "(", "RsrcIntr", "->", "IsImage", ")", "{", "unsigned", "DMask", "=", "cast", "<", "ConstantInt", ">", "(", "CI", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "DMaskLanes", "=", "DMask", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "countPopulation", "(", "DMask", ")", ";", "Info", ".", "memVT", "=", "memVTFromImageData", "(", "DataTy", ",", "DMaskLanes", ")", ";", "}", "else", "Info", ".", "memVT", "=", "EVT", "::", "getEVT", "(", "DataTy", ")", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "}", "else", "{", "Info", ".", "opc", "=", "CI", ".", "getType", "(", ")", "->", "isVoidTy", "(", ")", "?", "ISD", "::", "INTRINSIC_VOID", ":", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getArgOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MODereferenceable", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "}", "return", "true", ";", "}", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", ";", "const", "ConstantInt", "*", "Vol", "=", "cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "Vol", "->", "isZero", "(", ")", ")", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "amdgcn_buffer_atomic_fadd", ":", "{", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "MFI", "->", "getBufferPSV", "(", "*", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ")", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", ";", "const", "ConstantInt", "*", "Vol", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "Vol", "||", "!", "Vol", "->", "isZero", "(", ")", ")", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "amdgcn_ds_append", ":", "case", "Intrinsic", "::", "amdgcn_ds_consume", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", ";", "const", "ConstantInt", "*", "Vol", "=", "cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "Vol", "->", "isZero", "(", ")", ")", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "amdgcn_global_atomic_csub", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "amdgcn_global_atomic_fadd", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "amdgcn_image_bvh_intersect_ray", ":", "{", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "MFI", "->", "getImagePSV", "(", "*", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ")", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MODereferenceable", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "amdgcn_ds_gws_init", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_barrier", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_v", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_br", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_p", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_release_all", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Info", ".", "ptrVal", "=", "MFI", "->", "getGWSPSV", "(", "*", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "Info", ".", "size", "=", "<NUM_LIT>", ";", "Info", ".", "align", "=", "Align", "(", "<NUM_LIT>", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOStore", ";", "if", "(", "IntrID", "==", "Intrinsic", "::", "amdgcn_ds_gws_barrier", ")" ]

[ "return", "offset_within_block_p", "(", "base", ",", "INTVAL", "(", "offset", ")", ")", ";" ]

[ "mips_split_plus", "(", "x", ",", "&", "base", ",", "&", "offset_val", ")", ";", "if", "(", "base", "==", "virtual_incoming_args_rtx", "&&", "offset_val", ">=", "-", "cfun", "->", "machine", "->", "frame", ".", "total_size", "&&", "offset_val", "<", "cfun", "->", "machine", "->", "frame", ".", "args_size", ")", "return", "true", ";", "if", "(", "CONST_INT_P", "(", "x", ")", ")", "return", "r10k_uncached_address_p", "(", "INTVAL", "(", "x", ")", ")", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";" ]

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

[ "return", "Variant", "==", "AArch64MCExpr", "::", "VK_AARCH64_None", "||", "Variant", "==", "AArch64MCExpr", "::", "VK_AARCH64_GOT", "||", "Variant", "==", "AArch64MCExpr", "::", "VK_AARCH64_GOTTPREL", "||", "Variant", "==", "AArch64MCExpr", "::", "VK_AARCH64_TLSDESC", ";", "}", "return", "isLabel", "<", "<NUM_LIT>", "," ]

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

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

[ "(", "match_dup", "<NUM_LIT>", ")", ")", "]" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "I48MODE", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "mem", ":", "DI" ]

[ "<FIXS>", "sri", "->", "icode", "=", "code_for_aarch64_reload_mov", "(", "mode", ")", ";", "<FIXE>" ]

[ "&&", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", "&&", "!", "TARGET_SIMD", "&&", "reg_class_subset_p", "(", "rclass", ",", "FP_REGS", ")", ")", "{", "<BUGS>", "if", "(", "mode", "==", "TFmode", ")", "sri", "->", "icode", "=", "CODE_FOR_aarch64_reload_movtf", ";", "else", "if", "(", "mode", "==", "TImode", ")", "sri", "->", "icode", "=", "CODE_FOR_aarch64_reload_movti", ";", "<BUGE>", "return", "NO_REGS", ";", "}" ]

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

[ "let", "RenderMethod", "=", "<STR_LIT>", ";", "let", "PredicateMethod" ]

[ "}" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>" ]

[ "(", "match_operator", ":", "CCFP", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", "]" ]

[ "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "Optional", "<", "Hexagon", "::", "ArchEnum", ">", "ArchVer", "=", "Hexagon", "::", "getCpu", "(", "CPUString", ")", ";", "if", "(", "ArchVer", ")", "HexagonArchVersion", "=", "*", "ArchVer", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unrecognized Hexagon processor version", "<STR_LIT>", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseAudioOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "SubtargetFeatures", "Features", "(", "FS", ")", ";", "auto", "IsQFloatFS", "=", "[", "]", "(", "StringRef", "F", ")", "{", "return", "F", "==", "<STR_LIT>", "+hvx-qfloat", "<STR_LIT>", "||", "F", "==", "<STR_LIT>", "-hvx-qfloat", "<STR_LIT>", ";", "}", ";", "if", "(", "!", "llvm", "::", "count_if", "(", "Features", ".", "getFeatures", "(", ")", ",", "IsQFloatFS", ")", ")", "{", "auto", "getHvxVersion", "=", "[", "&", "Features", "]", "(", "StringRef", "FS", ")", "->", "StringRef", "{", "for", "(", "StringRef", "F", ":", "llvm", "::", "reverse", "(", "Features", ".", "getFeatures", "(", ")", ")", ")", "{", "if", "(", "F", ".", "startswith", "(", "<STR_LIT>", "+hvxv", "<STR_LIT>", ")", ")", "return", "F", ";", "}", "for", "(", "StringRef", "F", ":", "llvm", "::", "reverse", "(", "Features", ".", "getFeatures", "(", ")", ")", ")", "{", "if", "(", "F", "==", "<STR_LIT>", "-hvx", "<STR_LIT>", ")", "return", "StringRef", "(", ")", ";", "if", "(", "F", ".", "startswith", "(", "<STR_LIT>", "+hvx", "<STR_LIT>", ")", "||", "F", "==", "<STR_LIT>", "-hvx", "<STR_LIT>", ")", "return", "F", ".", "take_front", "(", "<NUM_LIT>", ")", ";", "}", "return", "StringRef", "(", ")", ";", "}", ";", "bool", "AddQFloat", "=", "false", ";", "StringRef", "HvxVer", "=", "getHvxVersion", "(", "FS", ")", ";", "if", "(", "HvxVer", ".", "startswith", "(", "<STR_LIT>", "+hvxv", "<STR_LIT>", ")", ")", "{", "int", "Ver", "=", "<NUM_LIT>", ";", "if", "(", "!", "HvxVer", ".", "drop_front", "(", "<NUM_LIT>", ")", ".", "consumeInteger", "(", "<NUM_LIT>", ",", "Ver", ")", "&&", "Ver", ">=", "<NUM_LIT>", ")", "AddQFloat", "=", "true", ";", "}", "else", "if", "(", "HvxVer", "==", "<STR_LIT>", "+hvx", "<STR_LIT>", ")", "{", "if", "(", "hasV68Ops", "(", ")", ")", "AddQFloat", "=", "true", ";", "}", "if", "(", "AddQFloat", ")", "Features", ".", "AddFeature", "(", "<STR_LIT>", "+hvx-qfloat", "<STR_LIT>", ")", ";", "}", "std", "::", "string", "FeatureString", "=", "Features", ".", "getString", "(", ")", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "CPUString", ",", "FeatureString", ")", ";", "bool", "GreaterThanV68", "=", "false", ";", "if", "(", "useHVXV69Ops", "(", ")", ")", "GreaterThanV68", "=", "true", ";", "if", "(", "!", "GreaterThanV68", ")", "{", "if", "(", "EnableV68FloatCodeGen", ")", "UseHVXFloatingPoint", "=", "true", ";", "}", "else", "{", "UseHVXFloatingPoint", "=", "true", ";", "}", "if", "(", "UseHVXQFloatOps", "&&", "UseHVXIEEEFPOps", "&&", "UseHVXFloatingPoint", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Behavior is undefined for simultaneous qfloat and ieee hvx codegen...", "<STR_LIT>", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "if", "(", "isTinyCore", "(", ")", ")", "{", "if", "(", "!", "EnableBSBSched", ".", "getPosition", "(", ")", ")", "UseBSBScheduling", "=", "false", ";", "}", "FeatureBitset", "FeatureBits", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "FeatureBits", ".", "reset", "(", "Hexagon", "::", "FeatureDuplex", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "FeatureBits", ")", ")", ";", "return", "*", "this", ";", "}" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "$", "Rn", ",", "regtype", ":", "$", "Rm", ",", "CPSR", ")", ")", ",", "(", "implicit", "CPSR", ")", "]", ">", "{" ]

[ "class", "BaseAddSubCarrySetFlags", "<", "bit", "isSub", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "SDNode", "OpNode", ">", ":", "BaseBaseAddSubCarry", "<", "isSub", ",", "regtype", ",", "asm", ",", "[", "(", "set", "regtype", ":", "$", "Rd", ",", "(", "OpNode", "regtype", ":" ]

[ "a", ";" ]

[ "return", "(", "int8x8_t", ")", "_", "_" ]

[ "}" ]

[ "if", "(", "ACPV", "->", "Kind", "==", "Kind", "&&", "ACPV", "->", "CVal", "==", "CVal", "&&", "ACPV", "->", "PCAdjust", "==", "PCAdjust", "&&", "(", "ACPV", "->", "S", "==", "S", "||", "strcmp", "(", "ACPV", "->", "S", ",", "S", ")", "==", "<NUM_LIT>", ")", "&&", "(", "ACPV", "->", "Modifier", "==", "Modifier", "||", "strcmp", "(", "ACPV", "->", "Modifier", ",", "Modifier", ")", "==", "<NUM_LIT>", ")", ")", "{", "if", "(", "ACPV", "->", "LabelId", "==", "LabelId", ")", "return", "true", ";", "if", "(", "Kind", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Kind", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "true", ";" ]

[ "MachineMemOperand", "::", "Flags", "Flags", "=", "TLI", "->", "getLoadMemOperandFlags", "(", "I", ",", "F", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";" ]

[ "if", "(", "!", "I", ".", "getType", "(", ")", "->", "isAggregateType", "(", ")", ")", "return", "&", "I", ";", "TrackConstants", "=", "false", ";", "const", "auto", "*", "TLI", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getTargetLowering", "(", ")", ";" ]

[ "<FIXS>", "SDValue", "V1", ",", "unsigned", "TargetMask", ",", "SelectionDAG", "&", "DAG", ")", "{", "<FIXE>" ]

[ "}", "static", "SDValue", "getTargetShuffleNode", "(", "unsigned", "Opc", ",", "DebugLoc", "dl", ",", "EVT", "VT", ",", "<BUGS>", "SDValue", "V1", ",", "unsigned", "TargetMask", ",", "SelectionDAG", "&", "DAG", ")", "{", "<BUGE>", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown x86 shuffle node", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "}" ]

[ "Op", ".", "setTokenValue", "(", "Tmp", ")", ";", "const", "char", "*", "Suffixes", "=", "Base", "[", "<NUM_LIT>", "]", "!=", "'", "f", "'", "?", "<STR_LIT>", "bwlq", "<STR_LIT>", ":", "<STR_LIT>", "slt\\0", "<STR_LIT>", ";", "uint64_t", "ErrorInfoIgnore", ";", "uint64_t", "ErrorInfoMissingFeature", "=", "<NUM_LIT>", ";", "unsigned", "Match", "[", "<NUM_LIT>", "]", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "array_lengthof", "(", "Match", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Tmp", ".", "back", "(", ")", "=", "Suffixes", "[", "I", "]", ";", "Match", "[", "I", "]", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfoIgnore", ",", "MatchingInlineAsm", ",", "isParsingIntelSyntax", "(", ")", ")", ";", "if", "(", "Match", "[", "I", "]", "==", "Match_MissingFeature", ")", "ErrorInfoMissingFeature", "=", "ErrorInfoIgnore", ";", "}", "Op", ".", "setTokenValue", "(", "Base", ")", ";", "unsigned", "NumSuccessfulMatches", "=", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::", "end", "(", "Match", ")", ",", "Match_Success", ")", ";", "if", "(", "NumSuccessfulMatches", "==", "<NUM_LIT>", ")", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "!", "MatchingInlineAsm", ")", "EmitInstruction", "(", "Inst", ",", "Operands", ",", "Out", ")", ";", "Opcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "return", "false", ";", "}", "if", "(", "NumSuccessfulMatches", ">", "<NUM_LIT>", ")", "{", "char", "MatchChars", "[", "<NUM_LIT>", "]", ";", "unsigned", "NumMatches", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "array_lengthof", "(", "Match", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "Match", "[", "I", "]", "==", "Match_Success", ")", "MatchChars", "[", "NumMatches", "++", "]", "=", "Suffixes", "[", "I", "]", ";", "SmallString", "<", "<NUM_LIT>", ">", "Msg", ";", "raw_svector_ostream", "OS", "(", "Msg", ")", ";", "OS", "<<", "<STR_LIT>", "ambiguous instructions require an explicit suffix (could be ", "<STR_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumMatches", ";", "++", "i", ")", "{", "if", "(", "i", "!=", "<NUM_LIT>", ")", "OS", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "if", "(", "i", "+", "<NUM_LIT>", "==", "NumMatches", ")", "OS", "<<", "<STR_LIT>", "or ", "<STR_LIT>", ";", "OS", "<<", "<STR_LIT>", "'", "<STR_LIT>", "<<", "Base", "<<", "MatchChars", "[", "i", "]", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "}", "OS", "<<", "<STR_LIT>", ")", "<STR_LIT>", ";", "Error", "(", "IDLoc", ",", "OS", ".", "str", "(", ")", ",", "EmptyRanges", ",", "MatchingInlineAsm", ")", ";", "return", "true", ";", "}", "if", "(", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::", "end", "(", "Match", ")", ",", "Match_MnemonicFail", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "!", "WasOriginallyInvalidOperand", ")", "{", "ArrayRef", "<", "SMRange", ">", "Ranges", "=", "MatchingInlineAsm", "?", "EmptyRanges", ":", "Op", ".", "getLocRange", "(", ")", ";", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction mnemonic '", "<STR_LIT>", "+", "Base", "+", "<STR_LIT>", "'", "<STR_LIT>", ",", "Ranges", ",", "MatchingInlineAsm", ")", ";", "}", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ",", "EmptyRanges", ",", "MatchingInlineAsm", ")", ";", "X86Operand", "&", "Operand", "=", "(", "X86Operand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ";", "if", "(", "Operand", ".", "getStartLoc", "(", ")", ".", "isValid", "(", ")", ")", "{", "SMRange", "OperandRange", "=", "Operand", ".", "getLocRange", "(", ")", ";", "return", "Error", "(", "Operand", ".", "getStartLoc", "(", ")", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ",", "OperandRange", ",", "MatchingInlineAsm", ")", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ",", "EmptyRanges", ",", "MatchingInlineAsm", ")", ";" ]

[ ">", ";" ]

[ "def", "AUTIB1716", ":", "SystemNoOperands", "<", "<NUM_LIT>", ",", "<STR_LIT>" ]

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

[ "SDValue", "Cmp", ";", "if", "(", "!", "isFloatingPointZero", "(", "RHS", ")", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Flag", ",", "LHS", ",", "RHS", ")", ";", "else", "Cmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Flag", ",", "LHS", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Flag", "," ]

[ "<STR_LIT>" ]

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

[ "_", "index", ",", "_", "_", "mask", ",", "_", "_", "scale", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mmask_i64gather_epi64", "(", "_", "_", "m256i", "_", "_", "v1_old", ",", "_", "_", "mmask8", "_", "_", "mask", ",", "_", "_", "m256i", "_", "_", "index", ",", "long", "long", "const", "*", "_", "_", "addr", ",", "int", "_", "_", "scale", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_gather3div4di", "(", "(", "_", "_", "v4di", ")", "_", "_", "v1_old", ",", "_", "_", "addr", ",", "(", "_", "_", "v4di", ")", "_" ]

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

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

[ "def", "SDC3", ":", "SW_FT3", "<", "<STR_LIT>", ",", "COP3Opnd", ",", "NoItinerary", ",", "store", ">" ]

[ "void", "altivec_expand_vec_perm_const_le", "(", "rtx", "operands", "[", "<NUM_LIT>", "]", ")", "{", "unsigned", "int", "i", ";", "rtx", "perm", "[", "<NUM_LIT>", "]", ";", "rtx", "constv", ",", "unspec", ";", "rtx", "target", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "op0", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "op1", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "sel", "=", "operands", "[", "<NUM_LIT>", "]", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "rtx", "e", "=", "XVECEXP", "(", "sel", ",", "<NUM_LIT>", ",", "i", ")", ";", "unsigned", "int", "elt", "=", "<NUM_LIT>", "-", "(", "INTVAL", "(", "e", ")", "&", "<NUM_LIT>", ")", ";", "perm", "[", "i", "]", "=", "GEN_INT", "(", "elt", ")", ";", "}", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "V16QImode", ",", "op0", ")", ";", "if", "(", "!", "REG_P", "(", "op1", ")", ")", "op1", "=", "force_reg", "(", "V16QImode", ",", "op1", ")", ";", "constv", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "perm", ")", ")", ";", "constv", "=", "force_reg", "(", "V16QImode", ",", "constv", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "V16QImode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "op1", ",", "op0", ",", "constv", ")", ",", "UNSPEC_VPERM", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_move_insn", "(", "tmp", ",", "unspec", ")", ";", "unspec", "=", "tmp", ";", "}", "emit_move_insn", "(", "target", ",", "unspec", ")", ";", "}" ]

[ "Expand", "an", "Altivec", "constant", "permutation", "for", "little", "endian", "mode", ".", "There", "are", "two", "issues", ":", "First", ",", "the", "two", "input", "operands", "must", "be", "swapped", "so", "that", "together", "they", "form", "a", "double-wide", "array", "in", "LE", "order", ".", "Second", ",", "the", "vperm", "instruction", "has", "surprising", "behavior", "in", "LE", "mode", ":", "it", "interprets", "the", "elements", "of", "the", "source", "vectors", "in", "BE", "mode", "(", "``", "left", "to", "right", "''", ")", "and", "interprets", "the", "elements", "of", "the", "destination", "vector", "in", "LE", "mode", "(", "``", "right", "to", "left", "''", ")", ".", "To", "correct", "for", "this", ",", "we", "must", "subtract", "each", "element", "of", "the", "permute", "control", "vector", "from", "31", ".", "For", "example", ",", "suppose", "we", "want", "to", "concatenate", "vr10", "=", "{", "0", ",", "1", ",", "2", ",", "3", "}", "with", "vr11", "=", "{", "4", ",", "5", ",", "6", ",", "7", "}", "and", "extract", "{", "0", ",", "2", ",", "4", ",", "6", "}", "using", "a", "vperm", ".", "We", "place", "{", "0,1,2,3,8,9,10,11,16,17,18,19,24,25,26,27", "}", "in", "vr12", "to", "serve", "as", "the", "permute", "control", "vector", ".", "Then", ",", "in", "BE", "mode", ",", "vperm", "9,10,11,12", "places", "the", "desired", "result", "in", "vr9", ".", "However", ",", "in", "LE", "mode", "the", "vector", "contents", "will", "be", "vr10", "=", "00000003", "00000002", "00000001", "00000000", "vr11", "=", "00000007", "00000006", "00000005", "00000004", "The", "result", "of", "the", "vperm", "using", "the", "same", "permute", "control", "vector", "is", "vr9", "=", "05000000", "07000000", "01000000", "03000000", "That", "is", ",", "the", "leftmost", "4", "bytes", "of", "vr10", "are", "interpreted", "as", "the", "source", "for", "the", "rightmost", "4", "bytes", "of", "vr9", ",", "and", "so", "on", ".", "If", "we", "change", "the", "permute", "control", "vector", "to", "vr12", "=", "{", "31,20,29,28,23,22,21,20,15,14,13,12,7,6,5,4", "}", "and", "issue", "vperm", "9,11,10,12", "we", "get", "the", "desired", "vr9", "=", "00000006", "00000004", "00000002", "00000000", "." ]

[ "idx", ";" ]

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

[ "<FIXS>", "int", "a", ",", "b", ";", "if", "(", "(", "b", "=", "a", "+", "c", ")", ">", "<NUM_LIT>", ")", "<FIXE>" ]

[ "if", "(", "GET_CODE", "(", "op0", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "op0", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "CONST_OK_FOR_K", "(", "INTVAL", "(", "XEXP", "(", "op0", ",", "<NUM_LIT>", ")", ")", ")", ")" ]

[ "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")" ]

[ "(", "call", "(", "mem", ":", "SI", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_operand", "<NUM_LIT>", ")", ")", "(", "use", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "use", "(", "const_int", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "call", "(", "mem", ":", "SI", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")" ]

[ ")", ")" ]

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

[ "let", "Uses", "=", "[", "USR", "]", ";" ]

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

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

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

[ "<FIXS>", "virtual", "void", "emitCCTopData", "(", "StringRef", "Name", ")", "LLVM_OVERRIDE", ";", "virtual", "void", "emitCCTopFunction", "(", "StringRef", "Name", ")", "LLVM_OVERRIDE", ";", "virtual", "void", "emitCCBottomData", "(", "StringRef", "Name", ")", "LLVM_OVERRIDE", ";", "virtual", "void", "emitCCBottomFunction", "(", "StringRef", "Name", ")", "LLVM_OVERRIDE", ";", "<FIXE>" ]

[ "formatted_raw_ostream", "&", "OS", ";", "public", ":", "XCoreTargetAsmStreamer", "(", "MCStreamer", "&", "S", ",", "formatted_raw_ostream", "&", "OS", ")", ";", "<BUGS>", "virtual", "void", "emitCCTopData", "(", "StringRef", "Name", ")", ";", "virtual", "void", "emitCCTopFunction", "(", "StringRef", "Name", ")", ";", "virtual", "void", "emitCCBottonData", "(", "StringRef", "Name", ")", ";", "virtual", "void", "emitCCBottonFunction", "(", "StringRef", "Name", ")", ";", "<BUGE>", "}", ";", "XCoreTargetAsmStreamer", "::", "XCoreTargetAsmStreamer", "(", "MCStreamer", "&", "S", "," ]

[ "static", "bool", "frv_sort_insn_group_1", "(", "enum", "frv_insn_group", "group", ",", "unsigned", "int", "lower_slot", ",", "unsigned", "int", "upper_slot", ",", "unsigned", "int", "issued", ",", "unsigned", "int", "num_insns", ",", "state_t", "state", ")", "{", "struct", "frv_packet_group", "*", "packet_group", ";", "unsigned", "int", "i", ";", "state_t", "test_state", ";", "size_t", "dfa_size", ";", "rtx_insn", "*", "insn", ";", "if", "(", "lower_slot", "==", "upper_slot", ")", "return", "true", ";", "packet_group", "=", "&", "frv_packet", ".", "groups", "[", "group", "]", ";", "dfa_size", "=", "state_size", "(", ")", ";", "test_state", "=", "alloca", "(", "dfa_size", ")", ";", "for", "(", "i", "=", "num_insns", "-", "<NUM_LIT>", ";", "i", "+", "<NUM_LIT>", "!=", "<NUM_LIT>", ";", "i", "--", ")", "if", "(", "~", "issued", "&", "(", "<NUM_LIT>", "<<", "i", ")", ")", "{", "insn", "=", "packet_group", "->", "sorted", "[", "i", "]", ";", "memcpy", "(", "test_state", ",", "state", ",", "dfa_size", ")", ";", "if", "(", "state_transition", "(", "test_state", ",", "insn", ")", "<", "<NUM_LIT>", "&&", "cpu_unit_reservation_p", "(", "test_state", ",", "NTH_UNIT", "(", "group", ",", "upper_slot", "-", "<NUM_LIT>", ")", ")", "&&", "frv_sort_insn_group_1", "(", "group", ",", "lower_slot", ",", "upper_slot", "-", "<NUM_LIT>", ",", "issued", "|", "(", "<NUM_LIT>", "<<", "i", ")", ",", "num_insns", ",", "test_state", ")", ")", "{", "packet_group", "->", "sorted", "[", "upper_slot", "-", "<NUM_LIT>", "]", "=", "insn", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Subroutine", "of", "frv_sort_insn_group", ".", "We", "are", "trying", "to", "sort", "frv_packet.groups", "[", "GROUP", "]", ".sorted", "[", "0", "...", "NUM_INSNS-1", "]", "into", "assembly", "language", "order", ".", "We", "have", "already", "picked", "a", "new", "position", "for", "frv_packet.groups", "[", "GROUP", "]", ".sorted", "[", "X", "]", "if", "bit", "X", "of", "ISSUED", "is", "set", ".", "These", "instructions", "will", "occupy", "elements", "[", "0", ",", "LOWER_SLOT", ")", "and", "[", "UPPER_SLOT", ",", "NUM_INSNS", ")", "of", "the", "final", "(", "sorted", ")", "array", ".", "STATE", "is", "the", "DFA", "state", "after", "issuing", "these", "instructions", ".", "Try", "filling", "elements", "[", "LOWER_SLOT", ",", "UPPER_SLOT", ")", "with", "every", "permutation", "of", "the", "unused", "instructions", ".", "Return", "true", "if", "one", "such", "permutation", "gives", "a", "valid", "ordering", ",", "leaving", "the", "successful", "permutation", "in", "sorted", "[", "]", ".", "Do", "not", "modify", "sorted", "[", "]", "until", "a", "valid", "permutation", "is", "found", "." ]

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

[ "(", "clobber", "(", "match_scratch", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "<STR_LIT>", "softvfp", "<STR_LIT>", ":", "TARGET_FPU_NAME", ")", ";" ]

[ "else", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\t.thumb\\n\\t.thumb_func\\n", "<STR_LIT>", ")", ";", "}", "else", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\t.arm\\n", "<STR_LIT>", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.fpu %s\\n", "<STR_LIT>", ",", "TARGET_SOFT_FLOAT", "?" ]

[ "t1", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";" ]

[ "unsigned", "i", ",", "mask", ";", "rtx", "rmask", ";", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_VECTORS", ")", ")", "return", "false", ";", "if", "(", "d", "->", "vmode", "!=", "V4HImode", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "for", "(", "i", "=", "mask", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "mask", "|=", "(", "d", "->", "perm", "[", "i", "]", "&", "<NUM_LIT>", ")", "<<", "(", "i", "*", "<NUM_LIT>", ")", ";", "rmask", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "mask", ")", ")", ";", "if", "(", "d", "->", "one_vector_p", ")", "emit_insn", "(", "gen_loongson_pshufh", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "rmask", ")", ")", ";", "else", "{", "rtx", "t0", ",", "t1", ",", "x", ",", "merge", ",", "rmerge", "[", "<NUM_LIT>", "]", ";", "t0", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";" ]

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

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

[ "}", "else", "if", "(", "TypeName", ".", "startswith", "(", "<STR_LIT>", "DeviceEvent", "<STR_LIT>", ")", ")", "return", "getOpTypeByOpcode", "(", "MIRBuilder", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "SPIRVType", "*", "SPIRVGlobalRegistry", "::", "getOrCreateSPIRVOpaqueType", "(", "const", "StructType", "*", "Ty", ",", "MachineIRBuilder", "&", "MIRBuilder", ",", "AQ", "::", "AccessQualifier", "AccessQual", ")", "{", "const", "StringRef", "Name", "=", "Ty", "->", "getName", "(", ")", ";", "assert", "(", "Name", ".", "startswith", "(", "<STR_LIT>", "spirv.", "<STR_LIT>", ")", "&&", "<STR_LIT>", "CL types should start with 'spirv.'", "<STR_LIT>", ")", ";", "auto", "TypeName", "=", "Name", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "spirv.", "<STR_LIT>", ")", ")", ";", "if", "(", "TypeName", ".", "startswith", "(", "<STR_LIT>", "Image.", "<STR_LIT>", ")", ")", "{", "auto", "TypeLiteralStr", "=", "TypeName", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "Image.", "<STR_LIT>", ")", ")", ";", "SmallVector", "<", "StringRef", ">", "TypeLiterals", ";", "SplitString", "(", "TypeLiteralStr", ",", "TypeLiterals", ",", "<STR_LIT>", "_", "<STR_LIT>", ")", ";", "assert", "(", "TypeLiterals", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Wrong number of literals in Image type", "<STR_LIT>", ")", ";", "auto", "*", "SpirvType", "=", "getOrCreateSPIRVTypeByName", "(", "TypeLiterals", "[", "<NUM_LIT>", "]", ",", "MIRBuilder", ")", ";", "unsigned", "Ddim", "=", "<NUM_LIT>", ",", "Depth", "=", "<NUM_LIT>", ",", "Arrayed", "=", "<NUM_LIT>", ",", "MS", "=", "<NUM_LIT>", ",", "Sampled", "=", "<NUM_LIT>", ";", "unsigned", "ImageFormat", "=", "<NUM_LIT>", ",", "AccQual", "=", "<NUM_LIT>", ";", "if", "(", "TypeLiterals", "[", "<NUM_LIT>", "]", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Ddim", ")", "||", "TypeLiterals", "[", "<NUM_LIT>", "]", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Depth", ")", "||", "TypeLiterals", "[", "<NUM_LIT>", "]", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Arrayed", ")", "||", "TypeLiterals", "[", "<NUM_LIT>", "]", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "MS", ")", "||", "TypeLiterals", "[", "<NUM_LIT>", "]", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Sampled", ")", "||", "TypeLiterals", "[", "<NUM_LIT>", "]", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "ImageFormat", ")", "||", "TypeLiterals", "[", "<NUM_LIT>", "]", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "AccQual", ")", ")", "llvm_unreachable", "(", "<STR_LIT>", "Unable to recognize Image type literals", "<STR_LIT>", ")", ";", "return", "getOrCreateOpTypeImage", "(", "MIRBuilder", ",", "SpirvType", ",", "Dim", "::", "Dim", "(", "Ddim", ")", ",", "Depth", ",", "Arrayed", ",", "MS", ",", "Sampled", ",", "ImageFormat", "::", "ImageFormat", "(", "ImageFormat", ")", ",", "AQ", "::", "AccessQualifier", "(", "AccQual", ")", ")", ";", "}", "else", "if", "(", "TypeName", ".", "startswith", "(", "<STR_LIT>", "SampledImage.", "<STR_LIT>", ")", ")", "{", "auto", "Literals", "=", "TypeName", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "SampledImage.", "<STR_LIT>", ")", ")", ";", "auto", "&", "Ctx", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "Type", "*", "ImgTy", "=", "StructType", "::", "getTypeByName", "(", "Ctx", ",", "<STR_LIT>", "spirv.Image.", "<STR_LIT>", "+", "Literals", ".", "str", "(", ")", ")", ";", "SPIRVType", "*", "SpirvImageType", "=", "getOrCreateSPIRVType", "(", "ImgTy", ",", "MIRBuilder", ")", ";", "return", "getOrCreateOpTypeSampledImage", "(", "SpirvImageType", ",", "MIRBuilder", ")", ";" ]

[ "<FIXS>", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "const", "MCExpr", "*", "OffsetImm", ",", "unsigned", "OffsetRegNum", ",", "<STR_LIT>", "::", "<STR_LIT>", "ShiftType", ",", "unsigned", "ShiftImm", ",", "unsigned", "Alignment", ",", "bool", "isNegative", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "SMLoc", "AlignmentLoc", "=", "SMLoc", "(", ")", ")", "{", "<FIXE>" ]

[ "}", "static", "std", "::", "unique_ptr", "ARMOperand", ">", "<BUGS>", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "const", "MCConstantExpr", "*", "OffsetImm", ",", "unsigned", "OffsetRegNum", ",", "<STR_LIT>", "::", "<STR_LIT>", "ShiftType", ",", "unsigned", "ShiftImm", ",", "unsigned", "Alignment", ",", "bool", "isNegative", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "SMLoc", "AlignmentLoc", "=", "SMLoc", "(", ")", ")", "{", "<BUGE>", "auto", "Op", "=", "std", "::", "make_unique", "ARMOperand", ">", "(", "k_Memory", ")", ";", "Op", "->", "Memory", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Op", "->", "Memory", ".", "OffsetImm", "=", "OffsetImm", ";" ]

[ "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";" ]

[ "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "X86", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "<STR_LIT>", "reloc_riprel_4byte", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "reloc_riprel_4byte_movq_load", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "reloc_riprel_4byte_relax", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "reloc_riprel_4byte_relax_rex", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "reloc_signed_4byte", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "reloc_signed_4byte_relax", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "reloc_global_offset_table", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "reloc_global_offset_table8", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "reloc_branch_4byte_pcrel", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";" ]

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

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "emit_insn", "(", "gen_cmpint", "(", "target", ",", "ccreg", ")", ")", ";", "<FIXE>" ]

[ "else", "if", "(", "TARGET_MVCLE", ")", "{", "emit_insn", "(", "gen_cmpmem_long", "(", "op0", ",", "op1", ",", "convert_to_mode", "(", "Pmode", ",", "len", ",", "<NUM_LIT>", ")", ")", ")", ";", "<BUGS>", "emit_move_insn", "(", "target", ",", "result", ")", ";", "<BUGE>", "}", "else", "{" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_scalef_round_sh", "(", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "mmask8", "_", "_", "B", ",", "_", "_", "m128h", "_", "_", "C", ",", "_", "_", "m128h", "_", "_", "D", ",", "const", "int", "_", "_", "E", ")", "{", "return", "_", "_", "builtin_ia32_scalefsh_mask_round", "(", "_", "_", "C", ",", "_", "_", "D", ",", "_", "_", "A", ",", "_", "_", "B", ",", "_", "_", "E", ")", ";" ]

[ "}" ]

[ "}", "bool", "BigStack", "=", "(", "RS", "&&", "(", "MFI", "->", "estimateStackSize", "(", "MF", ")", "+", "(", "(", "hasFP", "(", "MF", ")", "&&", "AFI", "->", "hasStackFrame", "(", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ">=", "estimateRSStackSizeLimit", "(", "MF", ",", "this", ")", ")", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "(", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "canSimplifyCallFramePseudos", "(", "MF", ")", ")", ";", "bool", "ExtraCSSpill", "=", "false", ";", "if", "(", "BigStack", "||", "!", "CanEliminateFrame", "||", "RegInfo", "->", "cannotEliminateFrame", "(", "MF", ")", ")", "{", "AFI", "->", "setHasStackFrame", "(", "true", ")", ";", "if", "(", "!", "LRSpilled", "&&", "CS1Spilled", ")", "{", "MRI", ".", "setPhysRegUsed", "(", "ARM", "::", "LR", ")", ";", "NumGPRSpills", "++", ";", "SmallVectorImpl", "<", "unsigned", ">", "::", "iterator", "LRPos", ";", "LRPos", "=", "std", "::", "find", "(", "UnspilledCS1GPRs", ".", "begin", "(", ")", ",", "UnspilledCS1GPRs", ".", "end", "(", ")", ",", "(", "unsigned", ")", "ARM", "::", "LR", ")", ";", "if", "(", "LRPos", "!=", "UnspilledCS1GPRs", ".", "end", "(", ")", ")", "UnspilledCS1GPRs", ".", "erase", "(", "LRPos", ")", ";", "ForceLRSpill", "=", "false", ";", "ExtraCSSpill", "=", "true", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MRI", ".", "setPhysRegUsed", "(", "FramePtr", ")", ";", "auto", "FPPos", "=", "std", "::", "find", "(", "UnspilledCS1GPRs", ".", "begin", "(", ")", ",", "UnspilledCS1GPRs", ".", "end", "(", ")", ",", "FramePtr", ")", ";", "if", "(", "FPPos", "!=", "UnspilledCS1GPRs", ".", "end", "(", ")", ")", "UnspilledCS1GPRs", ".", "erase", "(", "FPPos", ")", ";", "NumGPRSpills", "++", ";", "}", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "TargetAlign", "==", "<NUM_LIT>", "&&", "(", "NumGPRSpills", "&", "<NUM_LIT>", ")", ")", "{", "if", "(", "CS1Spilled", "&&", "!", "UnspilledCS1GPRs", ".", "empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "UnspilledCS1GPRs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "UnspilledCS1GPRs", "[", "i", "]", ";", "if", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "||", "isARMLowRegister", "(", "Reg", ")", "||", "Reg", "==", "ARM", "::", "LR", ")", "{", "MRI", ".", "setPhysRegUsed", "(", "Reg", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", ")", "ExtraCSSpill", "=", "true", ";", "break", ";", "}", "}", "}", "else", "if", "(", "!", "UnspilledCS2GPRs", ".", "empty", "(", ")", "&&", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "{", "unsigned", "Reg", "=", "UnspilledCS2GPRs", ".", "front", "(", ")", ";", "MRI", ".", "setPhysRegUsed", "(", "Reg", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", ")", "ExtraCSSpill", "=", "true", ";", "}", "}", "if", "(", "BigStack", "&&", "!", "ExtraCSSpill", ")", "{", "unsigned", "NumExtras", "=", "TargetAlign", "/", "<NUM_LIT>", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "Extras", ";", "while", "(", "NumExtras", "&&", "!", "UnspilledCS1GPRs", ".", "empty", "(", ")", ")", "{", "unsigned", "Reg", "=", "UnspilledCS1GPRs", ".", "back", "(", ")", ";", "UnspilledCS1GPRs", ".", "pop_back", "(", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", "&&", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "||", "isARMLowRegister", "(", "Reg", ")", "||", "Reg", "==", "ARM", "::", "LR", ")", ")", "{", "Extras", ".", "push_back", "(", "Reg", ")", ";", "NumExtras", "--", ";", "}", "}", "if", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "{", "while", "(", "NumExtras", "&&", "!", "UnspilledCS2GPRs", ".", "empty", "(", ")", ")", "{", "unsigned", "Reg", "=", "UnspilledCS2GPRs", ".", "back", "(", ")", ";", "UnspilledCS2GPRs", ".", "pop_back", "(", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", ")", "{", "Extras", ".", "push_back", "(", "Reg", ")", ";", "NumExtras", "--", ";", "}" ]

[ ")", ";" ]

[ "return", "getRegisterBitWidth", "(", "Vector" ]

[ "<STR_LIT>", ")" ]

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

[ "v4si", ")", "_", "_", "C", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_dpbusds_epi32", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ",", "_", "_", "m128i", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpdpbusds_v4si", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_", "_", "B", ",", "(", "_", "_" ]

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

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

[ "}" ]

[ "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "STI", ".", "getIORegSREG", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Pn", ";", "bits", "<", "<NUM_LIT>", ">", "Zn", ";", "bits", "<", "<NUM_LIT>", ">", "ZAda", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "S", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "}", "else", "if", "(", "TARGET_BACKCHAIN", ")", "{", "cfun_frame_layout", ".", "backchain_offset", "=", "(", "STACK_POINTER_OFFSET", "-", "UNITS_PER_WORD", ")", ";", "cfun_frame_layout", ".", "gprs_offset", "=", "(", "cfun_frame_layout", ".", "backchain_offset", "-", "(", "STACK_POINTER_REGNUM", "-", "cfun_frame_layout", ".", "first_save_gpr_slot", "+", "<NUM_LIT>", ")", "*", "UNITS_PER_WORD", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "cfun_frame_layout", ".", "f4_offset", "=", "(", "cfun_frame_layout", ".", "gprs_offset", "-", "<NUM_LIT>", "*", "(", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", "+", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", ")", ")", ";", "cfun_frame_layout", ".", "f0_offset", "=", "(", "cfun_frame_layout", ".", "f4_offset", "-", "<NUM_LIT>", "*", "(", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", "+", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", ")", ")", ";", "}", "else", "{", "cfun_frame_layout", ".", "f0_offset", "=", "(", "(", "cfun_frame_layout", ".", "gprs_offset", "&", "~", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", "-", "<NUM_LIT>", ")", ")", "-", "<NUM_LIT>", "*", "(", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", "+", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", ")", ")", ";", "cfun_frame_layout", ".", "f4_offset", "=", "(", "cfun_frame_layout", ".", "f0_offset", "-", "<NUM_LIT>", "*", "(", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", "+", "cfun_fpr_bit_p", "(", "<NUM_LIT>", ")", ")", ")", ";" ]

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

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

[ "_", "B", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "(", "(", "_", "_", "v2du", ")", "_", "_", "A", "*", "(", "_", "_", "v2du", ")", "_" ]

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

[ "(", "match_operand", ":", "SWI248", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]" ]

[ ")", ";" ]

[ "RegisterTargetMachine", "<", "ARMLETargetMachine", ">", "X", "(", "TheARMLETarget", ")", ";", "RegisterTargetMachine", "<", "ARMBETargetMachine", ">", "Y", "(", "TheARMBETarget", ")", ";", "RegisterTargetMachine", "<", "ThumbLETargetMachine", ">", "A", "(", "TheThumbLETarget", ")", ";", "RegisterTargetMachine", "<", "ThumbBETargetMachine", ">", "B", "(", "TheThumbBETarget", ")", ";", "PassRegistry", "&", "Registry", "=", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ";", "initializeARMLoadStoreOptPass", "(", "Registry" ]

[ "<FIXS>", "SrcReg", "==", "OISrcReg", "&&", "ImmMask", "==", "OIMask", ")", "{", "if", "(", "OIValue", "==", "ImmValue", ")", "{", "*", "ImmDelta", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "else", "if", "(", "static_cast", "uint64_t", ">", "(", "ImmValue", ")", "==", "static_cast", "uint64_t", ">", "(", "OIValue", ")", "-", "<NUM_LIT>", ")", "{", "*", "ImmDelta", "=", "-", "<NUM_LIT>", ";", "return", "true", ";", "}", "else", "if", "(", "static_cast", "uint64_t", ">", "(", "ImmValue", ")", "==", "static_cast", "uint64_t", ">", "(", "OIValue", ")", "+", "<NUM_LIT>", ")", "{", "*", "ImmDelta", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "<FIXE>" ]

[ "int64_t", "OIMask", ";", "int64_t", "OIValue", ";", "if", "(", "analyzeCompare", "(", "OI", ",", "OISrcReg", ",", "OISrcReg2", ",", "OIMask", ",", "OIValue", ")", "&&", "<BUGS>", "SrcReg", "==", "OISrcReg", "&&", "ImmMask", "==", "OIMask", "&&", "OIValue", "==", "ImmValue", ")", "{", "assert", "(", "SrcReg2", "==", "X86", "::", "NoRegister", "&&", "OISrcReg2", "==", "X86", "::", "NoRegister", "&&", "<STR_LIT>", "should not have 2nd register", "<STR_LIT>", ")", ";", "return", "true", ";", "<BUGE>", "}", "}", "return", "FlagI", ".", "isIdenticalTo", "(", "OI", ")", ";" ]

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

[ "def", "ro_Windexed32", ":", "ComplexPattern", "<", "i64", ",", "<NUM_LIT>" ]

[ "_", "B", ",", "(", "_", "_", "v16sf", ")", "_", "_", "C", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_fnmsub_ps", "(", "_", "_", "m512", "_", "_", "A", ",", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m512", "_", "_", "B", ",", "_", "_", "m512", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_vfnmsubps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_" ]

[ "OutStreamer", "->", "emitInstruction", "(", "MI", ",", "getSubtargetInfo", "(", ")", ")", ";" ]

[ "MCSymbol", "*", "HandlerLabel", "=", "FaultingMI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "unsigned", "Opcode", "=", "FaultingMI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "OperandsBeginIdx", "=", "<NUM_LIT>", ";", "auto", "&", "Ctx", "=", "OutStreamer", "->", "getContext", "(", ")", ";", "MCSymbol", "*", "FaultingLabel", "=", "Ctx", ".", "createTempSymbol", "(", ")", ";", "OutStreamer", "->", "emitLabel", "(", "FaultingLabel", ")", ";", "assert", "(", "FK", "<", "FaultMaps", "::", "FaultKindMax", "&&", "<STR_LIT>", "Invalid Faulting Kind!", "<STR_LIT>", ")", ";", "FM", ".", "recordFaultingOp", "(", "FK", ",", "FaultingLabel", ",", "HandlerLabel", ")", ";", "MCInst", "MI", ";", "MI", ".", "setOpcode", "(", "Opcode", ")", ";", "if", "(", "DefRegister", "!=", "(", "Register", ")", "<NUM_LIT>", ")", "MI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "DefRegister", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "llvm", "::", "drop_begin", "(", "FaultingMI", ".", "operands", "(", ")", ",", "OperandsBeginIdx", ")", ")", "{", "MCOperand", "Dest", ";", "lowerOperand", "(", "MO", ",", "Dest", ")", ";", "MI", ".", "addOperand", "(", "Dest", ")", ";", "}", "OutStreamer", "->", "AddComment", "(", "<STR_LIT>", "on-fault: ", "<STR_LIT>", "+", "HandlerLabel", "->", "getName", "(", ")", ")", ";" ]

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

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "match_operand", ":", "ssehalfvecmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "]", "<NUM_LIT>", ")", ")", "]", "<FIXE>" ]

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

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Imm", ")", ")", ";" ]

[ "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "if", "(", "ShiftExtend", ".", "Amount", "!=", "<NUM_LIT>", "&&", "ShiftExtend", ".", "Amount", "!=", "<NUM_LIT>", ")", "llvm_unreachable", "(", "<STR_LIT>", "Invalid shift amount for vector immediate inst.", "<STR_LIT>", ")", ";", "int64_t", "Imm", "=", "ShiftExtend", ".", "Amount", "/", "<NUM_LIT>", "-", "<NUM_LIT>", ";" ]

[ "LRegion", "->", "setParent", "(", "Region", "->", "getParent", "(", ")", "?", "Region", "->", "getParent", "(", ")", "->", "getLinearizedRegion", "(", ")", ":", "nullptr", ")", ";" ]

[ "LRegion", "->", "setRegionMRT", "(", "Region", ")", ";", "Region", "->", "setLinearizedRegion", "(", "LRegion", ")", ";" ]

[ "return", "DAG", ".", "getStore", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "dl", ",", "Offset", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "SV", ",", "<NUM_LIT>", ")", ";" ]

[ "static", "SDValue", "LowerVASTART", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "SparcTargetLowering", "&", "TLI", ")", "{", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SDValue", "Offset", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "TLI", ".", "getVarArgsFrameOffset", "(", ")", ",", "MVT", "::", "i32", ")", ")", ";", "const", "Value", "*", "SV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";" ]

[ "<FIXS>", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4f32", ",", "V1", ",", "V2", ",", "DAG", ".", "getIntPtrConstant", "(", "InsertPSMask", ",", "DL", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "Result", ")", ";", "<FIXE>" ]

[ "unsigned", "InsertPSMask", "=", "EltMaskIdx", "<<", "<NUM_LIT>", "|", "EltIdx", "<<", "<NUM_LIT>", "|", "ZMask", ";", "assert", "(", "(", "InsertPSMask", "&", "~", "<NUM_LIT>", "u", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid mask!", "<STR_LIT>", ")", ";", "<BUGS>", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "v4f32", ",", "V1", ",", "V2", ",", "DAG", ".", "getIntPtrConstant", "(", "InsertPSMask", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "Result", ")", ";", "<BUGE>", "}" ]

[ "NoItinerary", ",", "[", "(", "ARMcallseq_start", "timm", ":", "$", "amt", ")", "]", ">", ";" ]

[ "def", "ADJCALLSTACKDOWN", ":", "PseudoInst", "<", "(", "outs", ")", ",", "(", "ins", "i32imm", ":", "$", "amt", ",", "pred", ":", "$", "p", ")", "," ]

[ "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";" ]

[ "if", "(", "Cond", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", "||", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";" ]

[ "P0", "]", ";" ]

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

[ "}" ]

[ "MCInst", "AArch64InstrInfo", "::", "getNop", "(", ")", "const", "{", "return", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "x1", ",", "MODE", ")", ")", ")", "\\", "||", "(", "REG_P", "(", "_", "x1", ")", "\\", "&&", "(", "REG_OK_FOR_BASE_P", "(", "_", "x1", ")", "\\", "&&", "LEGITIMATE_INDEX_P", "(", "_", "x0", ",", "MODE", ")", ")", ")", ")", "\\", "goto", "ADDR", ";", "\\", "}", "\\", "else", "if", "(", "GET_CODE", "(", "X", ")", "==", "LO_SUM", ")", "\\", "{", "\\", "register", "rtx", "_", "x0", "=", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ";", "\\", "register", "rtx", "_", "x1", "=", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ";", "\\", "if", "(", "(", "(", "REG_P", "(", "_", "x0", ")", "\\", "&&", "REG_OK_FOR_BASE_P", "(", "_", "x0", ")", ")", "\\", "||", "(", "GET_CODE", "(", "_", "x0", ")", "==", "SUBREG", "\\", "&&", "REG_P", "(", "SUBREG_REG", "(", "_", "x0", ")", ")", "\\", "&&", "REG_OK_FOR_BASE_P", "(", "SUBREG_REG", "(", "_", "x0", ")", ")", ")", ")", "\\", "&&", "CONSTANT_P", "(", "_", "x1", ")", ")", "\\", "goto", "ADDR", ";", "\\", "}", "\\", "else", "if", "(", "GET_CODE", "(", "X", ")", "==", "CONST_INT", "\\", "&&", "SMALL_INT", "(", "X", ")", ")", "\\", "goto", "ADDR", ";", "\\", "else", "if", "(", "SHORT_ADDRESS_P", "(", "X", ",", "_", "x", ")", ")", "\\", "goto", "ADDR", ";", "\\", "}" ]

[ "{", "\\", "char", "buf", "[", "<NUM_LIT>", "]", ";", "\\", "static", "int", "labelno", "=", "<NUM_LIT>", ";", "\\", "labelno", "++", ";", "\\", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "<STR_LIT>", "LTRMP", "<STR_LIT>", ",", "labelno", ")", ";", "\\", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tor\\t %s,%s,0\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "\\", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tbsr\\t %s\\n", "<STR_LIT>", ",", "&", "buf", "[", "<NUM_LIT>", "]", ")", ";", "\\", "ASM_OUTPUT_INTERNAL_LABEL", "(", "FILE", ",", "<STR_LIT>", "LTRMP", "<STR_LIT>", ",", "labelno", ")", ";", "\\", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tst\\t %s,%s,24\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tor\\t %s,%s,0\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tor\\t %s,%s,0\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "\\", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tld\\t %s,%s,32\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tjmp.n\\t %s\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "\\", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tld.d\\t %s,%s,24\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "\\", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "\\", "}", "{", "\\", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "TRAMP", ",", "<NUM_LIT>", ")", ")", ",", "FNADDR", ")", ";", "\\", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "TRAMP", ",", "<NUM_LIT>", ")", ")", ",", "CXT", ")", ";", "\\", "}", "(", "GET_CODE", "(", "X", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "X", ")", "==", "SYMBOL_REF", "\\", "||", "GET_CODE", "(", "X", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "X", ")", "==", "HIGH", "\\", "||", "(", "GET_CODE", "(", "X", ")", "==", "CONST", "\\", "&&", "!", "(", "flag_pic", "&&", "pic_address_needs_scratch", "(", "X", ")", ")", ")", ")", "(", "GET_CODE", "(", "ADDR", ")", "==", "PLUS", "\\", "&&", "(", "GET_CODE", "(", "XEXP", "(", "ADDR", ",", "<NUM_LIT>", ")", ")", "==", "MULT", "\\", "||", "GET_CODE", "(", "XEXP", "(", "ADDR", ",", "<NUM_LIT>", ")", ")", "==", "MULT", ")", ")", "(", "(", "TEMP", ")", "=", "(", "GET_CODE", "(", "X", ")", "==", "CONST", "?", "get_related_value", "(", "X", ")", ":", "X", ")", ",", "\\", "(", "(", "TEMP", ")", "&&", "GET_CODE", "(", "TEMP", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FLAG", "(", "TEMP", ")", ")", ")", "(", "(", "GET_CODE", "(", "X", ")", "==", "CONST_INT", "\\", "&&", "SMALL_INT", "(", "X", ")", ")", "\\", "||", "(", "REG_P", "(", "X", ")", "\\", "&&", "REG_OK_FOR_INDEX_P", "(", "X", ")", ")", "\\", "||", "(", "GET_CODE", "(", "X", ")", "==", "MULT", "\\", "&&", "REG_P", "(", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ")", "\\", "&&", "REG_OK_FOR_INDEX_P", "(", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ")", "\\", "&&", "GET_CODE", "(", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "\\", "&&", "INTVAL", "(", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ")", "==", "GET_MODE_SIZE", "(", "MODE", ")", ")", ")", "(", "(", "GET_CODE", "(", "X", ")", "==", "REG", "&&", "REG_OK_FOR_BASE_P", "(", "X", ")", ")", "\\", "||", "(", "GET_CODE", "(", "X", ")", "==", "SUBREG", "\\", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "X", ")", ")", "==", "REG", "\\", "&&", "REG_OK_FOR_BASE_P", "(", "SUBREG_REG", "(", "X", ")", ")", ")", ")", "(", "(", "GET_CODE", "(", "X", ")", "==", "REG", "&&", "REG_OK_FOR_INDEX_P", "(", "X", ")", ")", "\\", "||", "(", "GET_CODE", "(", "X", ")", "==", "SUBREG", "\\", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "X", ")", ")", "==", "REG", "\\", "&&", "REG_OK_FOR_INDEX_P", "(", "SUBREG_REG", "(", "X", ")", ")", ")", ")", "{", "\\", "register", "rtx", "_", "x", ";", "\\", "if", "(", "REG_P", "(", "X", ")", ")", "\\", "{", "\\", "if", "(", "REG_OK_FOR_BASE_P", "(", "X", ")", ")", "\\", "goto", "ADDR", ";", "\\", "}", "\\", "else", "if", "(", "GET_CODE", "(", "X", ")", "==", "PLUS", ")", "\\", "{", "\\", "register", "rtx", "_", "x0", "=", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ";", "\\", "register", "rtx", "_", "x1", "=", "XEXP", "(", "X", ",", "<NUM_LIT>", ")", ";", "\\", "if", "(", "(", "flag_pic", "\\", "&&", "_", "x0", "==", "pic_offset_table_rtx", "\\", "&&", "(", "flag_pic", "==", "<NUM_LIT>", "\\", "?", "RTX_OK_FOR_BASE_P", "(", "_", "x1", ")", "\\", ":", "(", "GET_CODE", "(", "_", "x1", ")", "==", "SYMBOL_REF", "\\", "||", "GET_CODE", "(", "_", "x1", ")", "==", "LABEL_REF", ")", ")", ")", "\\", "||", "(", "REG_P", "(", "_", "x0", ")", "\\", "&&", "(", "REG_OK_FOR_BASE_P", "(", "_", "x0", ")", "\\", "&&", "LEGITIMATE_INDEX_P", "(", "_" ]

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

[ "vcle_u64", "(", "uint64x1_t", "_", "_", "a", ",", "uint64x1_t" ]

[ "Offset", ";" ]

[ "assert", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "<STR_LIT>", "Didn't find MI in its own basic block?", "<STR_LIT>", ")", ";", "Offset", "+=", "TII", "->", "GetInstSizeInBytes", "(", "I", ")", ";", "}", "return" ]

[ "<FIXS>", "FudgePtr", ",", "MachinePointerInfo", "::", "getConstantPool", "(", ")", ",", "MVT", "::", "f32", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "SDValue", "Fudge", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "f80", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "<BUGS>", "FudgePtr", ",", "PseudoSourceValue", "::", "getConstantPool", "(", ")", ",", "<NUM_LIT>", ",", "MVT", "::", "f32", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FADD", ",", "dl", ",", "MVT", "::", "f80", ",", "Fild", ",", "Fudge", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "DstVT", ",", "Add", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "<FIXS>", "internal_error", "(", "<STR_LIT>", "unknown dest", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "}", "else", "<BUGS>", "internal_error", "(", "<STR_LIT>", "Unknown dest", "<STR_LIT>", ")", ";", "<BUGE>", "val", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";" ]

[ ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_LOAD_SDATA", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";" ]

[ "default", ":", "gcc_unreachable", "(", ")", ";", "case", "<NUM_LIT>", ":", "if", "(", "d", ".", "testing_p", "||", "!", "rtx_equal_p", "(", "d", ".", "op0", ",", "d", ".", "op1", ")", ")", "{", "d", ".", "one_operand_p", "=", "false", ";", "break", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelt", ";", "++", "i", ")", "if", "(", "d", ".", "perm", "[", "i", "]", ">=", "nelt", ")", "d", ".", "perm", "[", "i", "]", "-=", "nelt", ";", "case", "<NUM_LIT>", ":", "d", ".", "op1", "=", "d", ".", "op0", ";", "d", ".", "one_operand_p", "=", "true", ";", "break", ";", "case", "<NUM_LIT>", ":", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "-=", "nelt", ";", "d", ".", "op0", "=", "d", ".", "op1", ";", "d", ".", "one_operand_p", "=", "true", ";", "break", ";", "}", "if", "(", "d", ".", "testing_p", ")", "{", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "if", "(", "!", "d", ".", "one_operand_p", ")", "d", ".", "op1", "=", "gen_raw_REG" ]

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

[ "def", "J4_jumpsetr", ":", "HInst", "<", "(", "outs", "GeneralSubRegs", ":", "$", "Rd16", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_0663f615", ",", "TypeCJ", ">", ",", "Enc_66bce1", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "<NUM_LIT>", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "<NUM_LIT>", ")", "{", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ";", "break", ";", "}", "}", "else", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "<NUM_LIT>", ")", "{", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_RESTORE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_RESTORE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "<NUM_LIT>", ")", "{", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "<STR_LIT>", "SIInstrInfo::loadRegFromStackSlot - Do not know how to", "<STR_LIT>", "<STR_LIT>", " restore register", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "DestReg", ")", ";", "}", "}" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "if", "(", "!", "STI", ".", "splitFramePushPop", "(", "MF", ")", ")", "{", "<FIXE>" ]

[ "break", ";", "}", "}", "else", "{", "<BUGS>", "if", "(", "!", "STI", ".", "splitFramePushPop", "(", ")", ")", "{", "<BUGE>", "UnspilledCS1GPRs", ".", "push_back", "(", "Reg", ")", ";", "continue", ";", "}" ]

[ "<STR_LIT>", ")" ]

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

[ "mmask16", ")", "_", "_", "M", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pminub128_mask", "(", "(", "_", "_", "v16qi", ")", "_", "_", "A", ",", "(", "_", "_", "v16qi", ")", "_", "_", "B", ",", "(", "_", "_", "v16qi", ")", "_", "_", "W", ",", "(", "_", "_" ]

[ "}" ]

[ "def", "L2_deallocframe", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_15aa71c5", ",", "TypeLD", ">", ",", "Enc_3a3d62", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "accessSize", "=", "DoubleWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "FRAMEKEY", "]", ";", "let", "Defs", "=", "[", "R29", "]", ";" ]

[ ",", "IOL", ",", "<STR_LIT>", ",", "SelectOp", ",", "pattern", ">", ";" ]

[ "class", "FSMHInst", "<", "dag", "OOL", ",", "dag", "IOL", ",", "list", "<", "dag", ">", "pattern", ">", ":", "RRForm_1", "<", "<NUM_LIT>", ",", "OOL" ]

[ "<FIXS>", "{", "if", "(", "TARGET_64BIT", ")", "temp", "=", "(", "mode", "==", "DImode", "||", "(", "regno", "==", "MD_REG_FIRST", "&&", "mode", "==", "TImode", ")", ")", ";", "elsetemp", "=", "(", "mode", "==", "SImode", "||", "(", "regno", "==", "MD_REG_FIRST", "&&", "mode", "==", "DImode", ")", ")", ";", "}", "<FIXE>" ]

[ "||", "(", "TARGET_DEBUG_H_MODE", "&&", "class", "==", "MODE_INT", ")", ")", ")", ";", "else", "if", "(", "MD_REG_P", "(", "regno", ")", ")", "<BUGS>", "temp", "=", "(", "mode", "==", "SImode", "||", "(", "regno", "==", "MD_REG_FIRST", "&&", "mode", "==", "DImode", ")", ")", ";", "<BUGE>", "elsetemp", "=", "FALSE", ";" ]

[ "unsigned", "RetReg", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";" ]

[ "if", "(", "!", "FuncInfo", ".", "CanLowerReturn", ")", "return", "false", ";", "if", "(", "TLI", ".", "supportSwiftError", "(", ")", "&&", "F", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "false", ";", "if", "(", "TLI", ".", "supportSplitCSR", "(", "FuncInfo", ".", "MF", ")", ")", "return", "false", ";", "CallingConv", "::", "ID", "CC", "=", "F", ".", "getCallingConv", "(", ")", ";", "if", "(", "CC", "!=", "CallingConv", "::", "C", "&&", "CC", "!=", "CallingConv", "::", "Fast", "&&", "CC", "!=", "CallingConv", "::", "X86_FastCall", "&&", "CC", "!=", "CallingConv", "::", "X86_StdCall", "&&", "CC", "!=", "CallingConv", "::", "X86_ThisCall", "&&", "CC", "!=", "CallingConv", "::", "X86_64_SysV", "&&", "CC", "!=", "CallingConv", "::", "X86_64_Win64", ")", "return", "false", ";", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "X86MFInfo", "->", "getBytesToPopOnReturn", "(", ")", ")", ")", "return", "false", ";", "if", "(", "CC", "==", "CallingConv", "::", "Fast", "&&", "TM", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "RetRegs", ";", "if", "(", "Ret", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", ")", "{", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "Outs", ";", "GetReturnInfo", "(", "F", ".", "getReturnType", "(", ")", ",", "F", ".", "getAttributes", "(", ")", ",", "Outs", ",", "TLI", ",", "DL", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ValLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "F", ".", "isVarArg", "(", ")", ",", "*", "FuncInfo", ".", "MF", ",", "ValLocs", ",", "I", "->", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_X86", ")", ";", "const", "Value", "*", "RV", "=", "Ret", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "RV", ")", ";", "if", "(", "Reg", "==", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "ValLocs", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "CCValAssign", "&", "VA", "=", "ValLocs", "[", "<NUM_LIT>", "]", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "return", "false", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "if", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP1", ")", "return", "false", ";", "unsigned", "SrcReg", "=", "Reg", "+", "VA", ".", "getValNo", "(", ")", ";", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "RV", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "SrcVT", "!=", "DstVT", ")", "{", "if", "(", "SrcVT", "!=", "MVT", "::", "i1", "&&", "SrcVT", "!=", "MVT", "::", "i8", "&&", "SrcVT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "if", "(", "!", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", "&&", "!", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSExt", "(", ")", ")", "return", "false", ";", "assert", "(", "DstVT", "==", "MVT", "::", "i32", "&&", "<STR_LIT>", "X86 should always ext to i32", "<STR_LIT>", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i1", ")", "{", "if", "(", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSExt", "(", ")", ")", "return", "false", ";", "if", "(", "MRI", ".", "getRegClass", "(", "SrcReg", ")", "==", "&", "X86", "::", "VK1RegClass", ")", "{", "unsigned", "KSrcReg", "=", "SrcReg", ";", "SrcReg", "=", "createResultReg", "(", "&", "X86", "::", "GR32RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "SrcReg", ")", ".", "addReg", "(", "KSrcReg", ")", ";", "SrcReg", "=", "fastEmitInst_extractsubreg", "(", "MVT", "::", "i8", ",", "SrcReg", ",", "true", ",", "X86", "::", "sub_8bit", ")", ";", "}", "SrcReg", "=", "fastEmitZExtFromI1", "(", "MVT", "::", "i8", ",", "SrcReg", ",", "false", ")", ";", "SrcVT", "=", "MVT", "::", "i8", ";", "}", "unsigned", "Op", "=", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", "?", "ISD", "::", "ZERO_EXTEND", ":", "ISD", "::", "SIGN_EXTEND", ";", "SrcReg", "=", "fastEmit_r", "(", "SrcVT", ".", "getSimpleVT", "(", ")", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "Op", ",", "SrcReg", ",", "false", ")", ";", "}", "unsigned", "DstReg", "=", "VA", ".", "getLocReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "if", "(", "!", "SrcRC", "->", "contains", "(", "DstReg", ")", ")", "return", "false", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "RetRegs", ".", "push_back", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "}", "if", "(", "F", ".", "hasStructRetAttr", "(", ")", "&&", "CC", "!=", "CallingConv", "::", "Swift", ")", "{", "unsigned", "Reg", "=", "X86MFInfo", "->", "getSRetReturnReg", "(", ")", ";", "assert", "(", "Reg", "&&", "<STR_LIT>", "SRetReturnReg should have been set in LowerFormalArguments()!", "<STR_LIT>", ")", ";" ]

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

[ "return", "(", "int8x8_t", ")", "_", "_", "builtin_neon_vreinterpretv8qiv2sf", "(" ]

[ ")" ]

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

[ "[", "{" ]

[ "def", "fpimm0", ":", "FPImmLeaf", "<", "fAny", ",", "[", "{", "return", "Imm", ".", "isExactlyValue", "(", "+", "<NUM_LIT>", ".", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "fpimm_half", ":", "FPImmLeaf", "<", "fAny", "," ]

[ ")", ";" ]

[ "MVT", "RegTy", "=", "MemTy", "==", "MVT", "::", "i64", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "SDNode", "*", "CmpSwap", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "N", ")", ",", "CurDAG", "->", "getVTList", "(", "RegTy", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ",", "Ops", ")", ";", "MachineSDNode", "::", "mmo_iterator", "MemOp", "=", "MF", "->", "allocateMemRefsArray", "(", "<NUM_LIT>", ")", ";", "MemOp", "[", "<NUM_LIT>", "]", "=", "cast", "<", "MemSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";", "cast", "<", "MachineSDNode", ">", "(", "CmpSwap", ")", "->", "setMemRefs", "(", "MemOp", ",", "MemOp", "+", "<NUM_LIT>", ")", ";", "ReplaceUses", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "CmpSwap", ",", "<NUM_LIT>", ")" ]

[ "}", ";" ]

[ "vdup_n_s64", "(", "int64_t", "_", "_", "a", ")", "{", "return", "(", "int64x1_t", ")", "{", "_", "_", "a" ]

[ "{" ]

[ "EVT", "PPCTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "return", "MVT", "::", "i64", ";", "}", "else" ]

[ "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";" ]

[ "addPass", "(", "createStraightLineStrengthReducePass", "(", ")", ")", ";", "addEarlyCSEOrGVNPass", "(", ")", ";", "addPass", "(", "createNaryReassociatePass", "(", ")", ")", ";" ]

[ "}" ]

[ "bool", "ARMInstructionSelector", "::", "validReg", "(", "MachineRegisterInfo", "&", "MRI", ",", "unsigned", "Reg", ",", "unsigned", "ExpectedSize", ",", "unsigned", "ExpectedRegBankID", ")", "const", "{", "if", "(", "MRI", ".", "getType", "(", "Reg", ")", ".", "getSizeInBits", "(", ")", "!=", "ExpectedSize", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Unexpected size for register", "<STR_LIT>", ")", ";", "return", "false", ";" ]