Update mojo sdk to rev 9fbbc4f0fef1187312316c0ed992342474e139f1

mojo/nacl/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 optparse
 import os.path
 import sys
@@ skipping 139 matching lines @@
 # Parameters passed into trusted code are handled differently depending on
 # details of the parameter.  ParamImpl instances encapsulate these differences
 # and are used to generate the code that transfers parameters across the
 # untrusted/trusted boundary.
 class ParamImpl(object):
   def __init__(self, param):
     self.param = param
 
   # Declare whatever variables are needed to handle this particular parameter.
   def DeclareVars(self, code):
-    raise NotImplementedError()
+    raise NotImplementedError(type(self))
 
   # Convert the untrusted representation of the parameter into a trusted
   # representation, such as a scalar value or a trusted pointer into the
   # untrusted address space.
   def ConvertParam(self):
-    raise NotImplementedError()
+    raise NotImplementedError(type(self))
 
   # For this particular parameter, what expression should be passed when
   # invoking the trusted Mojo API function?
   def CallParam(self):
-    raise NotImplementedError()
+    raise NotImplementedError(type(self))
 
   # After invoking the trusted Mojo API function, transfer data back into
   # untrusted memory.  Overriden for Out and InOut parameters.
   def CopyOut(self, code):
     pass
 
   # Converting array parameters needs to be defered until after the scalar
   # parameter containing the size of the array has itself been converted.
   def IsArray(self):
     return False
@@ skipping 12 matching lines @@
     return '%s_value' % self.param.name
 
 
 class ScalarOutputImpl(ParamImpl):
   def DeclareVars(self, code):
     code << '%s volatile* %s_ptr;' % (self.param.base_type, self.param.name)
     code << '%s %s_value;' % (self.param.base_type, self.param.name)
 
   def ConvertParam(self):
     p = self.param
-    return 'ConvertScalarOutput(nap, params[%d], &%s_ptr)' % (p.uid + 1, p.name)
+    return ('ConvertScalarOutput(nap, params[%d], %s, &%s_ptr)' %
+            (p.uid + 1, CBool(p.is_optional), p.name))
 
   def CallParam(self):
-    return '&%s_value' % self.param.name
+    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):
     name = self.param.name
-    code << '*%s_ptr = %s_value;' % (name, name)
+    if self.param.is_struct:
+      # C++ errors when you try to copy a volatile struct pointer.
+      # (There are no default copy constructors for this case.)
+      # memcpy instead.
+      copy_stmt = ('memcpy_volatile_out(%s_ptr, &%s_value, sizeof(%s));' %
+                   (name, name, self.param.base_type))
+    else:
+      copy_stmt = '*%s_ptr = %s_value;' % (name, name)
+
+    if self.param.is_optional:
+      code << 'if (%s_ptr != NULL) {' % (name)
+      with code.Indent():
+        code << copy_stmt
+      code << '}'
+    else:
+      code << copy_stmt
 
 
 class ScalarInOutImpl(ParamImpl):
   def DeclareVars(self, code):
     code << '%s volatile* %s_ptr;' % (self.param.base_type, self.param.name)
     code << '%s %s_value;' % (self.param.base_type, self.param.name)
 
   def ConvertParam(self):
     p = self.param
     return ('ConvertScalarInOut(nap, params[%d], %s, &%s_value, &%s_ptr)' %
@@ skipping 32 matching lines @@
             (p.uid + 1, p.size + '_value', element_size, CBool(p.is_optional),
              p.name))
 
   def CallParam(self):
     return self.param.name
 
   def IsArray(self):
     return True
 
 
-class StructInputImpl(ParamImpl):
+class ExtensibleStructInputImpl(ParamImpl):
   def DeclareVars(self, code):
     code << '%s %s;' % (self.param.param_type, self.param.name)
 
   def ConvertParam(self):
     p = self.param
-    return ('ConvertStruct(nap, params[%d], %s, &%s)' %
+    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:
         return ScalarInOutImpl(p)
       else:
-        return ScalarOutputImpl(p)
+        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)
   elif p.is_array:
     return ArrayImpl(p)
   elif p.is_struct:
-    return StructInputImpl(p)
-  else:
-    assert False, p
+    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, out):
   template = jinja_env.get_template('mojo_syscall.cc.tmpl')
@@ skipping 93 matching lines @@
 
   out = OutFile(options.out_dir, 'libmojo.cc')
   GenerateLibMojo(mojo.functions, out)
 
   out = OutFile(options.out_dir, 'mojo_syscall.cc')
   GenerateMojoSyscall(mojo.functions, out)
 
 
 if __name__ == '__main__':
   main(sys.argv[1:])