arch/x86/include/asm/calling.h

   1 /*
   2
   3  x86 function call convention, 64-bit:
   4  -------------------------------------
   5   arguments           |  callee-saved      | extra caller-saved | return
   6  [callee-clobbered]   |                    | [callee-clobbered] |
   7  ---------------------------------------------------------------------------
   8  rdi rsi rdx rcx r8-9 | rbx rbp [*] r12-15 | r10-11             | rax, rdx [**]
   9
  10  ( rsp is obviously invariant across normal function calls. (gcc can 'merge'
  11    functions when it sees tail-call optimization possibilities) rflags is
  12    clobbered. Leftover arguments are passed over the stack frame.)
  13
  14  [*]  In the frame-pointers case rbp is fixed to the stack frame.
  15
  16  [**] for struct return values wider than 64 bits the return convention is a
  17       bit more complex: up to 128 bits width we return small structures
  18       straight in rax, rdx. For structures larger than that (3 words or
  19       larger) the caller puts a pointer to an on-stack return struct
  20       [allocated in the caller's stack frame] into the first argument - i.e.
  21       into rdi. All other arguments shift up by one in this case.
  22       Fortunately this case is rare in the kernel.
  23
  24 For 32-bit we have the following conventions - kernel is built with
  25 -mregparm=3 and -freg-struct-return:
  26
  27  x86 function calling convention, 32-bit:
  28  ----------------------------------------
  29   arguments         | callee-saved        | extra caller-saved | return
  30  [callee-clobbered] |                     | [callee-clobbered] |
  31  -------------------------------------------------------------------------
  32  eax edx ecx        | ebx edi esi ebp [*] | <none>             | eax, edx [**]
  33
  34  ( here too esp is obviously invariant across normal function calls. eflags
  35    is clobbered. Leftover arguments are passed over the stack frame. )
  36
  37  [*]  In the frame-pointers case ebp is fixed to the stack frame.
  38
  39  [**] We build with -freg-struct-return, which on 32-bit means similar
  40       semantics as on 64-bit: edx can be used for a second return value
  41       (i.e. covering integer and structure sizes up to 64 bits) - after that
  42       it gets more complex and more expensive: 3-word or larger struct returns
  43       get done in the caller's frame and the pointer to the return struct goes
  44       into regparm0, i.e. eax - the other arguments shift up and the
  45       function's register parameters degenerate to regparm=2 in essence.
  46
  47 */
  48
  49 #include "dwarf2.h"
  50
  51 /*
  52  * 64-bit system call stack frame layout defines and helpers, for
  53  * assembly code (note that the seemingly unnecessary parentheses
  54  * are to prevent cpp from inserting spaces in expressions that get
  55  * passed to macros):
  56  */
  57
  58 #define R15               (0)
  59 #define R14               (8)
  60 #define R13              (16)
  61 #define R12              (24)
  62 #define RBP              (32)
  63 #define RBX              (40)
  64
  65 /* arguments: interrupts/non tracing syscalls only save up to here: */
  66 #define R11              (48)
  67 #define R10              (56)
  68 #define R9               (64)
  69 #define R8               (72)
  70 #define RAX              (80)
  71 #define RCX              (88)
  72 #define RDX              (96)
  73 #define RSI             (104)
  74 #define RDI             (112)
  75 #define ORIG_RAX        (120)       /* + error_code */
  76 /* end of arguments */
  77
  78 /* cpu exception frame or undefined in case of fast syscall: */
  79 #define RIP             (128)
  80 #define CS              (136)
  81 #define EFLAGS          (144)
  82 #define RSP             (152)
  83 #define SS              (160)
  84
  85 #define ARGOFFSET       R11
  86 #define SWFRAME         ORIG_RAX
  87
  88         .macro SAVE_ARGS addskip=0, norcx=0, nor891011=0
  89         subq  $9*8+\addskip, %rsp
  90         CFI_ADJUST_CFA_OFFSET   9*8+\addskip
  91         movq_cfi rdi, 8*8
  92         movq_cfi rsi, 7*8
  93         movq_cfi rdx, 6*8
  94
  95         .if \norcx
  96         .else
  97         movq_cfi rcx, 5*8
  98         .endif
  99
 100         movq_cfi rax, 4*8
 101
 102         .if \nor891011
 103         .else
 104         movq_cfi r8,  3*8
 105         movq_cfi r9,  2*8
 106         movq_cfi r10, 1*8
 107         movq_cfi r11, 0*8
 108         .endif
 109
 110         .endm
 111
 112 #define ARG_SKIP        (9*8)
 113
 114         .macro RESTORE_ARGS skiprax=0, addskip=0, skiprcx=0, skipr11=0, \
 115                             skipr8910=0, skiprdx=0
 116         .if \skipr11
 117         .else
 118         movq_cfi_restore 0*8, r11
 119         .endif
 120
 121         .if \skipr8910
 122         .else
 123         movq_cfi_restore 1*8, r10
 124         movq_cfi_restore 2*8, r9
 125         movq_cfi_restore 3*8, r8
 126         .endif
 127
 128         .if \skiprax
 129         .else
 130         movq_cfi_restore 4*8, rax
 131         .endif
 132
 133         .if \skiprcx
 134         .else
 135         movq_cfi_restore 5*8, rcx
 136         .endif
 137
 138         .if \skiprdx
 139         .else
 140         movq_cfi_restore 6*8, rdx
 141         .endif
 142
 143         movq_cfi_restore 7*8, rsi
 144         movq_cfi_restore 8*8, rdi
 145
 146         .if ARG_SKIP+\addskip > 0
 147         addq $ARG_SKIP+\addskip, %rsp
 148         CFI_ADJUST_CFA_OFFSET   -(ARG_SKIP+\addskip)
 149         .endif
 150         .endm
 151
 152         .macro LOAD_ARGS offset, skiprax=0
 153         movq \offset(%rsp),    %r11
 154         movq \offset+8(%rsp),  %r10
 155         movq \offset+16(%rsp), %r9
 156         movq \offset+24(%rsp), %r8
 157         movq \offset+40(%rsp), %rcx
 158         movq \offset+48(%rsp), %rdx
 159         movq \offset+56(%rsp), %rsi
 160         movq \offset+64(%rsp), %rdi
 161         .if \skiprax
 162         .else
 163         movq \offset+72(%rsp), %rax
 164         .endif
 165         .endm
 166
 167 #define REST_SKIP       (6*8)
 168
 169         .macro SAVE_REST
 170         subq $REST_SKIP, %rsp
 171         CFI_ADJUST_CFA_OFFSET   REST_SKIP
 172         movq_cfi rbx, 5*8
 173         movq_cfi rbp, 4*8
 174         movq_cfi r12, 3*8
 175         movq_cfi r13, 2*8
 176         movq_cfi r14, 1*8
 177         movq_cfi r15, 0*8
 178         .endm
 179
 180         .macro RESTORE_REST
 181         movq_cfi_restore 0*8, r15
 182         movq_cfi_restore 1*8, r14
 183         movq_cfi_restore 2*8, r13
 184         movq_cfi_restore 3*8, r12
 185         movq_cfi_restore 4*8, rbp
 186         movq_cfi_restore 5*8, rbx
 187         addq $REST_SKIP, %rsp
 188         CFI_ADJUST_CFA_OFFSET   -(REST_SKIP)
 189         .endm
 190
 191         .macro SAVE_ALL
 192         SAVE_ARGS
 193         SAVE_REST
 194         .endm
 195
 196         .macro RESTORE_ALL addskip=0
 197         RESTORE_REST
 198         RESTORE_ARGS 0, \addskip
 199         .endm
 200
 201         .macro icebp
 202         .byte 0xf1
 203         .endm