Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "reg", ";", "int", "regno", "=", "<NUM_LIT>", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "E_TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "<NUM_LIT>", ";", "break", ";", "case", "E_DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "<NUM_LIT>", ")", ";", "regno", "+=", "<NUM_LIT>", ";", "break", ";", "case", "E_VOIDmode", ":", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "i", "]", ")", ")", ";", "case", "E_DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "<NUM_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "use_reg", "(", "&", "usage", ",", "reg", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "E_TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "E_DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "E_DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "<NUM_LIT>", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "rtx", "mem", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "rtx_insn", "*", "tmp", "=", "emit_call_insn", "(", "gen_call_value", "(", "reg", ",", "mem", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "RTL_CONST_CALL_P", "(", "tmp", ")", "=", "<NUM_LIT>", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}" ]

[ "Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "." ]

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

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

[ ")", ";" ]

[ "}", "else", "if", "(", "STI", ".", "isTargetWin32", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "FS", ";", "TlsOffset", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetFreeBSD", "(", ")", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on FreeBSD i386.", "<STR_LIT>", ")", ";", "}", "else", "{", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on this platform.", "<STR_LIT>", ")", ";", "}", "if", "(", "CompareStackPointer", ")", "ScratchReg", "=", "X86", "::", "ESP", ";", "else", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "LEA32r", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "X86", "::", "ESP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "-", "StackSize", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "if", "(", "STI", ".", "isTargetLinux", "(", ")", "||", "STI", ".", "isTargetWin32", "(", ")", "||", "STI", ".", "isTargetWin64", "(", ")", ")", "{", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "CMP32rm", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "TlsOffset", ")", ".", "addReg", "(", "TlsReg", ")", ";", "}", "else", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "{", "unsigned", "ScratchReg2", ";", "bool", "SaveScratch2", ";", "if", "(", "CompareStackPointer", ")", "{", "ScratchReg2", "=", "GetScratchRegister", "(", "Is64Bit", ",", "MF", ",", "true", ")", ";", "SaveScratch2", "=", "false", ";", "}", "else", "{", "ScratchReg2", "=", "GetScratchRegister", "(", "Is64Bit", ",", "MF", ",", "false", ")", ";", "SaveScratch2", "=", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ScratchReg2", ")", ";", "}", "assert", "(", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ScratchReg2", ")", "||", "SaveScratch2", ")", "&&", "<STR_LIT>", "Scratch register is live-in and not saved", "<STR_LIT>", ")", ";", "if", "(", "SaveScratch2", ")", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "PUSH32r", ")", ")", ".", "addReg", "(", "ScratchReg2", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32ri", ")", ",", "ScratchReg2", ")", ".", "addImm", "(", "TlsOffset", ")", ";", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "CMP32rm", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg2", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "TlsReg", ")", ";", "if", "(", "SaveScratch2", ")", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "POP32r", ")", ",", "ScratchReg2", ")", ";", "}", "}", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "JA_4", ")", ")", ".", "addMBB", "(", "&", "prologueMBB", ")", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsNested", ")", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64rr", ")", ",", "X86", "::", "RAX", ")", ".", "addReg", "(", "X86", "::", "R10", ")", ";", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64ri", ")", ",", "X86", "::", "R10", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64ri", ")", ",", "X86", "::", "R11", ")", ".", "addImm", "(", "X86FI", "->", "getArgumentStackSize", "(", ")", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "setPhysRegUsed", "(", "X86", "::", "R10", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "setPhysRegUsed", "(", "X86", "::", "R11", ")", ";", "}", "else", "{", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "PUSHi32", ")", ")", ".", "addImm", "(", "X86FI", "->", "getArgumentStackSize", "(", ")", ")", ";", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "PUSHi32", ")", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "if", "(", "Is64Bit", ")", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "CALL64pcrel32", ")", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "__morestack", "<STR_LIT>", ")", ";", "else", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "CALLpcrel32", ")", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "__morestack", "<STR_LIT>", ")", ";", "if", "(", "IsNested", ")", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MORESTACK_RET_RESTORE_R10", ")", ")", ";", "else", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MORESTACK_RET", ")", ")", ";", "allocMBB", "->", "addSuccessor", "(", "&", "prologueMBB", ")", ";", "checkMBB", "->", "addSuccessor", "(", "allocMBB", ")", ";", "checkMBB", "->", "addSuccessor", "(", "&", "prologueMBB", ")", ";", "MF", ".", "verify", "(" ]

[ "static", "int", "dispatch_function_versions", "(", "tree", "dispatch_decl", ",", "void", "*", "fndecls_p", ",", "basic_block", "*", "empty_bb", ")", "{", "tree", "default_decl", ";", "gimple", "*", "ifunc_cpu_init_stmt", ";", "gimple_seq", "gseq", ";", "int", "ix", ";", "tree", "ele", ";", "vec", "<", "tree", ">", "*", "fndecls", ";", "unsigned", "int", "num_versions", "=", "<NUM_LIT>", ";", "unsigned", "int", "actual_versions", "=", "<NUM_LIT>", ";", "unsigned", "int", "i", ";", "struct", "_", "function_version_info", "{", "tree", "version_decl", ";", "tree", "predicate_chain", ";", "unsigned", "int", "dispatch_priority", ";", "}", "*", "function_version_info", ";", "gcc_assert", "(", "dispatch_decl", "!=", "NULL", "&&", "fndecls_p", "!=", "NULL", "&&", "empty_bb", "!=", "NULL", ")", ";", "fndecls", "=", "static_cast", "<", "vec", "<", "tree", ">", "*", ">", "(", "fndecls_p", ")", ";", "num_versions", "=", "fndecls", "->", "length", "(", ")", ";", "gcc_assert", "(", "num_versions", ">=", "<NUM_LIT>", ")", ";", "function_version_info", "=", "(", "struct", "_", "function_version_info", "*", ")", "XNEWVEC", "(", "struct", "_", "function_version_info", ",", "(", "num_versions", "-", "<NUM_LIT>", ")", ")", ";", "default_decl", "=", "(", "*", "fndecls", ")", "[", "<NUM_LIT>", "]", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "dispatch_decl", ")", ")", ";", "gseq", "=", "bb_seq", "(", "*", "empty_bb", ")", ";", "ifunc_cpu_init_stmt", "=", "gimple_build_call_vec", "(", "get_ix86_builtin", "(", "IX86_BUILTIN_CPU_INIT", ")", ",", "vNULL", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "ifunc_cpu_init_stmt", ")", ";", "gimple_set_bb", "(", "ifunc_cpu_init_stmt", ",", "*", "empty_bb", ")", ";", "set_bb_seq", "(", "*", "empty_bb", ",", "gseq", ")", ";", "pop_cfun", "(", ")", ";", "for", "(", "ix", "=", "<NUM_LIT>", ";", "fndecls", "->", "iterate", "(", "ix", ",", "&", "ele", ")", ";", "++", "ix", ")", "{", "tree", "version_decl", "=", "ele", ";", "tree", "predicate_chain", "=", "NULL_TREE", ";", "unsigned", "int", "priority", ";", "priority", "=", "get_builtin_code_for_version", "(", "version_decl", ",", "&", "predicate_chain", ")", ";", "if", "(", "predicate_chain", "==", "NULL_TREE", ")", "continue", ";", "function_version_info", "[", "actual_versions", "]", ".", "version_decl", "=", "version_decl", ";", "function_version_info", "[", "actual_versions", "]", ".", "predicate_chain", "=", "predicate_chain", ";", "function_version_info", "[", "actual_versions", "]", ".", "dispatch_priority", "=", "priority", ";", "actual_versions", "++", ";", "}", "qsort", "(", "function_version_info", ",", "actual_versions", ",", "sizeof", "(", "struct", "_", "function_version_info", ")", ",", "feature_compare", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "actual_versions", ";", "++", "i", ")", "*", "empty_bb", "=", "add_condition_to_bb", "(", "dispatch_decl", ",", "function_version_info", "[", "i", "]", ".", "version_decl", ",", "function_version_info", "[", "i", "]", ".", "predicate_chain", ",", "*", "empty_bb", ")", ";", "*", "empty_bb", "=", "add_condition_to_bb", "(", "dispatch_decl", ",", "default_decl", ",", "NULL", ",", "*", "empty_bb", ")", ";", "free", "(", "function_version_info", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "This", "function", "generates", "the", "dispatch", "function", "for", "multi-versioned", "functions", ".", "DISPATCH_DECL", "is", "the", "function", "which", "will", "contain", "the", "dispatch", "logic", ".", "FNDECLS", "are", "the", "function", "choices", "for", "dispatch", ",", "and", "is", "a", "tree", "chain", ".", "EMPTY_BB", "is", "the", "basic", "block", "pointer", "in", "DISPATCH_DECL", "in", "which", "the", "dispatch", "code", "is", "generated", "." ]

