1 /* Target-dependent globals. 2 Copyright (C) 2010-2020 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include "config.h" 21 #include "system.h" 22 #include "coretypes.h" 23 #include "backend.h" 24 #include "rtl.h" 25 #include "tree.h" 26 #include "expmed.h" 27 #include "optabs-query.h" 28 #include "insn-config.h" 29 #include "regs.h" 30 #include "memmodel.h" 31 #include "ira.h" 32 #include "ira-int.h" 33 #include "toplev.h" 34 #include "target-globals.h" 35 #include "flags.h" 36 #include "reload.h" 37 #include "libfuncs.h" 38 #include "cfgloop.h" 39 #include "builtins.h" 40 #include "gcse.h" 41 #include "bb-reorder.h" 42 #include "lower-subreg.h" 43 #include "function-abi.h" 44 45 #if SWITCHABLE_TARGET 46 class target_globals default_target_globals = { 47 &default_target_flag_state, 48 &default_target_regs, 49 &default_target_rtl, 50 &default_target_recog, 51 &default_target_hard_regs, 52 &default_target_function_abi_info, 53 &default_target_reload, 54 &default_target_expmed, 55 &default_target_optabs, 56 &default_target_libfuncs, 57 &default_target_cfgloop, 58 &default_target_ira, 59 &default_target_ira_int, 60 &default_target_builtins, 61 &default_target_gcse, 62 &default_target_bb_reorder, 63 &default_target_lower_subreg 64 }; 65 66 class target_globals * 67 save_target_globals (void) 68 { 69 class target_globals *g = ggc_cleared_alloc <target_globals> (); 70 g->flag_state = XCNEW (class target_flag_state); 71 g->regs = XCNEW (struct target_regs); 72 g->rtl = ggc_cleared_alloc<target_rtl> (); 73 g->recog = XCNEW (struct target_recog); 74 g->hard_regs = XCNEW (struct target_hard_regs); 75 g->function_abi_info = XCNEW (struct target_function_abi_info); 76 g->reload = XCNEW (struct target_reload); 77 g->expmed = XCNEW (struct target_expmed); 78 g->optabs = XCNEW (struct target_optabs); 79 g->libfuncs = ggc_cleared_alloc<target_libfuncs> (); 80 g->cfgloop = XCNEW (struct target_cfgloop); 81 g->ira = XCNEW (struct target_ira); 82 g->ira_int = XCNEW (class target_ira_int); 83 g->builtins = XCNEW (struct target_builtins); 84 g->gcse = XCNEW (struct target_gcse); 85 g->bb_reorder = XCNEW (struct target_bb_reorder); 86 g->lower_subreg = XCNEW (struct target_lower_subreg); 87 restore_target_globals (g); 88 init_reg_sets (); 89 target_reinit (); 90 return g; 91 } 92 93 /* Like save_target_globals() above, but set *this_target_optabs 94 correctly when a previous function has changed 95 *this_target_optabs. */ 96 97 class target_globals * 98 save_target_globals_default_opts () 99 { 100 class target_globals *globals; 101 102 if (optimization_current_node != optimization_default_node) 103 { 104 tree opts = optimization_current_node; 105 /* Temporarily switch to the default optimization node, so that 106 *this_target_optabs is set to the default, not reflecting 107 whatever a previous function used for the optimize 108 attribute. */ 109 optimization_current_node = optimization_default_node; 110 cl_optimization_restore 111 (&global_options, 112 TREE_OPTIMIZATION (optimization_default_node)); 113 globals = save_target_globals (); 114 optimization_current_node = opts; 115 cl_optimization_restore (&global_options, 116 TREE_OPTIMIZATION (opts)); 117 return globals; 118 } 119 return save_target_globals (); 120 } 121 122 target_globals::~target_globals () 123 { 124 /* default_target_globals points to static data so shouldn't be freed. */ 125 if (this != &default_target_globals) 126 { 127 ira_int->~target_ira_int (); 128 hard_regs->finalize (); 129 XDELETE (flag_state); 130 XDELETE (regs); 131 XDELETE (recog); 132 XDELETE (hard_regs); 133 XDELETE (function_abi_info); 134 XDELETE (reload); 135 XDELETE (expmed); 136 XDELETE (optabs); 137 XDELETE (cfgloop); 138 XDELETE (ira); 139 XDELETE (ira_int); 140 XDELETE (builtins); 141 XDELETE (gcse); 142 XDELETE (bb_reorder); 143 XDELETE (lower_subreg); 144 } 145 } 146 147 #endif 148