src/mapi/glapi/gen/gl_x86-64_asm.py

   1
   2 # (C) Copyright IBM Corporation 2005
   3 # All Rights Reserved.
   4 #
   5 # Permission is hereby granted, free of charge, to any person obtaining a
   6 # copy of this software and associated documentation files (the "Software"),
   7 # to deal in the Software without restriction, including without limitation
   8 # on the rights to use, copy, modify, merge, publish, distribute, sub
   9 # license, and/or sell copies of the Software, and to permit persons to whom
  10 # the Software is furnished to do so, subject to the following conditions:
  11 #
  12 # The above copyright notice and this permission notice (including the next
  13 # paragraph) shall be included in all copies or substantial portions of the
  14 # Software.
  15 #
  16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 # FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19 # IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  22 # IN THE SOFTWARE.
  23 #
  24 # Authors:
  25 #    Ian Romanick <idr@us.ibm.com>
  26
  27 from __future__ import print_function
  28
  29 import argparse
  30 import copy
  31
  32 import license
  33 import gl_XML, glX_XML
  34
  35 def should_use_push(registers):
  36     for [reg, offset] in registers:
  37         if reg[1:4] == "xmm":
  38             return 0
  39
  40     N = len(registers)
  41     return (N & 1) != 0
  42
  43
  44 def local_size(registers):
  45     # The x86-64 ABI says "the value (%rsp - 8) is always a multiple of
  46     # 16 when control is transfered to the function entry point."  This
  47     # means that the local stack usage must be (16*N)+8 for some value
  48     # of N.  (16*N)+8 = (8*(2N))+8 = 8*(2N+1).  As long as N is odd, we
  49     # meet this requirement.
  50
  51     N = (len(registers) | 1)
  52     return 8*N
  53
  54
  55 def save_all_regs(registers):
  56     adjust_stack = 0
  57     if not should_use_push(registers):
  58         adjust_stack = local_size(registers)
  59         print('\tsubq\t$%u, %%rsp' % (adjust_stack))
  60
  61     for [reg, stack_offset] in registers:
  62         save_reg( reg, stack_offset, adjust_stack )
  63     return
  64
  65
  66 def restore_all_regs(registers):
  67     adjust_stack = 0
  68     if not should_use_push(registers):
  69         adjust_stack = local_size(registers)
  70
  71     temp = copy.deepcopy(registers)
  72     while len(temp):
  73         [reg, stack_offset] = temp.pop()
  74         restore_reg(reg, stack_offset, adjust_stack)
  75
  76     if adjust_stack:
  77         print('\taddq\t$%u, %%rsp' % (adjust_stack))
  78     return
  79
  80
  81 def save_reg(reg, offset, use_move):
  82     if use_move:
  83         if offset == 0:
  84             print('\tmovq\t%s, (%%rsp)' % (reg))
  85         else:
  86             print('\tmovq\t%s, %u(%%rsp)' % (reg, offset))
  87     else:
  88         print('\tpushq\t%s' % (reg))
  89
  90     return
  91
  92
  93 def restore_reg(reg, offset, use_move):
  94     if use_move:
  95         if offset == 0:
  96             print('\tmovq\t(%%rsp), %s' % (reg))
  97         else:
  98             print('\tmovq\t%u(%%rsp), %s' % (offset, reg))
  99     else:
 100         print('\tpopq\t%s' % (reg))
 101
 102     return
 103
 104
 105 class PrintGenericStubs(gl_XML.gl_print_base):
 106
 107     def __init__(self):
 108         gl_XML.gl_print_base.__init__(self)
 109
 110         self.name = "gl_x86-64_asm.py (from Mesa)"
 111         self.license = license.bsd_license_template % ("(C) Copyright IBM Corporation 2005", "IBM")
 112         return
 113
 114
 115     def get_stack_size(self, f):
 116         size = 0
 117         for p in f.parameterIterator():
 118             size += p.get_stack_size()
 119
 120         return size
 121
 122
 123     def printRealHeader(self):
 124         print("/* If we build with gcc's -fvisibility=hidden flag, we'll need to change")
 125         print(" * the symbol visibility mode to 'default'.")
 126         print(' */')
 127         print('')
 128         print('#include "x86/assyntax.h"')
 129         print('')
 130         print('#ifdef __GNUC__')
 131         print('#  pragma GCC visibility push(default)')
 132         print('#  define HIDDEN(x) .hidden x')
 133         print('#else')
 134         print('#  define HIDDEN(x)')
 135         print('#endif')
 136         print('')
 137         print('# if defined(USE_MGL_NAMESPACE)')
 138         print('#  define GL_PREFIX(n) GLNAME(CONCAT(mgl,n))')
 139         print('#  define _glapi_Dispatch _mglapi_Dispatch')
 140         print('# else')
 141         print('#  define GL_PREFIX(n) GLNAME(CONCAT(gl,n))')
 142         print('# endif')
 143         print('')
 144         print('\t.text')
 145         print('')
 146         print('#ifdef GLX_USE_TLS')
 147         print('')
 148         print('_x86_64_get_dispatch:')
 149         print('\tmovq\t_glapi_tls_Dispatch@GOTTPOFF(%rip), %rax')
 150         print('\tmovq\t%fs:(%rax), %rax')
 151         print('\tret')
 152         print('\t.size\t_x86_64_get_dispatch, .-_x86_64_get_dispatch')
 153         print('')
 154         print('#elif defined(HAVE_PTHREAD)')
 155         print('')
 156         print('\t.extern\t_glapi_Dispatch')
 157         print('\t.extern\t_gl_DispatchTSD')
 158         print('\t.extern\tpthread_getspecific')
 159         print('')
 160         print('\t.p2align\t4,,15')
 161         print('_x86_64_get_dispatch:')
 162         print('\tmovq\t_gl_DispatchTSD@GOTPCREL(%rip), %rax')
 163         print('\tmovl\t(%rax), %edi')
 164         print('\tjmp\tpthread_getspecific@PLT')
 165         print('')
 166         print('#else')
 167         print('')
 168         print('\t.extern\t_glapi_get_dispatch')
 169         print('')
 170         print('#endif')
 171         print('')
 172         return
 173
 174
 175     def printRealFooter(self):
 176         print('')
 177         print('#if defined (__ELF__) && defined (__linux__)')
 178         print(' .section .note.GNU-stack,"",%progbits')
 179         print('#endif')
 180         return
 181
 182
 183     def printFunction(self, f):
 184
 185         # The x86-64 ABI divides function parameters into a couple
 186         # classes.  For the OpenGL interface, the only ones that are
 187         # relevant are INTEGER and SSE.  Basically, the first 8
 188         # GLfloat or GLdouble parameters are placed in %xmm0 - %xmm7,
 189         # the first 6 non-GLfloat / non-GLdouble parameters are placed
 190         # in registers listed in int_parameters.
 191         #
 192         # If more parameters than that are required, they are passed
 193         # on the stack.  Therefore, we just have to make sure that
 194         # %esp hasn't changed when we jump to the actual function.
 195         # Since we're jumping to the function (and not calling it), we
 196         # have to make sure of that anyway!
 197
 198         int_parameters = ["%rdi", "%rsi", "%rdx", "%rcx", "%r8", "%r9"]
 199
 200         int_class = 0
 201         sse_class = 0
 202         stack_offset = 0
 203         registers = []
 204         for p in f.parameterIterator():
 205             type_name = p.get_base_type_string()
 206
 207             if p.is_pointer() or (type_name != "GLfloat" and type_name != "GLdouble"):
 208                 if int_class < 6:
 209                     registers.append( [int_parameters[int_class], stack_offset] )
 210                     int_class += 1
 211                     stack_offset += 8
 212             else:
 213                 if sse_class < 8:
 214                     registers.append( ["%%xmm%u" % (sse_class), stack_offset] )
 215                     sse_class += 1
 216                     stack_offset += 8
 217
 218         if ((int_class & 1) == 0) and (sse_class == 0):
 219             registers.append( ["%rbp", 0] )
 220
 221
 222         name = f.dispatch_name()
 223
 224         print('\t.p2align\t4,,15')
 225         print('\t.globl\tGL_PREFIX(%s)' % (name))
 226         print('\t.type\tGL_PREFIX(%s), @function' % (name))
 227         if not f.is_static_entry_point(f.name):
 228             print('\tHIDDEN(GL_PREFIX(%s))' % (name))
 229         print('GL_PREFIX(%s):' % (name))
 230         print('#if defined(GLX_USE_TLS)')
 231         print('\tcall\t_x86_64_get_dispatch@PLT')
 232         print('\tmovq\t%u(%%rax), %%r11' % (f.offset * 8))
 233         print('\tjmp\t*%r11')
 234         print('#elif defined(HAVE_PTHREAD)')
 235
 236         save_all_regs(registers)
 237         print('\tcall\t_x86_64_get_dispatch@PLT')
 238         restore_all_regs(registers)
 239
 240         if f.offset == 0:
 241             print('\tmovq\t(%rax), %r11')
 242         else:
 243             print('\tmovq\t%u(%%rax), %%r11' % (f.offset * 8))
 244
 245         print('\tjmp\t*%r11')
 246
 247         print('#else')
 248         print('\tmovq\t_glapi_Dispatch(%rip), %rax')
 249         print('\ttestq\t%rax, %rax')
 250         print('\tje\t1f')
 251         print('\tmovq\t%u(%%rax), %%r11' % (f.offset * 8))
 252         print('\tjmp\t*%r11')
 253         print('1:')
 254
 255         save_all_regs(registers)
 256         print('\tcall\t_glapi_get_dispatch')
 257         restore_all_regs(registers)
 258
 259         print('\tmovq\t%u(%%rax), %%r11' % (f.offset * 8))
 260         print('\tjmp\t*%r11')
 261         print('#endif /* defined(GLX_USE_TLS) */')
 262
 263         print('\t.size\tGL_PREFIX(%s), .-GL_PREFIX(%s)' % (name, name))
 264         print('')
 265         return
 266
 267
 268     def printBody(self, api):
 269         for f in api.functionIterateByOffset():
 270             self.printFunction(f)
 271
 272
 273         for f in api.functionIterateByOffset():
 274             dispatch = f.dispatch_name()
 275             for n in f.entry_points:
 276                 if n != f.name:
 277                     if f.is_static_entry_point(n):
 278                         text = '\t.globl GL_PREFIX(%s) ; .set GL_PREFIX(%s), GL_PREFIX(%s)' % (n, n, dispatch)
 279
 280                         if f.has_different_protocol(n):
 281                             print('#ifndef GLX_INDIRECT_RENDERING')
 282                             print(text)
 283                             print('#endif')
 284                         else:
 285                             print(text)
 286
 287         return
 288
 289
 290 def _parser():
 291     """Parse arguments and return a namespace."""
 292     parser = argparse.ArgumentParser()
 293     parser.add_argument('-f',
 294                         default='gl_API.xml',
 295                         dest='filename',
 296                         help='An XML file describing an API')
 297     return parser.parse_args()
 298
 299
 300 def main():
 301     """Main file."""
 302     args = _parser()
 303     printer = PrintGenericStubs()
 304     api = gl_XML.parse_GL_API(args.filename, glX_XML.glx_item_factory())
 305
 306     printer.Print(api)
 307
 308
 309 if __name__ == '__main__':
 310     main()