Another round of gcc fixes for GPU command buffers.

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/python
 #
 # Copyright (c) 2006-2009 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 GL command buffers."""
 
 import os
 import os.path
@@ skipping 434 matching lines @@
     file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteCmdSizeTest(self, func, file):
     """Writes the size test for a command."""
-    file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4);  // NOLINT\n")
+    file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);  // NOLINT\n")
 
   def WriteFormatTest(self, func, file):
     """Writes a format test for a command."""
     file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name)
-    file.Write("  %s cmd = { 0, };\n" % func.name)
+    file.Write("  %s cmd = {{0}};\n" % func.name)
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
     value = 11
     for arg in args:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(");\n")
     value = 11
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
+    file.Write("            cmd.header.command);\n")
     func.type_handler.WriteCmdSizeTest(func, file)
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd));\n");
     for arg in args:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateFormatTest(self, func, file):
     """Writes a format test for an immediate version of a command."""
     file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name)
     file.Write("  int8 buf[256] = { 0, };\n")
     file.Write("  %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" %
                (func.name, func.name))
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
     value = 11
     for arg in args:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(");\n")
     value = 11
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
+    file.Write("            cmd.header.command);\n")
     func.type_handler.WriteImmediateCmdSizeTest(func, file)
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd));\n");
     for arg in args:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateCmdSizeTest(self, func, file):
     """Writes a size test for an immediate version of a command."""
     file.Write("  // TODO(gman): Compute correct size.\n")
-    file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4);\n")
+    file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);\n")
 
   def WriteImmediateHandlerImplementation (self, func, file):
     """Writes the handler impl for the immediate version of a command."""
     file.Write("  // Immediate version.\n")
     file.Write("  parse_error::ParseError result =\n")
     file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
