Support pointers in the NaCl bindings generator.

nacl_bindings_generator/generate_nacl_bindings.py

 #!/usr/bin/python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # pylint: disable=W0104,W0106,F0401,R0201
 
 import errno
 import os.path
 import sys
@@ skipping 216 matching lines @@
     name = self.param.name
     if self.param.is_optional:
       code << 'if (%s_ptr != NULL) {' % (name)
       with code.Indent():
         code << '*%s_ptr = %s_value;' % (name, name)
       code << '}'
     else:
       code << '*%s_ptr = %s_value;' % (name, name)
 
 
+class PointerInputImpl(ParamImpl):
+  def DeclareVars(self, code):
+    code << '%s %s_value;' % (self.param.base_type, self.param.name)
+
+  def ConvertParam(self):
+    p = self.param
+    return ('ConvertPointerInput(nap, params[%d], &%s_value)' %
+            (p.uid + 1, p.name))
+
+  def CallParam(self):
+    return '%s_value' % self.param.name
+
+
+class PointerInOutImpl(ParamImpl):
+  def DeclareVars(self, code):
+    code << 'uint32_t volatile* %s_ptr;' % (self.param.name,)
+    code << '%s %s_value;' % (self.param.base_type, self.param.name)
+
+  def ConvertParam(self):
+    p = self.param
+    return ('ConvertPointerInOut(nap, params[%d], %s, &%s_value, &%s_ptr)' %
+            (p.uid + 1, CBool(p.is_optional), p.name, p.name))
+
+  def CallParam(self):
+    name = self.param.name
+    expr = '&%s_value' % name
+    if self.param.is_optional:
+      expr = '%s_ptr ? %s : NULL' % (name, expr)
+    return expr
+
+  def CopyOut(self, code):
+    assert not self.param.is_optional
+    name = self.param.name
+    if self.param.is_optional:
+      code << 'if (%s_ptr != NULL) {' % (name)
+      with code.Indent():
+        code << 'CopyOutPointer(nap, %s_value, %s_ptr);' % (name, name)
+      code << '}'
+    else:
+      code << 'CopyOutPointer(nap, %s_value, %s_ptr);' % (name, name)
+
 class ArrayImpl(ParamImpl):
   def DeclareVars(self, code):
     code << '%s %s;' % (self.param.param_type, self.param.name)
 
   def ConvertParam(self):
     p = self.param
     if p.base_type == 'void':
       element_size = '1'
     else:
       element_size = 'sizeof(*%s)' % p.name
@@ skipping 14 matching lines @@
     code << '%s %s;' % (self.param.param_type, self.param.name)
 
   def ConvertParam(self):
     p = self.param
     return ('ConvertExtensibleStructInput(nap, params[%d], %s, &%s)' %
             (p.uid + 1, CBool(p.is_optional), p.name))
 
   def CallParam(self):
     return self.param.name
 
+
 def ImplForParam(p):
   if p.IsScalar():
     if p.is_output:
-      if p.is_input:
+      if p.is_pointer:
+        return PointerInOutImpl(p)
+      elif p.is_input:
         return ScalarInOutImpl(p)
       else:
         if p.is_always_written:
           return ScalarOutputImpl(p)
         else:
           # Mojo defines that some of its outputs will not be set in specific
           # cases.  To avoid the complexity of determining if the output was set
           # by Mojo, copy the output's current value (possibly junk) and copy it
           # back to untrusted memory afterwards.
           return ScalarInOutImpl(p)
     else:
-      return ScalarInputImpl(p)
+      if p.is_pointer:
+        return PointerInputImpl(p)
+      else:
+        return ScalarInputImpl(p)
   elif p.is_array:
     return ArrayImpl(p)
   elif p.is_struct:
     if p.is_input and not p.is_output and p.is_extensible:
       return ExtensibleStructInputImpl(p)
     if not p.is_input and p.is_output and not p.is_extensible:
       return ScalarOutputImpl(p)
   assert False, p.name
 
 
 def CBool(value):
   return 'true' if value else 'false'
 
 
 # A trusted wrapper that validates the arguments passed from untrusted code
 # before passing them to the underlying public Mojo API.
 def GenerateMojoSyscall(functions, common_vars, out):
   template = jinja_env.get_template('mojo_syscall.cc.tmpl')
 
   code = CodeWriter()
   code.PushMargin()
 
   for f in functions:
-    is_implemented = True
-
-    # Mojo API calls that take or return pointers are currently not supported.
-    # The underlying Mojo implementation is unaware of NaCl's address space. In
-    # addition, if we pass blindly pass the parameters through to the underlying
-    # Mojo API, memory corruption can result from pointer-size mistmatches.
-    for p in f.params:
-      if p.base_type.endswith("*"):
-        is_implemented = False
+    is_implemented = not f.broken_in_nacl
 
     impls = [ImplForParam(p) for p in f.params]
     impls.append(ImplForParam(f.result_param))
 
     code << 'case %d:' % f.uid
 
     if not is_implemented:
       with code.Indent():
         code << 'fprintf(stderr, "%s not implemented\\n");' % f.name
         code << 'return -1;'
@@ skipping 186 matching lines @@
   GenerateMojoSyscall(mojo.functions, common_vars, out)
 
   out = OutFile(full_platform_dir, 'mojo_irt.h')
   GenerateMojoIrtHeader(mojo.functions, common_vars, out)
 
   out = OutFile(full_bindings_dir, 'mojo_irt.c')
   GenerateMojoIrtImplementation(mojo.functions, common_vars, out)
 
 if __name__ == '__main__':
   main()