Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "a", ";" ]

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

[ "<FIXS>", "return", "rs6000_builtin_decls", "[", "bif", "]", ";", "<FIXE>" ]

[ "}", "if", "(", "in_mode", "==", "exp_mode", "&&", "in_vmode", "==", "exp_vmode", ")", "<BUGS>", "return", "rs6000_builtin_decls_x", "[", "bif", "]", ";", "<BUGE>", "}", "return", "NULL_TREE", ";" ]

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

[ "_", "_", "builtin_aarch64_tcommit" ]

[ "if", "(", "!", "DECL_EXTERNAL", "(", "node", ")", ")", "error", "(", "<STR_LIT>", "variables in %<__regio_symbol%> address space ", "<STR_LIT>", "<STR_LIT>", "must be declared %<extern%>", "<STR_LIT>", ")", ";" ]

[ "tree", "typ", "=", "TREE_TYPE", "(", "node", ")", ";", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "typ", ")", ";", "if", "(", "as", "==", "ADDR_SPACE_GENERIC", ")", "return", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "typ", ")", ")", "{", "error", "(", "<STR_LIT>", "aggregate types are prohibited in ", "<STR_LIT>", "<STR_LIT>", "%<__regio_symbol%> address space", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "DECL_INITIAL", "(", "node", ")", "!=", "NULL_TREE", ")", "error", "(", "<STR_LIT>", "variables in %<__regio_symbol%> address space ", "<STR_LIT>", "<STR_LIT>", "cannot have initial value", "<STR_LIT>", ")", ";", "if", "(", "DECL_REGISTER", "(", "node", ")", ")", "error", "(", "<STR_LIT>", "variables in %<__regio_symbol%> address space ", "<STR_LIT>", "<STR_LIT>", "cannot be declared %<register%>", "<STR_LIT>", ")", ";", "if", "(", "!", "TYPE_VOLATILE", "(", "typ", ")", ")", "error", "(", "<STR_LIT>", "variables in %<__regio_symbol%> address space ", "<STR_LIT>", "<STR_LIT>", "must be declared %<volatile%>", "<STR_LIT>", ")", ";" ]

[ "<FIXS>", "(", "clobber", "(", "reg", ":", "SI", "FPSCR_STAT_REG", ")", ")", "(", "use", "(", "reg", ":", "SI", "FPSCR_MODES_REG", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float", ":", "DF", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGS>", "(", "use", "(", "match_operand", ":", "PSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_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", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "if", "(", "MI", ".", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "fixupHack", "(", "MBB", ",", "MI", ")", ";", "<FIXE>" ]

