Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "SDValue", "Hi", "=", "DAG", ".", "getTargetExtractSubreg", "(", "isBigEndian", "?", "ARM", "::", "gsub_0", ":", "ARM", "::", "gsub_1", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "SDValue", "(", "CmpSwap", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "MachineMemOperand", "*", "MemOp", "=", "cast", "<", "MemSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";", "DAG", ".", "setNodeMemRefs", "(", "cast", "<", "MachineSDNode", ">", "(", "CmpSwap", ")", ",", "{", "MemOp", "}", ")", ";", "bool", "isBigEndian", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "isBigEndian", "(", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getTargetExtractSubreg", "(", "isBigEndian", "?", "ARM", "::", "gsub_1", ":", "ARM", "::", "gsub_0", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "SDValue", "(", "CmpSwap", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "}" ]

[ "_", "_", "asm__", "(", "<STR_LIT>", "frsqrts %0.2d,%1.2d,%2.2d", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "w", "<STR_LIT>", "(", "a", ")", ",", "<STR_LIT>", "w", "<STR_LIT>", "(", "b", ")", ":", ")", ";", "return", "result", ";" ]

[ "static", "int", "s390_sched_score", "(", "rtx_insn", "*", "insn", ")", "{", "unsigned", "int", "mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "int", "score", "=", "<NUM_LIT>", ";", "switch", "(", "sched_state", ".", "group_state", ")", "{", "case", "<NUM_LIT>", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "<NUM_LIT>", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "<NUM_LIT>", ")", "score", "+=", "<NUM_LIT>", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "<NUM_LIT>", ")", "score", "+=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "<NUM_LIT>", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "<NUM_LIT>", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "<NUM_LIT>", ")", "score", "+=", "<NUM_LIT>", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "==", "<NUM_LIT>", ")", "score", "+=", "<NUM_LIT>", ";", "if", "(", "sched_state", ".", "group_of_two", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPOFTWO", ")", "!=", "<NUM_LIT>", ")", "score", "+=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "<NUM_LIT>", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "<NUM_LIT>", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "<NUM_LIT>", ")", "score", "+=", "<NUM_LIT>", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "!=", "<NUM_LIT>", ")", "score", "+=", "<NUM_LIT>", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPOFTWO", ")", "!=", "<NUM_LIT>", ")", "score", "=", "MAX", "(", "<NUM_LIT>", ",", "score", "-", "<NUM_LIT>", ")", ";", "break", ";", "}", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "i", ";", "unsigned", "unit_mask", ",", "m", "=", "<NUM_LIT>", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "gcc_assert", "(", "units", "<=", "MAX_SCHED_UNITS", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "units", ";", "i", "++", ",", "m", "<<=", "<NUM_LIT>", ")", "if", "(", "m", "&", "unit_mask", ")", "score", "+=", "(", "last_scheduled_unit_distance", "[", "i", "]", "[", "sched_state", ".", "side", "]", "*", "MAX_SCHED_MIX_SCORE", "/", "MAX_SCHED_MIX_DISTANCE", ")", ";", "int", "other_side", "=", "<NUM_LIT>", "-", "sched_state", ".", "side", ";", "if", "(", "s390_is_longrunning", "(", "insn", ")", ")", "{", "if", "(", "s390_is_fxd", "(", "insn", ")", ")", "{", "if", "(", "fxd_longrunning", "[", "sched_state", ".", "side", "]", "&&", "fxd_longrunning", "[", "other_side", "]", "<=", "fxd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "=", "MAX", "(", "<NUM_LIT>", ",", "score", "-", "<NUM_LIT>", ")", ";", "else", "if", "(", "fxd_longrunning", "[", "other_side", "]", ">=", "fxd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "+=", "<NUM_LIT>", ";", "}", "if", "(", "s390_is_fpd", "(", "insn", ")", ")", "{", "if", "(", "fpd_longrunning", "[", "sched_state", ".", "side", "]", "&&", "fpd_longrunning", "[", "other_side", "]", "<=", "fpd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "=", "MAX", "(", "<NUM_LIT>", ",", "score", "-", "<NUM_LIT>", ")", ";", "else", "if", "(", "fpd_longrunning", "[", "other_side", "]", ">=", "fpd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "+=", "<NUM_LIT>", ";", "}", "}", "}", "return", "score", ";", "}" ]

[ "Return", "the", "scheduling", "score", "for", "INSN", ".", "The", "higher", "the", "score", "the", "better", ".", "The", "score", "is", "calculated", "from", "the", "OOO", "scheduling", "attributes", "of", "INSN", "and", "the", "scheduling", "state", "s390_sched_state", "." ]

[ "MF", ".", "insert", "(", "std", "::", "next", "(", "MachineFunction", "::", "iterator", "(", "CatchTermPad", ")", ")", ",", "CatchAllTermPad", ")", ";" ]

[ "for", "(", "auto", "&", "MBB", ":", "MF", ")", "if", "(", "WebAssembly", "::", "isCatchTerminatePad", "(", "MBB", ")", ")", "TermPads", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "TermPads", ".", "empty", "(", ")", ")", "return", "false", ";", "Function", "*", "StdTerminateFn", "=", "MF", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", "->", "getFunction", "(", "WebAssembly", "::", "StdTerminateFn", ")", ";", "assert", "(", "StdTerminateFn", "&&", "<STR_LIT>", "There is no std::terminate() function", "<STR_LIT>", ")", ";", "for", "(", "auto", "*", "CatchTermPad", ":", "TermPads", ")", "{", "DebugLoc", "DL", "=", "CatchTermPad", "->", "findDebugLoc", "(", "CatchTermPad", "->", "begin", "(", ")", ")", ";", "auto", "*", "CatchAllTermPad", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";" ]

[ "rtx", "mips_loongson_ext2_prefetch_cookie", "(", "rtx", "write", ",", "rtx", ")", "{", "if", "(", "INTVAL", "(", "write", ")", "==", "<NUM_LIT>", ")", "return", "GEN_INT", "(", "INTVAL", "(", "write", ")", ")", ";", "if", "(", "INTVAL", "(", "write", ")", "==", "<NUM_LIT>", ")", "return", "GEN_INT", "(", "INTVAL", "(", "write", ")", ")", ";", "gcc_unreachable", "(", ")", ";", "}" ]

[ "Loongson", "EXT2", "only", "implements", "pref", "hint=0", "(", "prefetch", "for", "load", ")", "and", "hint=1", "(", "prefetch", "for", "store", ")", ",", "other", "hint", "just", "scale", "to", "hint", "=", "0", "and", "hint", "=", "1", "." ]

[ "<FIXS>", "case", "E_V8HImode", ":", "<FIXE>", "<FIXS>", "case", "E_V4HImode", ":", "<FIXE>", "<FIXS>", "case", "E_V16QImode", ":", "<FIXE>", "<FIXS>", "case", "E_V8SFmode", ":", "<FIXE>" ]

[ "}", "break", ";", "<BUGS>", "case", "V8HImode", ":", "<BUGE>", "use_vec_extr", "=", "TARGET_SSE2", ";", "break", ";", "<BUGS>", "case", "V4HImode", ":", "<BUGE>", "use_vec_extr", "=", "mmx_ok", "&&", "(", "TARGET_SSE", "||", "TARGET_3DNOW_A", ")", ";", "break", ";", "<BUGS>", "case", "V16QImode", ":", "<BUGE>", "use_vec_extr", "=", "TARGET_SSE4_1", ";", "break", ";", "<BUGS>", "case", "V8SFmode", ":", "<BUGE>", "if", "(", "TARGET_AVX", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "V4SFmode", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_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>", ")", ")", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_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>", ")", ")", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_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>", ")", ")", ")", ")" ]

[ "}" ]

