ppapi/generators/idl_gen_pnacl.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """Generator for Pnacl Shim functions that bridges the calling conventions
   7 between GCC and PNaCl.  """
   8
   9 from datetime import datetime
  10 import difflib
  11 import glob
  12 import os
  13 import sys
  14
  15 from idl_c_proto import CGen
  16 from idl_gen_wrapper import Interface, WrapperGen
  17 from idl_log import ErrOut, InfoOut, WarnOut
  18 from idl_option import GetOption, Option, ParseOptions
  19 from idl_parser import ParseFiles
  20
  21 Option('pnaclshim', 'Name of the pnacl shim file.',
  22        default='temp_pnacl_shim.c')
  23
  24 Option('disable_pnacl_opt', 'Turn off optimization of pnacl shim.')
  25
  26
  27 class PnaclGen(WrapperGen):
  28   """PnaclGen generates shim code to bridge the Gcc ABI with PNaCl.
  29
  30   This subclass of WrapperGenerator takes the IDL sources and
  31   generates shim methods for bridging the calling conventions between GCC
  32   and PNaCl (LLVM). Some of the PPAPI methods do not need shimming, so
  33   this will also detect those situations and provide direct access to the
  34   original PPAPI methods (rather than the shim methods).
  35   """
  36
  37   def __init__(self):
  38     WrapperGen.__init__(self,
  39                         'Pnacl',
  40                         'Pnacl Shim Gen',
  41                         'pnacl',
  42                         'Generate the PNaCl shim.')
  43     self.cgen = CGen()
  44     self._skip_opt = False
  45
  46   ############################################################
  47
  48   def OwnHeaderFile(self):
  49     """Return the header file that specifies the API of this wrapper.
  50     We do not generate the header files.  """
  51     return 'ppapi/generators/pnacl_shim.h'
  52
  53
  54   def InterfaceVersionNeedsWrapping(self, iface, version):
  55     """Return true if the interface+version has ANY methods that
  56     need wrapping.
  57     """
  58     if self._skip_opt:
  59       return True
  60     if iface.GetName().endswith('Trusted'):
  61       return False
  62     for member in iface.GetListOf('Member'):
  63       release = member.GetRelease(version)
  64       if self.MemberNeedsWrapping(member, release):
  65         return True
  66     return False
  67
  68
  69   def MemberNeedsWrapping(self, member, release):
  70     """Return true if a particular member function at a particular
  71     release needs wrapping.
  72     """
  73     if self._skip_opt:
  74       return True
  75     if not member.InReleases([release]):
  76       return False
  77     ret, name, array, args_spec = self.cgen.GetComponents(member,
  78                                                           release,
  79                                                           'store')
  80     return self.TypeNeedsWrapping(ret, []) or self.ArgsNeedWrapping(args_spec)
  81
  82
  83   def ArgsNeedWrapping(self, args):
  84     """Return true if any parameter in the list needs wrapping.
  85     """
  86     for arg in args:
  87       (type_str, name, array_dims, more_args) = arg
  88       if self.TypeNeedsWrapping(type_str, array_dims):
  89         return True
  90     return False
  91
  92
  93   def TypeNeedsWrapping(self, type_node, array_dims):
  94     """Return true if a parameter type needs wrapping.
  95     Currently, this is true for byval aggregates.
  96     """
  97     is_aggregate = type_node.startswith('struct') or \
  98         type_node.startswith('union')
  99     is_reference = (type_node.find('*') != -1 or array_dims != [])
 100     return is_aggregate and not is_reference
 101
 102   ############################################################
 103
 104
 105   def ConvertByValueReturnType(self, ret, args_spec):
 106     if self.TypeNeedsWrapping(ret, array_dims=[]):
 107       args_spec = [(ret, '_struct_result', [], None)] + args_spec
 108       ret2 = 'void'
 109       wrap_return = True
 110     else:
 111       ret2 = ret
 112       wrap_return = False
 113     return wrap_return, ret2, args_spec
 114
 115
 116   def ConvertByValueArguments(self, args_spec):
 117     args = []
 118     for type_str, name, array_dims, more_args in args_spec:
 119       if self.TypeNeedsWrapping(type_str, array_dims):
 120         type_str += '*'
 121       args.append((type_str, name, array_dims, more_args))
 122     return args
 123
 124
 125   def FormatArgs(self, c_operator, args_spec):
 126     args = []
 127     for type_str, name, array_dims, more_args in args_spec:
 128       if self.TypeNeedsWrapping(type_str, array_dims):
 129         args.append(c_operator + name)
 130       else:
 131         args.append(name)
 132     return ', '.join(args)
 133
 134
 135   def GenerateWrapperForPPBMethod(self, iface, member):
 136     result = []
 137     func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
 138     ret, name, array, cspec = self.cgen.GetComponents(member,
 139                                                       iface.release,
 140                                                       'store')
 141     wrap_return, ret2, cspec2 = self.ConvertByValueReturnType(ret, cspec)
 142     cspec2 = self.ConvertByValueArguments(cspec2)
 143     sig = self.cgen.Compose(ret2, name, array, cspec2,
 144                             prefix=func_prefix,
 145                             func_as_ptr=False,
 146                             include_name=True,
 147                             unsized_as_ptr=False)
 148     result.append('static %s {\n' % sig)
 149     result.append('  const struct %s *iface = %s.real_iface;\n' %
 150                   (iface.struct_name, self.GetWrapperInfoName(iface)))
 151
 152     return_prefix = ''
 153     if wrap_return:
 154       return_prefix = '*_struct_result = '
 155     elif ret != 'void':
 156       return_prefix = 'return '
 157
 158     result.append('  %siface->%s(%s);\n}\n\n' % (return_prefix,
 159                                                  member.GetName(),
 160                                                  self.FormatArgs('*', cspec)))
 161     return result
 162
 163
 164   def GenerateWrapperForPPPMethod(self, iface, member):
 165     result = []
 166     func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
 167     sig = self.cgen.GetSignature(member, iface.release, 'store',
 168                                  func_prefix, False)
 169     result.append('static %s {\n' % sig)
 170     result.append('  const struct %s *iface = %s.real_iface;\n' %
 171                   (iface.struct_name, self.GetWrapperInfoName(iface)))
 172     ret, name, array, cspec = self.cgen.GetComponents(member,
 173                                                       iface.release,
 174                                                       'store')
 175     wrap_return, ret2, cspec = self.ConvertByValueReturnType(ret, cspec)
 176     cspec2 = self.ConvertByValueArguments(cspec)
 177     temp_fp = self.cgen.Compose(ret2, name, array, cspec2,
 178                                 prefix='temp_fp',
 179                                 func_as_ptr=True,
 180                                 include_name=False,
 181                                 unsized_as_ptr=False)
 182     cast = self.cgen.Compose(ret2, name, array, cspec2,
 183                              prefix='',
 184                              func_as_ptr=True,
 185                              include_name=False,
 186                              unsized_as_ptr=False)
 187     result.append('  %s =\n    ((%s)iface->%s);\n' % (temp_fp,
 188                                                       cast,
 189                                                       member.GetName()))
 190     return_prefix = ''
 191     if wrap_return:
 192       result.append('  %s _struct_result;\n' % ret)
 193     elif ret != 'void':
 194       return_prefix = 'return '
 195
 196     result.append('  %stemp_fp(%s);\n' % (return_prefix,
 197                                           self.FormatArgs('&', cspec)))
 198     if wrap_return:
 199       result.append('  return _struct_result;\n')
 200     result.append('}\n\n')
 201     return result
 202
 203
 204   def GenerateRange(self, ast, releases, options):
 205     """Generate shim code for a range of releases.
 206     """
 207     self._skip_opt = GetOption('disable_pnacl_opt')
 208     self.SetOutputFile(GetOption('pnaclshim'))
 209     return WrapperGen.GenerateRange(self, ast, releases, options)
 210
 211 pnaclgen = PnaclGen()
 212
 213 ######################################################################
 214 # Tests.
 215
 216 # Clean a string representing an object definition and return then string
 217 # as a single space delimited set of tokens.
 218 def CleanString(instr):
 219   instr = instr.strip()
 220   instr = instr.split()
 221   return ' '.join(instr)
 222
 223
 224 def PrintErrorDiff(old, new):
 225   oldlines = old.split(';')
 226   newlines = new.split(';')
 227   d = difflib.Differ()
 228   diff = d.compare(oldlines, newlines)
 229   ErrOut.Log('Diff is:\n%s' % '\n'.join(diff))
 230
 231
 232 def GetOldTestOutput(ast):
 233   # Scan the top-level comments in the IDL file for comparison.
 234   old = []
 235   for filenode in ast.GetListOf('File'):
 236     for node in filenode.GetChildren():
 237       instr = node.GetOneOf('Comment')
 238       if not instr: continue
 239       instr.Dump()
 240       old.append(instr.GetName())
 241   return CleanString(''.join(old))
 242
 243
 244 def TestFiles(filenames, test_releases):
 245   ast = ParseFiles(filenames)
 246   iface_releases = pnaclgen.DetermineInterfaces(ast, test_releases)
 247   new_output = CleanString(pnaclgen.GenerateWrapperForMethods(
 248       iface_releases, comments=False))
 249   old_output = GetOldTestOutput(ast)
 250   if new_output != old_output:
 251     PrintErrorDiff(old_output, new_output)
 252     ErrOut.Log('Failed pnacl generator test.')
 253     return 1
 254   else:
 255     InfoOut.Log('Passed pnacl generator test.')
 256     return 0
 257
 258
 259 def Main(args):
 260   filenames = ParseOptions(args)
 261   test_releases = ['M13', 'M14', 'M15']
 262   if not filenames:
 263     idldir = os.path.split(sys.argv[0])[0]
 264     idldir = os.path.join(idldir, 'test_gen_pnacl', '*.idl')
 265     filenames = glob.glob(idldir)
 266   filenames = sorted(filenames)
 267   if GetOption('test'):
 268     # Run the tests.
 269     return TestFiles(filenames, test_releases)
 270
 271   # Otherwise, generate the output file (for potential use as golden file).
 272   ast = ParseFiles(filenames)
 273   return pnaclgen.GenerateRange(ast, test_releases, filenames)
 274
 275
 276 if __name__ == '__main__':
 277   retval = Main(sys.argv[1:])
 278   sys.exit(retval)