diff --git a/src/dawn_native/ShaderModule.cpp b/src/dawn_native/ShaderModule.cpp
index dfa9acf..1cb3f21 100644
--- a/src/dawn_native/ShaderModule.cpp
+++ b/src/dawn_native/ShaderModule.cpp
@@ -66,6 +66,75 @@
             }
         }
 
+        wgpu::TextureViewDimension ToWGPUTextureViewDimension(
+            shaderc_spvc_texture_view_dimension dim) {
+            switch (dim) {
+                case shaderc_spvc_texture_view_dimension_undefined:
+                    return wgpu::TextureViewDimension::Undefined;
+                case shaderc_spvc_texture_view_dimension_e1D:
+                    return wgpu::TextureViewDimension::e1D;
+                case shaderc_spvc_texture_view_dimension_e2D:
+                    return wgpu::TextureViewDimension::e2D;
+                case shaderc_spvc_texture_view_dimension_e2D_array:
+                    return wgpu::TextureViewDimension::e2DArray;
+                case shaderc_spvc_texture_view_dimension_cube:
+                    return wgpu::TextureViewDimension::Cube;
+                case shaderc_spvc_texture_view_dimension_cube_array:
+                    return wgpu::TextureViewDimension::CubeArray;
+                case shaderc_spvc_texture_view_dimension_e3D:
+                    return wgpu::TextureViewDimension::e3D;
+            }
+            UNREACHABLE();
+        }
+
+        Format::Type ToDawnFormatType(shaderc_spvc_texture_format_type type) {
+            switch (type) {
+                case shaderc_spvc_texture_format_type_float:
+                    return Format::Type::Float;
+                case shaderc_spvc_texture_format_type_sint:
+                    return Format::Type::Sint;
+                case shaderc_spvc_texture_format_type_uint:
+                    return Format::Type::Uint;
+                case shaderc_spvc_texture_format_type_other:
+                    return Format::Type::Other;
+            }
+            UNREACHABLE();
+        }
+
+        wgpu::BindingType ToWGPUBindingType(shaderc_spvc_binding_type type) {
+            switch (type) {
+                case shaderc_spvc_binding_type_uniform_buffer:
+                    return wgpu::BindingType::UniformBuffer;
+                case shaderc_spvc_binding_type_storage_buffer:
+                    return wgpu::BindingType::StorageBuffer;
+                case shaderc_spvc_binding_type_readonly_storage_buffer:
+                    return wgpu::BindingType::ReadonlyStorageBuffer;
+                case shaderc_spvc_binding_type_sampler:
+                    return wgpu::BindingType::Sampler;
+                case shaderc_spvc_binding_type_sampled_texture:
+                    return wgpu::BindingType::SampledTexture;
+                case shaderc_spvc_binding_type_storage_texture:
+                    return wgpu::BindingType::StorageTexture;
+            }
+            UNREACHABLE();
+        }
+
+        // TODO(rharrison): Convert this to ResultOrError once ExtractSPIRVInfo turns an error
+        SingleShaderStage ToSingleShaderStage(shaderc_spvc_execution_model execution_model) {
+            switch (execution_model) {
+                case shaderc_spvc_execution_model_vertex:
+                    return SingleShaderStage::Vertex;
+                case shaderc_spvc_execution_model_fragment:
+                    return SingleShaderStage::Fragment;
+                case shaderc_spvc_execution_model_glcompute:
+                    return SingleShaderStage::Compute;
+                default:
+                    // This will be converted to an error return when the whole
+                    // calling stack is changed to passing errors.
+                    UNREACHABLE();
+                    return SingleShaderStage::Vertex;
+            }
+        }
     }  // anonymous namespace
 
     MaybeError ValidateShaderModuleDescriptor(DeviceBase*,
@@ -131,8 +200,159 @@
 
     void ShaderModuleBase::ExtractSpirvInfo(const spirv_cross::Compiler& compiler) {
         ASSERT(!IsError());
+        if (GetDevice()->IsToggleEnabled(Toggle::UseSpvc)) {
+            ExtractSpirvInfoWithSpvc(compiler);
+        } else {
+            ExtractSpirvInfoWithSpirvCross(compiler);
+        }
+    }
 
-        DeviceBase* device = GetDevice();
+    void ShaderModuleBase::ExtractSpirvInfoWithSpvc(const spirv_cross::Compiler& compiler) {
+        shaderc_spvc_execution_model execution_model;
+        if (!CheckSpvcSuccess(mSpvcContext.GetExecutionModel(&execution_model),
+                              "Unable to get execution model for shader.")) {
+            return;
+        }
+
+        mExecutionModel = ToSingleShaderStage(execution_model);
+
+        size_t push_constant_buffers_count;
+        if (!CheckSpvcSuccess(mSpvcContext.GetPushConstantBufferCount(&push_constant_buffers_count),
+                              "Unable to get push constant buffer count for shader.")) {
+            return;
+        }
+
+        // TODO(rharrison): This should be handled by spirv-val pass in spvc,
+        // but need to confirm.
+        if (push_constant_buffers_count > 0) {
+            GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                     "Push constants aren't supported.");
+            return;
+        }
+
+        // Fill in bindingInfo with the SPIRV bindings
+        auto ExtractResourcesBinding = [this](std::vector<shaderc_spvc_binding_info> bindings) {
+            for (const auto& binding : bindings) {
+                if (binding.binding >= kMaxBindingsPerGroup || binding.set >= kMaxBindGroups) {
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Binding over limits in the SPIRV");
+                    continue;
+                }
+
+                BindingInfo* info = &mBindingInfo[binding.set][binding.binding];
+                *info = {};
+                info->used = true;
+                info->id = binding.id;
+                info->base_type_id = binding.base_type_id;
+                if (binding.binding_type == shaderc_spvc_binding_type_sampled_texture) {
+                    info->multisampled = binding.multisampled;
+                    info->textureDimension = ToWGPUTextureViewDimension(binding.texture_dimension);
+                    info->textureComponentType = ToDawnFormatType(binding.texture_component_type);
+                }
+                info->type = ToWGPUBindingType(binding.binding_type);
+            }
+        };
+
+        std::vector<shaderc_spvc_binding_info> resource_bindings;
+        if (!CheckSpvcSuccess(mSpvcContext.GetBindingInfo(
+                                  shaderc_spvc_shader_resource_uniform_buffers,
+                                  shaderc_spvc_binding_type_uniform_buffer, &resource_bindings),
+                              "Unable to get binding info for uniform buffers from shader")) {
+            return;
+        }
+        ExtractResourcesBinding(resource_bindings);
+
+        if (!CheckSpvcSuccess(mSpvcContext.GetBindingInfo(
+                                  shaderc_spvc_shader_resource_separate_images,
+                                  shaderc_spvc_binding_type_sampled_texture, &resource_bindings),
+                              "Unable to get binding info for sampled textures from shader")) {
+            return;
+        }
+        ExtractResourcesBinding(resource_bindings);
+
+        if (!CheckSpvcSuccess(
+                mSpvcContext.GetBindingInfo(shaderc_spvc_shader_resource_separate_samplers,
+                                            shaderc_spvc_binding_type_sampler, &resource_bindings),
+                "Unable to get binding info for samples from shader")) {
+            return;
+        }
+        ExtractResourcesBinding(resource_bindings);
+
+        if (!CheckSpvcSuccess(mSpvcContext.GetBindingInfo(
+                                  shaderc_spvc_shader_resource_storage_buffers,
+                                  shaderc_spvc_binding_type_storage_buffer, &resource_bindings),
+                              "Unable to get binding info for storage buffers from shader")) {
+            return;
+        }
+        ExtractResourcesBinding(resource_bindings);
+
+        std::vector<shaderc_spvc_resource_location_info> input_stage_locations;
+        if (!CheckSpvcSuccess(mSpvcContext.GetInputStageLocationInfo(&input_stage_locations),
+                              "Unable to get input stage location information from shader")) {
+            input_stage_locations.clear();
+            return;
+        }
+
+        for (const auto& input : input_stage_locations) {
+            if (mExecutionModel == SingleShaderStage::Vertex) {
+                if (input.location >= kMaxVertexAttributes) {
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Attribute location over limits in the SPIRV");
+                    return;
+                }
+                mUsedVertexAttributes.set(input.location);
+            } else if (mExecutionModel == SingleShaderStage::Fragment) {
+                // Without a location qualifier on vertex inputs, spirv_cross::CompilerMSL gives
+                // them all the location 0, causing a compile error.
+                if (!input.has_location) {
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Need location qualifier on fragment input");
+                    return;
+                }
+            }
+        }
+
+        std::vector<shaderc_spvc_resource_location_info> output_stage_locations;
+        if (!CheckSpvcSuccess(mSpvcContext.GetOutputStageLocationInfo(&output_stage_locations),
+                              "Unable to get output stage location information from shader")) {
+            output_stage_locations.clear();
+            return;
+        }
+
+        for (const auto& output : output_stage_locations) {
+            if (mExecutionModel == SingleShaderStage::Vertex) {
+                // Without a location qualifier on vertex outputs, spirv_cross::CompilerMSL
+                // gives them all the location 0, causing a compile error.
+                if (!output.has_location) {
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Need location qualifier on vertex output");
+                    return;
+                }
+            } else if (mExecutionModel == SingleShaderStage::Fragment) {
+                if (output.location >= kMaxColorAttachments) {
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Fragment output location over limits in the SPIRV");
+                    return;
+                }
+            }
+        }
+
+        if (mExecutionModel == SingleShaderStage::Fragment) {
+            std::vector<shaderc_spvc_resource_type_info> output_types;
+            if (!CheckSpvcSuccess(mSpvcContext.GetOutputStageTypeInfo(&output_types),
+                                  "Unable to get output stage type information from shader")) {
+                output_stage_locations.clear();
+                return;
+            }
+
+            for (const auto& output : output_types) {
+                ASSERT(output.type != shaderc_spvc_texture_format_type_other);
+                mFragmentOutputFormatBaseTypes[output.location] = ToDawnFormatType(output.type);
+            }
+        }
+    }
+
+    void ShaderModuleBase::ExtractSpirvInfoWithSpirvCross(const spirv_cross::Compiler& compiler) {
         // TODO(cwallez@chromium.org): make errors here creation errors
         // currently errors here do not prevent the shadermodule from being used
         const auto& resources = compiler.get_shader_resources();
@@ -157,58 +377,59 @@
         }
 
         // Fill in bindingInfo with the SPIRV bindings
