Added 64 bit number support in the build gles2 command buffer script.

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """code generator for GLES2 command buffers."""
 
 import itertools
 import os
 import os.path
@@ skipping 2345 matching lines @@
     'decoder_func': 'glClearDepth',
     'gl_test_func': 'glClearDepth',
     'valid_args': {
       '0': '0.5f'
     },
   },
   'ClientWaitSync': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args': 'GLuint sync, GLbitfieldSyncFlushFlags flags, '
-                'GLuint timeout_0, GLuint timeout_1, GLenum* result',
+                'GLuint64 timeout, GLenum* result',
     'unsafe': True,
     'result': ['GLenum'],
     'trace_level': 2,
   },
   'ColorMask': {
     'type': 'StateSet',
     'state': 'ColorMask',
     'no_gl': True,
     'expectation': False,
   },
@@ skipping 1437 matching lines @@
   'VertexAttribPointer': {
     'type': 'Manual',
     'cmd_args': 'GLuint indx, GLintVertexAttribSize size, '
                 'GLenumVertexAttribType type, GLboolean normalized, '
                 'GLsizei stride, GLuint offset',
     'client_test': False,
   },
   'WaitSync': {
     'type': 'Custom',
     'cmd_args': 'GLuint sync, GLbitfieldSyncFlushFlags flags, '
-                'GLuint timeout_0, GLuint timeout_1',
+                'GLuint64 timeout',

[Zhenyao Mo, 2015/12/15 23:19:20]

Now it's the same original signature, we don't need to specify cmd_args at all.

[David Yen, 2015/12/15 23:20:30]

That's what I originally thought too, but actually the original signature for
the sync argument is GLSync.

     'impl_func': False,
     'client_test': False,
     'unsafe': True,
     'trace_level': 1,
   },
   'Scissor': {
     'type': 'StateSet',
     'state': 'Scissor',
   },
   'Viewport': {
@@ skipping 750 matching lines @@
       else:
         f.write("  struct Result {\n")
         for line in result:
           f.write("    %s;\n" % line)
         f.write("  };\n\n")
 
     func.WriteCmdComputeSize(f)
     func.WriteCmdSetHeader(f)
     func.WriteCmdInit(f)
     func.WriteCmdSet(f)
+    func.WriteArgAccessors(f)
 
     f.write("  gpu::CommandHeader header;\n")
+    total_args = 0
     args = func.GetCmdArgs()
     for arg in args:
-      f.write("  %s %s;\n" % (arg.cmd_type, arg.name))
+      for cmd_type, name in arg.GetArgDecls():
+        f.write("  %s %s;\n" % (cmd_type, name))
+        total_args += 1
 
     consts = func.GetCmdConstants()
     for const in consts:
+      const_decls = const.GetArgDecls()
+      assert(len(const_decls) == 1)
+      const_cmd_type, const_name = const_decls[0]
       f.write("  static const %s %s = %s;\n" %
-                 (const.cmd_type, const.name, const.GetConstantValue()))
+                 (const_cmd_type, const_name, const.GetConstantValue()))
 
     f.write("};\n")
     f.write("\n")
 
-    size = len(args) * _SIZE_OF_UINT32 + _SIZE_OF_COMMAND_HEADER
+    size = total_args * _SIZE_OF_UINT32 + _SIZE_OF_COMMAND_HEADER
     f.write("static_assert(sizeof(%s) == %d,\n" % (func.name, size))
     f.write("              \"size of %s should be %d\");\n" %
-               (func.name, size))
+            (func.name, size))
     f.write("static_assert(offsetof(%s, header) == 0,\n" % func.name)
     f.write("              \"offset of %s header should be 0\");\n" %
-               func.name)
+            func.name)
     offset = _SIZE_OF_COMMAND_HEADER
     for arg in args:
-      f.write("static_assert(offsetof(%s, %s) == %d,\n" %
-                 (func.name, arg.name, offset))
-      f.write("              \"offset of %s %s should be %d\");\n" %
-                 (func.name, arg.name, offset))
-      offset += _SIZE_OF_UINT32
+      for _, name in arg.GetArgDecls():
+        f.write("static_assert(offsetof(%s, %s) == %d,\n" %
+                (func.name, name, offset))
+        f.write("              \"offset of %s %s should be %d\");\n" %
+                (func.name, name, offset))
+        offset += _SIZE_OF_UINT32
     if not result == None and len(result) > 1:
       offset = 0;
       for line in result:
         parts = line.split()
         name = parts[-1]
         check = """
 static_assert(offsetof(%(cmd_name)s::Result, %(field_name)s) == %(offset)d,
               "offset of %(cmd_name)s Result %(field_name)s should be "
               "%(offset)d");
 """