[ ",", "i32imm", ":", "$", "idx", ")", ";" ]

[ "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd" ]

[ "void", "X86InstrInfo", "::", "setSpecialOperandAttr", "(", "MachineInstr", "&", "OldMI1", ",", "MachineInstr", "&", "OldMI2", ",", "MachineInstr", "&", "NewMI1", ",", "MachineInstr", "&", "NewMI2", ")", "const", "{", "uint16_t", "IntersectedFlags", "=", "OldMI1", ".", "getFlags", "(", ")", "&", "OldMI2", ".", "getFlags", "(", ")", ";", "NewMI1", ".", "setFlags", "(", "IntersectedFlags", ")", ";", "NewMI1", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoSWrap", ")", ";", "NewMI1", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoUWrap", ")", ";", "NewMI1", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "IsExact", ")", ";", "NewMI2", ".", "setFlags", "(", "IntersectedFlags", ")", ";", "NewMI2", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoSWrap", ")", ";", "NewMI2", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoUWrap", ")", ";", "NewMI2", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "IsExact", ")", ";", "MachineOperand", "*", "OldFlagDef1", "=", "OldMI1", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "MachineOperand", "*", "OldFlagDef2", "=", "OldMI2", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "assert", "(", "!", "OldFlagDef1", "==", "!", "OldFlagDef2", "&&", "<STR_LIT>", "Unexpected instruction type for reassociation", "<STR_LIT>", ")", ";", "if", "(", "!", "OldFlagDef1", "||", "!", "OldFlagDef2", ")", "return", ";", "assert", "(", "OldFlagDef1", "->", "isDead", "(", ")", "&&", "OldFlagDef2", "->", "isDead", "(", ")", "&&", "<STR_LIT>", "Must have dead EFLAGS operand in reassociable instruction", "<STR_LIT>", ")", ";", "MachineOperand", "*", "NewFlagDef1", "=", "NewMI1", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "MachineOperand", "*", "NewFlagDef2", "=", "NewMI2", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "assert", "(", "NewFlagDef1", "&&", "NewFlagDef2", "&&", "<STR_LIT>", "Unexpected operand in reassociable instruction", "<STR_LIT>", ")", ";", "NewFlagDef1", "->", "setIsDead", "(", ")", ";", "NewFlagDef2", "->", "setIsDead", "(", ")", ";", "}" ]

[ "This", "is", "an", "architecture-specific", "helper", "function", "of", "reassociateOps", "." ]

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

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

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

[ "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_arm_wsadh", "(", "(", "_", "_", "v4hi", ")", "_", "_", "A", ",", "(", "_", "_", "v4hi" ]

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

[ "return", "_", "_", "builtin_mve_vaddvaq_uv4si", "(", "_", "_", "a" ]

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

[ "static", "DecodeStatus", "DecodeShiftLeftImm64", "(", "MCInst", "&", "Inst", ",", "unsigned", "Val", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "if", "(", "Val", ">", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Val" ]

[ "}" ]

[ "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_cc", ":", "if", "(", "dest_arg_index", "==", "<NUM_LIT>", ")", "{", "folded_args", "->", "quick_push", "(", "build_int_cst", "(", "integer_type_node", ",", "s390_get_vstring_flags", "(", "ob_fcode", ")", ")", ")", ";", "arg_assigned_p", "=", "true", ";", "}", "break", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_sel", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_insert", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_load_len", ":", "if", "(", "dest_arg_index", "<", "<NUM_LIT>", ")", "{", "folded_args", "->", "quick_push", "(", "fully_fold_convert", "(", "TREE_VALUE", "(", "arg_chain", ")", ",", "(", "*", "*", "arglist", ")", "[", "<NUM_LIT>", "-", "dest_arg_index", "]", ")", ")", ";", "src_arg_index", "++", ";", "arg_assigned_p", "=", "true", ";", "}", "break", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_store_len", ":", "if", "(", "dest_arg_index", "==", "<NUM_LIT>", "||", "dest_arg_index", "==", "<NUM_LIT>", ")", "{", "folded_args", "->", "quick_push", "(", "fully_fold_convert", "(", "TREE_VALUE", "(", "arg_chain", ")", ",", "(", "*", "*", "arglist", ")", "[", "<NUM_LIT>", "-", "dest_arg_index", "]", ")", ")", ";", "src_arg_index", "++", ";", "arg_assigned_p", "=", "true", ";", "}", "break", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_load_bndry", ":", "{", "int", "code", ";", "if", "(", "dest_arg_index", "==", "<NUM_LIT>", ")", "{", "tree", "arg", "=", "(", "*", "*", "arglist", ")", "[", "src_arg_index", "]", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "!=", "INTEGER_CST", ")", "{", "error", "(", "<STR_LIT>", "constant value required for builtin %qF argument %d", "<STR_LIT>", ",", "decl", ",", "src_arg_index", "+", "<NUM_LIT>", ")", ";", "return", ";", "}", "switch", "(", "tree_to_uhwi", "(", "arg", ")", ")", "{", "case", "<NUM_LIT>", ":", "code", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "code", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "code", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "code", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "code", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "code", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "code", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "error", "(", "<STR_LIT>", "valid values for builtin %qF argument %d are 64, ", "<STR_LIT>", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "decl", ",", "src_arg_index", "+", "<NUM_LIT>", ")", ";", "return", ";", "}", "folded_args", "->", "quick_push", "(", "build_int_cst", "(", "integer_type_node", ",", "code", ")", ")", ";", "src_arg_index", "++", ";", "arg_assigned_p", "=", "true", ";", "}", "}", "break", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_rl_mask", ":", "if", "(", "dest_arg_index", "==", "<NUM_LIT>", ")", "{", "folded_args", "->", "quick_push", "(", "fully_fold_convert", "(", "TREE_VALUE", "(", "arg_chain", ")", ",", "(", "*", "*", "arglist", ")", "[", "src_arg_index", "]", ")", ")", ";", "arg_assigned_p", "=", "true", ";", "}", "break", ";", "default", ":", "break", ";" ]

[ "else", "if", "(", "exregs", "[", "i", "]", ")", "{" ]