[ "case", "X86", "::", "VCVTSI642SDZrr", ":", "case", "X86", "::", "VCVTSI642SDZrm", ":", "case", "X86", "::", "VCVTSI642SDZrr_Int", ":", "case", "X86", "::", "VCVTSI642SDZrrb_Int", ":", "case", "X86", "::", "VCVTSI642SDZrm_Int", ":", "case", "X86", "::", "VCVTUSI2SSZrr", ":", "case", "X86", "::", "VCVTUSI2SSZrm", ":", "case", "X86", "::", "VCVTUSI2SSZrr_Int", ":", "case", "X86", "::", "VCVTUSI2SSZrrb_Int", ":", "case", "X86", "::", "VCVTUSI2SSZrm_Int", ":", "case", "X86", "::", "VCVTUSI642SSZrr", ":", "case", "X86", "::", "VCVTUSI642SSZrm", ":", "case", "X86", "::", "VCVTUSI642SSZrr_Int", ":", "case", "X86", "::", "VCVTUSI642SSZrrb_Int", ":", "case", "X86", "::", "VCVTUSI642SSZrm_Int", ":", "case", "X86", "::", "VCVTUSI2SDZrr", ":", "case", "X86", "::", "VCVTUSI2SDZrm", ":", "case", "X86", "::", "VCVTUSI2SDZrr_Int", ":", "case", "X86", "::", "VCVTUSI2SDZrm_Int", ":", "case", "X86", "::", "VCVTUSI642SDZrr", ":", "case", "X86", "::", "VCVTUSI642SDZrm", ":", "case", "X86", "::", "VCVTUSI642SDZrr_Int", ":", "case", "X86", "::", "VCVTUSI642SDZrrb_Int", ":", "case", "X86", "::", "VCVTUSI642SDZrm_Int", ":", "return", "!", "ForLoadFold", ";", "case", "X86", "::", "VCVTSD2SSrr", ":", "case", "X86", "::", "VCVTSD2SSrm", ":", "case", "X86", "::", "VCVTSD2SSrr_Int", ":", "case", "X86", "::", "VCVTSD2SSrm_Int", ":", "case", "X86", "::", "VCVTSS2SDrr", ":", "case", "X86", "::", "VCVTSS2SDrm", ":", "case", "X86", "::", "VCVTSS2SDrr_Int", ":", "case", "X86", "::", "VCVTSS2SDrm_Int", ":", "case", "X86", "::", "VRCPSSr", ":", "case", "X86", "::", "VRCPSSr_Int", ":", "case", "X86", "::", "VRCPSSm", ":", "case", "X86", "::", "VRCPSSm_Int", ":", "case", "X86", "::", "VROUNDSDr", ":", "case", "X86", "::", "VROUNDSDm", ":", "case", "X86", "::", "VROUNDSDr_Int", ":", "case", "X86", "::", "VROUNDSDm_Int", ":", "case", "X86", "::", "VROUNDSSr", ":", "case", "X86", "::", "VROUNDSSm", ":", "case", "X86", "::", "VROUNDSSr_Int", ":", "case", "X86", "::", "VROUNDSSm_Int", ":", "case", "X86", "::", "VRSQRTSSr", ":", "case", "X86", "::", "VRSQRTSSr_Int", ":", "case", "X86", "::", "VRSQRTSSm", ":", "case", "X86", "::", "VRSQRTSSm_Int", ":", "case", "X86", "::", "VSQRTSSr", ":", "case", "X86", "::", "VSQRTSSr_Int", ":", "case", "X86", "::", "VSQRTSSm", ":", "case", "X86", "::", "VSQRTSSm_Int", ":", "case", "X86", "::", "VSQRTSDr", ":", "case", "X86", "::", "VSQRTSDr_Int", ":", "case", "X86", "::", "VSQRTSDm", ":", "case", "X86", "::", "VSQRTSDm_Int", ":", "case", "X86", "::", "VCVTSD2SSZrr", ":", "case", "X86", "::", "VCVTSD2SSZrr_Int", ":", "case", "X86", "::", "VCVTSD2SSZrrb_Int", ":", "case", "X86", "::", "VCVTSD2SSZrm", ":", "case", "X86", "::", "VCVTSD2SSZrm_Int", ":", "case", "X86", "::", "VCVTSS2SDZrr", ":", "case", "X86", "::", "VCVTSS2SDZrr_Int", ":", "case", "X86", "::", "VCVTSS2SDZrrb_Int", ":", "case", "X86", "::", "VCVTSS2SDZrm", ":", "case", "X86", "::", "VCVTSS2SDZrm_Int", ":", "case", "X86", "::", "VGETEXPSDZr", ":", "case", "X86", "::", "VGETEXPSDZrb", ":", "case", "X86", "::", "VGETEXPSDZm", ":", "case", "X86", "::", "VGETEXPSSZr", ":", "case", "X86", "::", "VGETEXPSSZrb", ":", "case", "X86", "::", "VGETEXPSSZm", ":", "case", "X86", "::", "VGETMANTSDZrri", ":", "case", "X86", "::", "VGETMANTSDZrrib", ":", "case", "X86", "::", "VGETMANTSDZrmi", ":", "case", "X86", "::", "VGETMANTSSZrri", ":", "case", "X86", "::", "VGETMANTSSZrrib", ":", "case", "X86", "::", "VGETMANTSSZrmi", ":", "case", "X86", "::", "VRNDSCALESDZr", ":", "case", "X86", "::", "VRNDSCALESDZr_Int", ":", "case", "X86", "::", "VRNDSCALESDZrb_Int", ":", "case", "X86", "::", "VRNDSCALESDZm", ":", "case", "X86", "::", "VRNDSCALESDZm_Int", ":", "case", "X86", "::", "VRNDSCALESSZr", ":", "case", "X86", "::", "VRNDSCALESSZr_Int", ":", "case", "X86", "::", "VRNDSCALESSZrb_Int", ":", "case", "X86", "::", "VRNDSCALESSZm", ":", "case", "X86", "::", "VRNDSCALESSZm_Int", ":", "case", "X86", "::", "VRCP14SDZrr", ":", "case", "X86", "::", "VRCP14SDZrm", ":", "case", "X86", "::", "VRCP14SSZrr", ":", "case", "X86", "::", "VRCP14SSZrm", ":", "case", "X86", "::", "VRCP28SDZr", ":", "case", "X86", "::", "VRCP28SDZrb", ":", "case", "X86", "::", "VRCP28SDZm", ":", "case", "X86", "::", "VRCP28SSZr", ":", "case", "X86", "::", "VRCP28SSZrb", ":", "case", "X86", "::", "VRCP28SSZm", ":", "case", "X86", "::", "VREDUCESSZrmi", ":", "case", "X86", "::", "VREDUCESSZrri", ":", "case", "X86", "::", "VREDUCESSZrrib", ":", "case", "X86", "::", "VRSQRT14SDZrr", ":", "case", "X86", "::", "VRSQRT14SDZrm", ":", "case", "X86", "::", "VRSQRT14SSZrr", ":", "case", "X86", "::", "VRSQRT14SSZrm", ":", "case", "X86", "::", "VRSQRT28SDZr", ":", "case", "X86", "::", "VRSQRT28SDZrb", ":", "case", "X86", "::", "VRSQRT28SDZm", ":", "case", "X86", "::", "VRSQRT28SSZr", ":", "case", "X86", "::", "VRSQRT28SSZrb", ":", "case", "X86", "::", "VRSQRT28SSZm", ":", "case", "X86", "::", "VSQRTSSZr", ":", "case", "X86", "::", "VSQRTSSZr_Int", ":", "case", "X86", "::", "VSQRTSSZrb_Int", ":", "case", "X86", "::", "VSQRTSSZm", ":", "case", "X86", "::", "VSQRTSSZm_Int", ":", "case", "X86", "::", "VSQRTSDZr", ":", "case", "X86", "::", "VSQRTSDZr_Int", ":", "case", "X86", "::", "VSQRTSDZrb_Int", ":", "case", "X86", "::", "VSQRTSDZm", ":", "case", "X86", "::", "VSQRTSDZm_Int", ":", "return", "true", ";" ]

