1 /* Copyright (C) 1992-2015 Free Software Foundation, Inc. 2 3 This file is part of GDB. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 17 18 #include "defs.h" 19 #include "target-dcache.h" 20 #include "gdbcmd.h" 21 #include "progspace.h" 22 23 /* The target dcache is kept per-address-space. This key lets us 24 associate the cache with the address space. */ 25 26 static const struct address_space_data *target_dcache_aspace_key; 27 28 /* Clean up dcache, represented by ARG, which is associated with 29 ASPACE. */ 30 31 static void 32 target_dcache_cleanup (struct address_space *aspace, void *arg) 33 { 34 dcache_free (arg); 35 } 36 37 /* Target dcache is initialized or not. */ 38 39 int 40 target_dcache_init_p (void) 41 { 42 DCACHE *dcache = address_space_data (current_program_space->aspace, 43 target_dcache_aspace_key); 44 45 return (dcache != NULL); 46 } 47 48 /* Invalidate the target dcache. */ 49 50 void 51 target_dcache_invalidate (void) 52 { 53 DCACHE *dcache = address_space_data (current_program_space->aspace, 54 target_dcache_aspace_key); 55 56 if (dcache != NULL) 57 dcache_invalidate (dcache); 58 } 59 60 /* Return the target dcache. Return NULL if target dcache is not 61 initialized yet. */ 62 63 DCACHE * 64 target_dcache_get (void) 65 { 66 DCACHE *dcache = address_space_data (current_program_space->aspace, 67 target_dcache_aspace_key); 68 69 return dcache; 70 } 71 72 /* Return the target dcache. If it is not initialized yet, initialize 73 it. */ 74 75 DCACHE * 76 target_dcache_get_or_init (void) 77 { 78 DCACHE *dcache = address_space_data (current_program_space->aspace, 79 target_dcache_aspace_key); 80 81 if (dcache == NULL) 82 { 83 dcache = dcache_init (); 84 set_address_space_data (current_program_space->aspace, 85 target_dcache_aspace_key, dcache); 86 } 87 88 return dcache; 89 } 90 91 /* The option sets this. */ 92 static int stack_cache_enabled_1 = 1; 93 /* And set_stack_cache updates this. 94 The reason for the separation is so that we don't flush the cache for 95 on->on transitions. */ 96 static int stack_cache_enabled = 1; 97 98 /* This is called *after* the stack-cache has been set. 99 Flush the cache for off->on and on->off transitions. 100 There's no real need to flush the cache for on->off transitions, 101 except cleanliness. */ 102 103 static void 104 set_stack_cache (char *args, int from_tty, struct cmd_list_element *c) 105 { 106 if (stack_cache_enabled != stack_cache_enabled_1) 107 target_dcache_invalidate (); 108 109 stack_cache_enabled = stack_cache_enabled_1; 110 } 111 112 static void 113 show_stack_cache (struct ui_file *file, int from_tty, 114 struct cmd_list_element *c, const char *value) 115 { 116 fprintf_filtered (file, _("Cache use for stack accesses is %s.\n"), value); 117 } 118 119 /* Return true if "stack cache" is enabled, otherwise, return false. */ 120 121 int 122 stack_cache_enabled_p (void) 123 { 124 return stack_cache_enabled; 125 } 126 127 /* The option sets this. */ 128 129 static int code_cache_enabled_1 = 1; 130 131 /* And set_code_cache updates this. 132 The reason for the separation is so that we don't flush the cache for 133 on->on transitions. */ 134 static int code_cache_enabled = 1; 135 136 /* This is called *after* the code-cache has been set. 137 Flush the cache for off->on and on->off transitions. 138 There's no real need to flush the cache for on->off transitions, 139 except cleanliness. */ 140 141 static void 142 set_code_cache (char *args, int from_tty, struct cmd_list_element *c) 143 { 144 if (code_cache_enabled != code_cache_enabled_1) 145 target_dcache_invalidate (); 146 147 code_cache_enabled = code_cache_enabled_1; 148 } 149 150 /* Show option "code-cache". */ 151 152 static void 153 show_code_cache (struct ui_file *file, int from_tty, 154 struct cmd_list_element *c, const char *value) 155 { 156 fprintf_filtered (file, _("Cache use for code accesses is %s.\n"), value); 157 } 158 159 /* Return true if "code cache" is enabled, otherwise, return false. */ 160 161 int 162 code_cache_enabled_p (void) 163 { 164 return code_cache_enabled; 165 } 166 167 /* -Wmissing-prototypes */ 168 extern initialize_file_ftype _initialize_target_dcache; 169 170 void 171 _initialize_target_dcache (void) 172 { 173 add_setshow_boolean_cmd ("stack-cache", class_support, 174 &stack_cache_enabled_1, _("\ 175 Set cache use for stack access."), _("\ 176 Show cache use for stack access."), _("\ 177 When on, use the target memory cache for all stack access, regardless of any\n\ 178 configured memory regions. This improves remote performance significantly.\n\ 179 By default, caching for stack access is on."), 180 set_stack_cache, 181 show_stack_cache, 182 &setlist, &showlist); 183 184 add_setshow_boolean_cmd ("code-cache", class_support, 185 &code_cache_enabled_1, _("\ 186 Set cache use for code segment access."), _("\ 187 Show cache use for code segment access."), _("\ 188 When on, use the target memory cache for all code segment accesses,\n\ 189 regardless of any configured memory regions. This improves remote\n\ 190 performance significantly. By default, caching for code segment\n\ 191 access is on."), 192 set_code_cache, 193 show_code_cache, 194 &setlist, &showlist); 195 196 target_dcache_aspace_key 197 = register_address_space_data_with_cleanup (NULL, 198 target_dcache_cleanup); 199 } 200