[ "int", "i", ";", "int", "exregs", "[", "FIRST_PSEUDO_REGISTER", "]", ";", "memset", "(", "exregs", ",", "<NUM_LIT>", ",", "sizeof", "(", "exregs", ")", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "i", ")", ")", "{", "exregs", "[", "renumber", "[", "i", "]", "]", "=", "<NUM_LIT>", ";", "}", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", "-", "<NUM_LIT>", ";", "i", "+=", "<NUM_LIT>", ")", "{", "if", "(", "exregs", "[", "i", "]", "&&", "exregs", "[", "i", "+", "<NUM_LIT>", "]", ")", "{", "push", "(", "rev_renumber", "[", "i", "]", ",", "SImode", ")", ";", "}" ]

[ "}" ]

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

[ "}" ]

[ "def", "X", ":", "BaseCmpBranch", "<", "GPR64", ",", "op", ",", "asm", ",", "node", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "BuildMI", "(", "*", "BB", ",", "BB", "->", "end", "(", ")", ",", "dl", ",", "TII", "->", "get", "(", "IsThumb1", "?", "ARM", "::", "tBcc", ":", "IsThumb2", "?", "ARM", "::", "t2Bcc", ":", "ARM", "::", "Bcc", ")", ")", ".", "addMBB", "(", "loopMBB", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ")", ";" ]

[ "else", "AddDefaultPred", "(", "BuildMI", "(", "*", "BB", ",", "MI", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "varEnd", ",", "RegState", "::", "Define", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "}", "BB", "->", "addSuccessor", "(", "loopMBB", ")", ";", "MachineBasicBlock", "*", "entryBB", "=", "BB", ";", "BB", "=", "loopMBB", ";", "unsigned", "varLoop", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "unsigned", "varPhi", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "unsigned", "srcLoop", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "unsigned", "srcPhi", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "unsigned", "destLoop", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "unsigned", "destPhi", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "PHI", ")", ",", "varPhi", ")", ".", "addReg", "(", "varLoop", ")", ".", "addMBB", "(", "loopMBB", ")", ".", "addReg", "(", "varEnd", ")", ".", "addMBB", "(", "entryBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "PHI", ")", ",", "srcPhi", ")", ".", "addReg", "(", "srcLoop", ")", ".", "addMBB", "(", "loopMBB", ")", ".", "addReg", "(", "src", ")", ".", "addMBB", "(", "entryBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "PHI", ")", ",", "destPhi", ")", ".", "addReg", "(", "destLoop", ")", ".", "addMBB", "(", "loopMBB", ")", ".", "addReg", "(", "dest", ")", ".", "addMBB", "(", "entryBB", ")", ";", "unsigned", "scratch", "=", "MRI", ".", "createVirtualRegister", "(", "IsNeon", "?", "VecTRC", ":", "TRC", ")", ";", "emitPostLd", "(", "BB", ",", "BB", "->", "end", "(", ")", ",", "TII", ",", "dl", ",", "UnitSize", ",", "scratch", ",", "srcPhi", ",", "srcLoop", ",", "IsThumb1", ",", "IsThumb2", ")", ";", "emitPostSt", "(", "BB", ",", "BB", "->", "end", "(", ")", ",", "TII", ",", "dl", ",", "UnitSize", ",", "scratch", ",", "destPhi", ",", "destLoop", ",", "IsThumb1", ",", "IsThumb2", ")", ";", "if", "(", "IsThumb1", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "BB", "->", "end", "(", ")", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tSUBi8", ")", ",", "varLoop", ")", ";", "MIB", "=", "AddDefaultT1CC", "(", "MIB", ")", ";", "MIB", ".", "addReg", "(", "varPhi", ")", ".", "addImm", "(", "UnitSize", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "}", "else", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "BB", "->", "end", "(", ")", ",", "dl", ",", "TII", "->", "get", "(", "IsThumb2", "?", "ARM", "::", "t2SUBri", ":", "ARM", "::", "SUBri", ")", ",", "varLoop", ")", ";", "AddDefaultCC", "(", "AddDefaultPred", "(", "MIB", ".", "addReg", "(", "varPhi", ")", ".", "addImm", "(", "UnitSize", ")", ")", ")", ";", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "ARM", "::", "CPSR", ")", ";", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDef", "(", "true", ")", ";", "}" ]

[ "=", "op16", ";" ]

[ "class", "MVE_ScalarShiftDRegImm", "<", "string", "iname", ",", "bits", "<", "<NUM_LIT>", ">", "op5_4", ",", "bit", "op16", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVE_ScalarShiftDoubleReg", "<", "iname", ",", "(", "ins", "tGPREven", ":", "$", "RdaLo_src", ",", "tGPROdd", ":", "$", "RdaHi_src", ",", "long_shift", ":", "$", "imm", ")", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "}" ]

[ "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "isMax", ",", "Rs", ",", "Rt", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "Rs", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "isMax", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isUnsigned", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";" ]

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

