Make command buffer commands and immediate data volatile

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 4859 matching lines @@
 
   def WriteBucketHandlerImplementation (self, func, f):
     """Writes the handler impl for the bucket version of a command."""
     self.__WriteIdMapping(func, f)
     f.write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteServiceHandlerFunctionHeader(self, func, f):
     """Writes function header for service implementation handlers."""
     f.write("""error::Error GLES2DecoderImpl::Handle%(name)s(
-        uint32_t immediate_data_size, const void* cmd_data) {
+        uint32_t immediate_data_size, const volatile void* cmd_data) {
       """ % {'name': func.name})
     if func.IsUnsafe():
       f.write("""if (!unsafe_es3_apis_enabled())
           return error::kUnknownCommand;
         """)
-    f.write("""const gles2::cmds::%(name)s& c =
-          *static_cast<const gles2::cmds::%(name)s*>(cmd_data);
-      (void)c;
-      """ % {'name': func.name})
+    if func.GetCmdArgs():
+      f.write("""const volatile gles2::cmds::%(name)s& c =
+            *static_cast<const volatile gles2::cmds::%(name)s*>(cmd_data);
+        """ % {'name': func.name})
 
   def WriteServiceHandlerArgGetCode(self, func, f):
     """Writes the argument unpack code for service handlers."""
     if len(func.GetOriginalArgs()) > 0:
       last_arg = func.GetLastOriginalArg()
       all_but_last_arg = func.GetOriginalArgs()[:-1]
       for arg in all_but_last_arg:
         arg.WriteGetCode(f)
       self.WriteGetDataSizeCode(func, f)
       last_arg.WriteGetCode(f)
@@ skipping 46 matching lines @@
     self.WriteBucketServiceHandlerArgGetCode(func, f)
     func.WriteHandlerValidation(f)
     func.WriteHandlerImplementation(f)
     f.write("  return error::kNoError;\n")
     f.write("}\n")
     f.write("\n")
 
   def WritePassthroughServiceFunctionHeader(self, func, f):
     """Writes function header for service passthrough handlers."""
     f.write("""error::Error GLES2DecoderPassthroughImpl::Handle%(name)s(
-        uint32_t immediate_data_size, const void* cmd_data) {
+        uint32_t immediate_data_size, const volatile void* cmd_data) {
       """ % {'name': func.name})
-    f.write("""const gles2::cmds::%(name)s& c =
-          *static_cast<const gles2::cmds::%(name)s*>(cmd_data);
-      (void)c;
-      """ % {'name': func.name})
+    if func.GetCmdArgs():
+      f.write("""const volatile gles2::cmds::%(name)s& c =
+            *static_cast<const volatile gles2::cmds::%(name)s*>(cmd_data);
+        """ % {'name': func.name})
 
   def WritePassthroughServiceFunctionDoerCall(self, func, f):
     """Writes the function call to the passthrough service doer."""
     f.write("""  error::Error error = Do%(name)s(%(args)s);
   if (error != error::kNoError) {
     return error;
   }""" % {'name': func.original_name,
           'args': func.MakePassthroughServiceDoerArgString("")})
 
   def WritePassthroughServiceImplementation(self, func, f):
@@ skipping 4019 matching lines @@
     match = re.match('(const\s+)?(?P<element_type>[\w]+)\s*\*', self.type)
     assert match
     return match.groupdict()['element_type']
 
   def AddCmdArgs(self, args):
     """Overridden from Argument."""
     pass
 
   def WriteGetCode(self, f):
     """Overridden from Argument."""
-    f.write("  %s %s = GetImmediateDataAs<%s>(\n" %
+    f.write("  volatile %s %s = GetImmediateDataAs<volatile %s>(\n" %
             (self.type, self.name, self.type))
     f.write("      c, data_size, immediate_data_size);\n")
 
   def WriteValidationCode(self, f, func):
     """Overridden from Argument."""
     if self.optional:
       return
     f.write("  if (%s == NULL) {\n" % self.name)
     f.write("    return error::kOutOfBounds;\n")
     f.write("  }\n")
@@ skipping 264 matching lines @@
   """Represents a GLuint64 argument which splits up into 2 uint32_t 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("  %s %s() const volatile {\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))
@@ skipping 2012 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:]))