[ "auto", "dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "auto", "mod", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "insertEmulatedTimings", "(", "MBB", ",", "MI", ",", "dst", ",", "mod", ")", ";", "<BUGS>", "fixupHack", "(", "MBB", ",", "MI", ")", ";", "<BUGE>", "MI", ".", "removeFromParent", "(", ")", ";", "return", "true", ";" ]

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

[ "static", "int", "rs6000_use_sched_lookahead", "(", "void", ")", "{", "if", "(", "rs6000_cpu_attr", "==", "CPU_PPC8540", ")" ]

[ "<FIXS>", "mnemonic", ",", "<STR_LIT>", ",", "pattern", ",", "itin", ">", ";", "<FIXE>", "<FIXS>", "(", "implicit", "EFLAGS", ")", "]", ">", ",", "Sched", "[", "WriteALULd", ",", "WriteRMW", "]", ">", ";", "<FIXE>", "<FIXS>", "[", "(", "store", "(", "opnode", "(", "load", "addr", ":", "$", "dst", ")", ",", "typeinfo", ".", "RegClass", ":", "$", "src", ",", "EFLAGS", ")", ",", "addr", ":", "$", "dst", ")", ",", "(", "implicit", "EFLAGS", ")", "]", ",", "IIC_BIN_CARRY_MEM", ">", ",", "Sched", "[", "WriteALULd", ",", "WriteRMW", "]", ">", ";", "<FIXE>", "<FIXS>", "typeinfo", ".", "RegClass", ":", "$", "src", ")", ")", "]", ">", ",", "Sched", "[", "WriteALULd", ",", "ReadAfterLd", "]", ">", ";", "<FIXE>" ]

[ "list", "dag", ">", "pattern", ",", "InstrItinClass", "itin", "=", "IIC_BIN_MEM", ">", ":", "ITy", "opcode", ",", "MRMDestMem", ",", "typeinfo", ",", "(", "outs", ")", ",", "(", "ins", "typeinfo", ".", "MemOperand", ":", "$", "dst", ",", "typeinfo", ".", "RegClass", ":", "$", "src", ")", ",", "<BUGS>", "mnemonic", ",", "<STR_LIT>", ",", "pattern", ",", "itin", ">", ",", "Sched", "[", "WriteALULd", ",", "WriteRMW", "]", ">", ";", "<BUGE>", "class", "BinOpMR_RMW", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "mnemonic", ",", "X86TypeInfo", "typeinfo", ",", "SDNode", "opnode", ">", ":", "BinOpMR", "opcode", ",", "mnemonic", ",", "typeinfo", ",", "[", "(", "store", "(", "opnode", "(", "load", "addr", ":", "$", "dst", ")", ",", "typeinfo", ".", "RegClass", ":", "$", "src", ")", ",", "addr", ":", "$", "dst", ")", ",", "<BUGS>", "(", "implicit", "EFLAGS", ")", "]", ">", ";", "<BUGE>", "class", "BinOpMR_RMW_FF", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "mnemonic", ",", "X86TypeInfo", "typeinfo", ",", "SDNode", "opnode", ">", ":", "BinOpMR", "opcode", ",", "mnemonic", ",", "typeinfo", ",", "<BUGS>", "[", "(", "store", "(", "opnode", "(", "load", "addr", ":", "$", "dst", ")", ",", "typeinfo", ".", "RegClass", ":", "$", "src", ",", "EFLAGS", ")", ",", "addr", ":", "$", "dst", ")", ",", "(", "implicit", "EFLAGS", ")", "]", ",", "IIC_BIN_CARRY_MEM", ">", ";", "<BUGE>", "class", "BinOpMR_F", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "mnemonic", ",", "X86TypeInfo", "typeinfo", ",", "SDPatternOperator", "opnode", ">", ":", "BinOpMR", "opcode", ",", "mnemonic", ",", "typeinfo", ",", "[", "(", "set", "EFLAGS", ",", "(", "opnode", "(", "typeinfo", ".", "LoadNode", "addr", ":", "$", "dst", ")", ",", "<BUGS>", "typeinfo", ".", "RegClass", ":", "$", "src", ")", ")", "]", ">", ";", "<BUGE>", "class", "BinOpMI", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "mnemonic", ",", "X86TypeInfo", "typeinfo", "," ]

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

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

[ "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VI1_AVX512", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_concat", ":", "VI1_AVX512", "(", "us_truncate", ":", "<", "ssehalfvecmode", ">", "(", "match_operand", ":", "<", "sseunpackmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "us_truncate", ":", "<", "ssehalfvecmode", ">", "(", "match_operand", ":", "<", "sseunpackmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

[ "}" ]

[ "unsigned", "j", "=", "DAG", ".", "getTarget", "(", ")", ".", "getDataLayout", "(", ")", "->", "isLittleEndian", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", ";", "i", "+=", "<NUM_LIT>", ")", "if", "(", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", ")", "return", "false", ";", "}", "return", "true", ";" ]

[ "::", "MOV64ri32", ":" ]

[ "Ops", ".", "push_back", "(", "dwarf", "::", "DW_OP_constu", ")", ";", "Ops", ".", "push_back", "(", "Coef", "+", "<NUM_LIT>", ")", ";", "Ops", ".", "push_back", "(", "dwarf", "::", "DW_OP_mul", ")", ";", "}", "else", "{", "if", "(", "Op", "&&", "Op2", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", "{", "int", "dwarfReg", "=", "TRI", "->", "getDwarfRegNum", "(", "Op2", ".", "getReg", "(", ")", ",", "false", ")", ";", "if", "(", "dwarfReg", "<", "<NUM_LIT>", ")", "return", "std", "::", "nullopt", ";", "else", "if", "(", "dwarfReg", "<", "<NUM_LIT>", ")", "{", "Ops", ".", "push_back", "(", "dwarf", "::", "DW_OP_breg0", "+", "dwarfReg", ")", ";", "Ops", ".", "push_back", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "Ops", ".", "push_back", "(", "dwarf", "::", "DW_OP_bregx", ")", ";", "Ops", ".", "push_back", "(", "dwarfReg", ")", ";", "Ops", ".", "push_back", "(", "<NUM_LIT>", ")", ";", "}", "}", "else", "if", "(", "!", "Op", ")", "{", "assert", "(", "Op2", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", ";", "Op", "=", "&", "Op2", ";", "}", "if", "(", "Coef", ">", "<NUM_LIT>", ")", "{", "assert", "(", "Op2", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", ";", "Ops", ".", "push_back", "(", "dwarf", "::", "DW_OP_constu", ")", ";", "Ops", ".", "push_back", "(", "Coef", ")", ";", "Ops", ".", "push_back", "(", "dwarf", "::", "DW_OP_mul", ")", ";", "}", "if", "(", "(", "(", "Op1", ".", "isReg", "(", ")", "&&", "Op1", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", "||", "Op1", ".", "isFI", "(", ")", ")", "&&", "Op2", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", "{", "Ops", ".", "push_back", "(", "dwarf", "::", "DW_OP_plus", ")", ";", "}", "}", "DIExpression", "::", "appendOffset", "(", "Ops", ",", "Offset", ")", ";", "Expr", "=", "DIExpression", "::", "get", "(", "MI", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ",", "Ops", ")", ";", "return", "ParamLoadedValue", "(", "*", "Op", ",", "Expr", ")", ";", "}", "case", "X86", "::", "MOV8ri", ":", "case", "X86", "::", "MOV16ri", ":", "return", "std", "::", "nullopt", ";", "case", "X86", "::", "MOV32ri", ":", "case", "X86", "::", "MOV64ri", ":", "case", "X86" ]

[ ")", ",", "(", "regno", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ",", "prefix", ",", "regno", ")", ";" ]

[ "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "if", "(", "TARGET_64BIT", ")", "goto", "aix_names", ";", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "<STR_LIT>", "_savegpr_", "<STR_LIT>", ":", "<STR_LIT>", "_restgpr_", "<STR_LIT>", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "<STR_LIT>", "_savefpr_", "<STR_LIT>", ":", "<STR_LIT>", "_restfpr_", "<STR_LIT>", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "<STR_LIT>", "_savevr_", "<STR_LIT>", ":", "<STR_LIT>", "_restvr_", "<STR_LIT>", ";", "else", "abort", "(", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_LR", ")", ")", "suffix", "=", "<STR_LIT>", "_x", "<STR_LIT>", ";", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "gcc_assert", "(", "!", "TARGET_AIX", "||", "(", "sel", "&", "SAVRES_REG", ")", "!=", "SAVRES_GPR", ")", ";", "aix_names", ":", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", ")", "prefix", "=", "(", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "<STR_LIT>", "_savegpr0_", "<STR_LIT>", ":", "<STR_LIT>", "_savegpr1_", "<STR_LIT>", ")", ":", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "<STR_LIT>", "_restgpr0_", "<STR_LIT>", ":", "<STR_LIT>", "_restgpr1_", "<STR_LIT>", ")", ")", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", ")", "{", "if", "(", "(", "sel", "&", "SAVRES_LR", ")", ")", "prefix", "=", "(", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "<STR_LIT>", "_savefpr_", "<STR_LIT>", ":", "<STR_LIT>", "_restfpr_", "<STR_LIT>", ")", ";", "else", "{", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "SAVE_FP_PREFIX", ":", "RESTORE_FP_PREFIX", ";", "suffix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "SAVE_FP_SUFFIX", ":", "RESTORE_FP_SUFFIX", ";", "}", "}", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "<STR_LIT>", "_savevr_", "<STR_LIT>", ":", "<STR_LIT>", "_restvr_", "<STR_LIT>", ";", "else", "abort", "(", ")", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "{", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "<STR_LIT>", "save", "<STR_LIT>", ":", "<STR_LIT>", "rest", "<STR_LIT>", ";", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", ")", "sprintf", "(", "savres_routine_name", ",", "<STR_LIT>", "*%sGPR%s%s%.0d ; %s r%d-r31", "<STR_LIT>", ",", "prefix", ",", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "<STR_LIT>", "x", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", ",", "(", "regno", "==", "<NUM_LIT>", "?", "<STR_LIT>", "<STR_LIT>", ":", "<STR_LIT>", "+", "<STR_LIT>", ")", ",", "(", "regno", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ",", "prefix", ",", "regno", ")", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", ")", "sprintf", "(", "savres_routine_name", ",", "<STR_LIT>", "*%sFP%s%.0d ; %s f%d-f31", "<STR_LIT>", ",", "prefix", ",", "(", "regno", "==", "<NUM_LIT>", "?", "<STR_LIT>", "<STR_LIT>", ":", "<STR_LIT>", "+", "<STR_LIT>", ")", ",", "(", "regno", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ",", "prefix", ",", "regno", ")", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "sprintf", "(", "savres_routine_name", ",", "<STR_LIT>", "*%sVEC%s%.0d ; %s v%d-v31", "<STR_LIT>", ",", "prefix", ",", "(", "regno", "==", "<NUM_LIT>", "?", "<STR_LIT>", "<STR_LIT>", ":", "<STR_LIT>", "+", "<STR_LIT>" ]

[ "LoadInst", "*", "LoadXY", "=", "Builder", ".", "CreateAlignedLoad", "(", "GEPXY", ",", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "!", "IsAMDHSA", ")", "{", "Function", "*", "LocalSizeYFn", "=", "Intrinsic", "::", "getDeclaration", "(", "Mod", ",", "Intrinsic", "::", "r600_read_local_size_y", ")", ";", "Function", "*", "LocalSizeZFn", "=", "Intrinsic", "::", "getDeclaration", "(", "Mod", ",", "Intrinsic", "::", "r600_read_local_size_z", ")", ";", "CallInst", "*", "LocalSizeY", "=", "Builder", ".", "CreateCall", "(", "LocalSizeYFn", ",", "{", "}", ")", ";", "CallInst", "*", "LocalSizeZ", "=", "Builder", ".", "CreateCall", "(", "LocalSizeZFn", ",", "{", "}", ")", ";", "LocalSizeY", "->", "setMetadata", "(", "LLVMContext", "::", "MD_range", ",", "MaxWorkGroupSizeRange", ")", ";", "LocalSizeZ", "->", "setMetadata", "(", "LLVMContext", "::", "MD_range", ",", "MaxWorkGroupSizeRange", ")", ";", "return", "std", "::", "make_pair", "(", "LocalSizeY", ",", "LocalSizeZ", ")", ";", "}", "assert", "(", "IsAMDGCN", ")", ";", "Function", "*", "DispatchPtrFn", "=", "Intrinsic", "::", "getDeclaration", "(", "Mod", ",", "Intrinsic", "::", "amdgcn_dispatch_ptr", ")", ";", "CallInst", "*", "DispatchPtr", "=", "Builder", ".", "CreateCall", "(", "DispatchPtrFn", ",", "{", "}", ")", ";", "DispatchPtr", "->", "addAttribute", "(", "AttributeSet", "::", "ReturnIndex", ",", "Attribute", "::", "NoAlias", ")", ";", "DispatchPtr", "->", "addAttribute", "(", "AttributeSet", "::", "ReturnIndex", ",", "Attribute", "::", "NonNull", ")", ";", "DispatchPtr", "->", "addDereferenceableAttr", "(", "AttributeSet", "::", "ReturnIndex", ",", "<NUM_LIT>", ")", ";", "Type", "*", "I32Ty", "=", "Type", "::", "getInt32Ty", "(", "Mod", "->", "getContext", "(", ")", ")", ";", "Value", "*", "CastDispatchPtr", "=", "Builder", ".", "CreateBitCast", "(", "DispatchPtr", ",", "PointerType", "::", "get", "(", "I32Ty", ",", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", ")", ";", "Value", "*", "GEPXY", "=", "Builder", ".", "CreateConstInBoundsGEP1_64", "(", "CastDispatchPtr", ",", "<NUM_LIT>", ")", ";" ]

[ "SDValue", "TGALo", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "SDValue", "TLSIndexLo", "=", "DAG", ".", "getTargetExternalSymbol", "(", "<STR_LIT>", "_tls_index", "<STR_LIT>", ",", "PtrVT", ",", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SDValue", "ADRP", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "TLSIndexHi", ")", ";", "SDValue", "TLSIndex", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "ADRP", ",", "TLSIndexLo", ")", ";", "TLSIndex", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "DL", ",", "Chain", ",", "TLSIndex", ",", "MachinePointerInfo", "(", ")", ")", ";", "Chain", "=", "TLSIndex", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "TLSIndex", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "PtrVT", ",", "TLSIndex", ")", ";", "SDValue", "Slot", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "PtrVT", ",", "TLSIndex", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "SDValue", "TLS", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "TLSArray", ",", "Slot", ")", ",", "MachinePointerInfo", "(", ")", ")", ";", "Chain", "=", "TLS", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "const", "GlobalAddressSDNode", "*", "GA", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ";", "const", "GlobalValue", "*", "GV", "=", "GA", "->", "getGlobal", "(", ")", ";", "SDValue", "TGAHi", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "static", "void", "rs6000_setup_reg_addr_masks", "(", "void", ")", "{", "ssize_t", "rc", ",", "reg", ",", "m", ",", "nregs", ";", "addr_mask_type", "any_addr_mask", ",", "addr_mask", ";", "for", "(", "m", "=", "<NUM_LIT>", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "{", "machine_mode", "m2", "=", "(", "machine_mode", ")", "m", ";", "bool", "complex_p", "=", "false", ";", "bool", "small_int_p", "=", "(", "m2", "==", "QImode", "||", "m2", "==", "HImode", "||", "m2", "==", "SImode", ")", ";", "size_t", "msize", ";", "if", "(", "COMPLEX_MODE_P", "(", "m2", ")", ")", "{", "complex_p", "=", "true", ";", "m2", "=", "GET_MODE_INNER", "(", "m2", ")", ";", "}", "msize", "=", "GET_MODE_SIZE", "(", "m2", ")", ";", "bool", "indexed_only_p", "=", "(", "m", "==", "SDmode", "&&", "TARGET_NO_SDMODE_STACK", ")", ";", "any_addr_mask", "=", "<NUM_LIT>", ";", "for", "(", "rc", "=", "FIRST_RELOAD_REG_CLASS", ";", "rc", "<=", "LAST_RELOAD_REG_CLASS", ";", "rc", "++", ")", "{", "addr_mask", "=", "<NUM_LIT>", ";", "reg", "=", "reload_reg_map", "[", "rc", "]", ".", "reg", ";", "if", "(", "reg", ">=", "<NUM_LIT>", "&&", "rs6000_hard_regno_mode_ok_p", "[", "m", "]", "[", "reg", "]", ")", "{", "bool", "small_int_vsx_p", "=", "(", "small_int_p", "&&", "(", "rc", "==", "RELOAD_REG_FPR", "||", "rc", "==", "RELOAD_REG_VMX", ")", ")", ";", "nregs", "=", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "reg", "]", ";", "addr_mask", "|=", "RELOAD_REG_VALID", ";", "if", "(", "small_int_vsx_p", ")", "addr_mask", "|=", "RELOAD_REG_INDEXED", ";", "else", "if", "(", "nregs", ">", "<NUM_LIT>", "||", "m", "==", "BLKmode", "||", "complex_p", ")", "addr_mask", "|=", "RELOAD_REG_MULTIPLE", ";", "else", "addr_mask", "|=", "RELOAD_REG_INDEXED", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "rc", "==", "RELOAD_REG_FPR", ")", "&&", "msize", "<=", "<NUM_LIT>", "&&", "!", "VECTOR_MODE_P", "(", "m2", ")", "&&", "!", "FLOAT128_VECTOR_P", "(", "m2", ")", "&&", "!", "complex_p", "&&", "!", "small_int_vsx_p", "&&", "(", "m2", "!=", "DFmode", "||", "!", "TARGET_UPPER_REGS_DF", ")", "&&", "(", "m2", "!=", "SFmode", "||", "!", "TARGET_UPPER_REGS_SF", ")", "&&", "!", "(", "TARGET_E500_DOUBLE", "&&", "msize", "==", "<NUM_LIT>", ")", ")", "{", "addr_mask", "|=", "RELOAD_REG_PRE_INCDEC", ";", "switch", "(", "m", ")", "{", "default", ":", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "E_DImode", ":", "if", "(", "TARGET_POWERPC64", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "E_DFmode", ":", "case", "E_DDmode", ":", "if", "(", "TARGET_DF_INSN", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "}", "}", "}", "if", "(", "(", "addr_mask", "!=", "<NUM_LIT>", ")", "&&", "!", "indexed_only_p", "&&", "msize", "<=", "<NUM_LIT>", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "(", "(", "msize", "==", "<NUM_LIT>", "||", "m2", "==", "SFmode", ")", "&&", "(", "rc", "==", "RELOAD_REG_FPR", "||", "(", "rc", "==", "RELOAD_REG_VMX", "&&", "TARGET_P9_DFORM_SCALAR", ")", ")", ")", ")", ")", "addr_mask", "|=", "RELOAD_REG_OFFSET", ";", "else", "if", "(", "(", "addr_mask", "!=", "<NUM_LIT>", ")", "&&", "!", "indexed_only_p", "&&", "msize", "==", "<NUM_LIT>", "&&", "TARGET_P9_DFORM_VECTOR", "&&", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "m2", ")", "||", "(", "m2", "==", "TImode", "&&", "TARGET_VSX_TIMODE", ")", ")", ")", "{", "addr_mask", "|=", "RELOAD_REG_OFFSET", ";", "if", "(", "rc", "==", "RELOAD_REG_FPR", "||", "rc", "==", "RELOAD_REG_VMX", ")", "addr_mask", "|=", "RELOAD_REG_QUAD_OFFSET", ";", "}", "if", "(", "rc", "==", "RELOAD_REG_VMX", "&&", "msize", "==", "<NUM_LIT>", "&&", "(", "addr_mask", "&", "RELOAD_REG_VALID", ")", "!=", "<NUM_LIT>", ")", "addr_mask", "|=", "RELOAD_REG_AND_M16", ";", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "rc", "]", "=", "addr_mask", ";", "any_addr_mask", "|=", "addr_mask", ";", "}", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "=", "any_addr_mask", ";", "}", "}" ]

