gcc/config/ft32/ft32.h

   1 /* Target Definitions for ft32.
   2    Copyright (C) 2015-2023 Free Software Foundation, Inc.
   3    Contributed by FTDI <support@ftdi.com>
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published
   9    by the Free Software Foundation; either version 3, or (at your
  10    option) any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING3.  If not see
  19    <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_FT32_H
  22 #define GCC_FT32_H
  23
  24 #undef  STARTFILE_SPEC
  25 #define STARTFILE_SPEC "crt0%O%s %{msim:crti.o%s} %{!msim:crti-hw.o%s} crtbegin.o%s"
  26
  27 /* Provide an ENDFILE_SPEC appropriate for svr4.  Here we tack on our own
  28    magical crtend.o file (see crtstuff.c) which provides part of the
  29    support for getting C++ file-scope static object constructed before
  30    entering `main', followed by the normal svr3/svr4 "finalizer" file,
  31    which is either `gcrtn.o' or `crtn.o'.  */
  32
  33 #undef  ENDFILE_SPEC
  34 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
  35
  36 /* Provide a LIB_SPEC appropriate for svr4.  Here we tack on the default
  37    standard C library (unless we are building a shared library) and
  38    the simulator BSP code.  */
  39
  40 #undef LIB_SPEC
  41 #define LIB_SPEC "%{!shared:%{!symbolic:-lc}} \
  42                    %{mcompress:--relax} \
  43                    %{msim:-Tsim.ld}"
  44
  45 #undef  LINK_SPEC
  46 #define LINK_SPEC "%{h*} %{v:-V} \
  47                    %{static:-Bstatic} %{shared:-shared} %{symbolic:-Bsymbolic}"
  48
  49 /* Layout of Source Language Data Types */
  50
  51 #define INT_TYPE_SIZE 32
  52 #define SHORT_TYPE_SIZE 16
  53 #define LONG_TYPE_SIZE 32
  54 #define LONG_LONG_TYPE_SIZE 64
  55
  56 #define FLOAT_TYPE_SIZE 32
  57 #define DOUBLE_TYPE_SIZE 64
  58 #define LONG_DOUBLE_TYPE_SIZE 64
  59
  60 #define DEFAULT_SIGNED_CHAR 1
  61
  62 #undef  SIZE_TYPE
  63 #define SIZE_TYPE "unsigned int"
  64
  65 #undef  PTRDIFF_TYPE
  66 #define PTRDIFF_TYPE "int"
  67
  68 #undef  WCHAR_TYPE
  69 #define WCHAR_TYPE "long int"
  70
  71 #undef  WCHAR_TYPE_SIZE
  72 #define WCHAR_TYPE_SIZE BITS_PER_WORD
  73
  74 #define REGISTER_NAMES {        \
  75   "$fp", "$sp", "$r0", "$r1",   \
  76   "$r2", "$r3", "$r4", "$r5",   \
  77   "$r6", "$r7", "$r8", "$r9",   \
  78   "$r10", "$r11", "$r12", "$r13",   \
  79   "$r14", "$r15", "$r16", "$r17", "$r18", "$r19", "$r20", "$r21", "$r22", "$r23", "$r24", "$r25", "$r26", "$r27", "$r28", "$cc", \
  80   "?fp", "?ap", "$pc", "?cc" }
  81
  82 #define FT32_FP     0
  83 #define FT32_SP     1
  84 #define FT32_R0     2
  85 #define FT32_R1     3
  86 #define FT32_R2     4
  87 #define FT32_R3     5
  88 #define FT32_R4     6
  89 #define FT32_R5     7
  90 #define FT32_R6     8
  91 #define FT32_R7     9
  92 #define FT32_R8     10
  93 #define FT32_R9     11
  94 #define FT32_R10    12
  95 #define FT32_R11    13
  96 #define FT32_R12    14
  97 #define FT32_R13    15
  98 #define FT32_R14    16
  99 #define FT32_R15    17
 100 #define FT32_R16    18
 101 #define FT32_R17    19
 102 #define FT32_R18    20
 103 #define FT32_R19    21
 104 #define FT32_R20    22
 105 #define FT32_R21    23
 106 #define FT32_R22    24
 107 #define FT32_R23    25
 108 #define FT32_R24    26
 109 #define FT32_R25    27
 110 #define FT32_R26    28
 111 #define FT32_R27    29
 112 #define FT32_R28    30
 113 #define FT32_R29    31
 114 #define FT32_QAP    (32 + 1)
 115 #define FT32_PC     (32 + 2)
 116 #define FT32_CC     (32 + 3)
 117 #define FIRST_PSEUDO_REGISTER (32 + 4)
 118
 119 enum reg_class
 120 {
 121   NO_REGS,
 122   GENERAL_REGS,
 123   SPECIAL_REGS,
 124   CC_REGS,
 125   ALL_REGS,
 126   LIM_REG_CLASSES
 127 };
 128
 129 #define REG_CLASS_CONTENTS \
 130 { { 0x00000000, 0x00000000 }, /* Empty */                      \
 131   { 0xFFFFFFFF, 0x00000003 }, /* $fp, $sp, $r0 to $r13, ?fp */ \
 132   { 0x00000000, 0x00000004 }, /* $pc */                        \
 133   { 0x00000000, 0x00000008 }, /* ?cc */                        \
 134   { 0xFFFFFFFF, 0x0000000F }  /* All registers */              \
 135 }
 136
 137 #define N_REG_CLASSES LIM_REG_CLASSES
 138
 139 #define REG_CLASS_NAMES {\
 140     "NO_REGS", \
 141     "GENERAL_REGS", \
 142     "SPECIAL_REGS", \
 143     "CC_REGS", \
 144     "ALL_REGS" }
 145
 146 #define FIXED_REGISTERS  /*  fp  sp  r0  r1 */   { 1, 1, 0, 0, \
 147                          /*  r2  r3  r4  r5 */     0, 0, 0, 0, \
 148                          /*  r6  r7  r8  r9 */     0, 0, 0, 0, \
 149                          /* r10 r11 r12 r13 */     0, 0, 0, 0, \
 150                          /* r14 r15 r16 r17 */     0, 0, 0, 0, \
 151                          /* r18 r19 r20 r21 */     0, 0, 0, 0, \
 152                          /* r22 r23 r24 r25 */     0, 0, 0, 0, \
 153                          /* r26 r27 r28 r29 */     0, 0, 1, 1, \
 154                          /* r30 r31         */     1, 1, 1, 1 }
 155
 156 #define CALL_USED_REGISTERS \
 157                          /*  fp  sp  r0  r1 */   { 1, 1, 1, 1, \
 158                          /*  r2  r3  r4  r5 */     1, 1, 1, 1, \
 159                          /*  r6  r7  r8  r9 */     1, 1, 1, 1, \
 160                          /* r10 r11 r12 r13 */     1, 1, 1, 0, \
 161                          /* r14 r15 r16 r17 */     0, 0, 0, 0, \
 162                          /* r18 r19 r20 r21 */     0, 0, 0, 0, \
 163                          /* r22 r23 r24 r25 */     0, 0, 0, 0, \
 164                          /* r26 r27 r28 r29 */     0, 0, 1, 1, \
 165                          /* r30 r31         */     1, 1, 1, 1 }
 166
 167 /* We can't copy to or from our CC register. */
 168 #define AVOID_CCMODE_COPIES 1
 169
 170 /* A C expression whose value is a register class containing hard
 171    register REGNO.  */
 172 #define REGNO_REG_CLASS(R) ((R < FT32_PC) ? GENERAL_REGS :                \
 173                             (R == FT32_CC ? CC_REGS : SPECIAL_REGS))
 174
 175 /* The Overall Framework of an Assembler File */
 176
 177 #undef  ASM_SPEC
 178 #define ASM_COMMENT_START "#"
 179 #define ASM_APP_ON ""
 180 #define ASM_APP_OFF ""
 181
 182 #define FILE_ASM_OP     "\t.file\n"
 183
 184 /* Switch to the text or data segment.  */
 185 #define TEXT_SECTION_ASM_OP  "\t.text"
 186 #define DATA_SECTION_ASM_OP  "\t.data"
 187
 188 /* Assembler Commands for Alignment */
 189
 190 #define ASM_OUTPUT_ALIGN(STREAM,POWER) \
 191         fprintf (STREAM, "\t.p2align\t%d\n", POWER);
 192
 193 /* A C compound statement to output to stdio stream STREAM the
 194    assembler syntax for an instruction operand X.  */
 195 #define PRINT_OPERAND(STREAM, X, CODE) ft32_print_operand (STREAM, X, CODE)
 196
 197 #define PRINT_OPERAND_ADDRESS(STREAM ,X) ft32_print_operand_address (STREAM, X)
 198
 199 /* Output and Generation of Labels */
 200
 201 #define GLOBAL_ASM_OP "\t.global\t"
 202
 203 #define JUMP_TABLES_IN_TEXT_SECTION (TARGET_NOPM ? 0 : 1)
 204
 205 /* This is how to output an element of a case-vector that is absolute.  */
 206
 207 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
 208     fprintf (FILE, "\t.long\t.L%d\n", VALUE)                            \
 209
 210 /* Passing Arguments in Registers */
 211
 212 /* A C type for declaring a variable that is used as the first
 213    argument of `FUNCTION_ARG' and other related values.  */
 214 #define CUMULATIVE_ARGS unsigned int
 215
 216 /* If defined, the maximum amount of space required for outgoing arguments
 217    will be computed and placed into the variable
 218    `current_function_outgoing_args_size'.  No space will be pushed
 219    onto the stack for each call; instead, the function prologue should
 220    increase the stack frame size by this amount.  */
 221 #define ACCUMULATE_OUTGOING_ARGS 1
 222
 223 /* A C statement (sans semicolon) for initializing the variable CUM
 224    for the state at the beginning of the argument list.
 225    For ft32, the first arg is passed in register 2 (aka $r0).  */
 226 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
 227   (CUM = FT32_R0)
 228
 229 /* How Scalar Function Values Are Returned */
 230
 231 /* STACK AND CALLING */
 232
 233 /* Define this macro if pushing a word onto the stack moves the stack
 234    pointer to a smaller address.  */
 235 #define STACK_GROWS_DOWNWARD 1
 236
 237 /* Offset from the argument pointer register to the first argument's
 238    address.  On some machines it may depend on the data type of the
 239    function.  */
 240 #define FIRST_PARM_OFFSET(F) 0
 241
 242 /* Define this macro to nonzero value if the addresses of local variable slots
 243    are at negative offsets from the frame pointer.  */
 244 #define FRAME_GROWS_DOWNWARD 1
 245
 246 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
 247    the stack pointer does not matter.  The value is tested only in
 248    functions that have frame pointers.
 249    No definition is equivalent to always zero.  */
 250
 251 #define EXIT_IGNORE_STACK 0
 252
 253 /* Define this macro as a C expression that is nonzero for registers that are
 254    used by the epilogue or the return pattern.  The stack and frame
 255    pointer registers are already assumed to be used as needed.  */
 256 #define EPILOGUE_USES(R) (R == FT32_R5)
 257
 258 /* A C expression whose value is RTL representing the location of the
 259    incoming return address at the beginning of any function, before
 260    the prologue.  */
 261 #define INCOMING_RETURN_ADDR_RTX                                        \
 262   gen_frame_mem (Pmode,                                                 \
 263                  plus_constant (Pmode, stack_pointer_rtx, 333 * UNITS_PER_WORD))
 264
 265 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR)                               \
 266   ((COUNT) == 0                                                         \
 267    ? gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, arg_pointer_rtx, GEN_INT (-4))) \
 268    : NULL_RTX)
 269
 270 /* Describe how we implement __builtin_eh_return.  */
 271 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N+2) : INVALID_REGNUM)
 272
 273 /* Store the return handler into the call frame.  */
 274 #define EH_RETURN_HANDLER_RTX                                           \
 275   gen_frame_mem (Pmode,                                                 \
 276                  plus_constant (Pmode, frame_pointer_rtx, UNITS_PER_WORD))
 277
 278 /* Storage Layout */
 279
 280 #define BITS_BIG_ENDIAN 0
 281 #define BYTES_BIG_ENDIAN 0
 282 #define WORDS_BIG_ENDIAN 0
 283
 284 /* Alignment required for a function entry point, in bits.  */
 285 #define FUNCTION_BOUNDARY 32
 286
 287 #define BRANCH_COST(speed_p, predictable_p)     2
 288
 289 /* Define this macro as a C expression which is nonzero if accessing
 290    less than a word of memory (i.e. a `char' or a `short') is no
 291    faster than accessing a word of memory.  */
 292 #define SLOW_BYTE_ACCESS 1
 293
 294 #define STORE_FLAG_VALUE                        1
 295
 296 #define MOVE_RATIO(speed) ((speed) ? 6 : 2)
 297
 298 /* Number of storage units in a word; normally the size of a
 299    general-purpose register, a power of two from 1 or 8.  */
 300 #define UNITS_PER_WORD 4
 301
 302 /* Define this macro to the minimum alignment enforced by hardware
 303    for the stack pointer on this machine.  The definition is a C
 304    expression for the desired alignment (measured in bits).  */
 305 #define STACK_BOUNDARY 32
 306
 307 /* Normal alignment required for function parameters on the stack, in
 308    bits.  All stack parameters receive at least this much alignment
 309    regardless of data type.  */
 310 #define PARM_BOUNDARY 32
 311
 312 /* Alignment of field after `int : 0' in a structure.  */
 313 #define EMPTY_FIELD_BOUNDARY  32
 314
 315 /* No data type wants to be aligned rounder than this.  */
 316 #define BIGGEST_ALIGNMENT 32
 317
 318 /* The best alignment to use in cases where we have a choice.  */
 319 #define FASTEST_ALIGNMENT 32
 320
 321 /* Align definitions of arrays, unions and structures so that
 322    initializations and copies can be made more efficient.  This is not
 323    ABI-changing, so it only affects places where we can see the
 324    definition. Increasing the alignment tends to introduce padding,
 325    so don't do this when optimizing for size/conserving stack space. */
 326 #define FT32_EXPAND_ALIGNMENT(COND, EXP, ALIGN)                         \
 327   (((COND) && ((ALIGN) < BITS_PER_WORD)                                 \
 328     && (TREE_CODE (EXP) == ARRAY_TYPE                                   \
 329         || TREE_CODE (EXP) == UNION_TYPE                                \
 330         || TREE_CODE (EXP) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN))
 331
 332 /* Make arrays of chars word-aligned for the same reasons.  */
 333 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
 334   (TREE_CODE (TYPE) == ARRAY_TYPE               \
 335    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
 336    && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))
 337
 338 /* Similarly, make sure that objects on the stack are sensibly aligned.  */
 339 #define LOCAL_ALIGNMENT(EXP, ALIGN)                             \
 340   FT32_EXPAND_ALIGNMENT(/*!flag_conserve_stack*/ 1, EXP, ALIGN)
 341
 342 /* Every structures size must be a multiple of 8 bits.  */
 343 #define STRUCTURE_SIZE_BOUNDARY 8
 344
 345 /* Look at the fundamental type that is used for a bit-field and use
 346    that to impose alignment on the enclosing structure.
 347    struct s {int a:8}; should have same alignment as "int", not "char".  */
 348 #define PCC_BITFIELD_TYPE_MATTERS       1
 349
 350 /* Largest integer machine mode for structures.  If undefined, the default
 351    is GET_MODE_SIZE(DImode).  */
 352 #define MAX_FIXED_MODE_SIZE 32
 353
 354 /* Set this nonzero if move instructions will actually fail to work
 355    when given unaligned data.  */
 356 #define STRICT_ALIGNMENT 1
 357
 358 /* Generating Code for Profiling */
 359 #define FUNCTION_PROFILER(FILE,LABELNO) (abort (), 0)
 360
 361 /* Trampolines for Nested Functions.  */
 362 #define TRAMPOLINE_SIZE (2 + 6 + 6 + 2 + 2 + 6)
 363
 364 /* Alignment required for trampolines, in bits.  */
 365 #define TRAMPOLINE_ALIGNMENT 32
 366
 367 /* An alias for the machine mode for pointers.  */
 368 #define Pmode         SImode
 369
 370 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \
 371 do { \
 372   if (((MODE) == HImode) \
 373    || ((MODE) == QImode)) \
 374        (MODE) = SImode;  \
 375 } while (0)
 376
 377 /* An alias for the machine mode used for memory references to
 378    functions being called, in `call' RTL expressions.  */
 379 #define FUNCTION_MODE QImode
 380
 381 #define STATIC_CHAIN_REGNUM  FT32_R28
 382
 383 /* The register number of the stack pointer register, which must also
 384    be a fixed register according to `FIXED_REGISTERS'.  */
 385 #define STACK_POINTER_REGNUM FT32_SP
 386
 387 /* The register number of the frame pointer register, which is used to
 388    access automatic variables in the stack frame.  */
 389 #define FRAME_POINTER_REGNUM FT32_FP
 390
 391 /* The register number of the arg pointer register, which is used to
 392    access the function's argument list.  */
 393 #define ARG_POINTER_REGNUM FT32_QAP
 394
 395 #define ELIMINABLE_REGS                                 \
 396 {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},            \
 397  {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM},            \
 398  {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
 399
 400
 401 /* This macro returns the initial difference between the specified pair
 402    of registers.  */
 403 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
 404   do {                                                                  \
 405     (OFFSET) = ft32_initial_elimination_offset ((FROM), (TO));            \
 406   } while (0)
 407
 408 /* A C expression that is nonzero if REGNO is the number of a hard
 409    register in which function arguments are sometimes passed.  */
 410 #define FUNCTION_ARG_REGNO_P(r) (r >= FT32_R0 && r <= FT32_R5)
 411
 412 /* A macro whose definition is the name of the class to which a valid
 413    base register must belong.  A base register is one used in an
 414    address which is the register value plus a displacement.  */
 415 #define BASE_REG_CLASS GENERAL_REGS
 416
 417 #define INDEX_REG_CLASS NO_REGS
 418
 419 #define HARD_REGNO_OK_FOR_BASE_P(NUM) \
 420   ((unsigned) (NUM) < FIRST_PSEUDO_REGISTER \
 421    && (REGNO_REG_CLASS(NUM) == GENERAL_REGS \
 422        || (NUM) == HARD_FRAME_POINTER_REGNUM))
 423
 424 /* A C expression which is nonzero if register number NUM is suitable
 425    for use as a base register in operand addresses.  */
 426 #ifdef REG_OK_STRICT
 427 #define REGNO_OK_FOR_BASE_P(NUM)                 \
 428   (HARD_REGNO_OK_FOR_BASE_P(NUM)                 \
 429    || HARD_REGNO_OK_FOR_BASE_P(reg_renumber[(NUM)]))
 430 #else
 431 #define REGNO_OK_FOR_BASE_P(NUM)                 \
 432   ((NUM) >= FIRST_PSEUDO_REGISTER || HARD_REGNO_OK_FOR_BASE_P(NUM))
 433 #endif
 434
 435 /* A C expression which is nonzero if register number NUM is suitable
 436    for use as an index register in operand addresses.  */
 437 #define REGNO_OK_FOR_INDEX_P(NUM) FT32_FP
 438
 439 /* The maximum number of bytes that a single instruction can move
 440    quickly between memory and registers or between two memory
 441    locations.  */
 442 #define MOVE_MAX 4
 443
 444 /* Define this to be nonzero if shift instructions ignore all but the low-order
 445    few bits.  */
 446 #define SHIFT_COUNT_TRUNCATED 1
 447
 448 /* All load operations zero extend.  */
 449 #define LOAD_EXTEND_OP(MEM) ZERO_EXTEND
 450
 451 /* A number, the maximum number of registers that can appear in a
 452    valid memory address.  */
 453 #define MAX_REGS_PER_ADDRESS 1
 454
 455 /* An alias for a machine mode name.  This is the machine mode that
 456    elements of a jump-table should have.  */
 457 #define CASE_VECTOR_MODE SImode
 458
 459 /* Run-time Target Specification */
 460
 461 #define TARGET_CPU_CPP_BUILTINS() \
 462   { \
 463     builtin_define ("__FT32__");          \
 464   }
 465
 466 #define HAS_LONG_UNCOND_BRANCH true
 467
 468 #define NO_FUNCTION_CSE 1
 469
 470 #define ADDR_SPACE_PM 1
 471
 472 #define REGISTER_TARGET_PRAGMAS() do { \
 473   c_register_addr_space ("__flash__", TARGET_NOPM ? 0 : ADDR_SPACE_PM); \
 474 } while (0)
 475
 476 extern int ft32_is_mem_pm(rtx o);
 477
 478 #define ASM_OUTPUT_SYMBOL_REF(stream, sym) \
 479   do { \
 480     assemble_name (stream, XSTR (sym, 0)); \
 481     int section_debug = in_section && \
 482       (SECTION_STYLE (in_section) == SECTION_NAMED) && \
 483       (in_section->named.common.flags & SECTION_DEBUG); \
 484     if (!section_debug && SYMBOL_REF_FLAGS (sym) & 0x1000) \
 485       asm_fprintf (stream, "-0x800000"); \
 486   } while (0)
 487
 488 #endif /* GCC_FT32_H */