1/* Generate code to allocate RTL structures. 2 Copyright (C) 1997-2020 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify it under 7the terms of the GNU General Public License as published by the Free 8Software Foundation; either version 3, or (at your option) any later 9version. 10 11GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or 13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14for more details. 15 16You should have received a copy of the GNU General Public License 17along with GCC; see the file COPYING3. If not see 18<http://www.gnu.org/licenses/>. */ 19 20 21#include "bconfig.h" 22#include "system.h" 23 24struct rtx_definition 25{ 26 const char *const enumname, *const name, *const format; 27}; 28 29/* rtl.def needs CONST_DOUBLE_FORMAT, but we don't care what 30 CONST_DOUBLE_FORMAT is because we're not going to be generating 31 anything for CONST_DOUBLE anyway. */ 32#define CONST_DOUBLE_FORMAT "" 33 34#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { #ENUM, NAME, FORMAT }, 35 36static const struct rtx_definition defs[] = 37{ 38#include "rtl.def" /* rtl expressions are documented here */ 39}; 40#define NUM_RTX_CODE ARRAY_SIZE (defs) 41 42static const char *formats[NUM_RTX_CODE]; 43 44/* Decode a format letter into a C type string. */ 45 46static const char * 47type_from_format (int c) 48{ 49 switch (c) 50 { 51 case 'i': 52 return "int "; 53 54 case 'w': 55 return "HOST_WIDE_INT "; 56 57 case 'p': 58 return "poly_uint16 "; 59 60 case 's': 61 return "const char *"; 62 63 case 'e': case 'u': 64 return "rtx "; 65 66 case 'E': 67 return "rtvec "; 68 case 't': 69 return "tree "; 70 case 'B': 71 return "basic_block "; 72 default: 73 gcc_unreachable (); 74 } 75} 76 77/* Decode a format letter into the proper accessor function. */ 78 79static const char * 80accessor_from_format (int c) 81{ 82 switch (c) 83 { 84 case 'i': 85 return "XINT"; 86 87 case 'w': 88 return "XWINT"; 89 90 case 's': 91 return "XSTR"; 92 93 case 'e': case 'u': 94 return "XEXP"; 95 96 case 'E': 97 return "XVEC"; 98 99 case 't': 100 return "XTREE"; 101 102 case 'B': 103 return "XBBDEF"; 104 105 default: 106 gcc_unreachable (); 107 } 108} 109 110/* Return nonzero if we should ignore FMT, an RTL format, when making 111 the list of formats we write routines to create. */ 112 113static int 114special_format (const char *fmt) 115{ 116 return (strchr (fmt, '*') != 0 117 || strchr (fmt, 'V') != 0 118 || strchr (fmt, 'S') != 0 119 || strchr (fmt, 'n') != 0 120 || strchr (fmt, 'r') != 0); 121} 122 123/* Return true if CODE always has VOIDmode. */ 124 125static inline bool 126always_void_p (int idx) 127{ 128 return strcmp (defs[idx].enumname, "SET") == 0; 129} 130 131/* Return nonzero if the RTL code given by index IDX is one that we should 132 generate a gen_rtx_raw_FOO macro for, not gen_rtx_FOO (because gen_rtx_FOO 133 is a wrapper in emit-rtl.c). */ 134 135static int 136special_rtx (int idx) 137{ 138 return (strcmp (defs[idx].enumname, "EXPR_LIST") == 0 139 || strcmp (defs[idx].enumname, "INSN_LIST") == 0 140 || strcmp (defs[idx].enumname, "INSN") == 0 141 || strcmp (defs[idx].enumname, "CONST_INT") == 0 142 || strcmp (defs[idx].enumname, "REG") == 0 143 || strcmp (defs[idx].enumname, "SUBREG") == 0 144 || strcmp (defs[idx].enumname, "MEM") == 0 145 || strcmp (defs[idx].enumname, "PC") == 0 146 || strcmp (defs[idx].enumname, "CC0") == 0 147 || strcmp (defs[idx].enumname, "RETURN") == 0 148 || strcmp (defs[idx].enumname, "SIMPLE_RETURN") == 0 149 || strcmp (defs[idx].enumname, "CONST_VECTOR") == 0); 150} 151 152/* Return nonzero if the RTL code given by index IDX is one that we should 153 generate no macro for at all (because gen_rtx_FOO is never used or 154 cannot have the obvious interface). */ 155 156static int 157excluded_rtx (int idx) 158{ 159 return (strcmp (defs[idx].enumname, "VAR_LOCATION") == 0 160 || strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0 161 || strcmp (defs[idx].enumname, "CONST_WIDE_INT") == 0 162 || strcmp (defs[idx].enumname, "CONST_POLY_INT") == 0 163 || strcmp (defs[idx].enumname, "CONST_FIXED") == 0); 164} 165 166/* Place a list of all format specifiers we use into the array FORMAT. */ 167 168static void 169find_formats (void) 170{ 171 unsigned int i; 172 173 for (i = 0; i < NUM_RTX_CODE; i++) 174 { 175 const char **f; 176 177 if (special_format (defs[i].format)) 178 continue; 179 180 for (f = formats; *f; f++) 181 if (! strcmp (*f, defs[i].format)) 182 break; 183 184 if (*f == 0) 185 *f = defs[i].format; 186 } 187} 188 189 190/* Generate macros to generate RTL of code IDX using the functions we 191 write. */ 192 193static void 194genmacro (int idx) 195{ 196 const char *p; 197 const char *sep = ""; 198 int i; 199 200 /* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to 201 gen_rtx_fmt_FORMAT where FORMAT is the RTX_FORMAT of RTLCODE. */ 202 203 if (excluded_rtx (idx)) 204 /* Don't define a macro for this code. */ 205 return; 206 207 bool has_mode_p = !always_void_p (idx); 208 printf ("#define gen_rtx_%s%s(", 209 special_rtx (idx) ? "raw_" : "", defs[idx].enumname); 210 if (has_mode_p) 211 { 212 printf ("MODE"); 213 sep = ", "; 214 } 215 216 for (p = defs[idx].format, i = 0; *p != 0; p++) 217 if (*p != '0') 218 { 219 printf ("%sARG%d", sep, i++); 220 sep = ", "; 221 } 222 223 printf (") \\\n gen_rtx_fmt_%s (%s, %s", 224 defs[idx].format, defs[idx].enumname, 225 has_mode_p ? "(MODE)" : "VOIDmode"); 226 227 for (p = defs[idx].format, i = 0; *p != 0; p++) 228 if (*p != '0') 229 printf (", (ARG%d)", i++); 230 231 puts (")"); 232} 233 234/* Generate the code for functions to generate RTL whose format is FORMAT. */ 235 236static void 237gendef (const char *format) 238{ 239 const char *p; 240 int i, j; 241 242 /* Write the definition of the init function name and the types 243 of the arguments. */ 244 245 puts ("static inline rtx"); 246 printf ("init_rtx_fmt_%s (rtx rt, machine_mode mode", format); 247 for (p = format, i = 0; *p != 0; p++) 248 if (*p != '0') 249 printf (",\n\t%sarg%d", type_from_format (*p), i++); 250 puts (")"); 251 252 /* Now write out the body of the init function itself. */ 253 puts ("{"); 254 puts (" PUT_MODE_RAW (rt, mode);"); 255 256 for (p = format, i = j = 0; *p ; ++p, ++i) 257 if (*p == '0') 258 printf (" X0EXP (rt, %d) = NULL_RTX;\n", i); 259 else if (*p == 'p') 260 printf (" SUBREG_BYTE (rt) = arg%d;\n", j++); 261 else 262 printf (" %s (rt, %d) = arg%d;\n", accessor_from_format (*p), i, j++); 263 264 puts (" return rt;\n}\n"); 265 266 /* Write the definition of the gen function name and the types 267 of the arguments. */ 268 269 puts ("static inline rtx"); 270 printf ("gen_rtx_fmt_%s_stat (RTX_CODE code, machine_mode mode", format); 271 for (p = format, i = 0; *p != 0; p++) 272 if (*p != '0') 273 printf (",\n\t%sarg%d", type_from_format (*p), i++); 274 puts (" MEM_STAT_DECL)"); 275 276 /* Now write out the body of the function itself, which allocates 277 the memory and initializes it. */ 278 puts ("{"); 279 puts (" rtx rt;\n"); 280 281 puts (" rt = rtx_alloc (code PASS_MEM_STAT);"); 282 printf (" return init_rtx_fmt_%s (rt, mode", format); 283 for (p = format, i = 0; *p != 0; p++) 284 if (*p != '0') 285 printf (", arg%d", i++); 286 puts (");\n}\n"); 287 288 /* Write the definition of gen macro. */ 289 290 printf ("#define gen_rtx_fmt_%s(c, m", format); 291 for (p = format, i = 0; *p != 0; p++) 292 if (*p != '0') 293 printf (", arg%d", i++); 294 printf (") \\\n gen_rtx_fmt_%s_stat ((c), (m)", format); 295 for (p = format, i = 0; *p != 0; p++) 296 if (*p != '0') 297 printf (", (arg%d)", i++); 298 printf (" MEM_STAT_INFO)\n\n"); 299 300 /* Write the definition of alloca macro. */ 301 302 printf ("#define alloca_rtx_fmt_%s(c, m", format); 303 for (p = format, i = 0; *p != 0; p++) 304 if (*p != '0') 305 printf (", arg%d", i++); 306 printf (") \\\n init_rtx_fmt_%s (rtx_alloca ((c)), (m)", format); 307 for (p = format, i = 0; *p != 0; p++) 308 if (*p != '0') 309 printf (", (arg%d)", i++); 310 printf (")\n\n"); 311} 312 313/* Generate the documentation header for files we write. */ 314 315static void 316genlegend (void) 317{ 318 puts ("/* Generated automatically by gengenrtl from rtl.def. */\n"); 319} 320 321/* Generate the text of the header file we make, genrtl.h. */ 322 323static void 324genheader (void) 325{ 326 unsigned int i; 327 const char **fmt; 328 329 puts ("#ifndef GCC_GENRTL_H"); 330 puts ("#define GCC_GENRTL_H\n"); 331 puts ("#include \"statistics.h\"\n"); 332 333 for (fmt = formats; *fmt; ++fmt) 334 gendef (*fmt); 335 336 putchar ('\n'); 337 338 for (i = 0; i < NUM_RTX_CODE; i++) 339 if (! special_format (defs[i].format)) 340 genmacro (i); 341 342 puts ("\n#endif /* GCC_GENRTL_H */"); 343} 344 345/* This is the main program. */ 346 347int 348main (void) 349{ 350 find_formats (); 351 genlegend (); 352 353 genheader (); 354 355 if (ferror (stdout) || fflush (stdout) || fclose (stdout)) 356 return FATAL_EXIT_CODE; 357 358 return SUCCESS_EXIT_CODE; 359} 360