-        auto ExtractResourcesBinding = [this](const spirv_cross::SmallVector<spirv_cross::Resource>&
-                                                  resources,
-                                              const spirv_cross::Compiler& compiler,
-                                              wgpu::BindingType bindingType) {
-            for (const auto& resource : resources) {
-                ASSERT(compiler.get_decoration_bitset(resource.id).get(spv::DecorationBinding));
-                ASSERT(
-                    compiler.get_decoration_bitset(resource.id).get(spv::DecorationDescriptorSet));
+        auto ExtractResourcesBinding =
+            [this](const spirv_cross::SmallVector<spirv_cross::Resource>& resources,
+                   const spirv_cross::Compiler& compiler, wgpu::BindingType bindingType) {
+                for (const auto& resource : resources) {
+                    ASSERT(compiler.get_decoration_bitset(resource.id).get(spv::DecorationBinding));
+                    ASSERT(compiler.get_decoration_bitset(resource.id)
+                               .get(spv::DecorationDescriptorSet));
 
-                uint32_t binding = compiler.get_decoration(resource.id, spv::DecorationBinding);
-                uint32_t set = compiler.get_decoration(resource.id, spv::DecorationDescriptorSet);
+                    uint32_t binding = compiler.get_decoration(resource.id, spv::DecorationBinding);
+                    uint32_t set =
+                        compiler.get_decoration(resource.id, spv::DecorationDescriptorSet);
 
-                if (binding >= kMaxBindingsPerGroup || set >= kMaxBindGroups) {
-                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
-                                             "Binding over limits in the SPIRV");
-                    continue;
+                    if (binding >= kMaxBindingsPerGroup || set >= kMaxBindGroups) {
+                        GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                                 "Binding over limits in the SPIRV");
+                        continue;
+                    }
+
+                    BindingInfo* info = &mBindingInfo[set][binding];
+                    *info = {};
+                    info->used = true;
+                    info->id = resource.id;
+                    info->base_type_id = resource.base_type_id;
+                    switch (bindingType) {
+                        case wgpu::BindingType::SampledTexture: {
+                            spirv_cross::SPIRType::ImageType imageType =
+                                compiler.get_type(info->base_type_id).image;
+                            spirv_cross::SPIRType::BaseType textureComponentType =
+                                compiler.get_type(imageType.type).basetype;
+
+                            info->multisampled = imageType.ms;
+                            info->textureDimension =
+                                SpirvDimToTextureViewDimension(imageType.dim, imageType.arrayed);
+                            info->textureComponentType =
+                                SpirvCrossBaseTypeToFormatType(textureComponentType);
+                            info->type = bindingType;
+                        } break;
+                        case wgpu::BindingType::StorageBuffer: {
+                            // Differentiate between readonly storage bindings and writable ones
+                            // based on the NonWritable decoration
+                            spirv_cross::Bitset flags =
+                                compiler.get_buffer_block_flags(resource.id);
+                            if (flags.get(spv::DecorationNonWritable)) {
+                                info->type = wgpu::BindingType::ReadonlyStorageBuffer;
+                            } else {
+                                info->type = wgpu::BindingType::StorageBuffer;
+                            }
+                        } break;
+                        default:
+                            info->type = bindingType;
+                    }
                 }
-
-                BindingInfo* info = &mBindingInfo[set][binding];
-                *info = {};
-                info->used = true;
-                info->id = resource.id;
-                info->base_type_id = resource.base_type_id;
-                switch (bindingType) {
-                    case wgpu::BindingType::SampledTexture: {
-                        spirv_cross::SPIRType::ImageType imageType =
-                            compiler.get_type(info->base_type_id).image;
-                        spirv_cross::SPIRType::BaseType textureComponentType =
-                            compiler.get_type(imageType.type).basetype;
-
-                        info->multisampled = imageType.ms;
-                        info->textureDimension =
-                            SpirvDimToTextureViewDimension(imageType.dim, imageType.arrayed);
-                        info->textureComponentType =
-                            SpirvCrossBaseTypeToFormatType(textureComponentType);
-                        info->type = bindingType;
-                    } break;
-                    case wgpu::BindingType::StorageBuffer: {
-                        // Differentiate between readonly storage bindings and writable ones based
-                        // on the NonWritable decoration
-                        spirv_cross::Bitset flags = compiler.get_buffer_block_flags(resource.id);
-                        if (flags.get(spv::DecorationNonWritable)) {
-                            info->type = wgpu::BindingType::ReadonlyStorageBuffer;
-                        } else {
-                            info->type = wgpu::BindingType::StorageBuffer;
-                        }
-                    } break;
-                    default:
-                        info->type = bindingType;
-                }
-            }
-        };
+            };
 
         ExtractResourcesBinding(resources.uniform_buffers, compiler,
                                 wgpu::BindingType::UniformBuffer);