[ "setCondCodeAction", "(", "ISD", "::", "SETONE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUEQ", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETLE", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETLT", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULE", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULT", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "v4i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "v2i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BRCOND", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FSUB", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "i1", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "MVT", "::", "i1", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "MVT", "::", "v2i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "MVT", "::", "v4i32", ",", "Expand", ")", ";", "if", "(", "Subtarget", "->", "hasCARRY", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "UADDO", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "if", "(", "Subtarget", "->", "hasBORROW", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "USUBO", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "if", "(", "!", "Subtarget", "->", "hasBFE", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i1", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v2i1", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v4i1", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", "->", "hasBFE", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v2i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v4i8", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", "->", "hasBFE", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v2i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v4i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v2i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v4i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FrameIndex", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "MVT", "::", "v2i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "MVT", "::", "v2f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "MVT", "::", "v4i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "MVT", "::", "v4f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "MVT", "::", "v2i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "MVT", "::", "v2f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "MVT", "::", "v4i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "MVT", "::", "v4f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL_PARTS", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL_PARTS", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA_PARTS", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "GlobalAddress", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "const", "MVT", "ScalarIntVTs", "[", "]", "=", "{", "MVT", "::", "i32", ",", "MVT", "::", "i64", "}", ";", "for", "(", "MVT", "VT", ":", "ScalarIntVTs", ")", "{", "setOperationAction", "(", "ISD", "::", "ADDC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SUBC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ADDE", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SUBE", ",", "VT", ",", "Expand", ")", ";", "}", "setSchedulingPreference", "(", "Sched", "::", "Source", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "FP_ROUND", ")", ";", "setTargetDAGCombine", "(", "ISD", "::" ]

[ "}" ]

[ "SDValue", "TPCTargetLowering", "::", "lowerADD", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "expandBinaryOperation", "(", "Op", ",", "DAG", ")", ";" ]

[ "}" ]

[ "bool", "hasV65TOps", "(", ")", "const", "{", "return", "getHexagonArchVersion", "(", ")", ">=", "Hexagon", "::", "ArchEnum", "::", "V65", ";" ]

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

[ "class", "VpuInst_NEARBYINT", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "RegisterClass", "Rsrc", ",", "string", "asmstr", ",", "Operand", "Pred", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "VpuInst_UnarySw", "<", "opc", ",", "Rdst", ",", "Rsrc", ",", "asmstr", ",", "Pred", ",", "pattern", ">", "{", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Rdst", ")", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "}", ";" ]

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

[ "def", "C4_or_andn", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ",", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Pu4", ")", ",", "<STR_LIT>", ",", "tc_b31c2e97", ",", "TypeCR", ">", ",", "Enc_9ac432", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "=", "Imm0_15Operand", ";" ]

[ "return", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass" ]

[ "static", "rtx", "arm_expand_unop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ",", "int", "do_load", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "do_load", ")", "op0", "=", "gen_rtx_MEM", "(", "mode0", ",", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "else", "{", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "}", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "<NUM_LIT>", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}" ]

[ "Subroutine", "of", "arm_expand_builtin", "to", "take", "care", "of", "unop", "insns", "." ]

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

[ "[", "(", "match_operand", ":", "VI1_AVX2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI1_AVX2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lt", ":", "VI1_AVX2", "(", "match_operand", ":", "VI1_AVX2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI1_AVX2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_BLENDV", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "VI1_AVX2", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_BLENDV", ")", ")", "]", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "bool", "SIInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MI", ")", ";", "case", "AMDGPU", "::", "SGPR_USE", ":", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "case", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "{", "unsigned", "Dst", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "DstLo", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "DstHi", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "AMDGPU", "::", "sub1", ")", ";", "const", "MachineOperand", "&", "SrcOp", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "!", "SrcOp", ".", "isFPImm", "(", ")", ")", ";", "if", "(", "SrcOp", ".", "isImm", "(", ")", ")", "{", "APInt", "Imm", "(", "<NUM_LIT>", ",", "SrcOp", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DstLo", ")", ".", "addImm", "(", "Imm", ".", "getLoBits", "(", "<NUM_LIT>", ")", ".", "getZExtValue", "(", ")", ")", ".", "addReg", "(", "Dst", ",", "RegState", "::", "Implicit", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DstHi", ")", ".", "addImm", "(", "Imm", ".", "getHiBits", "(", "<NUM_LIT>", ")", ".", "getZExtValue", "(", ")", ")", ".", "addReg", "(", "Dst", ",", "RegState", "::", "Implicit", ")", ";", "}", "else", "{", "assert", "(", "SrcOp", ".", "isReg", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DstLo", ")", ".", "addReg", "(", "RI", ".", "getSubReg", "(", "SrcOp", ".", "getReg", "(", ")", ",", "AMDGPU", "::", "sub0", ")", ")", ".", "addReg", "(", "Dst", ",", "RegState", "::", "Implicit", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DstHi", ")", ".", "addReg", "(", "RI", ".", "getSubReg", "(", "SrcOp", ".", "getReg", "(", ")", ",", "AMDGPU", "::", "sub1", ")", ")", ".", "addReg", "(", "Dst", ",", "RegState", "::", "Implicit", ")", ";", "}", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "V_CNDMASK_B64_PSEUDO", ":", "{", "unsigned", "Dst", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "DstLo", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "DstHi", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "AMDGPU", "::", "sub1", ")", ";", "unsigned", "Src0", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "MachineOperand", "&", "SrcCond", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstLo", ")", ".", "addReg", "(", "RI", ".", "getSubReg", "(", "Src0", ",", "AMDGPU", "::", "sub0", ")", ")", ".", "addReg", "(", "RI", ".", "getSubReg", "(", "Src1", ",", "AMDGPU", "::", "sub0", ")", ")", ".", "addOperand", "(", "SrcCond", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstHi", ")", ".", "addReg", "(", "RI", ".", "getSubReg", "(", "Src0", ",", "AMDGPU", "::", "sub1", ")", ")", ".", "addReg", "(", "RI", ".", "getSubReg", "(", "Src1", ",", "AMDGPU", "::", "sub1", ")", ")", ".", "addOperand", "(", "SrcCond", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_CONSTDATA_PTR", ":", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "ST", ".", "getRegisterInfo", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "RegLo", "=", "TRI", "->", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "RegHi", "=", "TRI", "->", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub1", ")", ";", "MIBundleBuilder", "Bundler", "(", "MBB", ",", "MI", ")", ";", "Bundler", ".", "append", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "Reg", ")", ")", ";", "Bundler", ".", "append", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "RegLo", ")", ".", "addReg", "(", "RegLo", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ";", "Bundler", ".", "append", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ",", "RegHi", ")", ".", "addReg", "(", "RegHi", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "llvm", "::", "finalizeBundle", "(", "MBB", ",", "Bundler", ".", "begin", "(", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "<FIXS>", "const", "char", "*", "const", "b64", "=", "TARGET_64BIT", "?", "<STR_LIT>", "g", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ";", "<FIXE>" ]

[ "long", "frame_size", ";", "rtx", "stack_label", "=", "<NUM_LIT>", ",", "got_label", "=", "<NUM_LIT>", ";", "char", "*", "l", ";", "<BUGS>", "char", "b64", "[", "<NUM_LIT>", "]", "=", "<STR_LIT>", "<STR_LIT>", ";", "b64", "[", "<NUM_LIT>", "]", "=", "TARGET_64BIT", "?", "'", "g", "'", ":", "'", "\\0", "'", ";", "<BUGE>" ]

[ "return", "Cond", "->", "getAPIntValue", "(", ")", "==", "(", "-", "Op", "->", "getAPIntValue", "(", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "case", "ISD", "::", "SETUGT", ":", "if", "(", "!", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", "&&", "(", "!", "DAG", ".", "isKnownNeverNaN", "(", "LHS", ")", "||", "!", "DAG", ".", "isKnownNeverNaN", "(", "RHS", ")", ")", ")", "break", ";", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SETOGT", ":", "case", "ISD", "::", "SETGT", ":", "case", "ISD", "::", "SETGE", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETULT", ":", "if", "(", "!", "DAG", ".", "isKnownNeverNaN", "(", "LHS", ")", "||", "!", "DAG", ".", "isKnownNeverNaN", "(", "RHS", ")", ")", "break", ";", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETOLE", ":", "if", "(", "!", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", "&&", "!", "DAG", ".", "isKnownNeverZeroFloat", "(", "LHS", ")", "&&", "!", "DAG", ".", "isKnownNeverZeroFloat", "(", "RHS", ")", ")", "{", "if", "(", "!", "DAG", ".", "isKnownNeverNaN", "(", "LHS", ")", "||", "!", "DAG", ".", "isKnownNeverNaN", "(", "RHS", ")", ")", "break", ";", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "}", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETULE", ":", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SETOLT", ":", "case", "ISD", "::", "SETLT", ":", "case", "ISD", "::", "SETLE", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "}", "if", "(", "Opcode", ")", "return", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "LHS", ",", "RHS", ")", ";", "}", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", "&&", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", "&&", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", ")", ")", "{", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "SDValue", "AndNode", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "AndNode", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "CC", "==", "ISD", "::", "SETEQ", "&&", "isNullConstant", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "isOneConstant", "(", "AndNode", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "AndNode", "=", "DAG", ".", "getZExtOrTrunc", "(", "AndNode", ",", "DL", ",", "MVT", "::", "i8", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "DL", ",", "VT", ",", "AndNode", ",", "RHS", ",", "LHS", ")", ";", "}", "}", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", "&&", "CondVT", ".", "isVector", "(", ")", "&&", "CondVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "(", "ExperimentalVectorWideningLegalization", "||", "VT", ".", "getVectorNumElements", "(", ")", ">", "<NUM_LIT>", ")", "&&", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", "||", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i16", ")", ")", "{", "Cond", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VT", ",", "Cond", ")", ";", "return", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "DL", ",", "VT", ",", "Cond", ",", "LHS", ",", "RHS", ")", ";", "}", "if", "(", "SDValue", "V", "=", "combineSelectOfTwoConstants", "(", "N", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", "&&", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", "&&", "DAG", ".", "isEqualTo", "(", "LHS", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "DAG", ".", "isEqualTo", "(", "RHS", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "switch", "(", "CC", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETLT", ":", "case", "ISD", "::", "SETGT", ":", "{", "ISD", "::", "CondCode", "NewCC", "=", "(", "CC", "==", "ISD", "::", "SETLT", ")", "?", "ISD", "::", "SETLE", ":", "ISD", "::", "SETGE", ";", "Cond", "=", "DAG", ".", "getSetCC", "(", "SDLoc", "(", "Cond", ")", ",", "Cond", ".", "getValueType", "(", ")", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "NewCC", ")", ";", "return", "DAG", ".", "getSelect", "(", "DL", ",", "VT", ",", "Cond", ",", "LHS", ",", "RHS", ")", ";", "}", "}", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "VSELECT", "&&", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", "&&", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", ">=", "<NUM_LIT>", "&&", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "&&", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", "||", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i16", ")", ")", "{", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "SDValue", "Other", ";", "if", "(", "ISD", "::", "isBuildVectorAllZeros", "(", "LHS", ".", "getNode", "(", ")", ")", ")", "{", "Other", "=", "RHS", ";", "CC", "=", "ISD", "::", "getSetCCInverse", "(", "CC", ",", "true", ")", ";", "}", "else", "if", "(", "ISD", "::", "isBuildVectorAllZeros", "(", "RHS", ".", "getNode", "(", ")", ")", ")", "{", "Other", "=", "LHS", ";", "}", "if", "(", "Other", ".", "getNode", "(", ")", "&&", "Other", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "Other", "->", "getOperand", "(", "<NUM_LIT>", ")", "==", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "{", "SDValue", "OpLHS", "=", "Other", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "OpRHS", "=", "Other", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "CondRHS", "=", "Cond", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "CC", "==", "ISD", "::", "SETUGE", "||", "CC", "==", "ISD", "::", "SETUGT", ")", "&&", "Other", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "&&", "OpRHS", "==", "CondRHS", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "USUBSAT", ",", "DL", ",", "VT", ",", "OpLHS", ",", "OpRHS", ")", ";", "if", "(", "auto", "*", "OpRHSBV", "=", "dyn_cast", "<", "BuildVectorSDNode", ">", "(", "OpRHS", ")", ")", "{", "if", "(", "isa", "<", "BuildVectorSDNode", ">", "(", "CondRHS", ")", ")", "{", "auto", "MatchUSUBSAT", "=", "[", "]", "(", "ConstantSDNode", "*", "Op", ",", "ConstantSDNode", "*", "Cond", ")", "{" ]

[ "<FIXS>", "if", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", "==", "AsmToken", "::", "Identifier", "&&", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "<STR_LIT>", "abs", "<STR_LIT>", ")", "{", "<FIXE>" ]

[ "Negate", "=", "true", ";", "}", "<BUGS>", "if", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", "==", "AsmToken", "::", "Identifier", "&&", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "<STR_LIT>", "abs", "<STR_LIT>", ")", "{", "<BUGE>", "Parser", ".", "Lex", "(", ")", ";", "Abs2", "=", "true", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "LParen", ")", ")", "{" ]

[ ")", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "HOST_WIDE_INT", "elem", "=", "(", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<", "<", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "emit_insn", "(", "gen_vec_set", "<", "mode", ">", "_internal", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "elem", ")", ",", "operands", "[", "<NUM_LIT>", "]" ]

[ "$", "Rn", ",", "simm9_offset_fb16", ":", "$", "offset", ")", ",", "<NUM_LIT>", ">", ";" ]

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "LDURSHWi", "GPR32", ":", "$", "Rt", ",", "GPR64sp", ":" ]

[ "par", ";" ]

[ "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "XFmode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "<NUM_LIT>", ";", "XVECEXP", "(", "dwarf", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "tmp", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "count", ";", "i", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "XFmode", ",", "base_reg", "++", ")", ";", "XVECEXP", "(", "par", ",", "<NUM_LIT>", ",", "i", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "XFmode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "i", "*", "<NUM_LIT>", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "<NUM_LIT>", ";", "XVECEXP", "(", "dwarf", ",", "<NUM_LIT>", ",", "i", "+", "<NUM_LIT>", ")", "=", "tmp", ";", "}", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "<NUM_LIT>", "*", "count", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "<NUM_LIT>", ";", "XVECEXP", "(", "dwarf", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "tmp", ";", "par", "=", "emit_insn", "(", "par", ")", ";", "REG_NOTES", "(", "par", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ",", "REG_NOTES", "(", "par", ")", ")", ";", "return" ]

[ "if", "(", "StoreSize", "!=", "unsigned", "(", "std", "::", "abs", "(", "Stride", ")", ")", ")", "return", "false", ";" ]

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

[ "<FIXS>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", ")", "]", "<FIXE>" ]

[ "}", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "{", "if", "(", "TARGET_SSE", ")" ]

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

[ "bool", "SITargetLowering", "::", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "return", "TII", "->", "isInlineConstant" ]

[ "}", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "DFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "V2SFmode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "DFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "V2SFmode", ",", "<NUM_LIT>", ")" ]

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

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "cond", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int" ]

[ "Rd", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "cond", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "(", "unspec", ":", "V4HF", "[", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

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

[ "const", "{" ]

[ "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")" ]

[ "_", "lane2", ")", "{" ]

[ "vcopy_lane_f32", "(", "float32x2_t", "_", "_", "a", ",", "const", "int", "_", "_", "lane1", ",", "float32x2_t", "_", "_", "b", ",", "const", "int", "_" ]

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

[ "assert", "(", "GISel", "&&", "<STR_LIT>", "Access to GlobalISel APIs not set", "<STR_LIT>", ")", ";", "return", "GISel", "->", "getRegBankInfo" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "op1" ]

[ "rtx", "op1", "=", "ia64_expand_move", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "!", "op1", ")", "DONE" ]

[ "Value", "[", "AGPR32", "]", ")", ";" ]

[ "unsigned", "getVGPRNum", "(", ")", "const", "{", "return", "std", "::", "max", "(", "Value", "[", "VGPR32", "]", "," ]

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

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

[ "}" ]

[ "def", "VecListDPairAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

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

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

[ "<FIXS>", "if", "(", "Binary", "<=", "UINT8_MAX", ")", "{", "OS", "<<", "uint8_t", "(", "Binary", ")", ";", "}", "else", "{", "assert", "(", "Binary", "<=", "UINT16_MAX", "&&", "<STR_LIT>", "Several-byte opcodes not supported yet", "<STR_LIT>", ")", ";", "OS", "<<", "uint8_t", "(", "Binary", ">>", "<NUM_LIT>", ")", "<<", "uint8_t", "(", "Binary", ")", ";", "}", "<FIXE>" ]

[ "uint64_t", "Start", "=", "OS", ".", "tell", "(", ")", ";", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "<BUGS>", "assert", "(", "Binary", "UINT8_MAX", "&&", "<STR_LIT>", "Multi-byte opcodes not supported yet", "<STR_LIT>", ")", ";", "OS", "<<", "uint8_t", "(", "Binary", ")", ";", "<BUGE>" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "let", "Predicates", "=", "[", "HasSSE2", ",", "NoAVX512", "]", "in", "{", "defm", "_FR16", ":", "CMOVrr_PSEUDO", "FR16", ",", "f16", ">", ";", "<FIXE>" ]

[ "let", "Predicates", "=", "[", "HasMMX", "]", "indefm", "_VR64", ":", "CMOVrr_PSEUDO", "VR64", ",", "x86mmx", ">", ";", "<BUGS>", "defm", "_FR16X", ":", "CMOVrr_PSEUDO", "FR16X", ",", "f16", ">", ";", "<BUGE>", "let", "Predicates", "=", "[", "HasSSE1", ",", "NoAVX512", "]", "indefm", "_FR32", ":", "CMOVrr_PSEUDO", "FR32", ",", "f32", ">", ";", "<BUGS>", "let", "Predicates", "=", "[", "HasSSE2", ",", "NoAVX512", "]", "in", "<BUGE>", "defm", "_FR64", ":", "CMOVrr_PSEUDO", "FR64", ",", "f64", ">", ";", "let", "Predicates", "=", "[", "HasAVX512", "]", "in", "{", "defm", "_FR32X", ":", "CMOVrr_PSEUDO", "FR32X", ",", "f32", ">", ";", "defm", "_FR64X", ":", "CMOVrr_PSEUDO", "FR64X", ",", "f64", ">", ";", "}" ]

[ "}" ]

[ "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_DECL", "(", "addr", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "else", "return", "true", ";" ]

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

[ "class", "AVE_U_W_ENC", ":", "MSA_3R_FMT", "<", "<NUM_LIT>" ]

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

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isIndirectBranch", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";" ]

[ "return", "DAG", ".", "getNode", "(", "(", "VT", ".", "getSizeInBits", "(", ")", "<", "<NUM_LIT>", "?", "ISD", "::", "TRUNCATE", ":", "ISD", "::", "ZERO_EXTEND", ")", ",", "DL", ",", "VT", ",", "RetVal", ")", ";" ]

[ "SDValue", "X86TargetLowering", "::", "LowerFLT_ROUNDS_", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "TM", ".", "getFrameLowering", "(", ")", ";", "unsigned", "StackAlignment", "=", "TFI", ".", "getStackAlignment", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "int", "SSFI", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateStackObject", "(", "<NUM_LIT>", ",", "StackAlignment", ",", "false", ")", ";", "SDValue", "StackSlot", "=", "DAG", ".", "getFrameIndex", "(", "SSFI", ",", "getPointerTy", "(", ")", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "SSFI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getEntryNode", "(", ")", ",", "StackSlot", "}", ";", "SDValue", "Chain", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ")", ",", "Ops", ",", "array_lengthof", "(", "Ops", ")", ",", "MVT", "::", "i16", ",", "MMO", ")", ";", "SDValue", "CWD", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i16", ",", "DL", ",", "Chain", ",", "StackSlot", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "CWD1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i16", ",", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i16", ",", "CWD", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i16", ")", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "CWD2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i16", ",", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i16", ",", "CWD", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i16", ")", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "RetVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i16", ",", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i16", ",", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "MVT", "::", "i16", ",", "CWD1", ",", "CWD2", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i16", ")", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i16", ")", ")", ";" ]

[ "A", ",", "(", "_", "_", "mmask16", ")", "_", "_", "B", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_vpshld_v16si_mask", "(", "(", "_", "_", "v16si", ")", "_", "_", "C", ",", "(", "_", "_", "v16si", ")", "_", "_", "D", ",", "_", "_", "E", ",", "(", "_", "_", "v16si", ")", "_", "_" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_svavgh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_1c80410a", ",", "TypeALU32_3op", ">", ",", "Enc_5ab2be", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCommutable", "=" ]

[ "return", "MCDisassembler", "::", "Success", ";" ]

[ "static", "DecodeStatus", "DecodeShiftRight16Imm", "(", "MCInst", "&", "Inst", ",", "unsigned", "Val", ",", "uint64_t", "Address", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", "-", "Val", ")", ")", ";" ]

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

[ "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZPostRewritePass", "(" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "pstatefield", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "pstatefield", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "hasCompleteDecoder", "=", "<NUM_LIT>", ";" ]

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

[ "(", "define_mode_iterator", "VNx4_NARROW", "[", "VNx4QI", "VNx4HI", "]", ")", "(", "define_mode_iterator", "VNx4_WIDE", "[" ]

[ "bool", "X86TargetLowering", "::", "allowsMemoryAccess", "(", "LLVMContext", "&", "Context", ",", "const", "DataLayout", "&", "DL", ",", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "unsigned", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "isMemoryAccessFast", "(", "VT", ",", "Alignment", ")", ";", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MONonTemporal", ")", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "AddrSpace", ",", "Alignment", ",", "Flags", ",", "nullptr", ")", ")", "return", "true", ";", "if", "(", "!", "isBitAligned", "(", "Alignment", ",", "VT", ".", "getSizeInBits", "(", ")", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "case", "<NUM_LIT>", ":", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MOLoad", ")", "&&", "Subtarget", ".", "hasSSE41", "(", ")", ")", "return", "true", ";", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MOStore", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", "true", ";", "return", "false", ";", "case", "<NUM_LIT>", ":", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MOLoad", ")", "&&", "Subtarget", ".", "hasAVX2", "(", ")", ")", "return", "true", ";", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MOStore", ")", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", "return", "true", ";", "return", "false", ";", "case", "<NUM_LIT>", ":", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "Subtarget", ".", "hasEVEX512", "(", ")", ")", "return", "true", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "This", "function", "returns", "true", "if", "the", "memory", "access", "is", "aligned", "or", "if", "the", "target", "allows", "this", "specific", "unaligned", "memory", "access", "." ]

[ "<STR_LIT>" ]

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

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

[ "(", "truncate", ":", "VNx2_NARROW", "(", "match_operand", ":", "VNx2_WIDE", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_ST1_SCATTER", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "{", "@", "[", "cons", ":", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", "[", "w", ",", "w", ",", "Upl", "]", "st1", "VNx2_NARROW", ":", "Vesize", ">", "\\t", "%", "<NUM_LIT>", ".", "d", ",", "%", "<NUM_LIT>", ",", "[", "%", "<NUM_LIT>", ".", "d", "]", "[", "w", ",", "w", ",", "Upl", "]", "st1", "VNx2_NARROW", ":", "Vesize", ">", "\\t", "%", "<NUM_LIT>", ".", "d", ",", "%", "<NUM_LIT>", ",", "[", "%", "<NUM_LIT>", ".", "d", ",", "#", "%", "<NUM_LIT>", "]" ]

[ "{" ]

[ "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "if", "(", "Binary", "<=", "UINT8_MAX", ")", "{", "OS", "<<", "uint8_t", "(", "Binary", ")", ";", "}", "else", "{", "assert", "(", "Binary", "<=", "UINT16_MAX", "&&", "<STR_LIT>", "Several-byte opcodes not supported yet", "<STR_LIT>", ")", ";", "OS", "<<", "uint8_t", "(", "Binary", ">>", "<NUM_LIT>", ")", "<<", "uint8_t", "(", "Binary", ")", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I32", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I64", ")", "encodeULEB128", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ",", "OS", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "if", "(", "i", "<", "Desc", ".", "getNumOperands", "(", ")", ")", "{", "assert", "(", "Desc", ".", "TSFlags", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "WebAssembly non-variable_ops don't use TSFlags", "<STR_LIT>", ")", ";", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "i", "]", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_I32IMM", ")", "{", "encodeSLEB128", "(", "int32_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "else", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_I64IMM", ")", "{", "encodeSLEB128", "(", "int64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "else", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_GLOBAL", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "wasm globals should only be accessed symbolicly", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_SIGNATURE", ")", "{", "OS", "<<", "uint8_t", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "{", "assert", "(", "Desc", ".", "TSFlags", "==", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "assert", "(", "i", "<", "Desc", ".", "getNumOperands", "(", ")", "&&", "<STR_LIT>", "Unexpected floating-point immediate as a non-fixed operand", "<STR_LIT>", ")", ";", "assert", "(", "Desc", ".", "TSFlags", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "WebAssembly variable_ops floating point ops don't use TSFlags", "<STR_LIT>", ")", ";", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "i", "]", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F32IMM", ")", "{", "float", "f", "=", "float", "(", "MO", ".", "getFPImm", "(", ")", ")", ";", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "float", ">", "(", "f", ")", ";", "}", "else", "{", "assert", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F64IMM", ")", ";", "double", "d", "=", "MO", ".", "getFPImm", "(", ")", ";", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "double", ">", "(", "d", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "i", "]", ";", "llvm", "::", "MCFixupKind", "FixupKind", ";", "size_t", "PaddedSize", "=", "<NUM_LIT>", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_I32IMM", ")", "{", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_code_sleb128_i32", ")", ";", "}", "else", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_I64IMM", ")", "{", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_code_sleb128_i64", ")", ";", "PaddedSize", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_FUNCTION32", "||", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_OFFSET32", "||", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_TYPEINDEX", ")", "{", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_code_uleb128_i32", ")", ";", "}", "else", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_GLOBAL", ")", "{", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_code_global_index", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "unexpected symbolic operand kind", "<STR_LIT>", ")", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "OS", ".", "tell", "(", ")", "-", "Start", ",", "MO", ".", "getExpr", "(", ")", ",", "FixupKind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "encodeULEB128", "(", "<NUM_LIT>", ",", "OS", ",", "PaddedSize", ")", ";", "}", "else" ]

