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/native_client/src/untrusted/pnacl_irt_shim/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     # TODO(dmichael): We have no way to wrap PPP_ interfaces without an
  63     # interface string. If any ever need wrapping, we'll need to figure out a
  64     # way to get the plugin-side of the Pepper proxy (within the IRT) to access
  65     # and use the wrapper.
  66     if iface.GetProperty("no_interface_string"):
  67       return False
  68     for member in iface.GetListOf('Member'):
  69       release = member.GetRelease(version)
  70       if self.MemberNeedsWrapping(member, release):
  71         return True
  72     return False
  73
  74
  75   def MemberNeedsWrapping(self, member, release):
  76     """Return true if a particular member function at a particular
  77     release needs wrapping.
  78     """
  79     if self._skip_opt:
  80       return True
  81     if not member.InReleases([release]):
  82       return False
  83     ret, name, array, args_spec = self.cgen.GetComponents(member,
  84                                                           release,
  85                                                           'store')
  86     return self.TypeNeedsWrapping(ret, []) or self.ArgsNeedWrapping(args_spec)
  87
  88
  89   def ArgsNeedWrapping(self, args):
  90     """Return true if any parameter in the list needs wrapping.
  91     """
  92     for arg in args:
  93       (type_str, name, array_dims, more_args) = arg
  94       if self.TypeNeedsWrapping(type_str, array_dims):
  95         return True
  96     return False
  97
  98
  99   def TypeNeedsWrapping(self, type_node, array_dims):
 100     """Return true if a parameter type needs wrapping.
 101     Currently, this is true for byval aggregates.
 102     """
 103     is_aggregate = type_node.startswith('struct') or \
 104         type_node.startswith('union')
 105     is_reference = (type_node.find('*') != -1 or array_dims != [])
 106     return is_aggregate and not is_reference
 107
 108   ############################################################
 109
 110
 111   def ConvertByValueReturnType(self, ret, args_spec):
 112     if self.TypeNeedsWrapping(ret, array_dims=[]):
 113       args_spec = [(ret, '_struct_result', [], None)] + args_spec
 114       ret2 = 'void'
 115       wrap_return = True
 116     else:
 117       ret2 = ret
 118       wrap_return = False
 119     return wrap_return, ret2, args_spec
 120
 121
 122   def ConvertByValueArguments(self, args_spec):
 123     args = []
 124     for type_str, name, array_dims, more_args in args_spec:
 125       if self.TypeNeedsWrapping(type_str, array_dims):
 126         type_str += '*'
 127       args.append((type_str, name, array_dims, more_args))
 128     return args
 129
 130
 131   def FormatArgs(self, c_operator, args_spec):
 132     args = []
 133     for type_str, name, array_dims, more_args in args_spec:
 134       if self.TypeNeedsWrapping(type_str, array_dims):
 135         args.append(c_operator + name)
 136       else:
 137         args.append(name)
 138     return ', '.join(args)
 139
 140
 141   def GenerateWrapperForPPBMethod(self, iface, member):
 142     result = []
 143     func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
 144     ret, name, array, cspec = self.cgen.GetComponents(member,
 145                                                       iface.release,
 146                                                       'store')
 147     wrap_return, ret2, cspec2 = self.ConvertByValueReturnType(ret, cspec)
 148     cspec2 = self.ConvertByValueArguments(cspec2)
 149     sig = self.cgen.Compose(ret2, name, array, cspec2,
 150                             prefix=func_prefix,
 151                             func_as_ptr=False,
 152                             include_name=True,
 153                             unsized_as_ptr=False)
 154     result.append('static %s {\n' % sig)
 155     result.append('  const struct %s *iface = %s.real_iface;\n' %
 156                   (iface.struct_name, self.GetWrapperInfoName(iface)))
 157
 158     return_prefix = ''
 159     if wrap_return:
 160       return_prefix = '*_struct_result = '
 161     elif ret != 'void':
 162       return_prefix = 'return '
 163
 164     result.append('  %siface->%s(%s);\n}\n\n' % (return_prefix,
 165                                                  member.GetName(),
 166                                                  self.FormatArgs('*', cspec)))
 167     return result
 168
 169
 170   def GenerateWrapperForPPPMethod(self, iface, member):
 171     result = []
 172     func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
 173     sig = self.cgen.GetSignature(member, iface.release, 'store',
 174                                  func_prefix, False)
 175     result.append('static %s {\n' % sig)
 176     result.append('  const struct %s *iface = %s.real_iface;\n' %
 177                   (iface.struct_name, self.GetWrapperInfoName(iface)))
 178     ret, name, array, cspec = self.cgen.GetComponents(member,
 179                                                       iface.release,
 180                                                       'store')
 181     wrap_return, ret2, cspec = self.ConvertByValueReturnType(ret, cspec)
 182     cspec2 = self.ConvertByValueArguments(cspec)
 183     temp_fp = self.cgen.Compose(ret2, name, array, cspec2,
 184                                 prefix='temp_fp',
 185                                 func_as_ptr=True,
 186                                 include_name=False,
 187                                 unsized_as_ptr=False)
 188     cast = self.cgen.Compose(ret2, name, array, cspec2,
 189                              prefix='',
 190                              func_as_ptr=True,
 191                              include_name=False,
 192                              unsized_as_ptr=False)
 193     result.append('  %s =\n    ((%s)iface->%s);\n' % (temp_fp,
 194                                                       cast,
 195                                                       member.GetName()))
 196     return_prefix = ''
 197     if wrap_return:
 198       result.append('  %s _struct_result;\n' % ret)
 199     elif ret != 'void':
 200       return_prefix = 'return '
 201
 202     result.append('  %stemp_fp(%s);\n' % (return_prefix,
 203                                           self.FormatArgs('&', cspec)))
 204     if wrap_return:
 205       result.append('  return _struct_result;\n')
 206     result.append('}\n\n')
 207     return result
 208
 209
 210   def GenerateRange(self, ast, releases, options):
 211     """Generate shim code for a range of releases.
 212     """
 213     self._skip_opt = GetOption('disable_pnacl_opt')
 214     self.SetOutputFile(GetOption('pnaclshim'))
 215     return WrapperGen.GenerateRange(self, ast, releases, options)
 216
 217 pnaclgen = PnaclGen()
 218
 219 ######################################################################
 220 # Tests.
 221
 222 # Clean a string representing an object definition and return then string
 223 # as a single space delimited set of tokens.
 224 def CleanString(instr):
 225   instr = instr.strip()
 226   instr = instr.split()
 227   return ' '.join(instr)
 228
 229
 230 def PrintErrorDiff(old, new):
 231   oldlines = old.split(';')
 232   newlines = new.split(';')
 233   d = difflib.Differ()
 234   diff = d.compare(oldlines, newlines)
 235   ErrOut.Log('Diff is:\n%s' % '\n'.join(diff))
 236
 237
 238 def GetOldTestOutput(ast):
 239   # Scan the top-level comments in the IDL file for comparison.
 240   old = []
 241   for filenode in ast.GetListOf('File'):
 242     for node in filenode.GetChildren():
 243       instr = node.GetOneOf('Comment')
 244       if not instr: continue
 245       instr.Dump()
 246       old.append(instr.GetName())
 247   return CleanString(''.join(old))
 248
 249
 250 def TestFiles(filenames, test_releases):
 251   ast = ParseFiles(filenames)
 252   iface_releases = pnaclgen.DetermineInterfaces(ast, test_releases)
 253   new_output = CleanString(pnaclgen.GenerateWrapperForMethods(
 254       iface_releases, comments=False))
 255   old_output = GetOldTestOutput(ast)
 256   if new_output != old_output:
 257     PrintErrorDiff(old_output, new_output)
 258     ErrOut.Log('Failed pnacl generator test.')
 259     return 1
 260   else:
 261     InfoOut.Log('Passed pnacl generator test.')
 262     return 0
 263
 264
 265 def Main(args):
 266   filenames = ParseOptions(args)
 267   test_releases = ['M13', 'M14', 'M15']
 268   if not filenames:
 269     idldir = os.path.split(sys.argv[0])[0]
 270     idldir = os.path.join(idldir, 'test_gen_pnacl', '*.idl')
 271     filenames = glob.glob(idldir)
 272   filenames = sorted(filenames)
 273   if GetOption('test'):
 274     # Run the tests.
 275     return TestFiles(filenames, test_releases)
 276
 277   # Otherwise, generate the output file (for potential use as golden file).
 278   ast = ParseFiles(filenames)
 279   return pnaclgen.GenerateRange(ast, test_releases, filenames)
 280
 281
 282 if __name__ == '__main__':
 283   retval = Main(sys.argv[1:])
 284   sys.exit(retval)