@@ -225,32 +446,32 @@
                 uint32_t location = compiler.get_decoration(attrib.id, spv::DecorationLocation);
 
                 if (location >= kMaxVertexAttributes) {
-                    device->HandleError(wgpu::ErrorType::Validation,
-                                        "Attribute location over limits in the SPIRV");
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Attribute location over limits in the SPIRV");
                     return;
                 }
 
                 mUsedVertexAttributes.set(location);
             }
 
-            // Without a location qualifier on vertex outputs, spirv_cross::CompilerMSL gives them
-            // all the location 0, causing a compile error.
+            // Without a location qualifier on vertex outputs, spirv_cross::CompilerMSL gives
+            // them all the location 0, causing a compile error.
             for (const auto& attrib : resources.stage_outputs) {
                 if (!compiler.get_decoration_bitset(attrib.id).get(spv::DecorationLocation)) {
-                    device->HandleError(wgpu::ErrorType::Validation,
-                                        "Need location qualifier on vertex output");
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Need location qualifier on vertex output");
                     return;
                 }
             }
         }
 
         if (mExecutionModel == SingleShaderStage::Fragment) {
-            // Without a location qualifier on vertex inputs, spirv_cross::CompilerMSL gives them
-            // all the location 0, causing a compile error.
+            // Without a location qualifier on vertex inputs, spirv_cross::CompilerMSL gives
+            // them all the location 0, causing a compile error.
             for (const auto& attrib : resources.stage_inputs) {
                 if (!compiler.get_decoration_bitset(attrib.id).get(spv::DecorationLocation)) {
-                    device->HandleError(wgpu::ErrorType::Validation,
-                                        "Need location qualifier on fragment input");
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Need location qualifier on fragment input");
                     return;
                 }
             }
@@ -261,8 +482,8 @@
                 uint32_t location =
                     compiler.get_decoration(fragmentOutput.id, spv::DecorationLocation);
                 if (location >= kMaxColorAttachments) {
-                    device->HandleError(wgpu::ErrorType::Validation,
-                                        "Fragment output location over limits in the SPIRV");
+                    GetDevice()->HandleError(wgpu::ErrorType::Validation,
+                                             "Fragment output location over limits in the SPIRV");
                     return;
                 }
 
@@ -379,4 +600,12 @@
         return a->mCode == b->mCode;
     }
 