[ "<FIXS>", "return", "std", "::", "optional", "BlockBRNZ", ">", "(", ")", ";", "<FIXE>" ]

[ "Zero", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "break", ";", "default", ":", "<BUGS>", "return", "Optional", "BlockBRNZ", ">", "(", ")", ";", "<BUGE>", "}", "BlockBRNZ", "Desc", ";" ]

[ "<FIXS>", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGS>", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "void", "AMDGPUTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "Threshold", "=", "<NUM_LIT>", ";", "UP", ".", "Count", "=", "UINT_MAX", ";", "UP", ".", "Partial", "=", "true", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", "||", "GEP", "->", "getAddressSpace", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "<NUM_LIT>", ";", "}", "}", "}", "}" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "<FIXS>", "return", "DAG", ".", "getConstant", "(", "Imm", ",", "DL", ",", "MVT", "::", "i8", ")", ";", "<FIXE>" ]

[ "Imm", "|=", "(", "Mask", "[", "<NUM_LIT>", "]", "==", "-", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "Mask", "[", "<NUM_LIT>", "]", ")", "<<", "<NUM_LIT>", ";", "Imm", "|=", "(", "Mask", "[", "<NUM_LIT>", "]", "==", "-", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "Mask", "[", "<NUM_LIT>", "]", ")", "<<", "<NUM_LIT>", ";", "Imm", "|=", "(", "Mask", "[", "<NUM_LIT>", "]", "==", "-", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "Mask", "[", "<NUM_LIT>", "]", ")", "<<", "<NUM_LIT>", ";", "<BUGS>", "return", "DAG", ".", "getConstant", "(", "Imm", ",", "MVT", "::", "i8", ")", ";", "<BUGE>", "}" ]

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

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

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