@@ skipping 79 matching lines @@
     args = func.GetCmdArgs()
     for value, arg in enumerate(args):
       f.write(",\n      static_cast<%s>(%d)" % (arg.type, value + 11))
     f.write(");\n")
     f.write("  EXPECT_EQ(static_cast<uint32_t>(cmds::%s::kCmdId),\n" %
                func.name)
     f.write("            cmd.header.command);\n")
     func.type_handler.WriteCmdSizeTest(func, f)
     for value, arg in enumerate(args):
       f.write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
-                 (arg.type, value + 11, arg.name))
+                 (arg.type, value + 11, arg.GetArgAccessor()))
     f.write("  CheckBytesWrittenMatchesExpectedSize(\n")
     f.write("      next_cmd, sizeof(cmd));\n")
     f.write("}\n")
     f.write("\n")
 
   def WriteImmediateFormatTest(self, func, f):
     """Writes a format test for an immediate version of a command."""
     pass
 
   def WriteGetDataSizeCode(self, func, f):
@@ skipping 757 matching lines @@
     f.write(
         "    uint32_t total_size = 0;  // WARNING: compute correct size.\n")
 
   def WriteImmediateCmdInit(self, func, f):
     """Overrriden from TypeHandler."""
     f.write("  void Init(%s) {\n" % func.MakeTypedCmdArgString("_"))
     self.WriteImmediateCmdGetTotalSize(func, f)
     f.write("    SetHeader(total_size);\n")
     args = func.GetCmdArgs()
     for arg in args:
