gpu/command_buffer/service/shader_translator.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/shader_translator.h"
   6
   7 #include <string.h>
   8 #include <algorithm>
   9
  10 #include "base/at_exit.h"
  11 #include "base/debug/trace_event.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/logging.h"
  14 #include "base/strings/string_number_conversions.h"
  15
  16 namespace {
  17
  18 using gpu::gles2::ShaderTranslator;
  19
  20 class ShaderTranslatorInitializer {
  21  public:
  22   ShaderTranslatorInitializer() {
  23     TRACE_EVENT0("gpu", "ShInitialize");
  24     CHECK(ShInitialize());
  25   }
  26
  27   ~ShaderTranslatorInitializer() {
  28     TRACE_EVENT0("gpu", "ShFinalize");
  29     ShFinalize();
  30   }
  31 };
  32
  33 base::LazyInstance<ShaderTranslatorInitializer> g_translator_initializer =
  34     LAZY_INSTANCE_INITIALIZER;
  35
  36 #if !defined(ANGLE_SH_VERSION) || ANGLE_SH_VERSION < 108
  37 typedef int ANGLEGetInfoType;
  38 #else
  39 typedef size_t ANGLEGetInfoType;
  40 #endif
  41
  42 void GetVariableInfo(ShHandle compiler, ShShaderInfo var_type,
  43                      ShaderTranslator::VariableMap* var_map) {
  44   ANGLEGetInfoType name_len = 0, mapped_name_len = 0;
  45   switch (var_type) {
  46     case SH_ACTIVE_ATTRIBUTES:
  47       ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &name_len);
  48       break;
  49     case SH_ACTIVE_UNIFORMS:
  50       ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &name_len);
  51       break;
  52     case SH_VARYINGS:
  53       ShGetInfo(compiler, SH_VARYING_MAX_LENGTH, &name_len);
  54       break;
  55     default: NOTREACHED();
  56   }
  57   ShGetInfo(compiler, SH_MAPPED_NAME_MAX_LENGTH, &mapped_name_len);
  58   if (name_len <= 1 || mapped_name_len <= 1) return;
  59   scoped_ptr<char[]> name(new char[name_len]);
  60   scoped_ptr<char[]> mapped_name(new char[mapped_name_len]);
  61
  62   ANGLEGetInfoType num_vars = 0;
  63   ShGetInfo(compiler, var_type, &num_vars);
  64   for (ANGLEGetInfoType i = 0; i < num_vars; ++i) {
  65     ANGLEGetInfoType len = 0;
  66     int size = 0;
  67     ShDataType type = SH_NONE;
  68     ShPrecisionType precision = SH_PRECISION_UNDEFINED;
  69     int static_use = 0;
  70
  71     ShGetVariableInfo(compiler, var_type, i,
  72                       &len, &size, &type, &precision, &static_use,
  73                       name.get(), mapped_name.get());
  74
  75     // In theory we should CHECK(len <= name_len - 1) here, but ANGLE needs
  76     // to handle long struct field name mapping before we can do this.
  77     // Also, we should modify the ANGLE interface to also return a length
  78     // for mapped_name.
  79     std::string name_string(name.get(), std::min(len, name_len - 1));
  80     mapped_name.get()[mapped_name_len - 1] = '\0';
  81
  82     ShaderTranslator::VariableInfo info(
  83         type, size, precision, static_use, name_string);
  84     (*var_map)[mapped_name.get()] = info;
  85   }
  86 }
  87
  88 void GetNameHashingInfo(
  89     ShHandle compiler, ShaderTranslator::NameMap* name_map) {
  90   ANGLEGetInfoType hashed_names_count = 0;
  91   ShGetInfo(compiler, SH_HASHED_NAMES_COUNT, &hashed_names_count);
  92   if (hashed_names_count == 0)
  93     return;
  94
  95   ANGLEGetInfoType name_max_len = 0, hashed_name_max_len = 0;
  96   ShGetInfo(compiler, SH_NAME_MAX_LENGTH, &name_max_len);
  97   ShGetInfo(compiler, SH_HASHED_NAME_MAX_LENGTH, &hashed_name_max_len);
  98
  99   scoped_ptr<char[]> name(new char[name_max_len]);
 100   scoped_ptr<char[]> hashed_name(new char[hashed_name_max_len]);
 101
 102   for (ANGLEGetInfoType i = 0; i < hashed_names_count; ++i) {
 103     ShGetNameHashingEntry(compiler, i, name.get(), hashed_name.get());
 104     (*name_map)[hashed_name.get()] = name.get();
 105   }
 106 }
 107
 108 }  // namespace
 109
 110 namespace gpu {
 111 namespace gles2 {
 112
 113 ShaderTranslator::DestructionObserver::DestructionObserver() {
 114 }
 115
 116 ShaderTranslator::DestructionObserver::~DestructionObserver() {
 117 }
 118
 119 ShaderTranslator::ShaderTranslator()
 120     : compiler_(NULL),
 121       implementation_is_glsl_es_(false),
 122       driver_bug_workarounds_(static_cast<ShCompileOptions>(0)) {
 123 }
 124
 125 bool ShaderTranslator::Init(
 126     ShShaderType shader_type,
 127     ShShaderSpec shader_spec,
 128     const ShBuiltInResources* resources,
 129     ShaderTranslatorInterface::GlslImplementationType glsl_implementation_type,
 130     ShCompileOptions driver_bug_workarounds) {
 131   // Make sure Init is called only once.
 132   DCHECK(compiler_ == NULL);
 133   DCHECK(shader_type == SH_FRAGMENT_SHADER || shader_type == SH_VERTEX_SHADER);
 134   DCHECK(shader_spec == SH_GLES2_SPEC || shader_spec == SH_WEBGL_SPEC);
 135   DCHECK(resources != NULL);
 136
 137   g_translator_initializer.Get();
 138
 139   ShShaderOutput shader_output =
 140       (glsl_implementation_type == kGlslES ? SH_ESSL_OUTPUT : SH_GLSL_OUTPUT);
 141
 142   {
 143     TRACE_EVENT0("gpu", "ShConstructCompiler");
 144     compiler_ = ShConstructCompiler(
 145         shader_type, shader_spec, shader_output, resources);
 146   }
 147   compiler_options_ = *resources;
 148   implementation_is_glsl_es_ = (glsl_implementation_type == kGlslES);
 149   driver_bug_workarounds_ = driver_bug_workarounds;
 150   return compiler_ != NULL;
 151 }
 152
 153 int ShaderTranslator::GetCompileOptions() const {
 154   int compile_options =
 155       SH_OBJECT_CODE | SH_VARIABLES | SH_ENFORCE_PACKING_RESTRICTIONS |
 156       SH_LIMIT_EXPRESSION_COMPLEXITY | SH_LIMIT_CALL_STACK_DEPTH |
 157       SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
 158
 159   compile_options |= driver_bug_workarounds_;
 160
 161   return compile_options;
 162 }
 163
 164 bool ShaderTranslator::Translate(const char* shader) {
 165   // Make sure this instance is initialized.
 166   DCHECK(compiler_ != NULL);
 167   DCHECK(shader != NULL);
 168   ClearResults();
 169
 170   bool success = false;
 171   {
 172     TRACE_EVENT0("gpu", "ShCompile");
 173     success = !!ShCompile(compiler_, &shader, 1, GetCompileOptions());
 174   }
 175   if (success) {
 176     // Get translated shader.
 177     ANGLEGetInfoType obj_code_len = 0;
 178     ShGetInfo(compiler_, SH_OBJECT_CODE_LENGTH, &obj_code_len);
 179     if (obj_code_len > 1) {
 180       translated_shader_.reset(new char[obj_code_len]);
 181       ShGetObjectCode(compiler_, translated_shader_.get());
 182     }
 183     // Get info for attribs and uniforms.
 184     GetVariableInfo(compiler_, SH_ACTIVE_ATTRIBUTES, &attrib_map_);
 185     GetVariableInfo(compiler_, SH_ACTIVE_UNIFORMS, &uniform_map_);
 186     GetVariableInfo(compiler_, SH_VARYINGS, &varying_map_);
 187     // Get info for name hashing.
 188     GetNameHashingInfo(compiler_, &name_map_);
 189   }
 190
 191   // Get info log.
 192   ANGLEGetInfoType info_log_len = 0;
 193   ShGetInfo(compiler_, SH_INFO_LOG_LENGTH, &info_log_len);
 194   if (info_log_len > 1) {
 195     info_log_.reset(new char[info_log_len]);
 196     ShGetInfoLog(compiler_, info_log_.get());
 197   } else {
 198     info_log_.reset();
 199   }
 200
 201   return success;
 202 }
 203
 204 std::string ShaderTranslator::GetStringForOptionsThatWouldAffectCompilation()
 205     const {
 206 #if ANGLE_SH_VERSION >= 124
 207   DCHECK(compiler_ != NULL);
 208
 209   ANGLEGetInfoType resource_len = 0;
 210   ShGetInfo(compiler_, SH_RESOURCES_STRING_LENGTH, &resource_len);
 211   DCHECK(resource_len > 1);
 212   scoped_ptr<char[]> resource_str(new char[resource_len]);
 213
 214   ShGetBuiltInResourcesString(compiler_, resource_len, resource_str.get());
 215
 216   return std::string(":CompileOptions:" +
 217          base::IntToString(GetCompileOptions())) +
 218          std::string(resource_str.get());
 219 #else
 220 #if ANGLE_SH_VERSION >= 123
 221   const size_t kNumIntFields = 21;
 222 #elif ANGLE_SH_VERSION >= 122
 223   const size_t kNumIntFields = 20;
 224 #else
 225   const size_t kNumIntFields = 16;
 226 #endif
 227   const size_t kNumEnumFields = 1;
 228   const size_t kNumFunctionPointerFields = 1;
 229   struct MustMatchShBuiltInResource {
 230     typedef khronos_uint64_t (*FunctionPointer)(const char*, size_t);
 231     enum Enum {
 232       kFirst,
 233     };
 234     int int_fields[kNumIntFields];
 235     FunctionPointer pointer_fields[kNumFunctionPointerFields];
 236     Enum enum_fields[kNumEnumFields];
 237   };
 238   // If this assert fails most likely that means something below needs updating.
 239   COMPILE_ASSERT(
 240       sizeof(ShBuiltInResources) == sizeof(MustMatchShBuiltInResource),
 241       Fields_Have_Changed_In_ShBuiltInResource_So_Update_Below);
 242
 243   return std::string(
 244       ":CompileOptions:" +
 245       base::IntToString(GetCompileOptions()) +
 246       ":MaxVertexAttribs:" +
 247       base::IntToString(compiler_options_.MaxVertexAttribs) +
 248       ":MaxVertexUniformVectors:" +
 249       base::IntToString(compiler_options_.MaxVertexUniformVectors) +
 250       ":MaxVaryingVectors:" +
 251       base::IntToString(compiler_options_.MaxVaryingVectors) +
 252       ":MaxVertexTextureImageUnits:" +
 253       base::IntToString(compiler_options_.MaxVertexTextureImageUnits) +
 254       ":MaxCombinedTextureImageUnits:" +
 255       base::IntToString(compiler_options_.MaxCombinedTextureImageUnits) +
 256       ":MaxTextureImageUnits:" +
 257       base::IntToString(compiler_options_.MaxTextureImageUnits) +
 258       ":MaxFragmentUniformVectors:" +
 259       base::IntToString(compiler_options_.MaxFragmentUniformVectors) +
 260       ":MaxDrawBuffers:" +
 261       base::IntToString(compiler_options_.MaxDrawBuffers) +
 262       ":OES_standard_derivatives:" +
 263       base::IntToString(compiler_options_.OES_standard_derivatives) +
 264       ":OES_EGL_image_external:" +
 265       base::IntToString(compiler_options_.OES_EGL_image_external) +
 266       ":ARB_texture_rectangle:" +
 267       base::IntToString(compiler_options_.ARB_texture_rectangle) +
 268       ":EXT_draw_buffers:" +
 269       base::IntToString(compiler_options_.EXT_draw_buffers) +
 270       ":FragmentPrecisionHigh:" +
 271       base::IntToString(compiler_options_.FragmentPrecisionHigh) +
 272       ":MaxExpressionComplexity:" +
 273       base::IntToString(compiler_options_.MaxExpressionComplexity) +
 274       ":MaxCallStackDepth:" +
 275       base::IntToString(compiler_options_.MaxCallStackDepth) +
 276       ":EXT_frag_depth:" +
 277 #if ANGLE_SH_VERSION >= 122
 278       base::IntToString(compiler_options_.EXT_frag_depth) +
 279 #if ANGLE_SH_VERSION >= 123
 280       ":EXT_shader_texture_lod:" +
 281       base::IntToString(compiler_options_.EXT_shader_texture_lod) +
 282 #endif
 283       ":MaxVertexOutputVectors:" +
 284       base::IntToString(compiler_options_.MaxVertexOutputVectors) +
 285       ":MaxFragmentInputVectors:" +
 286       base::IntToString(compiler_options_.MaxFragmentInputVectors) +
 287       ":MinProgramTexelOffset:" +
 288       base::IntToString(compiler_options_.MinProgramTexelOffset) +
 289       ":MaxProgramTexelOffset:" +
 290       base::IntToString(compiler_options_.MaxProgramTexelOffset));
 291 #else   // ANGLE_SH_VERSION < 122
 292       base::IntToString(compiler_options_.EXT_frag_depth));
 293 #endif
 294 #endif
 295 }
 296
 297 const char* ShaderTranslator::translated_shader() const {
 298   return translated_shader_.get();
 299 }
 300
 301 const char* ShaderTranslator::info_log() const {
 302   return info_log_.get();
 303 }
 304
 305 const ShaderTranslatorInterface::VariableMap&
 306 ShaderTranslator::attrib_map() const {
 307   return attrib_map_;
 308 }
 309
 310 const ShaderTranslatorInterface::VariableMap&
 311 ShaderTranslator::uniform_map() const {
 312   return uniform_map_;
 313 }
 314
 315 const ShaderTranslatorInterface::VariableMap&
 316 ShaderTranslator::varying_map() const {
 317   return varying_map_;
 318 }
 319
 320 const ShaderTranslatorInterface::NameMap&
 321 ShaderTranslator::name_map() const {
 322   return name_map_;
 323 }
 324
 325 void ShaderTranslator::AddDestructionObserver(
 326     DestructionObserver* observer) {
 327   destruction_observers_.AddObserver(observer);
 328 }
 329
 330 void ShaderTranslator::RemoveDestructionObserver(
 331     DestructionObserver* observer) {
 332   destruction_observers_.RemoveObserver(observer);
 333 }
 334
 335 ShaderTranslator::~ShaderTranslator() {
 336   FOR_EACH_OBSERVER(DestructionObserver,
 337                     destruction_observers_,
 338                     OnDestruct(this));
 339
 340   if (compiler_ != NULL)
 341     ShDestruct(compiler_);
 342 }
 343
 344 void ShaderTranslator::ClearResults() {
 345   translated_shader_.reset();
 346   info_log_.reset();
 347   attrib_map_.clear();
 348   uniform_map_.clear();
 349   varying_map_.clear();
 350   name_map_.clear();
 351 }
 352
 353 }  // namespace gles2
 354 }  // namespace gpu
 355