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