[ "dag", "OutOperandList", "=", "(", "outs", "GPROpnd", ":", "$", "rd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "GPROpnd", ":", "$", "rs", ",", "GPROpnd", ":", "$", "rt", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "GPROpnd", ":", "$", "rd", ",", "(", "Op", "GPROpnd", ":", "$", "rs", ",", "GPROpnd", ":", "$", "rt", ")", ")", "]", ";", "InstrItinClass", "Itinerary", "=", "itin", ";" ]

[ "*", "Disp", ".", "getExpr", "(", ")", ";" ]

[ "void", "MSP430InstPrinter", "::", "printSrcMemOperand", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "Modifier", ")", "{", "const", "MCOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "const", "MCOperand", "&", "Disp", "=", "MI", "->", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ";", "if", "(", "!", "Base", ".", "getReg", "(", ")", ")", "O", "<<", "'", "&", "'", ";", "if", "(", "Disp", ".", "isExpr", "(", ")", ")", "O", "<<" ]

[ "<STR_LIT>" ]

[ "(", "compare", ":", "CCV", "(", "neg", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_NEGV", ")", ")", ")", "]", "<STR_LIT>" ]

[ "instr_asm", ";" ]

[ "dag", "OutOperandList", "=", "(", "outs", "RO", ":", "$", "rt", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "]", ";", "Format", "f", "=", "FrmR", ";", "string", "BaseOpcode", "=" ]

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

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "def", "SDT_MSP430DAdd", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisSameAs", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ",", "SDTCisSameAs", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ",", "SDTCisInt", "<NUM_LIT>", ">", "]", ">", ";", "<FIXE>" ]