[ "}" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Matching: ", "<STR_LIT>", "<<", "R", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "unsigned", "MatchingType", "=", "getMatchingLoType", "(", "R", ")", ";", "assert", "(", "MatchingType", "!=", "ELF", "::", "R_MIPS_NONE", "&&", "<STR_LIT>", "Wrong list for reloc that doesn't need a match", "<STR_LIT>", ")", ";", "auto", "InsertionPoint", "=", "find_best", "(", "Sorted", ".", "begin", "(", ")", ",", "Sorted", ".", "end", "(", ")", ",", "[", "&", "R", ",", "&", "MatchingType", "]", "(", "const", "MipsRelocationEntry", "&", "X", ")", "{", "return", "isMatchingReloc", "(", "X", ",", "R", ",", "MatchingType", ")", ";", "}", ",", "compareMatchingRelocs", ")", ";", "if", "(", "InsertionPoint", "!=", "Sorted", ".", "end", "(", ")", ")", "InsertionPoint", "->", "Matched", "=", "true", ";", "Sorted", ".", "insert", "(", "InsertionPoint", ",", "R", ")", "->", "Matched", "=", "true", ";" ]

[ "}" ]

[ "def", "SwitchSet", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "SwitchSetAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "i32imm", ":", "$", "sw", ")", ";" ]

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

[ "MipsPtrClass", "PtrClassKind", "=", "static_cast", "<", "MipsPtrClass", ">", "(", "Kind", ")", ";", "switch", "(", "PtrClassKind", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "&", "Mips", "::", "GPRMM16RegClass", ";" ]

[ "}" ]

[ "bool", "isCPU", "(", ")", "const", "{", "return", "AccessTypes", "&", "(", "AccessType", "::", "GPR", "|", "AccessType", "::", "PPR", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cmplt_epu16_mask", "(", "_", "_", "m128i", "_", "_", "X", ",", "_", "_", "m128i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_ucmpw128_mask", "(", "(", "_", "_", "v8hi", ")", "_", "_", "X", ",", "(", "_", "_", "v8hi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "void", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "raw_ostream", "&", "OS", ")", "const", "{", "if", "(", "IsLittleEndian", "&&", "Size", "==", "<NUM_LIT>", "&&", "IsMicroMips", ")", "{", "EmitInstruction", "(", "Val", ">>", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "OS", ")", ";", "EmitInstruction", "(", "Val", ",", "<NUM_LIT>", ",", "OS", ")", ";", "}", "else", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "<NUM_LIT>", ":", "(", "Size", "-", "<NUM_LIT>", "-", "i", ")", "*", "<NUM_LIT>", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "<NUM_LIT>", ",", "OS", ")", ";", "}", "}", "}" ]

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

[ "=", "decl", ";" ]

[ "int", "avr_progmem_p", "(", "tree", "decl", ",", "tree", "attributes", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "<NUM_LIT>", ";", "if", "(", "avr_decl_memx_p", "(", "decl", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "avr_decl_flash_p", "(", "decl", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "<STR_LIT>", "progmem", "<STR_LIT>", ",", "attributes", ")", ")", "return", "-", "<NUM_LIT>", ";", "tree", "a" ]

[ "void", "XNCMRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "llvm_unreachable", "(", "<NUM_LIT>", ")", ";", "}" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "void", "PPCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "SavedRegs", ".", "reset", "(", "PPC", "::", "VSRp26", ")", ";", "SavedRegs", ".", "reset", "(", "PPC", "::", "VSRp27", ")", ";", "SavedRegs", ".", "reset", "(", "PPC", "::", "VSRp28", ")", ";", "SavedRegs", ".", "reset", "(", "PPC", "::", "VSRp29", ")", ";", "SavedRegs", ".", "reset", "(", "PPC", "::", "VSRp30", ")", ";", "SavedRegs", ".", "reset", "(", "PPC", "::", "VSRp31", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "FI", "->", "setMustSaveLR", "(", "MustSaveLR", "(", "MF", ",", "LR", ")", ")", ";", "SavedRegs", ".", "reset", "(", "LR", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "const", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "FPSI", "&&", "needsFP", "(", "MF", ")", ")", "{", "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "MFI", ".", "CreateFixedObject", "(", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "if", "(", "needsFP", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "isPPC64", "?", "PPC", "::", "X31", ":", "PPC", "::", "R31", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "RegInfo", "->", "getBaseRegister", "(", "MF", ")", ")", ";", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "SavedRegs", ".", "reset", "(", "PPC", "::", "R30", ")", ";", "int", "TCSPDelta", "=", "<NUM_LIT>", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "<NUM_LIT>", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "<NUM_LIT>", "*", "TCSPDelta", ",", "TCSPDelta", ",", "true", ")", ";", "}", "if", "(", "(", "SavedRegs", ".", "test", "(", "PPC", "::", "CR2", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR3", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR4", ")", ")", ")", "{", "const", "uint64_t", "SpillSize", "=", "<NUM_LIT>", ";", "const", "int64_t", "SpillOffset", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "<NUM_LIT>", ":", "Subtarget", ".", "isAIXABI", "(", ")", "?", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ";", "int", "FrameIdx", "=", "MFI", ".", "CreateFixedObject", "(", "SpillSize", ",", "SpillOffset", ",", "true", ",", "false", ")", ";", "FI", "->", "setCRSpillFrameIndex", "(", "FrameIdx", ")", ";", "}", "}" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

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

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

[ "<NUM_LIT>", ";" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=" ]

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

[ "int", "pdp11_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "get_frame_size", "(", ")", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "return", "pdp11_reg_save_size", "(", ")", "+", "<NUM_LIT>", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "pdp11_reg_save_size", "(" ]

[ "CR_TAB", "<STR_LIT>", "lsl %0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "lsl %0", "<STR_LIT>", ")", ";" ]

[ "*", "len", "=", "<NUM_LIT>", ";", "return", "<STR_LIT>", "clr %0", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "*", "len", "=", "<NUM_LIT>", ";", "return", "<STR_LIT>", "lsl %0", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "*", "len", "=", "<NUM_LIT>", ";", "return", "(", "<STR_LIT>", "lsl %0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "lsl %0", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "*", "len", "=", "<NUM_LIT>", ";", "return", "(", "<STR_LIT>", "lsl %0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "lsl %0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "lsl %0", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "*", "len", "=", "<NUM_LIT>", ";", "return", "(", "<STR_LIT>", "swap %0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "andi %0,0xf0", "<STR_LIT>", ")", ";", "}", "*", "len", "=", "<NUM_LIT>", ";", "return", "(", "<STR_LIT>", "lsl %0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "lsl %0", "<STR_LIT>" ]

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

[ "if", "(", "opts", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "%s\\n\\n", "<STR_LIT>", ",", "opts", ")", ";", "free", "(", "opts", ")", ";", "}", "else", "fputs", "(", "<STR_LIT>", "<no options>\\n\\n", "<STR_LIT>" ]

[ "void", "MOSInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "{", "std", "::", "string", "AiryOperands", ";", "raw_string_ostream", "AiryOperandStream", "(", "AiryOperands", ")", ";", "auto", "MnemonicInfo", "=", "getMnemonic", "(", "MI", ")", ";", "assert", "(", "MnemonicInfo", ".", "second", "&&", "<STR_LIT>", "Missing opcode for instruction.", "<STR_LIT>", ")", ";", "printInstruction", "(", "MI", ",", "Address", ",", "AiryOperandStream", ")", ";", "AiryOperands", "=", "AiryOperandStream", ".", "str", "(", ")", ";", "size_t", "SpacesSeen", "=", "<NUM_LIT>", ";", "std", "::", "string", "CorrectOperands", ";", "for", "(", "const", "auto", "&", "Letter", ":", "AiryOperands", ")", "{", "if", "(", "isspace", "(", "Letter", ")", "!=", "<NUM_LIT>", ")", "{", "if", "(", "++", "SpacesSeen", "<=", "<NUM_LIT>", ")", "{", "CorrectOperands", "+=", "'", "\\t", "'", ";", "}", "continue", ";", "}", "CorrectOperands", "+=", "Letter", ";", "}", "OS", "<<", "CorrectOperands", ";", "}" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "let", "ParserMatchClass", "=", "!", "cast", "<", "AsmOperandClass", ">", "(", "<STR_LIT>", "#", "OFFSET", "#", "<STR_LIT>", ")", ";" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", "#", "OFFSET", ";", "let", "DecoderMethod", "=", "<STR_LIT>", "#", "OFFSET", ";" ]

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

[ "def", "A4_vrmaxuh", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rxx32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rxx32in", ",", "DoubleRegs", ":", "$", "Rss32", ",", "IntRegs", ":", "$", "Ru32", ")", ",", "<STR_LIT>", ",", "tc_5b54b33f", ",", "TypeS_3op", ">", ",", "Enc_412ff0", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "for", "(", "int", "i", "=", "SndHalfBegin", ",", "e", "=", "SndHalfBegin", "+", "HalfSize", ";", "i", "!=", "e", ";", "++", "i", ")", "ShuffleMask", ".", "push_back", "(", "i", ")", ";" ]

[ "if", "(", "Imm", "&", "<NUM_LIT>", ")", "return", ";", "unsigned", "HalfSize", "=", "VT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ";", "unsigned", "FstHalfBegin", "=", "(", "Imm", "&", "<NUM_LIT>", ")", "*", "HalfSize", ";", "unsigned", "SndHalfBegin", "=", "(", "(", "Imm", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "HalfSize", ";", "for", "(", "int", "i", "=", "FstHalfBegin", ",", "e", "=", "FstHalfBegin", "+", "HalfSize", ";", "i", "!=", "e", ";", "++", "i", ")", "ShuffleMask", ".", "push_back", "(", "i", ")", ";" ]

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

[ "def", "L2_ploadrubtnew_pi", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "IntRegs", ":", "$", "Rx32in", ",", "s4_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_e9f3243f", ",", "TypeLD", ">", ",", "Enc_f4413a", ",", "PredNewRel", "{", "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", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "void", "setVarArgsFrameIndex", "(", "int", "Index", ")", "{", "VarArgsFrameIndex", "=", "Index" ]

[ "ParsedOp", ".", "getToken", "(", ")", "==", "OOp", ".", "Name", ")", ")", "return", "true", ";" ]

[ "const", "AMDGPUOperand", "&", "ParsedOp", "=", "(", "(", "const", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "i", "]", ")", ";", "if", "(", "(", "ParsedOp", ".", "isImm", "(", ")", "&&", "ParsedOp", ".", "getImmTy", "(", ")", "==", "OOp", ".", "Type", ")", "||", "(", "ParsedOp", ".", "isToken", "(", ")", "&&" ]

[ "return", "<STR_LIT>" ]

[ "<STR_LIT>", "{", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "CONST_INT", "&", "&", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "<NUM_LIT>", ")", "return", "<STR_LIT>", "else", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "CONST_INT", "&", "&", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ">", "=", "<NUM_LIT>", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "<NUM_LIT>", "-", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "(", "BUFFER_LOAD_FORMAT_D16", ")", "NODE_NAME_CASE", "(", "SBUFFER_LOAD", ")", "NODE_NAME_CASE", "(", "BUFFER_STORE", ")", "NODE_NAME_CASE", "(", "BUFFER_STORE_BYTE", ")", "NODE_NAME_CASE", "(", "BUFFER_STORE_SHORT", ")", "NODE_NAME_CASE", "(", "BUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "BUFFER_STORE_FORMAT_D16", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_SWAP", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_ADD", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_SUB", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_SMIN", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_UMIN", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_SMAX", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_UMAX", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_AND", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_OR", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_XOR", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_CMPSWAP", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_FADD", ")", "NODE_NAME_CASE", "(", "BUFFER_ATOMIC_PK_FADD", ")", "NODE_NAME_CASE", "(", "ATOMIC_FADD", ")", "NODE_NAME_CASE", "(", "ATOMIC_PK_FADD", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";" ]

[ "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "IF", ")", "NODE_NAME_CASE", "(", "ELSE", ")", "NODE_NAME_CASE", "(", "LOOP", ")", "NODE_NAME_CASE", "(", "CALL", ")", "NODE_NAME_CASE", "(", "TC_RETURN", ")", "NODE_NAME_CASE", "(", "TRAP", ")", "NODE_NAME_CASE", "(", "RET_FLAG", ")", "NODE_NAME_CASE", "(", "RETURN_TO_EPILOG", ")", "NODE_NAME_CASE", "(", "ENDPGM", ")", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "SETCC", ")", "NODE_NAME_CASE", "(", "SETREG", ")", "NODE_NAME_CASE", "(", "FMA_W_CHAIN", ")", "NODE_NAME_CASE", "(", "FMUL_W_CHAIN", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "FDOT2", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "FMAD_FTZ", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RCP_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RCP_IFLAG", ")", "NODE_NAME_CASE", "(", "FMUL_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "FFBH_I32", ")", "NODE_NAME_CASE", "(", "FFBL_B32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MULHI_U24", ")", "NODE_NAME_CASE", "(", "MULHI_I24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_U24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "MAD_I64_I32", ")", "NODE_NAME_CASE", "(", "MAD_U64_U32", ")", "NODE_NAME_CASE", "(", "PERM", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "EXPORT_DONE", ")", "NODE_NAME_CASE", "(", "R600_EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "CVT_PKRTZ_F16_F32", ")", "NODE_NAME_CASE", "(", "CVT_PKNORM_I16_F32", ")", "NODE_NAME_CASE", "(", "CVT_PKNORM_U16_F32", ")", "NODE_NAME_CASE", "(", "CVT_PK_I16_I32", ")", "NODE_NAME_CASE", "(", "CVT_PK_U16_U32", ")", "NODE_NAME_CASE", "(", "FP_TO_FP16", ")", "NODE_NAME_CASE", "(", "FP16_ZEXT", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "PC_ADD_REL_OFFSET", ")", "NODE_NAME_CASE", "(", "LDS", ")", "NODE_NAME_CASE", "(", "KILL", ")", "NODE_NAME_CASE", "(", "DUMMY_CHAIN", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "NODE_NAME_CASE", "(", "INIT_EXEC", ")", "NODE_NAME_CASE", "(", "INIT_EXEC_FROM_INPUT", ")", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "SENDMSGHALT", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "INTERP_P1LL_F16", ")", "NODE_NAME_CASE", "(", "INTERP_P1LV_F16", ")", "NODE_NAME_CASE", "(", "INTERP_P2_F16", ")", "NODE_NAME_CASE", "(", "LOAD_D16_HI", ")", "NODE_NAME_CASE", "(", "LOAD_D16_LO", ")", "NODE_NAME_CASE", "(", "LOAD_D16_HI_I8", ")", "NODE_NAME_CASE", "(", "LOAD_D16_HI_U8", ")", "NODE_NAME_CASE", "(", "LOAD_D16_LO_I8", ")", "NODE_NAME_CASE", "(", "LOAD_D16_LO_U8", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT_D16", ")", "NODE_NAME_CASE", "(", "TBUFFER_LOAD_FORMAT", ")", "NODE_NAME_CASE", "(", "TBUFFER_LOAD_FORMAT_D16", ")", "NODE_NAME_CASE", "(", "DS_ORDERED_COUNT", ")", "NODE_NAME_CASE", "(", "ATOMIC_CMP_SWAP", ")", "NODE_NAME_CASE", "(", "ATOMIC_INC", ")", "NODE_NAME_CASE", "(", "ATOMIC_DEC", ")", "NODE_NAME_CASE", "(", "ATOMIC_LOAD_FMIN", ")", "NODE_NAME_CASE", "(", "ATOMIC_LOAD_FMAX", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_UBYTE", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_USHORT", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_BYTE", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_SHORT", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_FORMAT", ")", "NODE_NAME_CASE" ]

[ "if", "(", "!", "thisBlockISELs", ".", "empty", "(", ")", ")", "ISELInstructions", ".", "insert", "(", "std", "::", "make_pair", "(", "MBB", ".", "getNumber", "(", ")", ",", "thisBlockISELs", ")", ")", ";" ]

[ "BlockISELList", "thisBlockISELs", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "if", "(", "isISEL", "(", "MI", ")", ")", "thisBlockISELs", ".", "push_back", "(", "&", "MI", ")", ";" ]

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

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

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "A", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "horizontalReduction", "=", "<NUM_LIT>", ";", "let", "validForTailPredication", "=", "<NUM_LIT>", ";" ]

[ "VHALF", ">" ]

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

[ "<FIXS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "[", "(", "clobber", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "reg", ":", "CCS", "<NUM_LIT>", ")", "(", "compare", ":", "CCS", "(", "mem", ":", "BLK", "(", "subreg", ":", "DI", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "mem", ":", "BLK", "(", "subreg", ":", "DI", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", ")", ")", "]", "<FIXE>", "<FIXS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "[", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "reg", ":", "CCS", "<NUM_LIT>", ")", "(", "compare", ":", "CCS", "(", "mem", ":", "BLK", "(", "subreg", ":", "SI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "mem", ":", "BLK", "(", "subreg", ":", "SI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", ")", ")", "]", "<FIXE>", "<FIXS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "reg", ":", "CCS", "<NUM_LIT>", ")", "(", "compare", ":", "CCS", "(", "mem", ":", "BLK", "(", "subreg", ":", "DI", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "mem", ":", "BLK", "(", "subreg", ":", "DI", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "subreg", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "subreg", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "subreg", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "subreg", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "reg", ":", "CCS", "<NUM_LIT>", ")", "(", "compare", ":", "CCS", "(", "mem", ":", "BLK", "(", "subreg", ":", "SI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "mem", ":", "BLK", "(", "subreg", ":", "SI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "subreg", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "subreg", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "subreg", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "subreg", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>" ]

[ "<FIXS>", "{", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "op1", "!=", "const0_rtx", "||", "code", "==", "GTU", "||", "code", "==", "GEU", ")", "<FIXE>" ]

[ "else", "{", "if", "(", "code", "!=", "EQ", "||", "mode", "==", "DImode", ")", "<BUGS>", "{", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "op1", "!=", "const0_rtx", "||", "code", "==", "GTU", "||", "code", "==", "GEU", ")", "<BUGE>", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "}", "}" ]

[ ",", "_", "_", "c", ",", "_", "_", "p", ")", ";" ]

[ "return", "_", "_", "builtin_mve_vmlasq_m_n_sv16qi", "(", "_", "_", "a", ",", "_", "_", "b" ]

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

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

[ "}" ]

[ "}", "break", ";", "case", "ZERO_EXTRACT", ":", "{", "rtx", "dest", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "addr", "=", "XEXP", "(", "dest", ",", "<NUM_LIT>", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "CONST_INT", ":", "*", "total", "+=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "*", "total", "+=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "break", ";", "default", ":", "*", "total", "+=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "break", ";", "}", "return", "true", ";", "}", "break", ";", "default", ":", "if", "(", "TARGET_A16", "&&", "mode", "==", "SImode", ")", "*", "total", "+=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "break", ";", "}", "return", "false", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "m128d", "_", "_", "lsx_vfrint_d", "(", "_", "_", "m128d", "_", "<NUM_LIT>", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_lsx_vfrint_d", "(", "(", "v2f64", ")", "_", "<NUM_LIT>", ")", ";" ]

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

[ "}", "}", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "-", "GPRCS1Size", ")", ";", "movePastCSLoadStoreOps", "(", "MBB", ",", "MBBI", ",", "ARM", "::", "STR", ",", "ARM", "::", "t2STRi12", ",", "<NUM_LIT>", ",", "STI", ")", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "||", "hasFP", "(", "MF", ")", ")", "{", "unsigned", "ADDriOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "ADDri", ":", "ARM", "::", "t2ADDri", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDriOpc", ")", ",", "FramePtr", ")", ".", "addFrameIndex", "(", "FramePtrSpillFI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "AddDefaultCC", "(", "AddDefaultPred", "(", "MIB", ")", ")", ";", "}", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "-", "GPRCS2Size", ")", ";", "movePastCSLoadStoreOps", "(", "MBB", ",", "MBBI", ",", "ARM", "::", "STR", ",", "ARM", "::", "t2STRi12", ",", "<NUM_LIT>", ",", "STI", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "-", "DPRCSSize", ")", ";", "unsigned", "DPRCSOffset", "=", "NumBytes", "-", "(", "GPRCS1Size", "+", "GPRCS2Size", "+", "DPRCSSize", ")", ";", "unsigned", "GPRCS2Offset", "=", "DPRCSOffset", "+", "DPRCSSize", ";", "unsigned", "GPRCS1Offset", "=", "GPRCS2Offset", "+", "GPRCS2Size", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "||", "hasFP", "(", "MF", ")", ")", "AFI", "->", "setFramePtrSpillOffset", "(", "MFI", "->", "getObjectOffset", "(", "FramePtrSpillFI", ")", "+", "NumBytes", ")", ";", "AFI", "->", "setGPRCalleeSavedArea1Offset", "(", "GPRCS1Offset", ")", ";", "AFI", "->", "setGPRCalleeSavedArea2Offset", "(", "GPRCS2Offset", ")", ";", "AFI", "->", "setDPRCalleeSavedAreaOffset", "(", "DPRCSOffset", ")", ";", "movePastCSLoadStoreOps", "(", "MBB", ",", "MBBI", ",", "ARM", "::", "VSTRD", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "STI", ")", ";", "NumBytes", "=", "DPRCSOffset", ";", "if", "(", "NumBytes", ")", "{", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "-", "NumBytes", ")", ";", "}", "if", "(", "STI", ".", "isTargetELF", "(", ")", "&&", "hasFP", "(", "MF", ")", ")", "{", "MFI", "->", "setOffsetAdjustment", "(", "MFI", "->", "getOffsetAdjustment", "(", ")", "-", "AFI", "->", "getFramePtrSpillOffset", "(", ")", ")", ";", "}", "AFI", "->", "setGPRCalleeSavedArea1Size", "(", "GPRCS1Size", ")", ";", "AFI", "->", "setGPRCalleeSavedArea2Size", "(", "GPRCS2Size", ")", ";", "AFI", "->", "setDPRCalleeSavedAreaSize", "(", "DPRCSSize", ")", ";", "if", "(", "needsStackRealignment", "(" ]

[ "<NUM_LIT>", "}", ",", "asm", ",", "ZPR64", ">", ";" ]

[ "def", "_D", ":", "sve_int_un_pred_arit", "<", "<NUM_LIT>", ",", "{", "opc", "," ]

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

[ "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_INDEXED", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "i", "'", ";", "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_OFFSET", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "o", "'", ";", "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_PRE_INCDEC", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "+", "'", ";", "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_PRE_MODIFY", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=", "'", "+", "'", ";", "else", "if", "(", "keep_spaces", ")", "*", "p", "++", "=", "'", "'", ";", "if", "(", "(", "mask", "&", "RELOAD_REG_AND_M16", ")", "!=", "<NUM_LIT>", ")", "*", "p", "++", "=" ]

[ "NewMask", ".", "append", "(", "NumElts", ",", "-", "<NUM_LIT>", ")", ";" ]

[ "assert", "(", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", "||", "VT", ".", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", ")", "&&", "<STR_LIT>", "VPERM* family of shuffles requires 32-bit or 64-bit elements", "<STR_LIT>", ")", ";", "if", "(", "!", "N0", ".", "hasOneUse", "(", ")", "||", "!", "N1", ".", "hasOneUse", "(", ")", "||", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_SUBVECTOR", "||", "N1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_SUBVECTOR", "||", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", "!=", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "WideVec", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MVT", "WideVT", "=", "WideVec", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "!", "WideVT", ".", "is256BitVector", "(", ")", "||", "!", "isa", "<", "ConstantSDNode", ">", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "||", "!", "isa", "<", "ConstantSDNode", ">", "(", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "NewMask", "(", "Mask", ".", "begin", "(", ")", ",", "Mask", ".", "end", "(", ")", ")", ";", "const", "APInt", "&", "ExtIndex0", "=", "N0", ".", "getConstantOperandAPInt", "(", "<NUM_LIT>", ")", ";", "const", "APInt", "&", "ExtIndex1", "=", "N1", ".", "getConstantOperandAPInt", "(", "<NUM_LIT>", ")", ";", "if", "(", "ExtIndex1", "==", "<NUM_LIT>", "&&", "ExtIndex0", "==", "NumElts", ")", "ShuffleVectorSDNode", "::", "commuteMask", "(", "NewMask", ")", ";", "else", "if", "(", "ExtIndex0", "!=", "<NUM_LIT>", "||", "ExtIndex1", "!=", "NumElts", ")", "return", "SDValue", "(", ")", ";", "if", "(", "NumElts", "==", "<NUM_LIT>", "&&", "(", "isSingleSHUFPSMask", "(", "NewMask", ")", "||", "is128BitUnpackShuffleMask", "(", "NewMask", ")", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "}" ]

[ "if", "(", "TARGET_64BIT", ")", "return", "copy_to_reg", "(", "virtual_incoming_args_rtx", ")", ";", "else", "return", "virtual_incoming_args_rtx", ";" ]

[ "int", "ARMAsmParser", "::", "tryParseRegister", "(", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "-", "<NUM_LIT>", ";", "std", "::", "string", "upperCase", "=", "Tok", ".", "getString", "(", ")", ".", "str", "(", ")", ";", "std", "::", "string", "lowerCase", "=", "LowercaseString", "(", "upperCase", ")", ";", "unsigned", "RegNum", "=", "MatchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "!", "RegNum", ")", "{", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "<STR_LIT>", "r13", "<STR_LIT>", ",", "ARM", "::", "SP", ")", ".", "Case", "(", "<STR_LIT>", "r14", "<STR_LIT>", ",", "ARM", "::", "LR", ")", ".", "Case", "(", "<STR_LIT>", "r15", "<STR_LIT>", ",", "ARM", "::", "PC", ")", ".", "Case", "(", "<STR_LIT>", "ip", "<STR_LIT>", ",", "ARM", "::", "R12", ")", ".", "Default", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "!", "RegNum", ")", "return", "-", "<NUM_LIT>", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "{", "SMLoc", "SIdx", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "const", "MCExpr", "*", "ImmVal", ";", "if", "(", "getParser", "(", ")", ".", "ParseExpression", "(", "ImmVal", ")", ")", "return", "MatchOperand_ParseFail", ";", "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "ImmVal", ")", ";", "if", "(", "!", "MCE", ")", "{", "TokError", "(", "<STR_LIT>", "immediate value expected for vector index", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "SMLoc", "E", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RBrac", ")", ")", "{", "Error", "(", "E", ",", "<STR_LIT>", "']' expected", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateVectorIndex", "(", "MCE", "->", "getValue", "(", ")", ",", "SIdx", ",", "E", ",", "getContext", "(", ")", ")", ")", ";", "}", "return", "RegNum", ";", "}" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "}" ]

[ "class", "nImmVINVIReplicate", "<", "ValueType", "From", ",", "ValueType", "To", ">", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "nImmVINVIAsmOperandReplicate", "<", "From", ",", "To", ">", ";" ]

[ "return", "LowerLabelRef", "(", "CPIHi", ",", "CPILo", ",", "IsPIC", ",", "DAG", ")", ";" ]

[ "if", "(", "IsPIC", "&&", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "SDValue", "GA", "=", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "CP", "->", "getAlignment", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "getTOCEntry", "(", "DAG", ",", "SDLoc", "(", "CP", ")", ",", "GA", ")", ";", "}", "SDValue", "CPIHi", "=", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "CP", "->", "getAlignment", "(", ")", ",", "<NUM_LIT>", ",", "MOHiFlag", ")", ";", "SDValue", "CPILo", "=", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "PtrVT", ",", "CP", "->", "getAlignment", "(", ")", ",", "<NUM_LIT>", ",", "MOLoFlag", ")", ";" ]

[ "}" ]

[ "static", "DecodeStatus", "decodeU16ImmOperand", "(", "MCInst", "&", "Inst", ",", "uint64_t", "Imm", ",", "uint64_t", "Address", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "return", "decodeUImmOperand", "<", "<NUM_LIT>", ">", "(", "Inst", ",", "Imm", ")", ";" ]

[ "static", "int", "sh_issue_rate", "(", "void", ")", "{", "if", "(", "TARGET_SUPERSCALAR", ")", "return", "<NUM_LIT>", ";", "else", "return", "<NUM_LIT>", ";", "}" ]

[ "This", "function", "returns", "``", "2", "''", "to", "indicate", "dual", "issue", "for", "the", "SH4", "processor", ".", "To", "be", "used", "by", "the", "DFA", "pipeline", "description", "." ]

[ "CC_NO_OVERFLOW", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "rcond", "(", "cc0", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "pc", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "{", "return", "(", "cc_prev_status", ".", "flags", "&" ]

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

[ "def", "D16", ":", "NamedOperandBit", "<", "<STR_LIT>", ",", "NamedMatchClass", "<", "<STR_LIT>" ]

[ "static", "int", "visium_issue_rate", "(", "void", ")", "{", "switch", "(", "visium_cpu", ")", "{", "case", "PROCESSOR_GR5", ":", "return", "<NUM_LIT>", ";", "case", "PROCESSOR_GR6", ":", "return", "<NUM_LIT>", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}" ]

[ "Return", "the", "number", "of", "instructions", "that", "can", "issue", "on", "the", "same", "cycle", "." ]

[ "}" ]

[ "def", "F2_conv_w2sf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op", ">", ",", "Enc_5e2823", "{", "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>", ";", "let", "Uses", "=", "[", "USR", "]", ";" ]

[ "i32", ",", "SplatValueB", ")", ";" ]

[ "SDLoc", "DL", "(", "SplatValue", ")", ";", "if", "(", "VecTy", "==", "MVT", "::", "v2i64", ")", "{", "ViaVecTy", "=", "MVT", "::", "v4i32", ";", "SplatValueA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i32", ",", "SplatValue", ")", ";", "SplatValueB", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i64", ",", "SplatValue", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SplatValueB", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::" ]

[ "MCSymbol", "*", "MILabel", "=", "Ctx", ".", "createTempSymbol", "(", ")", ";" ]

[ "CallTargetMCOp", "=", "MCIL", ".", "LowerSymbolOperand", "(", "CallTarget", ",", "MCIL", ".", "GetSymbolFromOperand", "(", "CallTarget", ")", ")", ";", "CallOpcode", "=", "X86", "::", "CALL64pcrel32", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "CallTargetMCOp", "=", "MCOperand", "::", "createImm", "(", "CallTarget", ".", "getImm", "(", ")", ")", ";", "CallOpcode", "=", "X86", "::", "CALL64pcrel32", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "Subtarget", "->", "useRetpolineIndirectCalls", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Lowering register statepoints with retpoline not ", "<STR_LIT>", "<STR_LIT>", "yet implemented.", "<STR_LIT>", ")", ";", "CallTargetMCOp", "=", "MCOperand", "::", "createReg", "(", "CallTarget", ".", "getReg", "(", ")", ")", ";", "CallOpcode", "=", "X86", "::", "CALL64r", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported operand type in statepoint call target", "<STR_LIT>", ")", ";", "break", ";", "}", "MCInst", "CallInst", ";", "CallInst", ".", "setOpcode", "(", "CallOpcode", ")", ";", "CallInst", ".", "addOperand", "(", "CallTargetMCOp", ")", ";", "OutStreamer", "->", "emitInstruction", "(", "CallInst", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "auto", "&", "Ctx", "=", "OutStreamer", "->", "getContext", "(", ")", ";" ]

[ "<FIXS>", "Requires", "[", "HasVFP2", ",", "HasDPVFP", ",", "UseFPVMLx", "]", ">", ",", "<FIXE>" ]

[ "[", "(", "set", "DPR", ":", "$", "Dd", ",", "(", "fadd_mlx", "(", "fmul_su", "DPR", ":", "$", "Dn", ",", "DPR", ":", "$", "Dm", ")", ",", "(", "f64", "DPR", ":", "$", "Ddin", ")", ")", ")", "]", ">", ",", "RegConstraint", "<STR_LIT>", ">", ",", "<BUGS>", "Requires", "[", "HasVFP2", ",", "HasDPVFP", ",", "UseFPVMLx", ",", "DontUseFusedMAC", "]", ">", ",", "<BUGE>", "Sched", "[", "WriteFPMAC64", ",", "ReadFPMAC", ",", "ReadFPMUL", ",", "ReadFPMUL", "]", ">", ";", "def", "VMLAS", ":", "ASbIn", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "static", "bool", "aarch64_pass_by_reference", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "if", "(", "!", "arg", ".", "type", ")", "return", "aarch64_pass_by_reference_1", "(", "pcum", ",", "arg", ")", ";", "pure_scalable_type_info", "pst_info", ";", "switch", "(", "pst_info", ".", "analyze", "(", "arg", ".", "type", ")", ")", "{", "case", "pure_scalable_type_info", "::", "IS_PST", ":", "if", "(", "pcum", "&&", "!", "pcum", "->", "silent_p", "&&", "!", "TARGET_SVE", ")", "fatal_error", "(", "input_location", ",", "<STR_LIT>", "arguments of type %qT require", "<STR_LIT>", "<STR_LIT>", " the SVE ISA extension", "<STR_LIT>", ",", "arg", ".", "type", ")", ";", "return", "(", "!", "arg", ".", "named", "||", "pcum", "->", "aapcs_nvrn", "+", "pst_info", ".", "num_zr", "(", ")", ">", "NUM_FP_ARG_REGS", "||", "pcum", "->", "aapcs_nprn", "+", "pst_info", ".", "num_pr", "(", ")", ">", "NUM_PR_ARG_REGS", ")", ";", "case", "pure_scalable_type_info", "::", "DOESNT_MATTER", ":", "gcc_assert", "(", "aarch64_pass_by_reference_1", "(", "pcum", ",", "arg", ")", ")", ";", "return", "true", ";", "case", "pure_scalable_type_info", "::", "NO_ABI_IDENTITY", ":", "case", "pure_scalable_type_info", "::", "ISNT_PST", ":", "return", "aarch64_pass_by_reference_1", "(", "pcum", ",", "arg", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}" ]

[ "Implement", "TARGET_PASS_BY_REFERENCE", "." ]

[ "emit_insn", "(", "gen_p9_xxbrd_v2di", "(", "op0", ",", "op1", ")", ")" ]

[ "[", "(", "use", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "rtx", "op0", "=", "gen_reg_rtx", "(", "V2DImode", ")", "rtx", "op1", "=", "gen_lowpart", "(", "V2DImode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "<FIXS>", "[", "(", "V8DI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "[", "(", "V8DI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")", "]", ")", "(", "define_mode_iterator", "VI8_256_512", "<BUGS>", "[", "V8DI", "(", "V4DI", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_mode_iterator", "VI1_AVX2", "[", "(", "V32QI", "<STR_LIT>", ")", "V16QI", "]", ")" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Scalar", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>" ]

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

[ "return", "_", "_", "builtin_mve_vsubq_m_n_uv16qi", "(", "_", "_", "inactive", ",", "_", "_", "a", ",", "_", "_", "b" ]

[ "static", "void", "cr16_override_options", "(", "void", ")", "{", "flag_delete_null_pointer_checks", "=", "<NUM_LIT>", ";", "if", "(", "flag_exceptions", ")", "flag_cse_follow_jumps", "=", "<NUM_LIT>", ";", "if", "(", "flag_pic", "==", "NEAR_PIC", ")", "{", "data_model", "=", "DM_FAR", ";", "}", "if", "(", "cr16_data_model", ")", "{", "if", "(", "strcmp", "(", "cr16_data_model", ",", "<STR_LIT>", "medium", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "data_model", "=", "DM_DEFAULT", ";", "else", "if", "(", "strcmp", "(", "cr16_data_model", ",", "<STR_LIT>", "near", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "data_model", "=", "DM_NEAR", ";", "else", "if", "(", "strcmp", "(", "cr16_data_model", ",", "<STR_LIT>", "far", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "TARGET_CR16CP", ")", "data_model", "=", "DM_FAR", ";", "else", "error", "(", "<STR_LIT>", "data-model=far not valid for cr16c architecture", "<STR_LIT>", ")", ";", "}", "else", "error", "(", "<STR_LIT>", "invalid data model option -mdata-model=%s", "<STR_LIT>", ",", "cr16_data_model", ")", ";", "}", "else", "data_model", "=", "DM_DEFAULT", ";", "}" ]

[ "Parse", "relevant", "options", "and", "override", "." ]

[ "}" ]

[ "case", "TargetOpcode", "::", "G_TRUNC", ":", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "case", "TargetOpcode", "::", "COPY", ":", "{", "MachineOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineInstr", "*", "Def", "=", "Op", ".", "isReg", "(", ")", "?", "MRI", ".", "getVRegDef", "(", "Op", ".", "getReg", "(", ")", ")", ":", "nullptr", ";", "if", "(", "Def", ")", "SpirvTy", "=", "propagateSPIRVType", "(", "Def", ",", "GR", ",", "MRI", ",", "MIB", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "if", "(", "SpirvTy", ")", "GR", "->", "assignSPIRVTypeToVReg", "(", "SpirvTy", ",", "Reg", ",", "MIB", ".", "getMF", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "getRegClassOrNull", "(", "Reg", ")", ")", "MRI", ".", "setRegClass", "(", "Reg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "}", "return", "SpirvTy", ";" ]

[ "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "<NUM_LIT>", ",", "GBZ80Expr", ",", "FixupKind", ")", ")", ";" ]

[ "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "if", "(", "Kind", "==", "MCExpr", "::", "Target", ")", "{", "GBZ80MCExpr", "const", "*", "GBZ80Expr", "=", "cast", "<", "GBZ80MCExpr", ">", "(", "Expr", ")", ";", "int64_t", "Result", ";", "if", "(", "GBZ80Expr", "->", "evaluateAsConstant", "(", "Result", ")", ")", "{", "return", "Result", ";", "}", "MCFixupKind", "FixupKind", "=", "static_cast", "<", "MCFixupKind", ">", "(", "GBZ80Expr", "->", "getFixupKind", "(", ")", ")", ";" ]

[ ")" ]

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CCZ", "CC_REGNUM", ")", "(", "compare", "(", "zero_extract", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")" ]

[ ";" ]

[ "}", "else", "{", "return", "Error", "(", "L", ",", "<STR_LIT>", "first parameter of this directive must be a symbol name", "<STR_LIT>", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "return", "Error", "(", "L", ",", "<STR_LIT>", "unexpected token in directive", "<STR_LIT>", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "const", "MCExpr", "*", "Length", ";", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "Length", ",", "E", ")", ")", "{", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "return", "Error", "(", "L", ",", "<STR_LIT>", "unexpected token in directive", "<STR_LIT>", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "int64_t", "Align", ";", "if", "(", "getParser", "(", ")", ".", "parseAbsoluteExpression", "(", "Align", ")", ")", "{", "return", "true", ";", "}", "if", "(", "Align", "<", "<NUM_LIT>", ")", "{", "return", "Error", "(", "L", ",", "<STR_LIT>", "alignment value must be a positive value", "<STR_LIT>", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "return", "Error", "(", "L", ",", "<STR_LIT>", "unexpected token in directive", "<STR_LIT>", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "PatmosTargetStreamer", "&", "PTS", "=", "static_cast", "<", "PatmosTargetStreamer", "&", ">", "(", "getParser", "(", ")", ".", "getStreamer", "(", ")", ".", "getTargetStreamer", "(", ")", ")", ";", "PTS", ".", "EmitFStart", "(", "Start", ",", "Length", ",", "(", "unsigned", ")", "Align", ")", ";", "return", "false" ]

[ "auto", "InstPt", "=", "A", "?", "&", "*", "A", "->", "getParent", "(", ")", "->", "getEntryBlock", "(", ")", ".", "begin", "(", ")", ":", "I", "->", "getNextNode", "(", ")", ";" ]

[ "}", "auto", "*", "A", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ";", "auto", "*", "I", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ";", "assert", "(", "(", "A", "||", "I", ")", "&&", "<STR_LIT>", "Unknown value type", "<STR_LIT>", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "R", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "ERROR:Should return for all cases within swtich.", "<STR_LIT>", ")", ";" ]

[ "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "switch", "(", "Op0", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "FMUL", ":", "case", "ISD", "::", "FSUB", ":", "{", "SDValue", "NewLoad", "[", "<NUM_LIT>", "]", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "ie", "=", "Op0", ".", "getNumOperands", "(", ")", ";", "i", "!=", "ie", ";", "++", "i", ")", "{", "SDValue", "LdOp", "=", "Op0", ".", "getOperand", "(", "i", ")", ";", "if", "(", "LdOp", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "SDValue", "(", ")", ";", "LoadSDNode", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "LdOp", ")", ";", "SDValue", "LoadOps", "[", "]", "=", "{", "LD", "->", "getChain", "(", ")", ",", "LD", "->", "getBasePtr", "(", ")", "}", ";", "NewLoad", "[", "i", "]", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "v4f32", ",", "MVT", "::", "Other", ")", ",", "LoadOps", ",", "LD", "->", "getMemoryVT", "(", ")", ",", "LD", "->", "getMemOperand", "(", ")", ")", ";", "}", "SDValue", "NewOp", "=", "DAG", ".", "getNode", "(", "Op0", ".", "getOpcode", "(", ")", ",", "SDLoc", "(", "Op0", ")", ",", "MVT", "::", "v4f32", ",", "NewLoad", "[", "<NUM_LIT>", "]", ",", "NewLoad", "[", "<NUM_LIT>", "]", ",", "Op0", ".", "getNode", "(", ")", "->", "getFlags", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v2f64", ",", "NewOp", ")", ";", "}", "case", "ISD", "::", "LOAD", ":", "{", "LoadSDNode", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "Op0", ")", ";", "SDValue", "LoadOps", "[", "]", "=", "{", "LD", "->", "getChain", "(", ")", ",", "LD", "->", "getBasePtr", "(", ")", "}", ";", "SDValue", "NewLd", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "v4f32", ",", "MVT", "::", "Other", ")", ",", "LoadOps", ",", "LD", "->", "getMemoryVT", "(", ")", ",", "LD", "->", "getMemOperand", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v2f64", ",", "NewLd", ")", ";", "}", "}" ]

[ "}" ]

[ "def", "A2_vabswsat", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_cf8126ae", ",", "TypeS_2op", ">", ",", "Enc_b9c5fb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

[ "EVT", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";" ]

[ "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", "->", "setReturnAddressIsTaken", "(", "true", ")", ";", "if", "(", "verifyReturnAddressArgumentIsConstant", "(", "Op", ",", "DAG", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "unsigned", "Depth", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";" ]

[ "}", ")" ]

[ "{", "HOST_WIDE_INT", "i", "=", "INTVAL", "(", "op", ")", "return", "i", "=", "=", "<NUM_LIT>", "|", "|", "i", "=", "=", "<NUM_LIT>", "|", "|", "i", "=", "=", "<NUM_LIT>", "|", "|", "i", "=", "=", "<NUM_LIT>" ]

[ ")", ")" ]

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

[ "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "\t", "<STR_LIT>", ")", ")", "]", "<STR_LIT>" ]

[ "<FIXS>", "ops", "->", "general_ops", "+=", "base_issue", "->", "fp_simd_store_general_ops", "*", "num_copies", ";", "<FIXE>" ]

[ "case", "scalar_store", ":", "ops", "->", "stores", "+=", "num_copies", ";", "if", "(", "vec_flags", "||", "FLOAT_TYPE_P", "(", "vectype", ")", ")", "<BUGS>", "ops", "->", "general_ops", "+=", "issue_info", "->", "fp_simd_store_general_ops", "*", "num_copies", ";", "<BUGE>", "break", ";", "}" ]

[ "}", "else", "{" ]

[ "}", "else", "if", "(", "Modifier", "&&", "strcmp", "(", "Modifier", ",", "<STR_LIT>", "wide", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "<STR_LIT>", "::", "<STR_LIT>", "Mode", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO2", ".", "getImm", "(", ")", ")", ";", "if", "(", "Mode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "O", "<<", "<STR_LIT>", ".w", "<STR_LIT>", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "L4_isub_memopw_zomap", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "u5_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_096199d3", ",", "TypeMAPPING", ">", "{", "let", "isPseudo", "=" ]

[ "<STR_LIT>", ")" ]

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

[ "*", "rfn_slot", "=", "&", "rfn", ";" ]

[ "registered_function", "&", "rfn", "=", "add_function", "(", "instance", ",", "name", ",", "fntype", ",", "attrs", ",", "required_extensions", ",", "false", ",", "false", ")", ";", "hashval_t", "hash", "=", "instance", ".", "hash", "(", ")", ";", "registered_function", "*", "*", "rfn_slot", "=", "function_table", "->", "find_slot_with_hash", "(", "instance", ",", "hash", ",", "INSERT", ")", ";", "gcc_assert", "(", "!", "*", "rfn_slot", ")", ";" ]

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

[ "Prog", ".", "MDVersionSeq", ".", "push_back", "(", "MDVersion", ")", ";", "Prog", ".", "MDVersionSeq", ".", "push_back", "(", "MDRevision", ")", ";", "if", "(", "auto", "MD", "=", "M", ".", "getNamedMetadata", "(", "<STR_LIT>", "llvm.printf.fmts", "<STR_LIT>", ")", ")", "{", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "MD", "->", "getNumOperands", "(", ")", ";", "++", "I", ")", "{", "auto", "Node", "=", "MD", "->", "getOperand", "(", "I", ")", ";", "if", "(", "Node", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", ")", "Prog", ".", "PrintfInfo", ".", "push_back", "(", "cast", "<", "MDString", ">", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getString", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "if", "(", "!", "F", ".", "getMetadata", "(", "<STR_LIT>", "kernel_arg_type", "<STR_LIT>", ")" ]

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

[ "return", "op", ".", "isImm", "(", ")", "&&", "op", "." ]

[ "(", "vec_select", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", "]" ]

[ "(", "vec_select", ":", "HI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "sign_extend", ":", "SI", "(", "vec_select", ":", "HI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "SI", "(", "sign_extend", ":", "SI", "(", "vec_select", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "zero_extend", ":", "SI" ]

[ "}" ]

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

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

[ "[", "(", "set", "(", "match_operand", ":", "BWD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "atomic_op", ":", "BWD", "(", "unspec_volatile", ":", "BWD", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "CRIS_UNSPEC_ATOMIC_OP", ")", "<BUGS>", "(", "match_operand", ":", "BWD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "set", "(", "match_operand", ":", "BWD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "}" ]

[ "int", "width", ",", "is_valid", ";", "static", "char", "templ", "[", "<NUM_LIT>", "]", ";", "is_valid", "=", "neon_immediate_valid_for_shift", "(", "*", "op2", ",", "mode", ",", "op2", ",", "&", "width", ",", "isleftshift", ")", ";", "gcc_assert", "(", "is_valid", "!=", "<NUM_LIT>", ")", ";", "if", "(", "quad", ")", "sprintf", "(", "templ", ",", "<STR_LIT>", "%s.%c%d\\t%%q0, %%q1, %%2", "<STR_LIT>", ",", "mnem", ",", "sign", ",", "width", ")", ";", "else", "sprintf", "(", "templ", ",", "<STR_LIT>", "%s.%c%d\\t%%P0, %%P1, %%2", "<STR_LIT>", ",", "mnem", ",", "sign", ",", "width", ")", ";", "return", "templ", ";" ]

[ "<FIXS>", "error", "(", "<STR_LIT>", "invalid data model option %<-mdata-model=%s%>", "<STR_LIT>", ",", "cr16_data_model", ")", ";", "<FIXE>" ]

[ "error", "(", "<STR_LIT>", "data-model=far not valid for cr16c architecture", "<STR_LIT>", ")", ";", "}", "else", "<BUGS>", "error", "(", "<STR_LIT>", "invalid data model option -mdata-model=%s", "<STR_LIT>", ",", "cr16_data_model", ")", ";", "<BUGE>", "}", "elsedata_model", "=", "DM_DEFAULT", ";" ]

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

[ "bool", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "PM", "->", "add", "(", "createX86MaxStackAlignmentHeuristicPass", "(", ")", ")", ";" ]

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

[ "let", "OutOperandList", "=", "(", "outs", "VRF", ":", "$", "dst", ")", ";", "let", "InOperandList", "=", "(", "ins", "VRF", ":", "$", "src", ",", "i32imm", ":", "$", "imm", ",", "SwitchSet", ":", "$", "sw", ",", "VRF", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dst", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "<NUM_LIT>", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<NUM_LIT>", ";" ]

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

[ "if", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "XOR", "&&", "isAllOnes", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "N1", ")", ";" ]

[ "SDValue", "R", "=", "CMPEQCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "if", "(", "R", ".", "getNode", "(", ")", ")", "return", "R", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "Subtarget", "->", "hasBMI", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", ")", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "DL", "=", "N", "->", "getDebugLoc", "(", ")", ";" ]

[ "<FIXS>", "switch", "(", "Subtarget", ".", "TargetType", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unknown subtarget type", "<STR_LIT>", ")", ";", "case", "X86Subtarget", "::", "isDarwin", ":", "return", "new", "X86DarwinTargetAsmInfo", "(", "*", "this", ")", ";", "case", "X86Subtarget", "::", "isELF", ":", "return", "new", "X86ELFTargetAsmInfo", "(", "*", "this", ")", ";", "case", "X86Subtarget", "::", "isMingw", ":", "case", "X86Subtarget", "::", "isCygwin", ":", "return", "new", "X86COFFTargetAsmInfo", "(", "*", "this", ")", ";", "case", "X86Subtarget", "::", "isWindows", ":", "return", "new", "X86WinTargetAsmInfo", "(", "*", "this", ")", ";", "}", "<FIXE>" ]

[ "const", "TargetAsmInfo", "*", "X86TargetMachine", "::", "createTargetAsmInfo", "(", ")", "const", "{", "if", "(", "Subtarget", ".", "isFlavorIntel", "(", ")", ")", "return", "new", "X86WinTargetAsmInfo", "(", "*", "this", ")", ";", "<BUGS>", "elseswitch", "(", "Subtarget", ".", "TargetType", ")", "{", "case", "X86Subtarget", "::", "isDarwin", ":", "return", "new", "X86DarwinTargetAsmInfo", "(", "*", "this", ")", ";", "case", "X86Subtarget", "::", "isELF", ":", "return", "new", "X86ELFTargetAsmInfo", "(", "*", "this", ")", ";", "case", "X86Subtarget", "::", "isMingw", ":", "case", "X86Subtarget", "::", "isCygwin", ":", "return", "new", "X86COFFTargetAsmInfo", "(", "*", "this", ")", ";", "case", "X86Subtarget", "::", "isWindows", ":", "return", "new", "X86WinTargetAsmInfo", "(", "*", "this", ")", ";", "default", ":", "return", "new", "X86GenericTargetAsmInfo", "(", "*", "this", ")", ";", "}", "<BUGE>", "}", "X86_32TargetMachine", "::", "X86_32TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Module", "&", "M", ",", "@", "@", "-", "<NUM_LIT>", ",", "<NUM_LIT>", "+", "<NUM_LIT>", ",", "<NUM_LIT>", "@", "@", "add_llvm_target", "(", "XCoreXCoreSubtarget", ".", "cppXCoreTargetAsmInfo", ".", "cppXCoreTargetMachine", ".", "cpp", ")" ]

[ "<FIXS>", "VR128X", ":", "$", "src1", ",", "VR128X", ":", "$", "src2", ")", ",", "<FIXE>", "<FIXS>", "(", "ins", "f32x_info", ".", "KRCWM", ":", "$", "mask", ",", "VR128X", ":", "$", "src1", ",", "VR128X", ":", "$", "src2", ")", ",", "<FIXE>", "<FIXS>", "(", "ins", "VR128X", ":", "$", "src1", ",", "VR128X", ":", "$", "src2", ")", ",", "<FIXE>" ]

[ "let", "Constraints", "=", "<STR_LIT>", "indef", "VMOVSSZrrk_REV", ":", "AVX512", "<NUM_LIT>", ",", "MRMDestReg", ",", "(", "outs", "VR128X", ":", "$", "dst", ")", ",", "(", "ins", "f32x_info", ".", "RC", ":", "$", "src0", ",", "f32x_info", ".", "KRCWM", ":", "$", "mask", ",", "<BUGS>", "VR128X", ":", "$", "src1", ",", "FR32X", ":", "$", "src2", ")", ",", "<BUGE>", "<STR_LIT>", "#", "<STR_LIT>", ",", "[", "]", ",", "NoItinerary", ">", ",", "EVEX_K", ",", "XS", ",", "EVEX_4V", ",", "VEX_LIG", ",", "FoldGenData", "<STR_LIT>", ">", ";", "def", "VMOVSSZrrkz_REV", ":", "AVX512", "<NUM_LIT>", ",", "MRMDestReg", ",", "(", "outs", "VR128X", ":", "$", "dst", ")", ",", "<BUGS>", "(", "ins", "f32x_info", ".", "KRCWM", ":", "$", "mask", ",", "VR128X", ":", "$", "src1", ",", "FR32X", ":", "$", "src2", ")", ",", "<BUGE>", "<STR_LIT>", "#", "<STR_LIT>", ",", "[", "]", ",", "NoItinerary", ">", ",", "EVEX_KZ", ",", "XS", ",", "EVEX_4V", ",", "VEX_LIG", ",", "FoldGenData", "<STR_LIT>", ">", ";", "def", "VMOVSDZrr_REV", ":", "AVX512", "<NUM_LIT>", ",", "MRMDestReg", ",", "(", "outs", "VR128X", ":", "$", "dst", ")", ",", "<BUGS>", "(", "ins", "VR128X", ":", "$", "src1", ",", "FR64X", ":", "$", "src2", ")", ",", "<BUGE>", "<STR_LIT>", ",", "[", "]", ",", "NoItinerary", ">", ",", "XD", ",", "EVEX_4V", ",", "VEX_LIG", ",", "VEX_W", ",", "FoldGenData", "<STR_LIT>", ">", ";" ]

[ ":" ]

[ "if", "(", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", "&&", "flag_pic", "&&", "!", "(", "(", "mode", "==", "Pmode", "||", "mode", "==", "ptr_mode", ")", "&&", "tls_symbolic_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "Pmode", ")", "!=", "<NUM_LIT>", ")", ")", "{", "rtx", "temp", ";", "if", "(", "SYMBOLIC_CONST_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "MEM", ")", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "else", "if", "(", "TARGET_SHMEDIA", "&&", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "LABEL_REF", "&&", "target_reg_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", ";", "else", "{", "temp", "=", "no_new_pseudos", "?", "operands", "[", "<NUM_LIT>", "]", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "legitimize_pic_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ",", "temp", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "SYMBOLIC_CONST_P", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "{", "temp", "=", "no_new_pseudos", "?", "operands", "[", "<NUM_LIT>", "]", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "temp", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "mode", ",", "temp", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "expand_binop", "(", "mode", ",", "add_optab", ",", "temp", ",", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "no_new_pseudos", "?", "temp", ":", "gen_reg_rtx", "(", "Pmode", ")", ",", "<NUM_LIT>", ",", "OPTAB_LIB_WIDEN", ")", ";", "}", "}", "if", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", ")", "{", "if", "(", "!", "register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", "&&", "!", "sh_register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "copy_to_mode_reg", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "MEM", "&&", "!", "memory_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "{", "rtx", "new", "=", "change_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ",", "<NUM_LIT>", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "new", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "new", ";", "}", "else", "if", "(", "TARGET_SH1", "&&", "refers_to_regno_p", "(", "R0_REG", ",", "R0_REG", "+", "<NUM_LIT>", ",", "operands", "[", "<NUM_LIT>", "]", ",", "(", "rtx", "*", ")", "<NUM_LIT>", ")", "&&", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "REG", ")", "operands", "[", "<NUM_LIT>", "]", "=", "copy_to_mode_reg", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "if", "(", "mode", "==", "Pmode", "||", "mode", "==", "ptr_mode", ")", "{", "rtx", "op0", ",", "op1", ",", "opc", ";", "enum", "tls_model", "tls_kind", ";", "op0", "=", "operands", "[", "<NUM_LIT>", "]", ";", "op1", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op1", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "tls_symbolic_operand", "(", "XEXP", "(", "XEXP", "(", "op1", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "Pmode", ")", ")", "{", "opc", "=", "XEXP", "(", "XEXP", "(", "op1", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "XEXP", "(", "op1", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "}", "else", "opc", "=", "NULL_RTX", ";", "if", "(", "(", "tls_kind", "=", "tls_symbolic_operand", "(", "op1", ",", "Pmode", ")", ")", ")", "{", "rtx", "tga_op1", ",", "tga_ret", ",", "tmp", ",", "tmp2", ";", "switch", "(", "tls_kind", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "tga_ret", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "emit_call_insn", "(", "gen_tls_global_dynamic", "(", "tga_ret", ",", "op1", ")", ")", ";", "op1", "=", "tga_ret", ";", "break", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "tga_ret", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "emit_call_insn", "(", "gen_tls_local_dynamic", "(", "tga_ret", ",", "op1", ")", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "tga_ret", ")", ";", "if", "(", "register_operand", "(", "op0", ",", "Pmode", ")", ")", "tmp2", "=", "op0", ";", "else", "tmp2", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_symDTPOFF2reg", "(", "tmp2", ",", "op1", ",", "tmp", ")", ")", ";", "op1", "=", "tmp2", ";", "break", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "if", "(", "!", "flag_pic", ")", "{", "if", "(", "flag_schedule_insns", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "emit_insn", "(", "gen_GOTaddr2picreg", "(", ")", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "PIC_REG", ")", ")", ")", ";", "if", "(", "flag_schedule_insns", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "tga_op1", "=", "no_new_pseudos", "?", "op0", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "tmp", "=", "gen_sym2GOTTPOFF", "(", "op1", ")", ";", "emit_insn", "(", "gen_tls_initial_exec", "(", "tga_op1", ",", "tmp", ")", ")", ";", "op1", "=", "tga_op1", ";", "break", ";", "case", "TLS_MODEL_LOCAL_EXEC" ]

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

[ "def", ":", "InstRW", "[", "VecBF", ",", "LSU", ",", "Lat12", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "VecBF", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "VecDF2", ",", "VecDF2", ",", "Lat11", ",", "GroupAlone", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "VecBF", ",", "LSU", ",", "Lat12", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ "unsigned", "Tmp", "=", "ARMMaterializeGV", "(", "GV", ",", "TLI", ".", "getValueType", "(", "Obj", "->", "getType", "(", ")", ")", ")", ";" ]

[ "}", "}", "else", "if", "(", "const", "ConstantExpr", "*", "C", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "Obj", ")", ")", "{", "Opcode", "=", "C", "->", "getOpcode", "(", ")", ";", "U", "=", "C", ";", "}", "if", "(", "const", "PointerType", "*", "Ty", "=", "dyn_cast", "<", "PointerType", ">", "(", "Obj", "->", "getType", "(", ")", ")", ")", "if", "(", "Ty", "->", "getAddressSpace", "(", ")", ">", "<NUM_LIT>", ")", "return", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "BitCast", ":", "{", "return", "ARMComputeAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Addr", ")", ";", "}", "case", "Instruction", "::", "IntToPtr", ":", "{", "if", "(", "TLI", ".", "getValueType", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", "==", "TLI", ".", "getPointerTy", "(", ")", ")", "return", "ARMComputeAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Addr", ")", ";", "break", ";", "}", "case", "Instruction", "::", "PtrToInt", ":", "{", "if", "(", "TLI", ".", "getValueType", "(", "U", "->", "getType", "(", ")", ")", "==", "TLI", ".", "getPointerTy", "(", ")", ")", "return", "ARMComputeAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Addr", ")", ";", "break", ";", "}", "case", "Instruction", "::", "GetElementPtr", ":", "{", "Address", "SavedAddr", "=", "Addr", ";", "int", "TmpOffset", "=", "Addr", ".", "Offset", ";", "gep_type_iterator", "GTI", "=", "gep_type_begin", "(", "U", ")", ";", "for", "(", "User", "::", "const_op_iterator", "i", "=", "U", "->", "op_begin", "(", ")", "+", "<NUM_LIT>", ",", "e", "=", "U", "->", "op_end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ",", "++", "GTI", ")", "{", "const", "Value", "*", "Op", "=", "*", "i", ";", "if", "(", "const", "StructType", "*", "STy", "=", "dyn_cast", "<", "StructType", ">", "(", "*", "GTI", ")", ")", "{", "const", "StructLayout", "*", "SL", "=", "TD", ".", "getStructLayout", "(", "STy", ")", ";", "unsigned", "Idx", "=", "cast", "<", "ConstantInt", ">", "(", "Op", ")", "->", "getZExtValue", "(", ")", ";", "TmpOffset", "+=", "SL", "->", "getElementOffset", "(", "Idx", ")", ";", "}", "else", "{", "uint64_t", "S", "=", "TD", ".", "getTypeAllocSize", "(", "GTI", ".", "getIndexedType", "(", ")", ")", ";", "for", "(", ";", ";", ")", "{", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Op", ")", ")", "{", "TmpOffset", "+=", "CI", "->", "getSExtValue", "(", ")", "*", "S", ";", "break", ";", "}", "if", "(", "isa", "<", "AddOperator", ">", "(", "Op", ")", "&&", "(", "!", "isa", "<", "Instruction", ">", "(", "Op", ")", "||", "FuncInfo", ".", "MBBMap", "[", "cast", "<", "Instruction", ">", "(", "Op", ")", "->", "getParent", "(", ")", "]", "==", "FuncInfo", ".", "MBB", ")", "&&", "isa", "<", "ConstantInt", ">", "(", "cast", "<", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "ConstantInt", "*", "CI", "=", "cast", "<", "ConstantInt", ">", "(", "cast", "<", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "TmpOffset", "+=", "CI", "->", "getSExtValue", "(", ")", "*", "S", ";", "Op", "=", "cast", "<", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "continue", ";", "}", "goto", "unsupported_gep", ";", "}", "}", "}", "Addr", ".", "Offset", "=", "TmpOffset", ";", "if", "(", "ARMComputeAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Addr", ")", ")", "return", "true", ";", "Addr", "=", "SavedAddr", ";", "unsupported_gep", ":", "break", ";", "}", "case", "Instruction", "::", "Alloca", ":", "{", "const", "AllocaInst", "*", "AI", "=", "cast", "<", "AllocaInst", ">", "(", "Obj", ")", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "Addr", ".", "BaseType", "=", "Address", "::", "FrameIndexBase", ";", "Addr", ".", "Base", ".", "FI", "=", "SI", "->", "second", ";", "return", "true", ";", "}", "break", ";", "}", "}", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "Obj", ")", ")", "{" ]

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

[ "if", "(", "!", "Memory", ".", "OffsetImm", ")", "return", "true", ";", "int64_t", "Val", "=", "Memory", ".", "OffsetImm", "->", "getValue", "(", ")", ";", "return", "Val", ">=", "<NUM_LIT>", "&&", "Val" ]