gcc/config/bpf/bpf.h

   1 /* Definition of the eBPF target for GCC.
   2    Copyright (C) 2019-2023 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
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GCC is distributed in the hope that it will be useful, but WITHOUT
  12    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14    License 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 #ifndef GCC_BPF_H
  21 #define GCC_BPF_H
  22
  23 /**** Controlling the Compilation Driver.  */
  24
  25 #define ASM_SPEC "%{mbig-endian:-EB} %{!mbig-endian:-EL} %{mxbpf:-mxbpf} " \
  26   "%{masm=pseudoc:-mdialect=pseudoc}"
  27 #define LINK_SPEC "%{mbig-endian:-EB} %{!mbig-endian:-EL}"
  28 #define LIB_SPEC ""
  29 #define STARTFILE_SPEC ""
  30
  31 /**** Run-time Target Specification.  */
  32
  33 #define TARGET_CPU_CPP_BUILTINS() bpf_target_macros (pfile)
  34
  35 /**** Storage Layout.  */
  36
  37 /* Endianness and word size.  */
  38 #define BITS_BIG_ENDIAN 0
  39 #define BYTES_BIG_ENDIAN (TARGET_BIG_ENDIAN)
  40 #define WORDS_BIG_ENDIAN (TARGET_BIG_ENDIAN)
  41 #define BITS_PER_WORD 64
  42 #define UNITS_PER_WORD 8
  43
  44 /* When storing an integer whose size is less than 64-bit in a
  45    register, promote it to a DImode.  */
  46 #define PROMOTE_MODE(M, UNSIGNEDP, TYPE)        \
  47   do                                            \
  48     {                                           \
  49       if (GET_MODE_CLASS (M) == MODE_INT        \
  50           && GET_MODE_SIZE (M) < 8)             \
  51         M = DImode;                             \
  52     } while (0)
  53
  54 /* Align argument parameters on the stack to 64-bit, at a minimum.  */
  55 #define PARM_BOUNDARY 64
  56
  57 /* The hardware enforces that the stack pointer should be aligned to
  58    64-bit at any time.  */
  59 #define STACK_BOUNDARY 64
  60
  61 /* Function entry points are aligned to 64 bits.  */
  62 #define FUNCTION_BOUNDARY 64
  63
  64 /* Maximum alignment required by data of any type.  */
  65 #define BIGGEST_ALIGNMENT 64
  66
  67 /* The best alignment to use in cases where we have a choice.  */
  68 #define FASTEST_ALIGNMENT 64
  69
  70 /* Use a fast alignment when storing arrays of chars in a local.  */
  71 #define LOCAL_ALIGNMENT(TYPE, ALIGN)                                    \
  72   (TREE_CODE (TYPE) == ARRAY_TYPE                                       \
  73    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode                            \
  74    && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))
  75
  76 /* The load and store instructions won't work if the data is not in
  77    it's expected alignment.  */
  78 #define STRICT_ALIGNMENT 1
  79
  80 /* We use Pmode as the mode of the size increment operand in an
  81    `allocate_stack' pattern.  */
  82 #define STACK_SIZE_MODE Pmode
  83
  84 /**** Layout of Source Language Data Types.  */
  85
  86 #define INT_TYPE_SIZE         32
  87 #define SHORT_TYPE_SIZE       16
  88 #define LONG_TYPE_SIZE        64
  89 #define LONG_LONG_TYPE_SIZE   64
  90 #define CHAR_TYPE_SIZE         8
  91 #define FLOAT_TYPE_SIZE       32
  92 #define DOUBLE_TYPE_SIZE      64
  93 #define LONG_DOUBLE_TYPE_SIZE 64
  94
  95 #define INTPTR_TYPE     "long int"
  96 #define UINTPTR_TYPE    "long unsigned int"
  97 #define SIZE_TYPE       "long unsigned int"
  98 #define PTRDIFF_TYPE "long int"
  99
 100 #define SIG_ATOMIC_TYPE "char"
 101
 102 #define INT8_TYPE "char"
 103 #define INT16_TYPE "short int"
 104 #define INT32_TYPE "int"
 105 #define INT64_TYPE "long int"
 106 #define UINT8_TYPE "unsigned char"
 107 #define UINT16_TYPE "short unsigned int"
 108 #define UINT32_TYPE "unsigned int"
 109 #define UINT64_TYPE "long unsigned int"
 110
 111 #define INT_LEAST8_TYPE INT8_TYPE
 112 #define INT_LEAST16_TYPE INT16_TYPE
 113 #define INT_LEAST32_TYPE INT32_TYPE
 114 #define INT_LEAST64_TYPE INT64_TYPE
 115 #define UINT_LEAST8_TYPE UINT8_TYPE
 116 #define UINT_LEAST16_TYPE UINT16_TYPE
 117 #define UINT_LEAST32_TYPE UINT32_TYPE
 118 #define UINT_LEAST64_TYPE UINT64_TYPE
 119
 120 #define INT_FAST8_TYPE INT8_TYPE
 121 #define INT_FAST16_TYPE INT16_TYPE
 122 #define INT_FAST32_TYPE INT32_TYPE
 123 #define INT_FAST64_TYPE INT64_TYPE
 124 #define UINT_FAST8_TYPE UINT8_TYPE
 125 #define UINT_FAST16_TYPE UINT16_TYPE
 126 #define UINT_FAST32_TYPE UINT32_TYPE
 127 #define UINT_FAST64_TYPE UINT64_TYPE
 128
 129 /* `char' is signed by default, like in x86.  */
 130 #define DEFAULT_SIGNED_CHAR 1
 131
 132 /* `wchar_t' is a signed 32-bit type.  The second constant is used by
 133    cpp, which can't use WCHAR_TYPE.  */
 134 #define WCHAR_TYPE "int"
 135 #define WCHAR_TYPE_SIZE 32
 136
 137 /* `wint_t' is a signed 32-bit type.  */
 138 #define WINT_TYPE "int"
 139 #define WINT_TYPE_SIZE 32
 140
 141 /**** Register Usage.  */
 142
 143 /*** Basic Characteristics of Registers.  */
 144
 145 #define BPF_R0  0
 146 #define BPF_R1  1
 147 #define BPF_R2  2
 148 #define BPF_R3  3
 149 #define BPF_R4  4
 150 #define BPF_R5  5
 151 #define BPF_R6  6
 152 #define BPF_CTX BPF_R6
 153 #define BPF_R7  7
 154 #define BPF_R8  8
 155 #define BPF_R9  9
 156 #define BPF_R10 10
 157 #define BPF_FP  BPF_R10
 158 #define BPF_R11 11
 159 #define BPF_R12 12
 160 #define BPF_SP  BPF_R12
 161
 162 /* 11 is not a real eBPF hard register and is eliminated or not used
 163    in the final assembler.  See below.  */
 164
 165 #define FIRST_PSEUDO_REGISTER 13
 166
 167 /* The registers %r0..%r8 are available for general allocation.
 168    %r10 is the stack frame, which is read-only.
 169    %r11 (__arg__) is a fake register that always gets eliminated.
 170    %r12 is the pseudo-stack pointer that always gets eliminated.  */
 171 #define FIXED_REGISTERS                         \
 172   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1}
 173
 174 /* %r0..%r5 are clobbered by function calls.  */
 175 #define CALL_USED_REGISTERS                             \
 176   {1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1}
 177
 178 /**** Register Classes.  */
 179
 180 enum reg_class
 181 {
 182   NO_REGS,              /* no registers in set.  */
 183   R0,                   /* register r0.  */
 184   ALL_REGS,             /* all registers.  */
 185   LIM_REG_CLASSES       /* max value + 1.  */
 186 };
 187
 188 #define N_REG_CLASSES (int) LIM_REG_CLASSES
 189 #define GENERAL_REGS ALL_REGS
 190
 191 /* An initializer containing the names of the register classes as C
 192    string constants.  These names are used in writing some of the
 193    debugging dumps.  */
 194 #define REG_CLASS_NAMES                         \
 195 {                                               \
 196   "NO_REGS",                                    \
 197   "R0",                                 \
 198   "ALL_REGS"                                    \
 199 }
 200
 201 /* An initializer containing the contents of the register classes, as
 202    integers which are bit masks.  The Nth integer specifies the
 203    contents of class N.  The way the integer MASK is interpreted is
 204    that register R is in the class if `MASK & (1 << R)' is 1.
 205
 206    In eBPF all the hard registers are considered general-purpose
 207    integer registers.  */
 208 #define REG_CLASS_CONTENTS                      \
 209 {                                               \
 210    0x00000000, /* NO_REGS */                    \
 211    0x00000001, /* R0 */                         \
 212    0x00001fff, /* ALL_REGS */                   \
 213 }
 214
 215 /* A C expression whose value is a register class containing hard
 216    register REGNO.  In general there is more that one such class;
 217    choose a class which is "minimal", meaning that no smaller class
 218    also contains the register.  */
 219 #define REGNO_REG_CLASS(REGNO) \
 220   ((REGNO) == 0 ? R0 : GENERAL_REGS)
 221
 222 /* A macro whose definition is the name of the class to which a
 223    valid base register must belong.  A base register is one used in
 224    an address which is the register value plus a displacement.  */
 225 #define BASE_REG_CLASS GENERAL_REGS
 226
 227 /* A macro whose definition is the name of the class to which a
 228    valid index register must belong.  An index register is one used
 229    in an address where its value is either multiplied by a scale
 230    factor or added to another register (as well as added to a
 231    displacement).  */
 232 #define INDEX_REG_CLASS NO_REGS
 233
 234 /* C expression which is nonzero if register number REGNO is suitable
 235    for use as a base register in operand addresses.  In eBPF every
 236    hard register can be used for this purpose.  */
 237 #define REGNO_OK_FOR_BASE_P(REGNO)                      \
 238   ((REGNO) < FIRST_PSEUDO_REGISTER)
 239
 240 /* C expression which is nonzero if register number REGNO is suitable
 241    for use as an index register in operand addresses.  */
 242 #define REGNO_OK_FOR_INDEX_P(REGNO) false
 243
 244 /**** Debugging Info ****/
 245
 246 /* In eBPF it is not possible to unwind frames. Disable CFA.  */
 247
 248 #define DWARF2_FRAME_INFO 0
 249
 250 /**** Stack Layout and Calling Conventions.  */
 251
 252 /*** Basic Stack Layout.  */
 253
 254 #define STACK_GROWS_DOWNWARD 1
 255 #define FRAME_GROWS_DOWNWARD 1
 256
 257 /* The argument pointer always points to the first argument.  */
 258 #define FIRST_PARM_OFFSET(FNDECL) 0
 259
 260 /* Unsupported.  */
 261 #define RETURN_ADDR_RTX(count, frame) const0_rtx
 262
 263 /*** Registers That Address the Stack Frame.  */
 264
 265 #define FRAME_POINTER_REGNUM 10
 266 #define ARG_POINTER_REGNUM 11
 267 #define STACK_POINTER_REGNUM 12
 268 #define STATIC_CHAIN_REGNUM 8
 269
 270 /*** Registers elimination.  */
 271
 272 #define ELIMINABLE_REGS                                 \
 273   {{ ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM },        \
 274    { STACK_POINTER_REGNUM, FRAME_POINTER_REGNUM }}
 275
 276 /* Define the offset between two registers, one to be eliminated, and
 277    the other its replacement, at the start of a routine.  */
 278 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)            \
 279   do                                                            \
 280     {                                                           \
 281       (OFFSET) = bpf_initial_elimination_offset ((FROM), (TO)); \
 282     } while (0)
 283
 284 /*** Passing Function Arguments on the Stack.  */
 285
 286 /* The eBPF ABI doesn't support passing arguments on the stack.  Only
 287    in the first five registers.  Code in bpf.cc assures the stack is
 288    never used when passing arguments.  However, we still have to
 289    define the constants below.  */
 290
 291 /* If nonzero, function arguments will be evaluated from last to
 292    first, rather than from first to last.  */
 293 #define PUSH_ARGS_REVERSED 1
 294
 295 /* Allocate stack space for arguments at the beginning of each
 296    function.  */
 297 #define ACCUMULATE_OUTGOING_ARGS 1
 298
 299 /*** Passing Arguments in Registers.  */
 300
 301 /* Use an integer in order to keep track of the number of arguments
 302    passed to a function in integer registers, up to
 303    MAX_ARGS_IN_REGISTERS.  */
 304 #define CUMULATIVE_ARGS int
 305
 306 /* INIT_CUMULATIVE_ARGS initializes a variable CUM of type
 307    CUMULATIVE_ARGS for a call to a function whose data type is FNTYPE.
 308    For a library call, FNTYPE is 0.  */
 309 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
 310   memset (&(CUM), 0, sizeof (CUM))
 311
 312 /* Nonzero if N is the number of a hard register in which function
 313    arguments are sometimes passed.  */
 314 #define FUNCTION_ARG_REGNO_P(N) ((N) >= 1 && (N) <= 5)
 315
 316 /*** How Scalar Function Values are Returned.  */
 317
 318 /* Define how to find the value returned by a library function
 319    assuming the value has mode MODE.  This is always %r0 for eBPF.  */
 320 #define LIBCALL_VALUE(MODE)  \
 321   gen_rtx_REG ((MODE), 0)
 322
 323 /*** Generating Code for Profiling.  */
 324
 325 /* We do not support profiling yet, so do not call `mcount'.  */
 326 #define FUNCTION_PROFILER(FILE, LABELNO) do { } while (0)
 327
 328 /*** Function Entry and Exit.  */
 329
 330 /* We do not require an accurate stack pointer at function return.
 331    This is because the stack pointer's original value is initialized
 332    from the frame pointer, rather than decreased, to satisfy the
 333    kernel's verifier.  Thus, we have to save the stack pointer in
 334    function prologue and restore it in function epilogue.  If
 335    EXIT_IGNORE_STACK is not set, then superfluous instructions are
 336    generated to save and restore the stack pointer after and before
 337    the function epilogue, respectively.  */
 338 #define EXIT_IGNORE_STACK 1
 339
 340 /**** Support for Nested Functions.  */
 341
 342 /* We have to define TRAMPOLINE_SIZE even if we don't ever generate
 343    them.  Set to 64 arbitrarily.  */
 344 #define TRAMPOLINE_SIZE 64
 345
 346 /**** Addressing Modes.  */
 347
 348 /* Maximum number of registers that can appear in a valid memory
 349    address.  */
 350 #define MAX_REGS_PER_ADDRESS 1
 351
 352 /* 1 if X is an rtx for a constant that is a valid address.  */
 353
 354 #define CONSTANT_ADDRESS_P(X) 0
 355
 356 /**** Describing Relative Costs of Operations.  */
 357
 358 /* Cost of a branch instruction.  A value of 1 is the default.  */
 359 #define BRANCH_COST(SPEED_P,PREDICTABLE_P) 1
 360
 361 /* The SPARC port says: Nonzero if access to memory by bytes is slow
 362    and undesirable.  For RISC chips, it means that access to memory by
 363    bytes is no better than access by words when possible, so grab a
 364    whole word and maybe make use of that.  */
 365 #define SLOW_BYTE_ACCESS 1
 366
 367 /* Threshold of number of scalar memory-to-memory move instructions,
 368    _below_ which a sequence of insns should be generated instead of a
 369    string move insn or a library call.  */
 370 #define MOVE_RATIO(speed) 128
 371
 372 /* Threshold of number of scalar move instructions, _below_ which a
 373    sequence of insns should be generated to clear memory instead of a
 374    string clear insn or a library call.  */
 375 #define CLEAR_RATIO(speed) 128
 376
 377 /* Threshold of number of scalar move instructions, _below_ which a
 378    sequence of insns should be generated to set memory to a constant
 379    value, instead of a block set insn or a library call.  */
 380 #define SET_RATIO(speed) 128
 381
 382 /* True if it is as good or better to call a constant function address
 383    than to call an address kept in a register.  */
 384 #define NO_FUNCTION_CSE 1
 385
 386 /**** Dividing the Output into Sections.  */
 387
 388 #define TEXT_SECTION_ASM_OP "\t.text"
 389 #define DATA_SECTION_ASM_OP "\t.data"
 390 #define BSS_SECTION_ASM_OP "\t.bss"
 391
 392 /**** Defining the Output Assembler Language.  */
 393
 394 /*** The Overall Framework of an Assembler File.  */
 395
 396 #define ASM_COMMENT_START "#"
 397
 398 /* Output to assembler file text saying following lines
 399    may contain character constants, extra white space, comments, etc.  */
 400
 401 #ifndef ASM_APP_ON
 402 #define ASM_APP_ON " #APP\n"
 403 #endif
 404
 405 /* Output to assembler file text saying following lines
 406    no longer contain unusual constructs.  */
 407
 408 #ifndef ASM_APP_OFF
 409 #define ASM_APP_OFF " #NO_APP\n"
 410 #endif
 411
 412 /*** Output of Data.  */
 413
 414 /*** Output of Uninitialized Variables.  */
 415
 416 /* A C statement (sans semicolon) to output to the stdio stream
 417    FILE the assembler definition of uninitialized global DECL named
 418    NAME whose size is SIZE bytes and alignment is ALIGN bytes.
 419    Try to use asm_output_aligned_bss to implement this macro.  */
 420
 421 #define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN)   \
 422   do                                                                    \
 423     {                                                                   \
 424       ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "object");                 \
 425       fprintf ((FILE), "%s", "\t.lcomm\t");                             \
 426       assemble_name ((FILE), (NAME));                                   \
 427       fprintf ((FILE), "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n",        \
 428                (SIZE), (ALIGN) / BITS_PER_UNIT);                        \
 429     }                                                                   \
 430   while (0)
 431
 432 /*** Output and Generation of Labels.  */
 433
 434 /* Globalizing directive for a label.  */
 435 #define GLOBAL_ASM_OP "\t.global\t"
 436
 437 /* This is how to store into the string LABEL
 438    the symbol_ref name of an internal numbered label where
 439    PREFIX is the class of label and NUM is the number within the class.
 440    This is suitable for output with `assemble_name'.  */
 441
 442 #undef ASM_GENERATE_INTERNAL_LABEL
 443 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)                   \
 444   sprintf ((LABEL), "*%s%s%ld", (LOCAL_LABEL_PREFIX), (PREFIX), (long)(NUM))
 445
 446 /*** Output of Assembler Instructions.  */
 447
 448 #define REGISTER_NAMES                                          \
 449   { "%r0", "%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7",     \
 450       "%r8", "%r9", "%fp", "__arg__", "__sp__" }
 451
 452 #define ADDITIONAL_REGISTER_NAMES               \
 453   { { "%a", 0 }, { "%ctx", 6 }, { "%r10" , 10 } }
 454
 455 #define LOCAL_LABEL_PREFIX "."
 456 #define USER_LABEL_PREFIX  ""
 457
 458 #define PRINT_OPERAND(STREAM,X,CODE)            \
 459   bpf_print_operand ((STREAM),(X),(CODE))
 460
 461 #define PRINT_OPERAND_ADDRESS(STREAM,X)         \
 462   bpf_print_operand_address ((STREAM), (X))
 463
 464 /*** Assembler Commands for Alignment.  */
 465
 466 /* This is how to output an assembler line that says to advance the
 467    location counter to a multiple of 2**LOG bytes.  */
 468 #define ASM_OUTPUT_ALIGN(STREAM,LOG)            \
 469   fprintf (STREAM, "\t.align\t%d\n", (LOG))
 470
 471 /**** Miscellaneous Parameters.  */
 472
 473 /* Specify the machine mode that this machine uses for the index in
 474    the tablejump instruction.  */
 475 #define CASE_VECTOR_MODE DImode
 476
 477 /* Define if operations between registers with integral mode smaller
 478    than a word are always performed on the entire register.  */
 479 #define WORD_REGISTER_OPERATIONS 1
 480
 481 /* C expression indicating when insns that read memory in MEM_MODE, an
 482    integral mode narrower than a word, set the bits outsize of
 483    MEM_MODE to be either the sign-extension or the zero-extension of
 484    the data read.  */
 485 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
 486
 487 /* The maximum number of bytes that a single instruction can move
 488    quickly between memory and registers or between two memory
 489    locations.  */
 490 #define MOVE_MAX 8
 491
 492 /* Allow upto 1024 bytes moves to occur using by_pieces
 493    infrastructure.  This mimics clang behaviour when using
 494    __builtin_memcmp.  */
 495 #define COMPARE_MAX_PIECES 1024
 496
 497 /* An alias for the machine mode for pointers.  */
 498 #define Pmode DImode
 499
 500 /* An alias for the machine mode used for memory references to
 501    functions being called, in 'call' RTL expressions.  */
 502 #define FUNCTION_MODE Pmode
 503
 504 /* No libm on eBPF (for now.)  */
 505 #define MATH_LIBRARY ""
 506
 507 /**** libgcc settings.  */
 508
 509 /* Iterating over the global constructors and destructors and
 510    executing them requires the ability of doing indirect calls.
 511
 512    eBPF doesn't support indirect calls, so no chance of supporting
 513    constructors and destructors.  */
 514 #define DO_GLOBAL_CTORS_BODY                    \
 515   do { } while (0)
 516 #define DO_GLOBAL_DTORS_BODY                    \
 517   do { } while (0)
 518
 519 #define ASSEMBLER_DIALECT ((int) asm_dialect)
 520
 521 #endif /* ! GCC_BPF_H */