[ "Update", "the", "addr", "mask", "bits", "in", "reg_addr", "to", "help", "secondary", "reload", "and", "go", "if", "legitimate", "address", "support", "to", "figure", "out", "the", "appropriate", "addressing", "to", "use", "." ]

[ ")", ";" ]

[ "else", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "RLWINM", ")", ",", "PtrReg", ")", ".", "addReg", "(", "Ptr1Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "SLW", ")", ",", "Incr2Reg", ")", ".", "addReg", "(", "incr", ")", ".", "addReg", "(", "ShiftReg", ")", ";", "if", "(", "is8bit", ")", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "LI", ")", ",", "Mask2Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "else", "{", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "LI", ")", ",", "Mask3Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "ORI", ")", ",", "Mask2Reg", ")", ".", "addReg", "(", "Mask3Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "SLW", ")", ",", "MaskReg", ")", ".", "addReg", "(", "Mask2Reg", ")", ".", "addReg", "(", "ShiftReg", ")", ";", "BB", "=", "loopMBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "LWARX", ")", ",", "TmpDestReg", ")", ".", "addReg", "(", "ZeroReg", ")", ".", "addReg", "(", "PtrReg", ")", ";", "if", "(", "BinOpcode", ")", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "TmpReg", ")", ".", "addReg", "(", "Incr2Reg", ")", ".", "addReg", "(", "TmpDestReg", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "ANDC8", ":", "PPC", "::", "ANDC", ")", ",", "Tmp2Reg", ")", ".", "addReg", "(", "TmpDestReg", ")", ".", "addReg", "(", "MaskReg", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "AND8", ":", "PPC", "::", "AND", ")", ",", "Tmp3Reg", ")", ".", "addReg", "(", "TmpReg", ")", ".", "addReg", "(", "MaskReg", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "OR8", ":", "PPC", "::", "OR", ")", ",", "Tmp4Reg", ")", ".", "addReg", "(", "Tmp3Reg", ")", ".", "addReg", "(", "Tmp2Reg", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "STWCX", ")", ")", ".", "addReg", "(", "Tmp4Reg", ")", ".", "addReg", "(", "ZeroReg", ")", ".", "addReg", "(", "PtrReg", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "BCC", ")", ")", ".", "addImm", "(", "PPC", "::", "PRED_NE", ")", ".", "addReg", "(", "PPC", "::", "CR0", ")", ".", "addMBB", "(", "loopMBB", ")", ";", "BB", "->", "addSuccessor", "(", "loopMBB" ]

[ "}" ]

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

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

[ "if", "(", "rx_max_constant_size", "==", "<NUM_LIT>", "||", "rx_max_constant_size", "==", "<NUM_LIT>", ")", "return", "true", ";", "return", "IN_RANGE", "(", "val", ",", "(", "HOST_WIDE_INT_M1U", "<<", "(", "rx_max_constant_size", "*", "<NUM_LIT>", ")", ")", "," ]

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

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

[ "if", "(", "wi", "::", "to_wide", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "count", "*", "GET_MODE_BITSIZE", "(", "*", "modep", ")", ")", "return", "-", "<NUM_LIT>", ";" ]

[ "if", "(", "*", "modep", "==", "mode", ")", "return", "<NUM_LIT>", ";", "break", ";", "case", "ARRAY_TYPE", ":", "{", "int", "count", ";", "tree", "index", "=", "TYPE_DOMAIN", "(", "type", ")", ";", "if", "(", "!", "COMPLETE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ")", "return", "-", "<NUM_LIT>", ";", "count", "=", "rs6000_aggregate_candidate", "(", "TREE_TYPE", "(", "type", ")", ",", "modep", ")", ";", "if", "(", "count", "==", "-", "<NUM_LIT>", "||", "!", "index", "||", "!", "TYPE_MAX_VALUE", "(", "index", ")", "||", "!", "tree_fits_uhwi_p", "(", "TYPE_MAX_VALUE", "(", "index", ")", ")", "||", "!", "TYPE_MIN_VALUE", "(", "index", ")", "||", "!", "tree_fits_uhwi_p", "(", "TYPE_MIN_VALUE", "(", "index", ")", ")", "||", "count", "<", "<NUM_LIT>", ")", "return", "-", "<NUM_LIT>", ";", "count", "*=", "(", "<NUM_LIT>", "+", "tree_to_uhwi", "(", "TYPE_MAX_VALUE", "(", "index", ")", ")", "-", "tree_to_uhwi", "(", "TYPE_MIN_VALUE", "(", "index", ")", ")", ")", ";", "if", "(", "wi", "::", "to_wide", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "count", "*", "GET_MODE_BITSIZE", "(", "*", "modep", ")", ")", "return", "-", "<NUM_LIT>", ";", "return", "count", ";", "}", "case", "RECORD_TYPE", ":", "{", "int", "count", "=", "<NUM_LIT>", ";", "int", "sub_count", ";", "tree", "field", ";", "if", "(", "!", "COMPLETE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ")", "return", "-", "<NUM_LIT>", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "sub_count", "=", "rs6000_aggregate_candidate", "(", "TREE_TYPE", "(", "field", ")", ",", "modep", ")", ";", "if", "(", "sub_count", "<", "<NUM_LIT>", ")", "return", "-", "<NUM_LIT>", ";", "count", "+=", "sub_count", ";", "}", "if", "(", "wi", "::", "to_wide", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "count", "*", "GET_MODE_BITSIZE", "(", "*", "modep", ")", ")", "return", "-", "<NUM_LIT>", ";", "return", "count", ";", "}", "case", "UNION_TYPE", ":", "case", "QUAL_UNION_TYPE", ":", "{", "int", "count", "=", "<NUM_LIT>", ";", "int", "sub_count", ";", "tree", "field", ";", "if", "(", "!", "COMPLETE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ")", "return", "-", "<NUM_LIT>", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "sub_count", "=", "rs6000_aggregate_candidate", "(", "TREE_TYPE", "(", "field", ")", ",", "modep", ")", ";", "if", "(", "sub_count", "<", "<NUM_LIT>", ")", "return", "-", "<NUM_LIT>", ";", "count", "=", "count", ">", "sub_count", "?", "count", ":", "sub_count", ";", "}" ]

[ "let", "isExtendable", "=", "<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", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "UNKNOWN_REGNUM", ")", ")", "]", ")", "]", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "]", ")", "]" ]

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

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

[ "def", "A2_vrsadub_acc", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rxx32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rxx32in", ",", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_d773585a", ",", "TypeM", ">", ",", "Enc_88c16c", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_struct_load_store_lane_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_STRUCT_LOAD_STORE_LANE_INDEX", ";" ]

[ "int", "k", ";", "bool", "neon", "=", "false", ";", "bool", "mve", "=", "false", ";", "if", "(", "IN_RANGE", "(", "fcode", ",", "ARM_BUILTIN_VFP_BASE", ",", "ARM_BUILTIN_ACLE_BASE", "-", "<NUM_LIT>", ")", ")", "neon", "=", "true", ";", "if", "(", "IN_RANGE", "(", "fcode", ",", "ARM_BUILTIN_MVE_BASE", ",", "ARM_BUILTIN_MAX", "-", "<NUM_LIT>", ")", ")", "mve", "=", "true", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "<NUM_LIT>", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "<NUM_LIT>", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "<NUM_LIT>", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_pair_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_PAIR_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_quadtup_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_QUADTUP_INDEX", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";" ]

[ "}", "else", "if", "(", "RegVT", "==", "MVT", "::", "i16", ")", "{", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unknown argument type!", "<STR_LIT>", ")", ";", "}", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "RC", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RegVT", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":" ]