+    bool ShaderModuleBase::CheckSpvcSuccess(shaderc_spvc_status status, const char* error_msg) {
+        if (status != shaderc_spvc_status_success) {
+            GetDevice()->HandleError(wgpu::ErrorType::Validation, error_msg);
+            return false;
+        }
+        return true;
+    }
+
 }  // namespace dawn_native
diff --git a/src/dawn_native/ShaderModule.h b/src/dawn_native/ShaderModule.h
index da69c4d..9a6bccc 100644
--- a/src/dawn_native/ShaderModule.h
+++ b/src/dawn_native/ShaderModule.h
@@ -89,6 +89,13 @@
 
         bool IsCompatibleWithBindGroupLayout(size_t group, const BindGroupLayoutBase* layout) const;
 
+        // Different implementations reflection into the shader depending on
+        // whether using spvc, or directly accessing spirv-cross.
+        void ExtractSpirvInfoWithSpvc(const spirv_cross::Compiler& compiler);
+        void ExtractSpirvInfoWithSpirvCross(const spirv_cross::Compiler& compiler);
+
+        bool CheckSpvcSuccess(shaderc_spvc_status status, const char* error_msg);
+
         // TODO(cwallez@chromium.org): The code is only stored for deduplication. We could maybe
         // store a cryptographic hash of the code instead?
         std::vector<uint32_t> mCode;