[ "def", "SDT_MSP430SelectCC", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisSameAs", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ",", "SDTCisSameAs", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ",", "SDTCisVT", "<NUM_LIT>", ",", "i8", ">", "]", ">", ";", "<BUGS>", "def", "SDT_MSP430Shift", ":", "SDTypeProfile", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisSameAs", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ",", "SDTCisI8", "<NUM_LIT>", ">", "]", ">", ";", "<BUGE>" ]

[ ";" ]

[ "def", "J2_endloop0", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "tc_1b6f7cec", ",", "TypeJ", ">", "{", "let", "Uses", "=", "[", "LC0", ",", "SA0", "]", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "PC", ",", "USR", "]", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_code" ]

[ "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumRets", ";", "i", "++", ")", "NodeTys", ".", "push_back", "(", "TheCall", "->", "getRetValType", "(", "i", ")", ")", ";" ]

[ "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "unsigned", "NumArgs", "=", "TheCall", "->", "getNumArgs", "(", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumArgs", ";", "i", "++", ")", "{", "Ops", ".", "push_back", "(", "TheCall", "->", "getArg", "(", "i", ")", ")", ";", "Ops", ".", "push_back", "(", "TheCall", "->", "getArgFlagsVal", "(", "i", ")", ")", ";", "}", "std", "::", "vector", "<", "MVT", ">", "NodeTys", ";", "unsigned", "NumRets", "=", "TheCall", "->", "getNumRetVals", "(", ")", ";" ]

[ ";" ]

[ "def", "II_SEQI_SNEI", ":", "InstrItinClass" ]

[ "}" ]

[ "SDValue", "Src0", "=", "peekThroughBitcasts", "(", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Src1", "=", "peekThroughBitcasts", "(", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "SrcOpc0", "=", "Src0", ".", "getOpcode", "(", ")", ";", "unsigned", "SrcOpc1", "=", "Src1", ".", "getOpcode", "(", ")", ";", "EVT", "SrcVT0", "=", "Src0", ".", "getValueType", "(", ")", ";", "EVT", "SrcVT1", "=", "Src1", ".", "getValueType", "(", ")", ";", "if", "(", "!", "Src1", ".", "isUndef", "(", ")", "&&", "(", "SrcVT0", "!=", "SrcVT1", "||", "SrcOpc0", "!=", "SrcOpc1", ")", ")", "return", "SDValue", "(", ")", ";", "switch", "(", "SrcOpc0", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "LHS", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "Src0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "RHS", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "Src1", ".", "isUndef", "(", ")", "?", "Src1", ":", "Src1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "LHS", ",", "RHS", ",", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "SrcOpc0", ",", "DL", ",", "SrcVT0", ",", "DAG", ".", "getBitcast", "(", "SrcVT0", ",", "Res", ")", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "Res", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "SrcVT0", "==", "MVT", "::", "v4f64", ")", "{", "uint64_t", "Mask", "=", "Src0", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "Mask", "&", "<NUM_LIT>", ")", "!=", "(", "(", "Mask", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ")", "break", ";", "}", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "Src1", ".", "isUndef", "(", ")", "||", "Src0", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "Src1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "{", "SDValue", "LHS", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "Src0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "RHS", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "Src1", ".", "isUndef", "(", ")", "?", "Src1", ":", "Src1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "LHS", ",", "RHS", ",", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "SrcOpc0", ",", "DL", ",", "SrcVT0", ",", "DAG", ".", "getBitcast", "(", "SrcVT0", ",", "Res", ")", ",", "Src0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "Res", ")", ";", "}", "break", ";", "}", "return", "SDValue", "(", ")", ";" ]

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

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Imm", "=", "(", "Imm", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Imm", "=", "Imm", "&", "<NUM_LIT>", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Only HI/LO target flags are expected", "<STR_LIT>", ")", ";", "}", "return", "MachineOperand", "::", "CreateImm", "(", "Imm", ")", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "return", "MachineOperand", "::", "CreateES", "(", "MO", ".", "getSymbolName", "(", ")", ",", "TF", ")", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "return", "MachineOperand", "::", "CreateJTI", "(", "MO", ".", "getIndex", "(", ")", ",", "TF", ")", ";", "default", ":", "return", "MachineOperand", "::", "CreateGA", "(", "MO", ".", "getGlobal", "(", ")", ",", "MO", ".", "getOffset", "(", ")" ]

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

[ "DecodeStatus", "Status", "=", "MCDisassembler", "::", "Success", ";", "unsigned", "S", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "J1", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "J2", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "I1", "=", "!", "(", "J1", "^", "S", ")", ";", "unsigned", "I2", "=", "!", "(", "J2", "^", "S", ")", ";", "unsigned", "imm10", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "imm11", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", "," ]

[ ";" ]

[ "static", "bool", "consume", "(", "InternalInstruction", "*", "insn", ",", "T", "&", "ptr", ")", "{", "auto", "r", "=", "insn", "->", "bytes", ";", "uint64_t", "offset", "=", "insn", "->", "readerCursor", "-", "insn", "->", "startLocation", ";", "if", "(", "offset", "+", "sizeof", "(", "T", ")", ">", "r", ".", "size", "(", ")", ")", "return", "true", ";", "T", "ret", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "sizeof", "(", "T", ")", ";", "++", "i", ")", "ret", "|=", "(", "uint64_t", ")", "r", "[", "offset", "+", "i", "]", "<<", "(", "i", "*", "<NUM_LIT>", ")", ";", "ptr", "=", "ret" ]

[ "}" ]

[ "bool", "hasSEInReg", "(", ")", "const", "{", "return", "HasSEInReg", ";" ]

[ "II_MSUB", ">", ",", "ISA_MIPS32_NOT_32R6_64R6", ";" ]

[ "def", "PseudoMSUB", ":", "MAddSubPseudo", "<", "MSUB", ",", "MipsMSub", "," ]

[ ")" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "DecoderMethod" ]

[ "eq", "lt", "ltu", "]", ")" ]

[ "(", "define_code_iterator", "v2op_immed", "[", "plus", "smax", "smin" ]

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

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

[ "}" ]

[ "assert", "(", "TM", ".", "TargetABI", "!=", "ARMBaseTargetMachine", "::", "ARM_ABI_UNKNOWN", ")", ";", "return", "TM", ".", "TargetABI", "==", "ARMBaseTargetMachine", "::", "ARM_ABI_AAPCS16", ";" ]

[ "MachinePointerInfo", "(", "SV", ")", ")", ";" ]

[ "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "TL45MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "TL45MachineFunctionInfo", ">", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "FI", "=", "DAG", ".", "getFrameIndex", "(", "FuncInfo", "->", "getVarArgsFrameIndex", "(", ")", ",", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ")", ";", "const", "Value", "*", "SV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "return", "DAG", ".", "getStore", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DL", ",", "FI", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", "," ]

[ "!=", "NULL", ")", "{" ]

[ "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk", ")", "{", "int", "i", "=", "regno", ";", "if", "(", "i", ">=", "FIRST_REX_INT_REG", ")", "i", "-=", "(", "FIRST_REX_INT_REG", "-", "LAST_INT_REG", "-", "<NUM_LIT>", ")", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "indirect_thunks_bnd_used", "|=", "<NUM_LIT>", "<<", "i", ";", "else", "indirect_thunks_used", "|=", "<NUM_LIT>", "<<", "i", ";", "}", "indirect_thunk_name", "(", "thunk_name_buf", ",", "regno", ",", "need_prefix", ",", "false", ")", ";", "thunk_name", "=", "thunk_name_buf", ";", "}", "else", "thunk_name", "=", "NULL", ";", "if", "(", "sibcall_p", ")", "{", "if", "(", "thunk_name", "!=", "NULL", ")", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\tbnd jmp\\t%s\\n", "<STR_LIT>", ",", "thunk_name", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\tjmp\\t%s\\n", "<STR_LIT>", ",", "thunk_name", ")", ";", "}", "else", "output_indirect_thunk", "(", "need_prefix", ",", "regno", ")", ";", "}", "else", "{", "if", "(", "thunk_name", "!=", "NULL", ")", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\tbnd call\\t%s\\n", "<STR_LIT>", ",", "thunk_name", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\tcall\\t%s\\n", "<STR_LIT>", ",", "thunk_name", ")", ";", "return", ";", "}", "char", "indirectlabel1", "[", "<NUM_LIT>", "]", ";", "char", "indirectlabel2", "[", "<NUM_LIT>", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel1", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel2", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fputs", "(", "<STR_LIT>", "\\tbnd jmp\\t", "<STR_LIT>", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "<STR_LIT>", "\\tjmp\\t", "<STR_LIT>", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputc", "(", "'", "\\n", "'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "if", "(", "thunk_name" ]

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

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_pmovqd512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v8si", ")", "_" ]

[ "=", "VecListFourQAllLanesAsmOperand", ";" ]

[ "def", "VecListFourQAllLanes", ":", "RegisterOperand", "<", "DPR", ",", "<STR_LIT>", ">", "{", "let", "ParserMatchClass" ]

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

[ "def", "VLD4DUPq16", ":", "VLD4DUP", "<", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

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

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

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

[ "if", "(", "frame_pointer_needed", ")", "{", "load_reg", "(", "<NUM_LIT>", ",", "ret_off", ",", "FRAME_POINTER_REGNUM", ")", ";", "ret_off", "=", "<NUM_LIT>", ";", "}", "else", "{", "if", "(", "VAL_14_BITS_P", "(", "ret_off", "-", "actual_fsize", ")", ")", "{", "load_reg", "(", "<NUM_LIT>", ",", "ret_off", "-", "actual_fsize", ",", "STACK_POINTER_REGNUM", ")", ";", "ret_off", "=", "<NUM_LIT>", ";", "}", "}", "}", "if", "(", "frame_pointer_needed", ")", "{", "offset", "=", "local_fsize", ";", "if", "(", "DO_FRAME_NOTES", "&&", "current_function_calls_eh_return", ")", "{", "unsigned", "int", "i", ",", "regno", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", ";", "++", "i", ")", "{", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "break", ";", "load_reg", "(", "regno", ",", "offset", ",", "FRAME_POINTER_REGNUM", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "{", "load_reg", "(", "i", ",", "offset", ",", "FRAME_POINTER_REGNUM", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "}", "else", "{", "offset", "=", "local_fsize", "-", "actual_fsize", ";", "if", "(", "DO_FRAME_NOTES", "&&", "current_function_calls_eh_return", ")", "{", "unsigned", "int", "i", ",", "regno", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", ";", "++", "i", ")", "{", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "merge_sp_adjust_with_load", "==", "<NUM_LIT>", "&&", "local_fsize", "==", "<NUM_LIT>", "&&", "VAL_14_BITS_P", "(", "-", "actual_fsize", ")", ")", "merge_sp_adjust_with_load", "=", "regno", ";", "else", "load_reg", "(", "regno", ",", "offset", ",", "STACK_POINTER_REGNUM", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "{", "if", "(", "merge_sp_adjust_with_load", "==", "<NUM_LIT>", "&&", "local_fsize", "==", "<NUM_LIT>", "&&", "VAL_14_BITS_P", "(", "-", "actual_fsize", ")", ")", "merge_sp_adjust_with_load", "=", "i", ";", "else", "load_reg", "(", "i", ",", "offset", ",", "STACK_POINTER_REGNUM", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "}", "}", "offset", "=", "(", "offset", "+", "<NUM_LIT>", ")", "&", "~", "<NUM_LIT>", ";", "if", "(", "save_fregs", ")", "{", "if", "(", "frame_pointer_needed", ")", "set_reg_plus_d", "(", "<NUM_LIT>" ]

[ "V", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "WideVT", ",", "V", ")", ";" ]

[ "MVT", "WideEltVT", "=", "WideVT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "(", "Subtarget", ".", "hasDQI", "(", ")", "&&", "WideEltVT", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", "||", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "WideEltVT", ".", "getSizeInBits", "(", ")", "<=", "<NUM_LIT>", ")", ")", "{", "V", "=", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "dl", ",", "WideVT", ",", "In", ")", ";", "}", "else", "{", "SDValue", "NegOne", "=", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "dl", ",", "WideVT", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "WideVT", ")", ";", "V", "=", "DAG", ".", "getSelect", "(", "dl", ",", "WideVT", ",", "In", ",", "NegOne", ",", "Zero", ")", ";", "}", "if", "(", "VT", "!=", "ExtVT", ")", "{", "WideVT", "=", "MVT", "::", "getVectorVT", "(", "VTElt", ",", "NumElts", ")", ";" ]

[ ",", "[", "(", "set", "DPR", ":", "$", "Vd", ",", "(", "v8i8", "(", "NEONvtbl1", "VecListOneD", ":", "$", "Vn", ",", "DPR", ":", "$", "Vm", ")", ")", ")", "]", ">", ";" ]

[ "def", "VTBL1", ":", "N3V", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "DPR", ":", "$", "Vd", ")", ",", "(", "ins", "VecListOneD", ":", "$", "Vn", ",", "DPR", ":", "$", "Vm", ")", ",", "NVTBLFrm", ",", "IIC_VTB1", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>" ]

[ "<<", "WavefrontSizeLog2", ";" ]

[ "unsigned", "getWavefrontSize", "(", ")", "const", "{", "return", "<NUM_LIT>" ]