-      f.write("    %s = _%s;\n" % (arg.name, arg.name))
+      arg.WriteSetCode(f, 4, '_%s' % arg.name)
     f.write("  }\n")
     f.write("\n")
 
   def WriteImmediateCmdSet(self, func, f):
     """Overrriden from TypeHandler."""
     copy_args = func.MakeCmdArgString("_", False)
     f.write("  void* Set(void* cmd%s) {\n" %
                func.MakeTypedCmdArgString("_", True))
     self.WriteImmediateCmdGetTotalSize(func, f)
     f.write("    static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args)
@@ skipping 3003 matching lines @@
 
     return len(self.GetValidValues()) == 1
 
   def GetConstantValue(self):
     return self.GetValidValues()[0]
 
 class Argument(object):
   """A class that represents a function argument."""
 
   cmd_type_map_ = {
-    'GLenum': 'uint32_t',
-    'GLint': 'int32_t',
-    'GLintptr': 'int32_t',
-    'GLsizei': 'int32_t',
-    'GLsizeiptr': 'int32_t',
-    'GLfloat': 'float',
-    'GLclampf': 'float',
+    'GLenum': ['uint32_t'],
+    'GLint': ['int32_t'],
+    'GLintptr': ['int32_t'],
+    'GLsizei': ['int32_t'],
+    'GLsizeiptr': ['int32_t'],
+    'GLfloat': ['float'],
+    'GLclampf': ['float'],
+    'GLuint64': ['uint32_t', 'uint32_t'],
   }
   need_validation_ = ['GLsizei*', 'GLboolean*', 'GLenum*', 'GLint*']
 
   def __init__(self, name, type):
     self.name = name
     self.optional = type.endswith("Optional*")
     if self.optional:
       type = type[:-len("Optional*")] + "*"
     self.type = type
 
     if type in self.cmd_type_map_:
       self.cmd_type = self.cmd_type_map_[type]
     else:
-      self.cmd_type = 'uint32_t'
+      self.cmd_type = ['uint32_t']
 
   def IsPointer(self):
     """Returns true if argument is a pointer."""
     return False
 
   def IsPointer2D(self):
     """Returns true if argument is a 2D pointer."""
     return False
 
   def IsConstant(self):
@@ skipping 12 matching lines @@
 
   def GetValidArg(self, func):
     """Gets a valid value for this argument."""
     valid_arg = func.GetValidArg(self)
     if valid_arg != None:
       return valid_arg
 
     index = func.GetOriginalArgs().index(self)
     return str(index + 1)
 
+  def GetArgDecls(self):
+    if len(self.cmd_type) == 1:
+      return [(self.cmd_type[0], self.name)]
+    else:
+      return [(cmd_type, self.name + '_%d' % i)
+              for i, cmd_type
+              in enumerate(self.cmd_type)]
+
   def GetValidClientSideArg(self, func):
     """Gets a valid value for this argument."""
     valid_arg = func.GetValidArg(self)
     if valid_arg != None:
       return valid_arg
 
     if self.IsPointer():
       return 'nullptr'
     index = func.GetOriginalArgs().index(self)
     if self.type == 'GLsync':
@@ skipping 37 matching lines @@
     return '123'
 
   def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
     return 0
 
   def GetInvalidArg(self, index):
     """returns an invalid value and expected parse result by index."""
     return ("---ERROR0---", "---ERROR2---", None)
 
+  def GetArgAccessor(self):
+    """Returns the name of the accessor for the argument within the struct."""
+    return self.name
+
   def GetLogArg(self):
     """Get argument appropriate for LOG macro."""
     if self.type == 'GLboolean':
       return 'GLES2Util::GetStringBool(%s)' % self.name
     if self.type == 'GLenum':
       return 'GLES2Util::GetStringEnum(%s)' % self.name
     return self.name
 
   def WriteGetCode(self, f):
     """Writes the code to get an argument from a command structure."""
     if self.type == 'GLsync':
       my_type = 'GLuint'
     else:
       my_type = self.type
     f.write("  %s %s = static_cast<%s>(c.%s);\n" %
                (my_type, self.name, my_type, self.name))
 
+  def WriteSetCode(self, f, indent, var):
+    f.write("%s%s = %s;\n" % (' ' * indent, self.name, var))
+
+  def WriteArgAccessor(self, f):
+    """Writes specialized accessor for argument."""
+    pass
+
   def WriteValidationCode(self, f, func):
     """Writes the validation code for an argument."""
     pass
 
   def WriteClientSideValidationCode(self, f, func):
     """Writes the validation code for an argument."""
     pass
 
   def WriteDestinationInitalizationValidation(self, f, func):
     """Writes the client side destintion initialization validation."""
@@ skipping 221 matching lines @@
   """A class that represents a GLenum argument"""
 
   def __init__(self, name, type):
     EnumBaseArgument.__init__(self, name, "GLenum", type, "GL_INVALID_ENUM")
 
   def GetLogArg(self):
     """Overridden from Argument."""
     return ("GLES2Util::GetString%s(%s)" %
             (self.type_name, self.name))
 
-
 class IntArgument(EnumBaseArgument):
   """A class for a GLint argument that can only accept specific values.
 
   For example glTexImage2D takes a GLint for its internalformat
   argument instead of a GLenum.
   """
 
   def __init__(self, name, type):
     EnumBaseArgument.__init__(self, name, "GLint", type, "GL_INVALID_VALUE")
 
@@ skipping 252 matching lines @@
     else:
       type = type.replace(match.group(1), "GLuint")
     Argument.__init__(self, name, type)
 
   def WriteGetCode(self, f):
     """Overridden from Argument."""
     if self.type == "GLsync":
       my_type = "GLuint"
     else:
       my_type = self.type
-    f.write("  %s %s = c.%s;\n" % (my_type, self.name, self.name))
+    f.write("  %s %s = c.%s;\n" % (my_type, self.name, self.GetArgAccessor()))
 
   def GetValidArg(self, func):
     return "client_%s_id_" % self.resource_type.lower()
 
   def GetValidGLArg(self, func):
     if self.resource_type == "Sync":
       return "reinterpret_cast<GLsync>(kService%sId)" % self.resource_type
     return "kService%sId" % self.resource_type
 
 
@@ skipping 23 matching lines @@
   """Represents a resource id argument to a function that can be zero."""
 
   def __init__(self, name, type):
     match = re.match("(GLidZero\w+)", type)
     self.resource_type = match.group(1)[8:]
     type = type.replace(match.group(1), "GLuint")
     Argument.__init__(self, name, type)
 
   def WriteGetCode(self, f):
     """Overridden from Argument."""
-    f.write("  %s %s = c.%s;\n" % (self.type, self.name, self.name))
+    f.write("  %s %s = c.%s;\n" % (self.type, self.name, self.GetArgAccessor()))
 
   def GetValidArg(self, func):
     return "client_%s_id_" % self.resource_type.lower()
 
   def GetValidGLArg(self, func):
     return "kService%sId" % self.resource_type
 
   def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
     return 1
 
   def GetInvalidArg(self, index):
     """returns an invalid value by index."""
     return ("kInvalidClientId", "kNoError", "GL_INVALID_VALUE")
 
 
+class Int64Argument(Argument):
+  """Represents a GLuint64 argument which splits up into 2 uint32 items."""
+
+  def __init__(self, name, type):
+    Argument.__init__(self, name, type)
+
+  def GetArgAccessor(self):
+    return "%s()" % self.name
+
+  def WriteArgAccessor(self, f):
+    """Writes specialized accessor for compound members."""
+    f.write("  %s %s() const {\n" % (self.type, self.name))
+    f.write("    return static_cast<%s>(\n" % self.type)
+    f.write("        GLES2Util::MapTwoUint32ToUint64(\n")
+    f.write("            %s_0,\n" % self.name)
+    f.write("            %s_1));\n" % self.name)
+    f.write("  }\n")
+    f.write("\n")
+
+  def WriteGetCode(self, f):
+    """Writes the code to get an argument from a command structure."""
+    f.write("  %s %s = c.%s();\n" % (self.type, self.name, self.name))
+
+  def WriteSetCode(self, f, indent, var):
+    indent_str = ' ' * indent
+    f.write("%sGLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(%s),\n" %
+            (indent_str, var))
+    f.write("%s                                &%s_0,\n" %
+            (indent_str, self.name))
+    f.write("%s                                &%s_1);\n" %
+            (indent_str, self.name))
+
 class Function(object):
   """A class that represents a function."""
 
   type_handlers = {
     '': TypeHandler(),
     'Bind': BindHandler(),
     'Create': CreateHandler(),
     'Custom': CustomHandler(),
     'Data': DataHandler(),
     'Delete': DeleteHandler(),
@@ skipping 356 matching lines @@
     f.write("    header.SetCmd<ValueType>();\n")
     f.write("  }\n")
     f.write("\n")
 
   def WriteCmdInit(self, f):
     """Writes the cmd's Init function."""
     f.write("  void Init(%s) {\n" % self.MakeTypedCmdArgString("_"))
     f.write("    SetHeader();\n")
     args = self.GetCmdArgs()
     for arg in args:
-      f.write("    %s = _%s;\n" % (arg.name, arg.name))
+      arg.WriteSetCode(f, 4, '_%s' % arg.name)
     f.write("  }\n")
     f.write("\n")
 
   def WriteCmdSet(self, f):
     """Writes the cmd's Set function."""
     copy_args = self.MakeCmdArgString("_", False)
     f.write("  void* Set(void* cmd%s) {\n" %
                self.MakeTypedCmdArgString("_", True))
     f.write("    static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args)
     f.write("    return NextCmdAddress<ValueType>(cmd);\n")
     f.write("  }\n")
     f.write("\n")
 
+  def WriteArgAccessors(self, f):
+    """Writes the cmd's accessor functions."""
+    for arg in self.GetCmdArgs():
+      arg.WriteArgAccessor(f)
+
   def WriteStruct(self, f):
     self.type_handler.WriteStruct(self, f)
 
   def WriteDocs(self, f):
     self.type_handler.WriteDocs(self, f)
 
   def WriteCmdHelper(self, f):
     """Writes the cmd's helper."""
     self.type_handler.WriteCmdHelper(self, f)
 
@@ skipping 253 matching lines @@
     return BoolArgument(arg_name, arg_type)
   elif t.startswith('GLintUniformLocation'):
     return UniformLocationArgument(arg_name)
   elif (t.startswith('GLint') and t != 'GLint' and
         not t.startswith('GLintptr')):
     return IntArgument(arg_name, arg_type)
   elif t == 'GLsizeiNotNegative' or t == 'GLintptrNotNegative':
     return SizeNotNegativeArgument(arg_name, t.replace('NotNegative', ''))
   elif t.startswith('GLsize'):
     return SizeArgument(arg_name, arg_type)
+  elif t == 'GLuint64' or t == 'GLint64':
+    return Int64Argument(arg_name, arg_type)
   else:
     return Argument(arg_name, arg_type)
 
 
 class GLGenerator(object):
   """A class to generate GL command buffers."""
 
   _function_re = re.compile(r'GL_APICALL(.*?)GL_APIENTRY (.*?) \((.*?)\);')
 
   def __init__(self, verbose):
@@ skipping 1355 matching lines @@
   Format(gen.generated_cpp_filenames)
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))