1# Copyright (C) 2003-2021 Free Software Foundation, Inc. 2# Contributed by Kelley Cook, June 2004. 3# Original code from Neil Booth, May 2003. 4# 5# This program is free software; you can redistribute it and/or modify it 6# under the terms of the GNU General Public License as published by the 7# Free Software Foundation; either version 3, or (at your option) any 8# 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; see the file COPYING3. If not see 17# <http://www.gnu.org/licenses/>. 18 19# Some common subroutines for use by opt[ch]-gen.awk. 20 21# Define some helpful character classes, for portability. 22BEGIN { 23 lower = "abcdefghijklmnopqrstuvwxyz" 24 upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 25 digit = "0123456789" 26 alnum = lower "" upper "" digit 27} 28 29# Return nonzero if FLAGS contains a flag matching REGEX. 30function flag_set_p(regex, flags) 31{ 32 # Ignore the arguments of flags with arguments. 33 gsub ("\\([^)]+\\)", "", flags); 34 return (" " flags " ") ~ (" " regex " ") 35} 36 37# Return STRING if FLAGS contains a flag matching regexp REGEX, 38# otherwise return the empty string. 39function test_flag(regex, flags, string) 40{ 41 if (flag_set_p(regex, flags)) 42 return string 43 return "" 44} 45 46# Return a field initializer, with trailing comma, for a field that is 47# 1 if FLAGS contains a flag matching REGEX and 0 otherwise. 48function flag_init(regex, flags) 49{ 50 if (flag_set_p(regex, flags)) 51 return "1 /* " regex " */, " 52 else 53 return "0, " 54} 55 56# If FLAGS contains a "NAME(...argument...)" flag, return the value 57# of the argument. Return the empty string otherwise. 58function opt_args(name, flags) 59{ 60 flags = " " flags 61 if (flags !~ " " name "\\(") 62 return "" 63 sub(".* " name "\\(", "", flags) 64 if (flags ~ "^[{]") 65 { 66 sub ("^[{]", "", flags) 67 sub ("}\\).*", "", flags) 68 } 69 else 70 sub("\\).*", "", flags) 71 72 return flags 73} 74 75# If FLAGS contains a "NAME(...argument...)" flag, return the value 76# of the argument. Print error message otherwise. 77function opt_args_non_empty(name, flags, description) 78{ 79 args = opt_args(name, flags) 80 if (args == "") 81 print "#error Empty option argument '" name "' during parsing of: " flags 82 return args 83} 84 85# Return the Nth comma-separated element of S. Return the empty string 86# if S does not contain N elements. 87function nth_arg(n, s) 88{ 89 while (n-- > 0) { 90 if (s !~ ",") 91 return "" 92 sub("[^,]*, *", "", s) 93 } 94 sub(",.*", "", s) 95 return s 96} 97 98# Return a bitmask of CL_* values for option flags FLAGS. 99function switch_flags (flags) 100{ 101 result = "0" 102 for (j = 0; j < n_langs; j++) { 103 regex = langs[j] 104 gsub ( "\\+", "\\+", regex ) 105 result = result test_flag(regex, flags, " | " macros[j]) 106 } 107 result = result \ 108 test_flag("Common", flags, " | CL_COMMON") \ 109 test_flag("Target", flags, " | CL_TARGET") \ 110 test_flag("PchIgnore", flags, " | CL_PCH_IGNORE") \ 111 test_flag("Driver", flags, " | CL_DRIVER") \ 112 test_flag("Joined", flags, " | CL_JOINED") \ 113 test_flag("JoinedOrMissing", flags, " | CL_JOINED") \ 114 test_flag("Separate", flags, " | CL_SEPARATE") \ 115 test_flag("Undocumented", flags, " | CL_UNDOCUMENTED") \ 116 test_flag("NoDWARFRecord", flags, " | CL_NO_DWARF_RECORD") \ 117 test_flag("Warning", flags, " | CL_WARNING") \ 118 test_flag("(Optimization|PerFunction)", flags, " | CL_OPTIMIZATION") \ 119 test_flag("Param", flags, " | CL_PARAMS") 120 sub( "^0 \\| ", "", result ) 121 return result 122} 123 124# Return bit-field initializers for option flags FLAGS. 125function switch_bit_fields (flags) 126{ 127 uinteger_flag = "" 128 vn = var_name(flags); 129 if (host_wide_int[vn] == "yes") 130 hwi = "Host_Wide_Int" 131 else if (flag_set_p("Host_Wide_Int", flags)) { 132 hwi = "Host_Wide_Int" 133 uinteger_flag = flag_init("UInteger", flags) 134 } 135 else 136 hwi = "" 137 result = "" 138 sep_args = opt_args("Args", flags) 139 if (sep_args == "") 140 sep_args = 0 141 else 142 sep_args-- 143 result = result sep_args ", " 144 145 if (uinteger_flag == "") 146 uinteger_flag = flag_init("UInteger", flags) 147 148 hwi_flag = flag_init("Host_Wide_Int", hwi) 149 byte_size_flag = flag_init("ByteSize", flags) 150 151 if (substr(byte_size_flag, 1, 1) != "0" \ 152 && substr(uinteger_flag, 1, 1) == "0" \ 153 && substr(hwi_flag, 1, 1) == "0") 154 print "#error only UInteger amd Host_Wide_Int options can specify a ByteSize suffix" 155 156 # The following flags need to be in the same order as 157 # the corresponding members of struct cl_option defined 158 # in gcc/opts.h. 159 result = result \ 160 flag_init("SeparateAlias", flags) \ 161 flag_init("NegativeAlias", flags) \ 162 flag_init("NoDriverArg", flags) \ 163 flag_init("RejectDriver", flags) \ 164 flag_init("RejectNegative", flags) \ 165 flag_init("JoinedOrMissing", flags) \ 166 uinteger_flag \ 167 hwi_flag \ 168 flag_init("ToLower", flags) \ 169 byte_size_flag 170 171 if (flag_set_p("Report", flags)) 172 print "#error Report option property is dropped" 173 174 sub(", $", "", result) 175 return result 176} 177 178# If FLAGS includes a Var flag, return the name of the variable it specifies. 179# Return the empty string otherwise. 180function var_name(flags) 181{ 182 return nth_arg(0, opt_args("Var", flags)) 183} 184 185# Return the name of the variable if FLAGS has a HOST_WIDE_INT variable. 186# Return the empty string otherwise. 187function host_wide_int_var_name(flags) 188{ 189 split (flags, array, "[ \t]+") 190 if (array[1] == "HOST_WIDE_INT") 191 return array[2] 192 else 193 return "" 194} 195 196# Return true if the option described by FLAGS has a globally-visible state. 197function global_state_p(flags) 198{ 199 return (var_name(flags) != "" \ 200 || opt_args("Mask", flags) != "" \ 201 || opt_args("InverseMask", flags) != "") 202} 203 204# Return true if the option described by FLAGS must have some state 205# associated with it. 206function needs_state_p(flags) 207{ 208 return (flag_set_p("Target", flags) \ 209 && !flag_set_p("Alias.*", flags) \ 210 && !flag_set_p("Ignore", flags)) 211} 212 213# If FLAGS describes an option that needs state without a public 214# variable name, return the name of that field, minus the initial 215# "x_", otherwise return "". NAME is the name of the option. 216function static_var(name, flags) 217{ 218 if (global_state_p(flags) || !needs_state_p(flags)) 219 return "" 220 gsub ("[^" alnum "]", "_", name) 221 return "VAR_" name 222} 223 224# Return the type of variable that should be associated with the given flags. 225function var_type(flags) 226{ 227 if (flag_set_p("Defer", flags)) 228 return "void *" 229 else if (flag_set_p("Enum.*", flags)) { 230 en = opt_args("Enum", flags); 231 return enum_type[en] " " 232 } 233 else if (!flag_set_p("Joined.*", flags) && !flag_set_p("Separate", flags)) 234 return "int " 235 else if (flag_set_p("Host_Wide_Int", flags)) 236 return "HOST_WIDE_INT " 237 else if (flag_set_p("UInteger", flags)) 238 return "int " 239 else 240 return "const char *" 241} 242 243# Return the type of variable that should be associated with the given flags 244# for use within a structure. Simple variables are changed to signed char 245# type instead of int to save space. 246function var_type_struct(flags) 247{ 248 if (flag_set_p("UInteger", flags)) { 249 if (host_wide_int[var_name(flags)] == "yes") 250 return "HOST_WIDE_INT "; 251 if (flag_set_p("ByteSize", flags)) 252 return "HOST_WIDE_INT " 253 return "int " 254 } 255 else if (flag_set_p("Enum.*", flags)) { 256 en = opt_args("Enum", flags); 257 return enum_type[en] " " 258 } 259 else if (!flag_set_p("Joined.*", flags) && !flag_set_p("Separate", flags)) { 260 if (flag_set_p(".*Mask.*", flags)) { 261 if (host_wide_int[var_name(flags)] == "yes") 262 return "HOST_WIDE_INT " 263 else 264 return "/* - */ int " 265 } 266 else 267 return "signed char " 268 } 269 else 270 return "const char *" 271} 272 273# Given that an option has flags FLAGS, return an initializer for the 274# "var_enum", "var_type" and "var_value" fields of its cl_options[] entry. 275function var_set(flags) 276{ 277 if (flag_set_p("Defer", flags)) 278 return "0, CLVC_DEFER, 0" 279 s = nth_arg(1, opt_args("Var", flags)) 280 if (s != "") 281 return "0, CLVC_EQUAL, " s 282 s = opt_args("Mask", flags); 283 if (s != "") { 284 vn = var_name(flags); 285 if (vn) 286 return "0, CLVC_BIT_SET, OPTION_MASK_" s 287 else 288 return "0, CLVC_BIT_SET, MASK_" s 289 } 290 s = nth_arg(0, opt_args("InverseMask", flags)); 291 if (s != "") { 292 vn = var_name(flags); 293 if (vn) 294 return "0, CLVC_BIT_CLEAR, OPTION_MASK_" s 295 else 296 return "0, CLVC_BIT_CLEAR, MASK_" s 297 } 298 if (flag_set_p("Enum.*", flags)) { 299 en = opt_args("Enum", flags); 300 return enum_index[en] ", CLVC_ENUM, 0" 301 } 302 if (var_type(flags) == "const char *") 303 return "0, CLVC_STRING, 0" 304 if (flag_set_p("ByteSize", flags)) 305 return "0, CLVC_SIZE, 0" 306 return "0, CLVC_BOOLEAN, 0" 307} 308 309# Given that an option called NAME has flags FLAGS, return an initializer 310# for the "flag_var" field of its cl_options[] entry. 311function var_ref(name, flags) 312{ 313 name = var_name(flags) static_var(name, flags) 314 if (name != "") 315 return "offsetof (struct gcc_options, x_" name ")" 316 if (opt_args("Mask", flags) != "") 317 return "offsetof (struct gcc_options, x_target_flags)" 318 if (opt_args("InverseMask", flags) != "") 319 return "offsetof (struct gcc_options, x_target_flags)" 320 return "(unsigned short) -1" 321} 322 323# Given the option called NAME return a sanitized version of its name. 324function opt_sanitized_name(name) 325{ 326 gsub ("[^" alnum "]", "_", name) 327 return name 328} 329 330# Given the option called NAME return the appropriate enum for it. 331function opt_enum(name) 332{ 333 return "OPT_" opt_sanitized_name(name) 334} 335 336# Given the language called NAME return a sanitized version of its name. 337function lang_sanitized_name(name) 338{ 339 gsub( "[^" alnum "_]", "X", name ) 340 return name 341} 342 343# Search for a valid var_name among all OPTS equal to option NAME. 344# If not found, return "". 345function search_var_name(name, opt_numbers, opts, flags, n_opts) 346{ 347 opt_var_name = var_name(flags[opt_numbers[name]]); 348 if (opt_var_name != "") { 349 return opt_var_name; 350 } 351 for (k = 0; k < n_opts; k++) { 352 if (opts[k] == name && var_name(flags[k]) != "") { 353 return var_name(flags[k]); 354 } 355 } 356 return "" 357} 358 359function integer_range_info(range_option, init, option) 360{ 361 if (range_option != "") { 362 ival = init + 0; 363 start = nth_arg(0, range_option) + 0; 364 end = nth_arg(1, range_option) + 0; 365 if (init != "" && init != "-1" && (ival < start || ival > end)) 366 print "#error initial value " init " of '" option "' must be in range [" start "," end "]" 367 return start ", " end 368 } 369 else 370 return "-1, -1" 371} 372 373# Handle LangEnabledBy(ENABLED_BY_LANGS, ENABLEDBY_NAME, ENABLEDBY_POSARG, 374# ENABLEDBY_NEGARG). This function does not return anything. 375function lang_enabled_by(enabledby_langs, enabledby_name, enabledby_posarg, enabledby_negarg) 376{ 377 n_enabledby_arg_langs = split(enabledby_langs, enabledby_arg_langs, " "); 378 if (enabledby_posarg != "" && enabledby_negarg != "") { 379 with_args = "," enabledby_posarg "," enabledby_negarg 380 } else if (enabledby_posarg == "" && enabledby_negarg == "") { 381 with_args = "" 382 } else { 383 print "#error " opts[i] " LangEnabledBy("enabledby_langs","enabledby_name", " \ 384 enabledby_posarg", " enabledby_negargs \ 385 ") with three arguments, it should have either 2 or 4" 386 } 387 388 n_enabledby_array = split(enabledby_name, enabledby_array, " \\|\\| "); 389 for (k = 1; k <= n_enabledby_array; k++) { 390 enabledby_index = opt_numbers[enabledby_array[k]]; 391 if (enabledby_index == "") { 392 print "#error " opts[i] " LangEnabledBy("enabledby_langs","enabledby_name", " \ 393 enabledby_posarg", " enabledby_negargs"), unknown option '" enabledby_name "'" 394 } else { 395 for (j = 1; j <= n_enabledby_arg_langs; j++) { 396 lang_name = lang_sanitized_name(enabledby_arg_langs[j]); 397 lang_index = lang_numbers[enabledby_arg_langs[j]]; 398 if (enables[lang_name,enabledby_array[k]] == "") { 399 enabledby[lang_name,n_enabledby_lang[lang_index]] = enabledby_array[k]; 400 n_enabledby_lang[lang_index]++; 401 } 402 enables[lang_name,enabledby_array[k]] \ 403 = enables[lang_name,enabledby_array[k]] opts[i] with_args ";"; 404 } 405 } 406 } 407} 408