[ ")", ";" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** determineCalleeSaves\\nUsed CSRs:", "<STR_LIT>", ")", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "CSRegs", "[", "i", "]", ";", "i", "+=", "<NUM_LIT>", ")", "{", "assert", "(", "CSRegs", "[", "i", "+", "<NUM_LIT>", "]", "&&", "<STR_LIT>", "Odd number of callee-saved registers!", "<STR_LIT>", ")", ";", "const", "unsigned", "OddReg", "=", "CSRegs", "[", "i", "]", ";", "const", "unsigned", "EvenReg", "=", "CSRegs", "[", "i", "+", "<NUM_LIT>", "]", ";", "assert", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "OddReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "EvenReg", ")", ")", "^", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "OddReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "EvenReg", ")", ")", "&&", "<STR_LIT>", "Register class mismatch!", "<STR_LIT>", ")", ";", "const", "bool", "OddRegUsed", "=", "SavedRegs", ".", "test", "(", "OddReg", ")", ";", "const", "bool", "EvenRegUsed", "=", "SavedRegs", ".", "test", "(", "EvenReg", ")", ";", "if", "(", "!", "OddRegUsed", "&&", "!", "EvenRegUsed", ")", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "OddReg", ")", ")", "{", "UnspilledCSGPRs", ".", "push_back", "(", "OddReg", ")", ";", "UnspilledCSGPRs", ".", "push_back", "(", "EvenReg", ")", ";", "}", "else", "{", "UnspilledCSFPRs", ".", "push_back", "(", "OddReg", ")", ";", "UnspilledCSFPRs", ".", "push_back", "(", "EvenReg", ")", ";", "}", "continue", ";", "}", "unsigned", "Reg", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "OddRegUsed", "^", "EvenRegUsed", ")", "{", "Reg", "=", "OddRegUsed", "?", "EvenReg", ":", "OddReg", ";", "SavedRegs", ".", "set", "(", "Reg", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "'", "'", "<<", "PrintReg", "(", "OddReg", ",", "RegInfo", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "'", "'", "<<", "PrintReg", "(", "EvenReg", ",", "RegInfo", ")", ")", ";", "assert", "(", "(", "(", "OddReg", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "EvenReg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "(", "RegInfo", "->", "getEncodingValue", "(", "OddReg", ")", "+", "<NUM_LIT>", "==", "RegInfo", "->", "getEncodingValue", "(", "EvenReg", ")", ")", ")", "&&", "<STR_LIT>", "Register pair of non-adjacent registers!", "<STR_LIT>", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "OddReg", ")", ")", "{", "NumGPRSpilled", "+=", "<NUM_LIT>", ";", "if", "(", "Reg", "!=", "<STR_LIT>", "::", "<STR_LIT>", "&&", "!", "RegInfo", "->", "isReservedReg", "(", "MF", ",", "Reg", ")", ")", "ExtraCSSpill", "=", "true", ";", "}", "else", "NumFPRSpilled", "+=", "<NUM_LIT>", ";", "CanEliminateFrame", "=", "false", ";", "}", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "MFI", "->", "estimateStackSize", "(", "MF", ")", "+", "<NUM_LIT>", "*", "(", "NumGPRSpilled", "+", "NumFPRSpilled", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Estimated stack frame size: ", "<STR_LIT>", "<<", "CFSize", "<<", "<STR_LIT>", " bytes.\\n", "<STR_LIT>", ")", ";", "bool", "BigStack", "=", "(", "CFSize", ">=", "<NUM_LIT>", ")", ";", "if", "(", "BigStack", "||", "!", "CanEliminateFrame", "||", "RegInfo", "->", "cannotEliminateFrame", "(", "MF", ")", ")", "AFI", "->", "setHasStackFrame", "(", "true", ")", ";", "if", "(", "BigStack", "&&", "!", "ExtraCSSpill", ")", "{", "assert", "(", "(", "(", "UnspilledCSGPRs", ".", "size", "(", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Odd number of registers!", "<STR_LIT>", ")", ";", "unsigned", "Count", "=", "<NUM_LIT>", ";", "while", "(", "!", "UnspilledCSGPRs", ".", "empty", "(", ")", "&&", "Count", "<", "<NUM_LIT>", ")", "{", "unsigned", "Reg", "=", "UnspilledCSGPRs", ".", "back", "(", ")", ";", "UnspilledCSGPRs", ".", "pop_back", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Spilling ", "<STR_LIT>", "<<", "PrintReg", "(", "Reg", ",", "RegInfo", ")", "<<", "<STR_LIT>", " to get a scratch register.\\n", "<STR_LIT>", ")", ";", "SavedRegs", ".", "set", "(", "Reg", ")", ";", "ExtraCSSpill", "=", "true", ";", "++", "Count", ";", "}", "if", "(", "!", "ExtraCSSpill", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "int", "FI", "=", "MFI", "->", "CreateStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "RC", "->", "getAlignment", "(", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI" ]

[ "static", "void", "*", "ix86_init_cost", "(", "class", "loop", "*", ")", "{", "unsigned", "*", "cost", "=", "XNEWVEC", "(", "unsigned", ",", "<NUM_LIT>", ")", ";", "cost", "[", "vect_prologue", "]", "=", "cost", "[", "vect_body", "]", "=", "cost", "[", "vect_epilogue", "]", "=", "<NUM_LIT>", ";", "return", "cost", ";", "}" ]

[ "Implement", "targetm.vectorize.init_cost", "." ]

[ "<FIXS>", "emitSegmentOverridePrefix", "(", "MemoryOperand", "+", "X86", "::", "AddrSegmentReg", ",", "MI", ",", "OS", ")", ";", "<FIXE>", "<FIXS>", "emitByte", "(", "<NUM_LIT>", ",", "OS", ")", ";", "<FIXE>", "<FIXS>", "emitByte", "(", "<NUM_LIT>", ",", "OS", ")", ";", "<FIXE>" ]

[ "if", "(", "MemoryOperand", "!=", "-", "<NUM_LIT>", ")", "{", "MemoryOperand", "+=", "CurOp", ";", "<BUGS>", "emitSegmentOverridePrefix", "(", "CurByte", ",", "MemoryOperand", "+", "X86", "::", "AddrSegmentReg", ",", "MI", ",", "OS", ")", ";", "<BUGE>", "}", "unsigned", "Flags", "=", "MI", ".", "getFlags", "(", ")", ";", "if", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", "||", "Flags", "&", "X86", "::", "IP_HAS_REPEAT", ")", "<BUGS>", "emitByte", "(", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";", "<BUGE>", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT_NE", ")", "<BUGS>", "emitByte", "(", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";", "<BUGE>", "bool", "NeedAddressOverride", ";" ]

[ "<FIXS>", "if", "(", "T", "==", "LGKM_CNT", "&&", "hasPendingEvent", "(", "SMEM_ACCESS", ")", ")", "return", "true", ";", "return", "MixedPendingEvents", "[", "T", "]", ";", "<FIXE>" ]

[ "setScoreLB", "(", "T", ",", "std", "::", "max", "(", "getScoreLB", "(", "T", ")", ",", "UB", "-", "(", "int32_t", ")", "Count", ")", ")", ";", "}", "else", "{", "setScoreLB", "(", "T", ",", "UB", ")", ";", "}", "}", "bool", "BlockWaitcntBrackets", "::", "counterOutOfOrder", "(", "InstCounterType", "T", ")", "const", "{", "<BUGS>", "switch", "(", "T", ")", "{", "case", "VM_CNT", ":", "return", "false", ";", "case", "LGKM_CNT", ":", "{", "if", "(", "EventUBs", "[", "SMEM_ACCESS", "]", ">", "ScoreLBs", "[", "LGKM_CNT", "]", "&&", "EventUBs", "[", "SMEM_ACCESS", "]", "<=", "ScoreUBs", "[", "LGKM_CNT", "]", ")", "{", "return", "true", ";", "}", "int", "NumEventTypes", "=", "<NUM_LIT>", ";", "if", "(", "EventUBs", "[", "LDS_ACCESS", "]", ">", "ScoreLBs", "[", "LGKM_CNT", "]", "&&", "EventUBs", "[", "LDS_ACCESS", "]", "<=", "ScoreUBs", "[", "LGKM_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "EventUBs", "[", "GDS_ACCESS", "]", ">", "ScoreLBs", "[", "LGKM_CNT", "]", "&&", "EventUBs", "[", "GDS_ACCESS", "]", "<=", "ScoreUBs", "[", "LGKM_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "EventUBs", "[", "SQ_MESSAGE", "]", ">", "ScoreLBs", "[", "LGKM_CNT", "]", "&&", "EventUBs", "[", "SQ_MESSAGE", "]", "<=", "ScoreUBs", "[", "LGKM_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "NumEventTypes", "<=", "<NUM_LIT>", ")", "{", "return", "false", ";", "}", "break", ";", "}", "case", "EXP_CNT", ":", "{", "if", "(", "MixedExpTypes", ")", "return", "true", ";", "int", "NumEventTypes", "=", "<NUM_LIT>", ";", "if", "(", "EventUBs", "[", "EXP_GPR_LOCK", "]", ">", "ScoreLBs", "[", "EXP_CNT", "]", "&&", "EventUBs", "[", "EXP_GPR_LOCK", "]", "<=", "ScoreUBs", "[", "EXP_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "EventUBs", "[", "GDS_GPR_LOCK", "]", ">", "ScoreLBs", "[", "EXP_CNT", "]", "&&", "EventUBs", "[", "GDS_GPR_LOCK", "]", "<=", "ScoreUBs", "[", "EXP_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "EventUBs", "[", "VMW_GPR_LOCK", "]", ">", "ScoreLBs", "[", "EXP_CNT", "]", "&&", "EventUBs", "[", "VMW_GPR_LOCK", "]", "<=", "ScoreUBs", "[", "EXP_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "EventUBs", "[", "EXP_PARAM_ACCESS", "]", ">", "ScoreLBs", "[", "EXP_CNT", "]", "&&", "EventUBs", "[", "EXP_PARAM_ACCESS", "]", "<=", "ScoreUBs", "[", "EXP_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "EventUBs", "[", "EXP_POS_ACCESS", "]", ">", "ScoreLBs", "[", "EXP_CNT", "]", "&&", "EventUBs", "[", "EXP_POS_ACCESS", "]", "<=", "ScoreUBs", "[", "EXP_CNT", "]", ")", "{", "NumEventTypes", "++", ";", "}", "if", "(", "NumEventTypes", "<=", "<NUM_LIT>", ")", "{", "return", "false", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "true", ";", "<BUGE>", "}", "INITIALIZE_PASS_BEGIN", "(", "SIInsertWaitcnts", ",", "DEBUG_TYPE", ",", "<STR_LIT>", "SI Insert Waitcnts", "<STR_LIT>", ",", "false", "," ]

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

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

[ "(", "fix", ":", "V4SI", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

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

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "CS", "]", ";" ]

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

[ "(", "define_code_attr", "tbz", "[", "(", "eq", "<STR_LIT>", ")", "(", "ne", "<STR_LIT>", ")", "(", "lt", "<STR_LIT>", ")", "(", "ge" ]

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

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

[ "return", "!", "MaskedInsts", ".", "empty", "(", ")", ";" ]

[ "}", "else", "if", "(", "auto", "*", "Int", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "Int", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "fma", ")", "continue", ";", "for", "(", "auto", "&", "U", ":", "Int", "->", "args", "(", ")", ")", "{", "if", "(", "isa", "<", "VectorType", ">", "(", "U", "->", "getType", "(", ")", ")", ")", "return", "false", ";", "}", "}", "}", "}" ]

[ "APInt", "UsefulBitsForUse", "=", "APInt", "(", "UsefulBits", ")", ";" ]

[ "unsigned", "Bitwidth", "=", "Op", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "UsefulBits", "=", "APInt", "(", "Bitwidth", ",", "<NUM_LIT>", ")", ";", "UsefulBits", ".", "flipAllBits", "(", ")", ";", "}", "APInt", "UsersUsefulBits", "(", "UsefulBits", ".", "getBitWidth", "(", ")", ",", "<NUM_LIT>", ")", ";", "for", "(", "SDNode", "*", "Node", ":", "Op", ".", "getNode", "(", ")", "->", "uses", "(", ")", ")", "{" ]

[ ",", "ptr", "->", "x_ix86_fpmath", ",", "false", ",", "true", ")", ";" ]

[ "static", "void", "ix86_function_specific_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "char", "*", "target_string", "=", "ix86_target_string", "(", "ptr", "->", "x_ix86_isa_flags", ",", "ptr", "->", "x_ix86_isa_flags2", ",", "ptr", "->", "x_target_flags", ",", "ptr", "->", "x_ix86_target_flags", ",", "NULL", ",", "NULL" ]

[ "<FIXS>", "#", "include", "<STR_LIT>", "recog.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "tm_p.h", "<STR_LIT>", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "function.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "expr.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "flags.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "machmode.h", "<STR_LIT>", "<BUGE>", "extern", "char", "regs_ever_live", "[", "]", ";" ]

[ "if", "(", "EnableEmExceptionHandling", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenExceptions", "(", ")", ")", ";" ]

[ "else", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";" ]

[ "i64", ",", "[", "{" ]

[ "def", "imm0_31", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<" ]

[ "}" ]

[ "vsra_n_u32", "(", "uint32x2_t", "_", "_", "a", ",", "uint32x2_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "uint32x2_t", ")", "_", "_", "builtin_neon_vsrau_nv2si", "(", "(", "int32x2_t", ")", "_", "_", "a", ",", "(", "int32x2_t", ")", "_", "_", "b", ",", "_", "_", "c", ")", ";" ]

[ "bool", "AlphaAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "if", "(", "TM", ".", "getSubtarget", "<", "AlphaSubtarget", ">", "(", ")", ".", "hasCT", "(", ")", ")", "O", "<<", "<STR_LIT>", "\\t.arch ev6\\n", "<STR_LIT>", ";", "else", "O", "<<", "<STR_LIT>", "\\t.arch ev6\\n", "<STR_LIT>", ";", "O", "<<", "<STR_LIT>", "\\t.set noat\\n", "<STR_LIT>", ";", "return", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "}" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "HI", "(", "any_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "static", "void", "bpf_init_builtins", "(", "void", ")", "{", "tree", "ullt", "=", "long_long_unsigned_type_node", ";", "def_builtin", "(", "<STR_LIT>", "__builtin_bpf_load_byte", "<STR_LIT>", ",", "BPF_BUILTIN_LOAD_BYTE", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "<NUM_LIT>", ")", ")", ";", "def_builtin", "(", "<STR_LIT>", "__builtin_bpf_load_half", "<STR_LIT>", ",", "BPF_BUILTIN_LOAD_HALF", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "<NUM_LIT>", ")", ")", ";", "def_builtin", "(", "<STR_LIT>", "__builtin_bpf_load_word", "<STR_LIT>", ",", "BPF_BUILTIN_LOAD_WORD", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "<NUM_LIT>", ")", ")", ";", "def_builtin", "(", "<STR_LIT>", "__builtin_preserve_access_index", "<STR_LIT>", ",", "BPF_BUILTIN_PRESERVE_ACCESS_INDEX", ",", "build_function_type_list", "(", "ptr_type_node", ",", "ptr_type_node", ",", "<NUM_LIT>", ")", ")", ";", "def_builtin", "(", "<STR_LIT>", "__builtin_preserve_field_info", "<STR_LIT>", ",", "BPF_BUILTIN_PRESERVE_FIELD_INFO", ",", "build_function_type_list", "(", "unsigned_type_node", ",", "ptr_type_node", ",", "unsigned_type_node", ",", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "Define", "machine-specific", "built-in", "functions", "." ]

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

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

[ "<STR_LIT>", ")" ]

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

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

[ "(", "minus", ":", "SI", "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "void", "XCoreFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "XCoreSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "int", "RemainingAdj", "=", "MFI", ".", "getStackSize", "(", ")", ";", "assert", "(", "RemainingAdj", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Misaligned frame size", "<STR_LIT>", ")", ";", "RemainingAdj", "/", "=", "<NUM_LIT>", ";", "if", "(", "RetOpcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "Constant", "*", "PersonalityFn", "=", "Fn", "->", "hasPersonalityFn", "(", ")", "?", "Fn", "->", "getPersonalityFn", "(", ")", ":", "nullptr", ";", "SmallVector", "<", "StackSlotInfo", ",", "<NUM_LIT>", ">", "SpillList", ";", "GetEHSpillList", "(", "SpillList", ",", "MFI", ",", "XFI", ",", "PersonalityFn", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "RestoreSpillList", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "RemainingAdj", ",", "SpillList", ")", ";", "unsigned", "EhStackReg", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "EhHandlerReg", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "EhStackReg", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "EhHandlerReg", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "return", ";", "}", "bool", "restoreLR", "=", "XFI", "->", "hasLRSpillSlot", "(", ")", ";", "bool", "UseRETSP", "=", "restoreLR", "&&", "RemainingAdj", "&&", "(", "MFI", ".", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "==", "<NUM_LIT>", ")", ";", "if", "(", "UseRETSP", ")", "restoreLR", "=", "false", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "FP", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "FramePtr", ")", ";", "SmallVector", "<", "StackSlotInfo", ",", "<NUM_LIT>", ">", "SpillList", ";", "GetSpillList", "(", "SpillList", ",", "MFI", ",", "XFI", ",", "restoreLR", ",", "FP", ")", ";", "RestoreSpillList", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "RemainingAdj", ",", "SpillList", ")", ";", "if", "(", "RemainingAdj", ")", "{", "IfNeededLDAWSP", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "<NUM_LIT>", ",", "RemainingAdj", ")", ";", "if", "(", "UseRETSP", ")", "{", "assert", "(", "RetOpcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "RetOpcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int", "Opcode", "=", "isImmU6", "(", "RemainingAdj", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "RemainingAdj", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "MIB", "->", "addOperand", "(", "MBBI", "->", "getOperand", "(", "i", ")", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "int", "Opcode", "=", "isImmU6", "(", "RemainingAdj", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "RemainingAdj", ")", ";", "}", "}", "}" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

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

[ "bits", "<", "<NUM_LIT>", ">", "imod", ";", "bits", "<", "<NUM_LIT>", ">", "iflags", ";", "bits", "<", "<NUM_LIT>", ">", "mode", ";", "bit", "M", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imod", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "M", ";" ]

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

[ "[", "(", "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>", ")", "(", "any_extend", ":", "DI", "(", "unspec", ":", "I124MODE", "[", "(", "unspec", ":", "I124MODE", "[", "(", "mem", ":", "I124MODE", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "UNSPEC_NON_TEMPORAL", ")", "]", "UNSPEC_LATENCY_L2", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "replace_equiv_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ",", "<FIXE>" ]

[ "emit_insn", "(", "gen_addsi3", "(", "operands", "[", "<NUM_LIT>", "]", ",", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "replace_equiv_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ",", "<BUGE>", "operands", "[", "<NUM_LIT>", "]", ")", ")", "if", "(", "code", "=", "=", "POST_DEC", ")" ]

[ "<FIXS>", "(", "zero_extend", ":", "DWI", ">", "<FIXE>", "<FIXS>", "(", "plus", ":", "SWI48", "(", "match_operator", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "plus", ":", "DWI", ">", "(", "zero_extend", ":", "DWI", ">", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_operator", ":", "DWI", ">", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "<FIXE>", "<FIXS>", "(", "plus", ":", "SWI48", "(", "plus", ":", "SWI48", "(", "match_op_dup", "<NUM_LIT>", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CCC", "FLAGS_REG", ")", "(", "compare", ":", "CCC", "<BUGS>", "(", "plus", ":", "SWI48", "<BUGE>", "(", "plus", ":", "SWI48", "<BUGS>", "(", "match_operator", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "<BUGE>", "(", "set", "(", "match_operand", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "plus", ":", "SWI48", "(", "plus", ":", "SWI48", "(", "match_op_dup", "<NUM_LIT>", "<BUGE>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "}" ]

[ "const", "char", "*", "mangle", ";", "if", "(", "(", "mangle", "=", "aarch64_mangle_builtin_vector_type", "(", "type", ")", ")", "||", "(", "mangle", "=", "aarch64_mangle_builtin_scalar_type", "(", "type", ")", ")", ")", "return", "mangle", ";", "return", "NULL", ";" ]

[ "}" ]

[ "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "MipsUimm5Lsl2AsmOperand", ";" ]

[ "PI", ".", "ComputePGMRSrc1", ")", ")", ";" ]

[ "memset", "(", "&", "KernelDescriptor", ",", "<NUM_LIT>", ",", "sizeof", "(", "KernelDescriptor", ")", ")", ";", "assert", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "PI", ".", "ScratchSize", ")", ")", ";", "assert", "(", "isUInt", "<", "<NUM_LIT>", ">", "(" ]

[ "}" ]

[ "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "RegisterCoalescerID", ",", "&", "SIPreAllocateWWMRegsID", ",", "false", ")", ";", "TargetPassConfig", "::", "addFastRegAlloc", "(", ")", ";" ]

[ "<FIXS>", "if", "(", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "<FIXE>" ]

[ "assert", "(", "(", "!", "MF", ".", "getInfo", "PPCFunctionInfo", ">", "(", ")", "->", "mustSaveTOC", "(", ")", "||", "(", "Reg", "!=", "PPC", "::", "X2", "&&", "Reg", "!=", "PPC", "::", "R2", ")", ")", "&&", "<STR_LIT>", "Not expecting to try to spill R2 in a function that must save TOC", "<STR_LIT>", ")", ";", "<BUGS>", "if", "(", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "Reg", ")", "||", "PPC", "::", "SPE4RCRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "<BUGE>", "HasGPSaveArea", "=", "true", ";", "GPRegs", ".", "push_back", "(", "CSI", "[", "i", "]", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "dst2", ";", "bits", "<", "<NUM_LIT>", ">", "base", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "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>", ";" ]

[ "<FIXS>", "else", "if", "(", "ResolveZero", "&&", "SrcEltBits", "[", "SrcIdx", "]", "[", "M", "]", "==", "<NUM_LIT>", ")", "<FIXE>" ]

[ "if", "(", "IsSrcConstant", "[", "SrcIdx", "]", ")", "{", "if", "(", "UndefSrcElts", "[", "SrcIdx", "]", "[", "M", "]", ")", "Mask", "[", "i", "]", "=", "SM_SentinelUndef", ";", "<BUGS>", "else", "if", "(", "SrcEltBits", "[", "SrcIdx", "]", "[", "M", "]", "==", "<NUM_LIT>", ")", "<BUGE>", "Mask", "[", "i", "]", "=", "SM_SentinelZero", ";", "}", "}" ]

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

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

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

[ "void", "EmitARM64WinCFISaveRegPX", "(", "unsigned", "Reg", ",", "int", "Offset", ")", "override", "{", "OS", "<<", "<STR_LIT>", "\\t.seh_save_regp_x\\tx", "<STR_LIT>", "<<", "Reg", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "Offset" ]

[ "<FIXS>", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ")", ";", "<FIXE>", "<FIXS>", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ")", ";", "<FIXE>" ]

[ "assert", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "ppcf128", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<BUGS>", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<BUGS>", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "SDValue", "FPreg", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "f64", ",", "Lo", ",", "Hi", ")", ";" ]

[ "static", "void", "nios2_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "gcc_assert", "(", "size", "==", "<NUM_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.4byte\\t%%tls_ldo(", "<STR_LIT>", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", ")", "<STR_LIT>", ")", ";", "}" ]

[ "Implement", "TARGET_ASM_OUTPUT_DWARF_DTPREL", "." ]

[ ")", ";" ]

[ "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\n", "<STR_LIT>" ]

[ "<FIXS>", "def", ":", "InstRW", "[", "ADLPWriteResGroup12", ",", "ReadAfterLd", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "ADLPWriteResGroup12", ",", "ReadAfterLd", "]", ",", "(", "instrs", "AND64rm", ")", ">", ";", "<FIXE>" ]

[ "}", "def", ":", "InstRW", "[", "ADLPWriteResGroup12", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "ADLPWriteResGroup12", "]", ",", "(", "instrs", "TEST64mi32", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "ADLPWriteResGroup12", ",", "ReadAfterLd", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "ADLPWriteResGroup12", ",", "ReadAfterLd", ",", "ReadDefault", ",", "ReadDefault", ",", "ReadDefault", ",", "ReadDefault", ",", "ReadDefault", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", "ADLPWriteResGroup13", ":", "SchedWriteRes", "[", "ADLPPort01_05_10", ",", "ADLPPort02_03_11", "]", ">", "{" ]

[ "<FIXS>", "return", "GR", ".", "getOrCreateConstVector", "(", "One", ".", "getZExtValue", "(", ")", ",", "I", ",", "ResType", ",", "TII", ")", ";", "<FIXE>" ]

[ "APInt", "One", "=", "AllOnes", "?", "APInt", "::", "getAllOnes", "(", "BitWidth", ")", ":", "APInt", "::", "getOneBitSet", "(", "BitWidth", ",", "<NUM_LIT>", ")", ";", "if", "(", "ResType", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "<BUGS>", "return", "GR", ".", "getOrCreateConsIntVector", "(", "One", ".", "getZExtValue", "(", ")", ",", "I", ",", "ResType", ",", "TII", ")", ";", "<BUGE>", "return", "GR", ".", "getOrCreateConstInt", "(", "One", ".", "getZExtValue", "(", ")", ",", "I", ",", "ResType", ",", "TII", ")", ";", "}" ]

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

[ "class", "BaseMulAccum", "<", "bit", "isSub", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "multype", ",", "RegisterClass", "addtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "addtype", ":", "$", "Rd", ")", ",", "(", "ins", "multype", ":", "$", "Rn", ",", "multype", ":", "$", "Rm", ",", "addtype", ":", "$", "Ra", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "Ra", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Unexpected node to lower", "<STR_LIT>", ")", ";" ]

[ "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "lowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "lowerSMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "lowerOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_STORE", ":", "return", "lowerATOMIC_STORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "return", "lowerATOMIC_LOAD_SUB", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "return", "lowerATOMIC_LOAD_OP", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "lowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKSAVE", ":", "return", "lowerSTACKSAVE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "lowerSTACKRESTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "PREFETCH", ":", "return", "lowerPREFETCH", "(", "Op", ",", "DAG", ")", ";", "default", ":" ]

[ "default", ":" ]

[ "case", "ADDR_SPACE_NEAR", ":", "return", "HImode", ";", "case", "ADDR_SPACE_FAR", ":", "return", "SImode", ";" ]

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

[ "let", "neverHasSideEffects", "=", "<NUM_LIT>", "indef", "VNEGf32d_sfp", ":", "N2V", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "DPR_VFP2", ":", "$", "dst", ")", ",", "(", "ins", "DPR_VFP2", ":", "$", "src", ")", ",", "IIC_VUNAD", ",", "<BUGS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "def", ":", "N2VDIntsPat", "fneg", ",", "VNEGf32d_sfp", ">", ";" ]

[ "void", "X86FrameLowering", "::", "adjustForHiPEPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "PrologueMBB", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", ";", "assert", "(", "&", "(", "*", "MF", ".", "begin", "(", ")", ")", "==", "&", "PrologueMBB", "&&", "<STR_LIT>", "Shrink-wrapping not supported yet", "<STR_LIT>", ")", ";", "NamedMDNode", "*", "HiPELiteralsMD", "=", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getNamedMetadata", "(", "<STR_LIT>", "hipe.literals", "<STR_LIT>", ")", ";", "if", "(", "!", "HiPELiteralsMD", ")", "report_fatal_error", "(", "<STR_LIT>", "Can't generate HiPE prologue without runtime parameters", "<STR_LIT>", ")", ";", "const", "unsigned", "HipeLeafWords", "=", "getHiPELiteral", "(", "HiPELiteralsMD", ",", "Is64Bit", "?", "<STR_LIT>", "AMD64_LEAF_WORDS", "<STR_LIT>", ":", "<STR_LIT>", "X86_LEAF_WORDS", "<STR_LIT>", ")", ";", "const", "unsigned", "CCRegisteredArgs", "=", "Is64Bit", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "const", "unsigned", "Guaranteed", "=", "HipeLeafWords", "*", "SlotSize", ";", "unsigned", "CallerStkArity", "=", "MF", ".", "getFunction", "(", ")", "->", "arg_size", "(", ")", ">", "CCRegisteredArgs", "?", "MF", ".", "getFunction", "(", ")", "->", "arg_size", "(", ")", "-", "CCRegisteredArgs", ":", "<NUM_LIT>", ";", "unsigned", "MaxStack", "=", "MFI", ".", "getStackSize", "(", ")", "+", "CallerStkArity", "*", "SlotSize", "+", "SlotSize", ";", "assert", "(", "STI", ".", "isTargetLinux", "(", ")", "&&", "<STR_LIT>", "HiPE prologue is only supported on Linux operating systems.", "<STR_LIT>", ")", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", ")", "{", "unsigned", "MoreStackForCalls", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "continue", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "continue", ";", "const", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "!", "F", ")", "continue", ";", "if", "(", "F", "->", "getName", "(", ")", ".", "find", "(", "<STR_LIT>", "erlang.", "<STR_LIT>", ")", "!=", "StringRef", "::", "npos", "||", "F", "->", "getName", "(", ")", ".", "find", "(", "<STR_LIT>", "bif_", "<STR_LIT>", ")", "!=", "StringRef", "::", "npos", "||", "F", "->", "getName", "(", ")", ".", "find_first_of", "(", "<STR_LIT>", "._", "<STR_LIT>", ")", "==", "StringRef", "::", "npos", ")", "continue", ";", "unsigned", "CalleeStkArity", "=", "F", "->", "arg_size", "(", ")", ">", "CCRegisteredArgs", "?", "F", "->", "arg_size", "(", ")", "-", "CCRegisteredArgs", ":", "<NUM_LIT>", ";", "if", "(", "HipeLeafWords", "-", "<NUM_LIT>", ">", "CalleeStkArity", ")", "MoreStackForCalls", "=", "std", "::", "max", "(", "MoreStackForCalls", ",", "(", "HipeLeafWords", "-", "<NUM_LIT>", "-", "CalleeStkArity", ")", "*", "SlotSize", ")", ";", "}", "}", "MaxStack", "+=", "MoreStackForCalls", ";", "}", "if", "(", "MaxStack", ">", "Guaranteed", ")", "{", "MachineBasicBlock", "*", "stackCheckMBB", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "MachineBasicBlock", "*", "incStackMBB", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "for", "(", "const", "auto", "&", "LI", ":", "PrologueMBB", ".", "liveins", "(", ")", ")", "{", "stackCheckMBB", "->", "addLiveIn", "(", "LI", ")", ";", "incStackMBB", "->", "addLiveIn", "(", "LI", ")", ";", "}", "MF", ".", "push_front", "(", "incStackMBB", ")", ";", "MF", ".", "push_front", "(", "stackCheckMBB", ")", ";", "unsigned", "ScratchReg", ",", "SPReg", ",", "PReg", ",", "SPLimitOffset", ";", "unsigned", "LEAop", ",", "CMPop", ",", "CALLop", ";", "SPLimitOffset", "=", "getHiPELiteral", "(", "HiPELiteralsMD", ",", "<STR_LIT>", "P_NSP_LIMIT", "<STR_LIT>", ")", ";", "if", "(", "Is64Bit", ")", "{", "SPReg", "=", "X86", "::", "RSP", ";", "PReg", "=", "X86", "::", "RBP", ";", "LEAop", "=", "X86", "::", "LEA64r", ";", "CMPop", "=", "X86", "::", "CMP64rm", ";", "CALLop", "=", "X86", "::", "CALL64pcrel32", ";", "}", "else", "{", "SPReg", "=", "X86", "::", "ESP", ";", "PReg", "=", "X86", "::", "EBP", ";", "LEAop", "=", "X86", "::", "LEA32r", ";", "CMPop", "=", "X86", "::", "CMP32rm", ";", "CALLop", "=", "X86", "::", "CALLpcrel32", ";", "}", "ScratchReg", "=", "GetScratchRegister", "(", "Is64Bit", ",", "IsLP64", ",", "MF", ",", "true", ")", ";", "assert", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ScratchReg", ")", "&&", "<STR_LIT>", "HiPE prologue scratch register is live-in", "<STR_LIT>", ")", ";", "addRegOffset", "(", "BuildMI", "(", "stackCheckMBB", ",", "DL", ",", "TII", ".", "get", "(", "LEAop", ")", ",", "ScratchReg", ")", ",", "SPReg", ",", "false", ",", "-", "MaxStack", ")", ";", "addRegOffset", "(", "BuildMI", "(", "stackCheckMBB", ",", "DL", ",", "TII", ".", "get", "(", "CMPop", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ",", "PReg", ",", "false", ",", "SPLimitOffset", ")", ";", "BuildMI", "(", "stackCheckMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "JAE_1", ")", ")", ".", "addMBB", "(", "&", "PrologueMBB", ")", ";", "BuildMI", "(", "incStackMBB", ",", "DL", ",", "TII", ".", "get", "(", "CALLop", ")", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "inc_stack_0", "<STR_LIT>", ")", ";", "addRegOffset", "(", "BuildMI", "(", "incStackMBB", ",", "DL", ",", "TII", ".", "get", "(", "LEAop", ")", ",", "ScratchReg", ")", ",", "SPReg", ",", "false", ",", "-", "MaxStack", ")", ";", "addRegOffset", "(", "BuildMI", "(", "incStackMBB", ",", "DL", ",", "TII", ".", "get", "(", "CMPop", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ",", "PReg", ",", "false", ",", "SPLimitOffset", ")", ";", "BuildMI", "(", "incStackMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "JLE_1", ")", ")", ".", "addMBB", "(", "incStackMBB", ")", ";", "stackCheckMBB", "->", "addSuccessor", "(", "&", "PrologueMBB", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "stackCheckMBB", "->", "addSuccessor", "(", "incStackMBB", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "incStackMBB", "->", "addSuccessor", "(", "&", "PrologueMBB", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "incStackMBB", "->", "addSuccessor", "(", "incStackMBB", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "}", "MF", ".", "verify", "(", ")", ";", "}" ]

[ "Erlang", "programs", "may", "need", "a", "special", "prologue", "to", "handle", "the", "stack", "size", "they", "might", "need", "at", "runtime", "." ]

[ "KORWrr", ":" ]

[ "case", "X86", "::", "PADDDrr", ":", "case", "X86", "::", "PADDQrr", ":", "case", "X86", "::", "PMULLWrr", ":", "case", "X86", "::", "PMULLDrr", ":", "case", "X86", "::", "VPANDrr", ":", "case", "X86", "::", "VPANDYrr", ":", "case", "X86", "::", "VPANDDZ128rr", ":", "case", "X86", "::", "VPANDDZ256rr", ":", "case", "X86", "::", "VPANDDZrr", ":", "case", "X86", "::", "VPANDQZ128rr", ":", "case", "X86", "::", "VPANDQZ256rr", ":", "case", "X86", "::", "VPANDQZrr", ":", "case", "X86", "::", "VPORrr", ":", "case", "X86", "::", "VPORYrr", ":", "case", "X86", "::", "VPORDZ128rr", ":", "case", "X86", "::", "VPORDZ256rr", ":", "case", "X86", "::", "VPORDZrr", ":", "case", "X86", "::", "VPORQZ128rr", ":", "case", "X86", "::", "VPORQZ256rr", ":", "case", "X86", "::", "VPORQZrr", ":", "case", "X86", "::", "VPXORrr", ":", "case", "X86", "::", "VPXORYrr", ":", "case", "X86", "::", "VPXORDZ128rr", ":", "case", "X86", "::", "VPXORDZ256rr", ":", "case", "X86", "::", "VPXORDZrr", ":", "case", "X86", "::", "VPXORQZ128rr", ":", "case", "X86", "::", "VPXORQZ256rr", ":", "case", "X86", "::", "VPXORQZrr", ":", "case", "X86", "::", "VANDPDrr", ":", "case", "X86", "::", "VANDPSrr", ":", "case", "X86", "::", "VANDPDYrr", ":", "case", "X86", "::", "VANDPSYrr", ":", "case", "X86", "::", "VANDPDZ128rr", ":", "case", "X86", "::", "VANDPSZ128rr", ":", "case", "X86", "::", "VANDPDZ256rr", ":", "case", "X86", "::", "VANDPSZ256rr", ":", "case", "X86", "::", "VANDPDZrr", ":", "case", "X86", "::", "VANDPSZrr", ":", "case", "X86", "::", "VORPDrr", ":", "case", "X86", "::", "VORPSrr", ":", "case", "X86", "::", "VORPDYrr", ":", "case", "X86", "::", "VORPSYrr", ":", "case", "X86", "::", "VORPDZ128rr", ":", "case", "X86", "::", "VORPSZ128rr", ":", "case", "X86", "::", "VORPDZ256rr", ":", "case", "X86", "::", "VORPSZ256rr", ":", "case", "X86", "::", "VORPDZrr", ":", "case", "X86", "::", "VORPSZrr", ":", "case", "X86", "::", "VXORPDrr", ":", "case", "X86", "::", "VXORPSrr", ":", "case", "X86", "::", "VXORPDYrr", ":", "case", "X86", "::", "VXORPSYrr", ":", "case", "X86", "::", "VXORPDZ128rr", ":", "case", "X86", "::", "VXORPSZ128rr", ":", "case", "X86", "::", "VXORPDZ256rr", ":", "case", "X86", "::", "VXORPSZ256rr", ":", "case", "X86", "::", "VXORPDZrr", ":", "case", "X86", "::", "VXORPSZrr", ":", "case", "X86", "::", "KADDBrr", ":", "case", "X86", "::", "KADDWrr", ":", "case", "X86", "::", "KADDDrr", ":", "case", "X86", "::", "KADDQrr", ":", "case", "X86", "::", "KANDBrr", ":", "case", "X86", "::", "KANDWrr", ":", "case", "X86", "::", "KANDDrr", ":", "case", "X86", "::", "KANDQrr", ":", "case", "X86", "::", "KORBrr", ":", "case", "X86", "::" ]

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

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

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

[ "return", "LoopStack", "." ]

[ ",", "CSI", ",", "TRI", ")", ";" ]

[ "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "PushOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STMDB_UPD", ":", "ARM", "::", "STMDB_UPD", ";", "unsigned", "PushOneOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STR_PRE", ":", "ARM", "::", "STR_PRE_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VSTMDDB_UPD", ";", "unsigned", "NumAlignedDPRCS2Regs", "=", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea1Register", ",", "<NUM_LIT>", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea2Register", ",", "<NUM_LIT>", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "<NUM_LIT>", ",", "true", ",", "&", "isARMArea3Register", ",", "NumAlignedDPRCS2Regs", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "NumAlignedDPRCS2Regs", ")", "emitAlignedDPRCS2Spills", "(", "MBB", ",", "MI", ",", "NumAlignedDPRCS2Regs" ]

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

[ "(", "vec_concat", ":", "V32QI", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(" ]

[ "<STR_LIT>", ";" ]

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

[ "bool", "isLegalBroadcastLoad", "(", "Type", "*", "ElementTy", ",", "ElementCount", "NumElements", ")", "const", "{", "if", "(", "!", "ST", "->", "hasNEON", "(", ")", "||", "NumElements", ".", "isScalable", "(", ")", ")", "return", "false", ";", "switch", "(", "unsigned", "ElementBits", "=", "ElementTy", "->", "getScalarSizeInBits", "(", ")", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "{", "unsigned", "VectorBits", "=", "NumElements", ".", "getFixedValue", "(", ")", "*", "ElementBits", ";", "return", "VectorBits", ">=", "<NUM_LIT>", ";", "}", "}", "return", "false", ";", "}" ]

[ "\\Returns", "true", "if", "the", "target", "supports", "broadcasting", "a", "load", "to", "a", "vector", "of", "type", "<", "NumElements", "x", "ElementTy", ">", "." ]

[ ")", ";" ]

[ "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "if", "(", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "unsafe-fp-math", "<STR_LIT>", ")", ".", "getValueAsBool", "(", ")", ")", "FS", "=", "FS", ".", "empty", "(", ")", "?", "<STR_LIT>", "+unsafe-fp", "<STR_LIT>", ":", "<STR_LIT>", "+unsafe-fp,", "<STR_LIT>", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "HexagonSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(" ]

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

[ "if", "(", "DefInsn", "->", "isPHI", "(", ")", ")", "{", "if", "(", "PhiInsns", ".", "find", "(", "DefInsn", ")", "!=", "PhiInsns", ".", "end", "(", ")", ")", "return", "false", ";", "PhiInsns", ".", "insert", "(" ]

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

[ "SDLoc", "DL", "(", "Op", ")", ";", "unsigned", "int", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "!=", "<NUM_LIT>", "&&", "NumElts", "!=", "<NUM_LIT>", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "VT", ".", "is512BitVector", "(", ")", "&&", "InVT", ".", "getVectorElementType", "(", ")", "!=", "MVT", "::", "i1", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "In", ")", ";", "assert", "(", "InVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", ";", "MVT", "ExtVT", "=", "NumElts", "==", "<NUM_LIT>", "?", "MVT", "::", "v8i64", ":", "MVT", "::", "v16i32", ";", "SDValue", "One", "=", "DAG", ".", "getConstant", "(", "APInt", "(", "ExtVT", ".", "getScalarSizeInBits", "(", ")" ]

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

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

[ "FuncType", "&", "F", ")", "{" ]

[ "void", "addRule", "(", "StringRef", "N", ",", "const", "Rule", "::" ]

[ "return", "true", ";" ]

[ "static", "bool", "isScalarToVector", "(", "SDValue", "Op", ")", "{", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "Op", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "!", "Op", ".", "getOperand", "(", "I", ")", ".", "isUndef", "(", ")", ")", "return", "false", ";" ]

[ "MF", ")", "const", "override", "{" ]

[ "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&" ]

[ "if", "(", "TLI", ".", "isTypeLegal", "(", "VT", ")", ")", "if", "(", "SDValue", "AddSub", "=", "combineShuffleToAddSubOrFMAddSub", "(", "N", ",", "Subtarget", ",", "DAG", ")", ")", "return", "AddSub", ";" ]

[ "static", "SDValue", "combineShuffle", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "TargetLowering", "::", "DAGCombinerInfo", "&", "DCI", ",", "const", "X86Subtarget", "&", "Subtarget", ")", "{", "if", "(", "auto", "*", "Shuf", "=", "dyn_cast", "<", "ShuffleVectorSDNode", ">", "(", "N", ")", ")", "if", "(", "SDValue", "V", "=", "narrowShuffle", "(", "Shuf", ",", "DAG", ")", ")", "return", "V", ";", "SDLoc", "dl", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";" ]

[ ";" ]

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

[ ")", "{" ]

[ "static", "SDValue", "NormalizeVectorShuffle", "(", "SDValue", "Op", ",", "const", "X86Subtarget", "*", "Subtarget", ",", "SelectionDAG", "&", "DAG", ")", "{", "ShuffleVectorSDNode", "*", "SVOp", "=", "cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ")", ";", "MVT", "VT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "V1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "V2", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "isZeroShuffle", "(", "SVOp", ")", ")", "return", "getZeroVector", "(", "VT", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ";", "if", "(", "SVOp", "->", "isSplat", "(", ")", ")", "{", "SDValue", "Broadcast", "=", "LowerVectorBroadcast", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "if", "(", "Broadcast", ".", "getNode", "(", ")", ")", "return", "Broadcast", ";", "}", "SDValue", "NewOp", "=", "LowerVectorIntExtend", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "if", "(", "NewOp", ".", "getNode", "(", ")", ")", "return", "NewOp", ";", "if", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", "||", "VT", "==", "MVT", "::", "v16i16", "||", "VT", "==", "MVT", "::", "v32i8", ")", "{", "SDValue", "NewOp", "=", "RewriteAsNarrowerShuffle", "(", "SVOp", ",", "DAG", ")", ";", "if", "(", "NewOp", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VT", ",", "NewOp", ")", ";", "}", "else", "if", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "{", "if", "(", "ISD", "::", "isBuildVectorAllZeros", "(", "V2", ".", "getNode", "(", ")", ")", ")", "{", "SDValue", "NewOp", "=", "RewriteAsNarrowerShuffle", "(", "SVOp", ",", "DAG", ")", ";", "if", "(", "NewOp", ".", "getNode", "(", ")", ")", "{", "MVT", "NewVT", "=", "NewOp", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "isCommutedMOVLMask", "(", "cast", "<", "ShuffleVectorSDNode", ">", "(", "NewOp", ")", "->", "getMask", "(", ")", ",", "NewVT", ",", "true", ",", "false", ")", ")", "return", "getVZextMovL", "(", "VT", ",", "NewVT", ",", "NewOp", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ",", "Subtarget", ",", "dl", ")", ";", "}", "}", "else", "if", "(", "ISD", "::", "isBuildVectorAllZeros", "(", "V1", ".", "getNode", "(", ")", ")", ")", "{", "SDValue", "NewOp", "=", "RewriteAsNarrowerShuffle", "(", "SVOp", ",", "DAG", ")", ";", "if", "(", "NewOp", ".", "getNode", "(", ")" ]

[ "}" ]

[ "DecodeStatus", "S", "=", "Decode2OpInstruction", "(", "Insn", ",", "Op1", ",", "Op2", ")", ";", "if", "(", "S", "==", "MCDisassembler", "::", "Success", ")", "{", "DecodeGRRegsRegisterClass", "(", "Inst", ",", "Op1", ",", "Address", ",", "Decoder", ")", ";", "DecodeGRRegsRegisterClass", "(", "Inst", ",", "Op1", ",", "Address", ",", "Decoder", ")", ";", "DecodeGRRegsRegisterClass", "(", "Inst", ",", "Op2", ",", "Address", ",", "Decoder", ")", ";", "}", "return", "S", ";" ]

[ "return", "true", ";" ]

[ "if", "(", "!", "Pic", "||", "(", "getABI", "(", ")", ".", "IsN32", "(", ")", "||", "getABI", "(", ")", ".", "IsN64", "(", ")", ")", ")", "return", "true", ";", "emitStoreWithImmOffset", "(", "Mips", "::", "SW", ",", "GPReg", ",", "Mips", "::", "SP", ",", "Offset", ",", "GetATReg", ",", "IDLoc", ",", "STI", ")", ";" ]

[ "<FIXS>", "static", "const", "char", "*", "get_stub_name", "(", "enum", "xlogue_stub", "stub", ",", "unsigned", "n_extra_args", ")", ";", "<FIXE>", "<FIXS>", "static", "rtx", "get_stub_rtx", "(", "enum", "xlogue_stub", "stub", ")", ";", "<FIXE>", "<FIXS>", "const", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "unsigned", "last_reg", "=", "m", "->", "call_ms2sysv_extra_regs", "+", "MIN_REGS", "-", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "gcc_assert", "(", "m", "->", "call_ms2sysv_extra_regs", "<=", "MAX_EXTRA_REGS", ")", ";", "<FIXE>", "<FIXS>", "+", "(", "m", "->", "call_ms2sysv_pad_out", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "+", "STUB_INDEX_OFFSET", ";", "<FIXE>" ]

[ "return", "m_regs", "[", "reg", "]", ";", "}", "<BUGS>", "const", "char", "*", "get_stub_name", "(", "enum", "xlogue_stub", "stub", ",", "unsigned", "n_extra_args", ")", "const", ";", "<BUGE>", "<BUGS>", "rtx", "get_stub_rtx", "(", "enum", "xlogue_stub", "stub", ")", "const", ";", "<BUGE>", "HOST_WIDE_INT", "get_stack_space_used", "(", ")", "const", "{", "<BUGS>", "const", "struct", "machine_function", "&", "m", "=", "*", "cfun", "->", "machine", ";", "unsigned", "last_reg", "=", "m", ".", "call_ms2sysv_extra_regs", "+", "MIN_REGS", "-", "<NUM_LIT>", ";", "<BUGE>", "<BUGS>", "gcc_assert", "(", "m", ".", "call_ms2sysv_extra_regs", "<=", "MAX_EXTRA_REGS", ")", ";", "<BUGE>", "return", "m_regs", "[", "last_reg", "]", ".", "offset", "<BUGS>", "+", "(", "m", ".", "call_ms2sysv_pad_out", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "+", "STUB_INDEX_OFFSET", ";", "<BUGE>", "}" ]

[ "createEntryPHI", "(", "CurrentRegion", ",", "DestReg", ")", ";" ]

[ "for", "(", "auto", "DRI", "=", "PHIInfo", ".", "dests_begin", "(", ")", ",", "DE", "=", "PHIInfo", ".", "dests_end", "(", ")", ";", "DRI", "!=", "DE", ";", "++", "DRI", ")", "{", "unsigned", "DestReg", "=", "*", "DRI", ";" ]

[ "SDValue", "VSelM", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ";" ]

[ "unsigned", "NumElems", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "{", "SDValue", "Op", "=", "Amt", "->", "getOperand", "(", "i", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "{", "Elts", ".", "push_back", "(", "Op", ")", ";", "continue", ";", "}", "ConstantSDNode", "*", "ND", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ";", "const", "APInt", "&", "C", "=", "APInt", "(", "SVTBits", ",", "ND", "->", "getAPIntValue", "(", ")", ".", "getZExtValue", "(", ")", ")", ";", "uint64_t", "ShAmt", "=", "C", ".", "getZExtValue", "(", ")", ";", "if", "(", "ShAmt", ">=", "SVTBits", ")", "{", "Elts", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "SVT", ")", ")", ";", "continue", ";", "}", "Elts", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "One", ".", "shl", "(", "ShAmt", ")", ",", "dl", ",", "SVT", ")", ")", ";", "}", "SDValue", "BV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "VT", ",", "Elts", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "VT", ",", "R", ",", "BV", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "v4i32", "&&", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "{", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "VT", ",", "Amt", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "VT", ",", "Op", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "U", ",", "dl", ",", "VT", ")", ")", ";", "Op", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v4f32", ",", "Op", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_TO_SINT", ",", "dl", ",", "VT", ",", "Op", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "VT", ",", "Op", ",", "R", ")", ";", "}", "if", "(", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v4i32", ")", "&&", "ISD", "::", "isBuildVectorOfConstantSDNodes", "(", "Amt", ".", "getNode", "(", ")", ")", ")", "{", "unsigned", "TargetOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "bool", "CanBeSimplified", ";", "SDValue", "Amt1", "=", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Amt2", "=", "(", "VT", "==", "MVT", "::", "v4i32", ")", "?", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ":", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v4i32", ")", "{", "CanBeSimplified", "=", "Amt2", "==", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", "&&", "Amt2", "==", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "CanBeSimplified", ")", "{", "CanBeSimplified", "=", "Amt1", "==", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", "&&", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", "==", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "TargetOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Amt2", "=", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "CanBeSimplified", "=", "Amt1", "==", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", "&&", "CanBeSimplified", ";", "++", "i", ")", "CanBeSimplified", "=", "Amt2", "==", "Amt", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "CanBeSimplified", ")", "{", "TargetOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CanBeSimplified", "=", "true", ";", "Amt2", "=", "Amt", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", "&&", "CanBeSimplified", ";", "++", "i", ")", "CanBeSimplified", "=", "Amt1", "==", "Amt", "->", "getOperand", "(", "i", ")", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "!=", "<NUM_LIT>", "&&", "CanBeSimplified", ";", "++", "j", ")", "CanBeSimplified", "=", "Amt2", "==", "Amt", "->", "getOperand", "(", "j", ")", ";", "}", "}", "if", "(", "CanBeSimplified", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Amt1", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Amt2", ")", ")", "{", "EVT", "CastVT", "=", "MVT", "::", "v4i32", ";", "SDValue", "Splat1", "=", "DAG", ".", "getConstant", "(", "cast", "<", "ConstantSDNode", ">", "(", "Amt1", ")", "->", "getAPIntValue", "(", ")", ",", "dl", ",", "VT", ")", ";", "SDValue", "Shift1", "=", "DAG", ".", "getNode", "(", "Op", "->", "getOpcode", "(", ")", ",", "dl", ",", "VT", ",", "R", ",", "Splat1", ")", ";", "SDValue", "Splat2", "=", "DAG", ".", "getConstant", "(", "cast", "<", "ConstantSDNode", ">", "(", "Amt2", ")", "->", "getAPIntValue", "(", ")", ",", "dl", ",", "VT", ")", ";", "SDValue", "Shift2", "=", "DAG", ".", "getNode", "(", "Op", "->", "getOpcode", "(", ")", ",", "dl", ",", "VT", ",", "R", ",", "Splat2", ")", ";", "if", "(", "TargetOpcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "CastVT", "=", "MVT", "::", "v2i64", ";", "SDValue", "BitCast1", "=", "DAG", ".", "getBitcast", "(", "CastVT", ",", "Shift1", ")", ";", "SDValue", "BitCast2", "=", "DAG", ".", "getBitcast", "(", "CastVT", ",", "Shift2", ")", ";", "SDValue", "Result", "=", "getTargetShuffleNode", "(", "TargetOpcode", ",", "dl", ",", "CastVT", ",", "BitCast2", ",", "BitCast1", ",", "DAG", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "Result", ")", ";", "}", "}", "if", "(", "VT", "==", "MVT", "::", "v16i8", "&&", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "{", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "VT", ",", "Amt", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ")", ";" ]

[ "}" ]

[ "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "printRegName", "(", "O", ",", "Reg", ")", ";", "}", "else", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "O", "<<", "markup", "(", "<STR_LIT>", "<imm:", "<STR_LIT>", ")", "<<", "'", "#", "'", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", "<<", "markup", "(", "<STR_LIT>", ">", "<STR_LIT>", ")", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "unknown operand kind in printOperand", "<STR_LIT>", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "EvaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "O", ".", "write_hex", "(", "(", "uint32_t", ")", "Address", ")", ";" ]

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

[ "if", "(", "IsWin64Prologue", ")", "{", "assert", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "StackSize", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ";", "uint64_t", "FrameSize", "=", "StackSize", "-", "SlotSize", ";", "if", "(", "X86FI", "->", "getRestoreBasePointer", "(", ")", ")", "FrameSize", "+=", "SlotSize", ";", "uint64_t", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "uint64_t", "SEHFrameOffset", "=", "calculateSetFPREG", "(", "NumBytes", ")", ";", "if", "(", "FI", "&&", "FI", "==", "X86FI", "->", "getFAIndex", "(", ")", ")", "return", "-", "SEHFrameOffset", ";", "FPDelta", "=", "FrameSize", "-", "SEHFrameOffset", ";", "assert", "(", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "FPDelta", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "FPDelta isn't aligned per the Win64 ABI!", "<STR_LIT>", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "assert", "(", "HasFP", "&&", "<STR_LIT>", "VLAs and dynamic stack realign, but no FP?!", "<STR_LIT>", ")", ";", "if", "(", "FI", "<", "<NUM_LIT>", ")", "{", "return", "Offset", "+", "SlotSize", "+", "FPDelta", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "<NUM_LIT>", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "if", "(", "FI", "<", "<NUM_LIT>", ")", "{", "return", "Offset", "+", "SlotSize", "+", "FPDelta", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "<NUM_LIT>", ")", ";", "return", "Offset", "+", "StackSize", ";", "}" ]

[ "::", "scalarOrVector", "(", "RemainderElts", ",", "EltTy", ")", "}", ";" ]

[ "unsigned", "FirstPartNumElts", "=", "FirstSize", "/", "EltSize", ";", "unsigned", "RemainderElts", "=", "(", "TotalSize", "-", "FirstSize", ")", "/", "EltSize", ";", "return", "{", "LLT", "::", "scalarOrVector", "(", "FirstPartNumElts", ",", "EltTy", ")", ",", "LLT" ]