@@ skipping 452 matching lines @@
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
     value = 11
     for arg in args:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(",\n      ids);\n")
     args = func.GetCmdArgs()
     value = 11
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
+    file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(sizeof(cmd) +\n")
-    file.Write("            RoundSizeToMultipleOfEntries(cmd.n * 4),\n")
-    file.Write("            cmd.header.size * 4);  // NOLINT\n")
+    file.Write("            RoundSizeToMultipleOfEntries(cmd.n * 4u),\n")
+    file.Write("            cmd.header.size * 4u);  // NOLINT\n")
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd) +\n");
+    file.Write("                RoundSizeToMultipleOfEntries(cmd.n * 4u));\n");
     for arg in args:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("  // TODO(gman): Check that ids were inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class CreateHandler(TypeHandler):
@@ skipping 152 matching lines @@
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
     value = 11
     for arg in args:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(",\n      ids);\n")
     args = func.GetCmdArgs()
     value = 11
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
+    file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(sizeof(cmd) +\n")
-    file.Write("            RoundSizeToMultipleOfEntries(cmd.n * 4),\n")
-    file.Write("            cmd.header.size * 4);  // NOLINT\n")
+    file.Write("            RoundSizeToMultipleOfEntries(cmd.n * 4u),\n")
+    file.Write("            cmd.header.size * 4u);  // NOLINT\n")
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd) +\n");
+    file.Write("                RoundSizeToMultipleOfEntries(cmd.n * 4u));\n");
     for arg in args:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("  // TODO(gman): Check that ids were inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class GETnHandler(TypeHandler):
@@ skipping 161 matching lines @@
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
     value = 11
     for arg in args:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(",\n      data);\n")
     args = func.GetCmdArgs()
     value = 11
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
+    file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(sizeof(cmd) +\n")
     file.Write("            RoundSizeToMultipleOfEntries(sizeof(data)),\n")
-    file.Write("            cmd.header.size * 4);  // NOLINT\n")
+    file.Write("            cmd.header.size * 4u);  // NOLINT\n")
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd) +\n")
+    file.Write("                RoundSizeToMultipleOfEntries(sizeof(data)));\n")
     for arg in args:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("  // TODO(gman): Check that data was inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class PUTnHandler(TypeHandler):
@@ skipping 105 matching lines @@
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
     value = 1
     for arg in args:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(",\n      data);\n")
     args = func.GetCmdArgs()
     value = 1
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
+    file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(sizeof(cmd) +\n")
     file.Write("            RoundSizeToMultipleOfEntries(sizeof(data)),\n")
-    file.Write("            cmd.header.size * 4);  // NOLINT\n")
+    file.Write("            cmd.header.size * 4u);  // NOLINT\n")
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd) +\n")
+    file.Write("                RoundSizeToMultipleOfEntries(sizeof(data)));\n")
     for arg in args:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("  // TODO(gman): Check that data was inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class GLcharHandler(TypeHandler):
@@ skipping 152 matching lines @@
     file.Write("  static const char* const test_str = \"test string\";\n")
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     all_but_last_arg = func.GetCmdArgs()[:-1]
     value = 11
     for arg in all_but_last_arg:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(",\n      test_str);\n")
     value = 11
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
+    file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(sizeof(cmd) +  // NOLINT\n")
     file.Write("            RoundSizeToMultipleOfEntries(strlen(test_str)),\n")
-    file.Write("            cmd.header.size * 4);\n")
+    file.Write("            cmd.header.size * 4u);\n")
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd) +\n")
+    file.Write("                strlen(test_str) + 1);\n")
     for arg in all_but_last_arg:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("  // TODO(gman): check that string got copied.\n")
     file.Write("}\n")
     file.Write("\n")
 
 class GetGLcharHandler(GLcharHandler):
   """Handler for glGetAttibLoc, glGetUniformLoc."""
@@ skipping 155 matching lines @@
     file.Write("  static const char* const test_str = \"test string\";\n")
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     all_but_last_arg = func.GetCmdArgs()[:-1]
     value = 11
     for arg in all_but_last_arg:
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
       value += 1
     file.Write(",\n      test_str);\n")
     value = 11
-    file.Write("  EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name)
+    file.Write("  EXPECT_EQ(%s::kCmdId ^ cmd.header.command);\n" % func.name)
     file.Write("  EXPECT_EQ(sizeof(cmd) +  // NOLINT\n")
     file.Write("            RoundSizeToMultipleOfEntries(strlen(test_str)),\n")
-    file.Write("            cmd.header.size * 4);\n")
+    file.Write("            cmd.header.size * 4u);\n")
+    file.Write("  EXPECT_EQ(static_cast<char*>(next_cmd),\n")
+    file.Write("            reinterpret_cast<char*>(&cmd) + sizeof(cmd));\n");
     for arg in all_but_last_arg:
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value, arg.name))
       value += 1
     file.Write("  // TODO(gman): check that string got copied.\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class IsHandler(TypeHandler):
@@ skipping 75 matching lines @@
       setattr(self, key, info[key])
     self.type_handler = type_handler
     if not 'type' in info:
       self.type = ''
 
 
 class Argument(object):
   """A class that represents a function argument."""
 
   cmd_type_map_ = {
+    'GLint': 'int32',
+    'GLsizei': 'int32',
     'GLfloat': 'float',
     'GLclampf': 'float',
   }
 
   def __init__(self, name, type):
     self.name = name
     self.type = type
 
     if type in self.cmd_type_map_:
       self.cmd_type = self.cmd_type_map_[type]
@@ skipping 758 matching lines @@
   if options.generate_implementation_templates:
     gen.WriteGLES2ImplementationImpl("client/gles2_implementation_gen.h")
     gen.WriteServiceValidation("service/gles2_cmd_decoder_validate.h")
 
   if options.generate_command_id_tests:
     gen.WriteCommandIdTest("common/gles2_cmd_id_test.cc")
 
 
 if __name__ == '__main__':
   main(sys.argv[1:])
-