diff --git a/.references/spirv-tools b/.references/spirv-tools
index 414a565..7f87f92 100644
--- a/.references/spirv-tools
+++ b/.references/spirv-tools
@@ -1 +1 @@
-v2024.3
+v2024.4.rc1
diff --git a/spirv-tools/source/binary.cpp b/spirv-tools/source/binary.cpp
index a39bcf0..772e98c 100644
--- a/spirv-tools/source/binary.cpp
+++ b/spirv-tools/source/binary.cpp
@@ -671,6 +671,11 @@ spv_result_t Parser::parseOperand(size_t inst_offset,
     case SPV_OPERAND_TYPE_OVERFLOW_MODES:
     case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT:
     case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT:
+    case SPV_OPERAND_TYPE_FPENCODING:
+    case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING:
+    case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER:
+    case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL:
+    case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL:
     case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: {
       // A single word that is a plain enum value.
 
@@ -679,6 +684,8 @@ spv_result_t Parser::parseOperand(size_t inst_offset,
         parsed_operand.type = SPV_OPERAND_TYPE_ACCESS_QUALIFIER;
       if (type == SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT)
         parsed_operand.type = SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT;
+      if (type == SPV_OPERAND_TYPE_OPTIONAL_FPENCODING)
+        parsed_operand.type = SPV_OPERAND_TYPE_FPENCODING;
 
       spv_operand_desc entry;
       if (grammar_.lookupOperand(type, word, &entry)) {
@@ -699,7 +706,7 @@ spv_result_t Parser::parseOperand(size_t inst_offset,
                << ", if you are creating a new source language please use "
                   "value 0 "
                   "(Unknown) and when ready, add your source language to "
-                  "SPRIV-Headers";
+                  "SPIRV-Headers";
       }
       // Prepare to accept operands to this operand, if needed.
       spvPushOperandTypes(entry->operandTypes, expected_operands);
diff --git a/spirv-tools/source/disassemble.cpp b/spirv-tools/source/disassemble.cpp
index aa20fab..db99151 100644
--- a/spirv-tools/source/disassemble.cpp
+++ b/spirv-tools/source/disassemble.cpp
@@ -605,7 +605,7 @@ uint32_t GetLineLengthWithoutColor(const std::string line) {
     if (line[i] == '\x1b') {
       do {
         ++i;
-      } while (line[i] != 'm');
+      } while (i < line.size() && line[i] != 'm');
       continue;
     }
 
@@ -944,6 +944,7 @@ void InstructionDisassembler::EmitOperand(std::ostream& stream,
     case SPV_OPERAND_TYPE_FPDENORM_MODE:
     case SPV_OPERAND_TYPE_FPOPERATION_MODE:
     case SPV_OPERAND_TYPE_QUANTIZATION_MODES:
+    case SPV_OPERAND_TYPE_FPENCODING:
     case SPV_OPERAND_TYPE_OVERFLOW_MODES: {
       spv_operand_desc entry;
       if (grammar_.lookupOperand(operand.type, word, &entry))
diff --git a/spirv-tools/source/name_mapper.cpp b/spirv-tools/source/name_mapper.cpp
index b2d0f44..7e5f091 100644
--- a/spirv-tools/source/name_mapper.cpp
+++ b/spirv-tools/source/name_mapper.cpp
@@ -25,24 +25,15 @@
 #include "source/binary.h"
 #include "source/latest_version_spirv_header.h"
 #include "source/parsed_operand.h"
+#include "source/to_string.h"
 #include "spirv-tools/libspirv.h"
 
 namespace spvtools {
-namespace {
 
-// Converts a uint32_t to its string decimal representation.
-std::string to_string(uint32_t id) {
-  // Use stringstream, since some versions of Android compilers lack
-  // std::to_string.
-  std::stringstream os;
-  os << id;
-  return os.str();
+NameMapper GetTrivialNameMapper() {
+  return [](uint32_t i) { return spvtools::to_string(i); };
 }
 
-}  // anonymous namespace
-
-NameMapper GetTrivialNameMapper() { return to_string; }
-
 FriendlyNameMapper::FriendlyNameMapper(const spv_const_context context,
                                        const uint32_t* code,
                                        const size_t wordCount)
@@ -218,6 +209,7 @@ spv_result_t FriendlyNameMapper::ParseInstruction(
     } break;
     case spv::Op::OpTypeFloat: {
       const auto bit_width = inst.words[2];
+      // TODO: Handle optional fpencoding enum once actually used.
       switch (bit_width) {
         case 16:
           SaveName(result_id, "half");
@@ -255,6 +247,11 @@ spv_result_t FriendlyNameMapper::ParseInstruction(
                                                  inst.words[2]) +
                               "_" + NameForId(inst.words[3]));
       break;
+    case spv::Op::OpTypeUntypedPointerKHR:
+      SaveName(result_id, std::string("_ptr_") +
+                              NameForEnumOperand(SPV_OPERAND_TYPE_STORAGE_CLASS,
+                                                 inst.words[2]));
+      break;
     case spv::Op::OpTypePipe:
       SaveName(result_id,
                std::string("Pipe") +
diff --git a/spirv-tools/source/opcode.cpp b/spirv-tools/source/opcode.cpp
index 5076bbd..32fa10d 100644
--- a/spirv-tools/source/opcode.cpp
+++ b/spirv-tools/source/opcode.cpp
@@ -276,6 +276,7 @@ int32_t spvOpcodeIsComposite(const spv::Op opcode) {
     case spv::Op::OpTypeMatrix:
     case spv::Op::OpTypeArray:
     case spv::Op::OpTypeStruct:
+    case spv::Op::OpTypeRuntimeArray:
     case spv::Op::OpTypeCooperativeMatrixNV:
     case spv::Op::OpTypeCooperativeMatrixKHR:
       return true;
@@ -287,8 +288,11 @@ int32_t spvOpcodeIsComposite(const spv::Op opcode) {
 bool spvOpcodeReturnsLogicalVariablePointer(const spv::Op opcode) {
   switch (opcode) {
     case spv::Op::OpVariable:
+    case spv::Op::OpUntypedVariableKHR:
     case spv::Op::OpAccessChain:
     case spv::Op::OpInBoundsAccessChain:
+    case spv::Op::OpUntypedAccessChainKHR:
+    case spv::Op::OpUntypedInBoundsAccessChainKHR:
     case spv::Op::OpFunctionParameter:
     case spv::Op::OpImageTexelPointer:
     case spv::Op::OpCopyObject:
@@ -296,6 +300,7 @@ bool spvOpcodeReturnsLogicalVariablePointer(const spv::Op opcode) {
     case spv::Op::OpPhi:
     case spv::Op::OpFunctionCall:
     case spv::Op::OpPtrAccessChain:
+    case spv::Op::OpUntypedPtrAccessChainKHR:
     case spv::Op::OpLoad:
     case spv::Op::OpConstantNull:
     case spv::Op::OpRawAccessChainNV:
@@ -308,8 +313,11 @@ bool spvOpcodeReturnsLogicalVariablePointer(const spv::Op opcode) {
 int32_t spvOpcodeReturnsLogicalPointer(const spv::Op opcode) {
   switch (opcode) {
     case spv::Op::OpVariable:
+    case spv::Op::OpUntypedVariableKHR:
     case spv::Op::OpAccessChain:
     case spv::Op::OpInBoundsAccessChain:
+    case spv::Op::OpUntypedAccessChainKHR:
+    case spv::Op::OpUntypedInBoundsAccessChainKHR:
     case spv::Op::OpFunctionParameter:
     case spv::Op::OpImageTexelPointer:
     case spv::Op::OpCopyObject:
@@ -351,6 +359,7 @@ int32_t spvOpcodeGeneratesType(spv::Op op) {
     // spv::Op::OpTypeAccelerationStructureNV
     case spv::Op::OpTypeRayQueryKHR:
     case spv::Op::OpTypeHitObjectNV:
+    case spv::Op::OpTypeUntypedPointerKHR:
       return true;
     default:
       // In particular, OpTypeForwardPointer does not generate a type,
@@ -792,3 +801,16 @@ bool spvOpcodeIsBit(spv::Op opcode) {
       return false;
   }
 }
+
+bool spvOpcodeGeneratesUntypedPointer(spv::Op opcode) {
+  switch (opcode) {
+    case spv::Op::OpUntypedVariableKHR:
+    case spv::Op::OpUntypedAccessChainKHR:
+    case spv::Op::OpUntypedInBoundsAccessChainKHR:
+    case spv::Op::OpUntypedPtrAccessChainKHR:
+    case spv::Op::OpUntypedInBoundsPtrAccessChainKHR:
+      return true;
+    default:
+      return false;
+  }
+}
diff --git a/spirv-tools/source/opcode.h b/spirv-tools/source/opcode.h
index cecd566..08fc56d 100644
--- a/spirv-tools/source/opcode.h
+++ b/spirv-tools/source/opcode.h
@@ -162,4 +162,7 @@ bool spvOpcodeIsBit(spv::Op opcode);
 // Gets the name of an instruction, without the "Op" prefix.
 const char* spvOpcodeString(const spv::Op opcode);
 
+// Returns true for opcodes that generate an untyped pointer result.
+bool spvOpcodeGeneratesUntypedPointer(spv::Op opcode);
+
 #endif  // SOURCE_OPCODE_H_
diff --git a/spirv-tools/source/operand.cpp b/spirv-tools/source/operand.cpp
index e150045..508a5d1 100644
--- a/spirv-tools/source/operand.cpp
+++ b/spirv-tools/source/operand.cpp
@@ -252,6 +252,9 @@ const char* spvOperandTypeStr(spv_operand_type_t type) {
       return "OpenCL.DebugInfo.100 debug operation";
     case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY:
       return "OpenCL.DebugInfo.100 debug imported entity";
+    case SPV_OPERAND_TYPE_FPENCODING:
+    case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING:
+      return "FP encoding";
 
     // The next values are for values returned from an instruction, not actually
     // an operand.  So the specific strings don't matter.  But let's add them
@@ -366,6 +369,7 @@ bool spvOperandIsConcrete(spv_operand_type_t type) {
     case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL:
     case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL:
     case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS:
+    case SPV_OPERAND_TYPE_FPENCODING:
       return true;
     default:
       break;
@@ -407,6 +411,7 @@ bool spvOperandIsOptional(spv_operand_type_t type) {
     case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS:
     case SPV_OPERAND_TYPE_OPTIONAL_CIV:
     case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS:
+    case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING:
       return true;
     default:
       break;
diff --git a/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp b/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp
index 4737da5..6e86c37 100644
--- a/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp
+++ b/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp
@@ -134,7 +134,12 @@ void AggressiveDCEPass::AddStores(Function* func, uint32_t ptrId) {
         }
         break;
       // If default, assume it stores e.g. frexp, modf, function call
-      case spv::Op::OpStore:
+      case spv::Op::OpStore: {
+        const uint32_t kStoreTargetAddrInIdx = 0;
+        if (user->GetSingleWordInOperand(kStoreTargetAddrInIdx) == ptrId)
+          AddToWorklist(user);
+        break;
+      }
       default:
         AddToWorklist(user);
         break;
@@ -262,6 +267,7 @@ void AggressiveDCEPass::AddBreaksAndContinuesToWorklist(
 }
 
 bool AggressiveDCEPass::AggressiveDCE(Function* func) {
+  if (func->IsDeclaration()) return false;
   std::list<BasicBlock*> structured_order;
   cfg()->ComputeStructuredOrder(func, &*func->begin(), &structured_order);
   live_local_vars_.clear();
@@ -1004,7 +1010,10 @@ void AggressiveDCEPass::InitExtensions() {
       "SPV_NV_bindless_texture",
       "SPV_EXT_shader_atomic_float_add",
       "SPV_EXT_fragment_shader_interlock",
-      "SPV_NV_compute_shader_derivatives"
+      "SPV_NV_compute_shader_derivatives",
+      "SPV_NV_cooperative_matrix",
+      "SPV_KHR_cooperative_matrix",
+      "SPV_KHR_ray_tracing_position_fetch"
   });
   // clang-format on
 }
diff --git a/spirv-tools/source/opt/copy_prop_arrays.cpp b/spirv-tools/source/opt/copy_prop_arrays.cpp
index c2bea8a..26b5ef7 100644
--- a/spirv-tools/source/opt/copy_prop_arrays.cpp
+++ b/spirv-tools/source/opt/copy_prop_arrays.cpp
@@ -751,6 +751,8 @@ void CopyPropagateArrays::UpdateUses(Instruction* original_ptr_inst,
           uint32_t pointee_type_id =
               pointer_type->GetSingleWordInOperand(kTypePointerPointeeInIdx);
           uint32_t copy = GenerateCopy(original_ptr_inst, pointee_type_id, use);
+          assert(copy != 0 &&
+                 "Should not be updating uses unless we know it can be done.");
 
           context()->ForgetUses(use);
           use->SetInOperand(index, {copy});
diff --git a/spirv-tools/source/opt/debug_info_manager.cpp b/spirv-tools/source/opt/debug_info_manager.cpp
index 1e614c6..24094b3 100644
--- a/spirv-tools/source/opt/debug_info_manager.cpp
+++ b/spirv-tools/source/opt/debug_info_manager.cpp
@@ -768,15 +768,29 @@ void DebugInfoManager::ConvertDebugGlobalToLocalVariable(
          local_var->opcode() == spv::Op::OpFunctionParameter);
 
   // Convert |dbg_global_var| to DebugLocalVariable
+  // All of the operands up to the scope operand are the same for the type
+  // instructions. The flag operand needs to move from operand
+  // kDebugGlobalVariableOperandFlagsIndex to
+  // kDebugLocalVariableOperandFlagsIndex. No other operands are needed to
+  // define the DebugLocalVariable.
+
+  // Modify the opcode.
   dbg_global_var->SetInOperand(kExtInstInstructionInIdx,
                                {CommonDebugInfoDebugLocalVariable});
+
+  // Move the flags operand.
   auto flags = dbg_global_var->GetSingleWordOperand(
       kDebugGlobalVariableOperandFlagsIndex);
-  for (uint32_t i = dbg_global_var->NumInOperands() - 1;
-       i >= kDebugLocalVariableOperandFlagsIndex; --i) {
+  dbg_global_var->SetOperand(kDebugLocalVariableOperandFlagsIndex, {flags});
+
+  // Remove the  extra operands. Starting at the end to avoid copying too much
+  // data.
+  for (uint32_t i = dbg_global_var->NumOperands() - 1;
+       i > kDebugLocalVariableOperandFlagsIndex; --i) {
     dbg_global_var->RemoveOperand(i);
   }
-  dbg_global_var->SetOperand(kDebugLocalVariableOperandFlagsIndex, {flags});
+
+  // Update the def-use manager.
   context()->ForgetUses(dbg_global_var);
   context()->AnalyzeUses(dbg_global_var);
 
diff --git a/spirv-tools/source/opt/desc_sroa.cpp b/spirv-tools/source/opt/desc_sroa.cpp
index 2c0f482..124a3d3 100644
--- a/spirv-tools/source/opt/desc_sroa.cpp
+++ b/spirv-tools/source/opt/desc_sroa.cpp
@@ -31,11 +31,14 @@ bool IsDecorationBinding(Instruction* inst) {
 
 Pass::Status DescriptorScalarReplacement::Process() {
   bool modified = false;
-
   std::vector<Instruction*> vars_to_kill;
 
   for (Instruction& var : context()->types_values()) {
-    if (descsroautil::IsDescriptorArray(context(), &var)) {
+    bool is_candidate =
+        flatten_arrays_ && descsroautil::IsDescriptorArray(context(), &var);
+    is_candidate |= flatten_composites_ &&
+                    descsroautil::IsDescriptorStruct(context(), &var);
+    if (is_candidate) {
       modified = true;
       if (!ReplaceCandidate(&var)) {
         return Status::Failure;
diff --git a/spirv-tools/source/opt/desc_sroa.h b/spirv-tools/source/opt/desc_sroa.h
index 901be3e..d6af4df 100644
--- a/spirv-tools/source/opt/desc_sroa.h
+++ b/spirv-tools/source/opt/desc_sroa.h
@@ -32,9 +32,16 @@ namespace opt {
 // Documented in optimizer.hpp
 class DescriptorScalarReplacement : public Pass {
  public:
-  DescriptorScalarReplacement() {}
-
-  const char* name() const override { return "descriptor-scalar-replacement"; }
+  DescriptorScalarReplacement(bool flatten_composites, bool flatten_arrays)
+      : flatten_composites_(flatten_composites),
+        flatten_arrays_(flatten_arrays) {}
+
+  const char* name() const override {
+    if (flatten_composites_ && flatten_arrays_)
+      return "descriptor-scalar-replacement";
+    if (flatten_composites_) return "descriptor-compososite-scalar-replacement";
+    return "descriptor-array-scalar-replacement";
+  }
 
   Status Process() override;
 
@@ -141,6 +148,9 @@ class DescriptorScalarReplacement : public Pass {
   // array |var|. If the entry is |0|, then the variable has not been
   // created yet.
   std::map<Instruction*, std::vector<uint32_t>> replacement_variables_;
+
+  bool flatten_composites_;
+  bool flatten_arrays_;
 };
 
 }  // namespace opt
diff --git a/spirv-tools/source/opt/desc_sroa_util.cpp b/spirv-tools/source/opt/desc_sroa_util.cpp
index dba3de9..62d9476 100644
--- a/spirv-tools/source/opt/desc_sroa_util.cpp
+++ b/spirv-tools/source/opt/desc_sroa_util.cpp
@@ -29,41 +29,58 @@ uint32_t GetLengthOfArrayType(IRContext* context, Instruction* type) {
   return length_const->GetU32();
 }
 
-}  // namespace
-
-namespace descsroautil {
+bool HasDescriptorDecorations(IRContext* context, Instruction* var) {
+  const auto& decoration_mgr = context->get_decoration_mgr();
+  return decoration_mgr->HasDecoration(
+             var->result_id(), uint32_t(spv::Decoration::DescriptorSet)) &&
+         decoration_mgr->HasDecoration(var->result_id(),
+                                       uint32_t(spv::Decoration::Binding));
+}
 
-bool IsDescriptorArray(IRContext* context, Instruction* var) {
+Instruction* GetVariableType(IRContext* context, Instruction* var) {
   if (var->opcode() != spv::Op::OpVariable) {
-    return false;
+    return nullptr;
   }
 
   uint32_t ptr_type_id = var->type_id();
   Instruction* ptr_type_inst = context->get_def_use_mgr()->GetDef(ptr_type_id);
   if (ptr_type_inst->opcode() != spv::Op::OpTypePointer) {
-    return false;
+    return nullptr;
   }
 
   uint32_t var_type_id = ptr_type_inst->GetSingleWordInOperand(1);
-  Instruction* var_type_inst = context->get_def_use_mgr()->GetDef(var_type_id);
-  if (var_type_inst->opcode() != spv::Op::OpTypeArray &&
-      var_type_inst->opcode() != spv::Op::OpTypeStruct) {
-    return false;
+  return context->get_def_use_mgr()->GetDef(var_type_id);
+}
+
+}  // namespace
+
+namespace descsroautil {
+
+bool IsDescriptorArray(IRContext* context, Instruction* var) {
+  Instruction* var_type_inst = GetVariableType(context, var);
+  if (var_type_inst == nullptr) return false;
+  return var_type_inst->opcode() == spv::Op::OpTypeArray &&
+         HasDescriptorDecorations(context, var);
+}
+
+bool IsDescriptorStruct(IRContext* context, Instruction* var) {
+  Instruction* var_type_inst = GetVariableType(context, var);
+  if (var_type_inst == nullptr) return false;
+
+  while (var_type_inst->opcode() == spv::Op::OpTypeArray) {
+    var_type_inst = context->get_def_use_mgr()->GetDef(
+        var_type_inst->GetInOperand(0).AsId());
   }
 
+  if (var_type_inst->opcode() != spv::Op::OpTypeStruct) return false;
+
   // All structures with descriptor assignments must be replaced by variables,
   // one for each of their members - with the exceptions of buffers.
   if (IsTypeOfStructuredBuffer(context, var_type_inst)) {
     return false;
   }
 
-  if (!context->get_decoration_mgr()->HasDecoration(
-          var->result_id(), uint32_t(spv::Decoration::DescriptorSet))) {
-    return false;
-  }
-
-  return context->get_decoration_mgr()->HasDecoration(
-      var->result_id(), uint32_t(spv::Decoration::Binding));
+  return HasDescriptorDecorations(context, var);
 }
 
 bool IsTypeOfStructuredBuffer(IRContext* context, const Instruction* type) {
diff --git a/spirv-tools/source/opt/desc_sroa_util.h b/spirv-tools/source/opt/desc_sroa_util.h
index 2f45c0c..0423356 100644
--- a/spirv-tools/source/opt/desc_sroa_util.h
+++ b/spirv-tools/source/opt/desc_sroa_util.h
@@ -27,6 +27,10 @@ namespace descsroautil {
 // descriptor array.
 bool IsDescriptorArray(IRContext* context, Instruction* var);
 
+// Returns true if |var| is an OpVariable instruction that represents a
+// struct containing descriptors.
+bool IsDescriptorStruct(IRContext* context, Instruction* var);
+
 // Returns true if |type| is a type that could be used for a structured buffer
 // as opposed to a type that would be used for a structure of resource
 // descriptors.
diff --git a/spirv-tools/source/opt/fix_storage_class.cpp b/spirv-tools/source/opt/fix_storage_class.cpp
index 564cd1b..b64026e 100644
--- a/spirv-tools/source/opt/fix_storage_class.cpp
+++ b/spirv-tools/source/opt/fix_storage_class.cpp
@@ -141,22 +141,26 @@ bool FixStorageClass::IsPointerResultType(Instruction* inst) {
   if (inst->type_id() == 0) {
     return false;
   }
-  const analysis::Type* ret_type =
-      context()->get_type_mgr()->GetType(inst->type_id());
-  return ret_type->AsPointer() != nullptr;
+
+  Instruction* type_def = get_def_use_mgr()->GetDef(inst->type_id());
+  return type_def->opcode() == spv::Op::OpTypePointer;
 }
 
 bool FixStorageClass::IsPointerToStorageClass(Instruction* inst,
                                               spv::StorageClass storage_class) {
-  analysis::TypeManager* type_mgr = context()->get_type_mgr();
-  analysis::Type* pType = type_mgr->GetType(inst->type_id());
-  const analysis::Pointer* result_type = pType->AsPointer();
+  if (inst->type_id() == 0) {
+    return false;
+  }
 
-  if (result_type == nullptr) {
+  Instruction* type_def = get_def_use_mgr()->GetDef(inst->type_id());
+  if (type_def->opcode() != spv::Op::OpTypePointer) {
     return false;
   }
 
-  return (result_type->storage_class() == storage_class);
+  const uint32_t kPointerTypeStorageClassIndex = 0;
+  spv::StorageClass pointer_storage_class = static_cast<spv::StorageClass>(
+      type_def->GetSingleWordInOperand(kPointerTypeStorageClassIndex));
+  return pointer_storage_class == storage_class;
 }
 
 bool FixStorageClass::ChangeResultType(Instruction* inst,
@@ -233,6 +237,9 @@ bool FixStorageClass::PropagateType(Instruction* inst, uint32_t type_id,
         }
 
         uint32_t copy_id = GenerateCopy(obj_inst, pointee_type_id, inst);
+        if (copy_id == 0) {
+          return false;
+        }
         inst->SetInOperand(1, {copy_id});
         context()->UpdateDefUse(inst);
       }
@@ -301,9 +308,11 @@ uint32_t FixStorageClass::WalkAccessChainType(Instruction* inst, uint32_t id) {
       break;
   }
 
-  Instruction* orig_type_inst = get_def_use_mgr()->GetDef(id);
-  assert(orig_type_inst->opcode() == spv::Op::OpTypePointer);
-  id = orig_type_inst->GetSingleWordInOperand(1);
+  Instruction* id_type_inst = get_def_use_mgr()->GetDef(id);
+  assert(id_type_inst->opcode() == spv::Op::OpTypePointer);
+  id = id_type_inst->GetSingleWordInOperand(1);
+  spv::StorageClass input_storage_class =
+      static_cast<spv::StorageClass>(id_type_inst->GetSingleWordInOperand(0));
 
   for (uint32_t i = start_idx; i < inst->NumInOperands(); ++i) {
     Instruction* type_inst = get_def_use_mgr()->GetDef(id);
@@ -312,6 +321,7 @@ uint32_t FixStorageClass::WalkAccessChainType(Instruction* inst, uint32_t id) {
       case spv::Op::OpTypeRuntimeArray:
       case spv::Op::OpTypeMatrix:
       case spv::Op::OpTypeVector:
+      case spv::Op::OpTypeCooperativeMatrixKHR:
         id = type_inst->GetSingleWordInOperand(0);
         break;
       case spv::Op::OpTypeStruct: {
@@ -335,9 +345,19 @@ uint32_t FixStorageClass::WalkAccessChainType(Instruction* inst, uint32_t id) {
            "Tried to extract from an object where it cannot be done.");
   }
 
-  return context()->get_type_mgr()->FindPointerToType(
-      id, static_cast<spv::StorageClass>(
-              orig_type_inst->GetSingleWordInOperand(0)));
+  Instruction* orig_type_inst = get_def_use_mgr()->GetDef(inst->type_id());
+  spv::StorageClass orig_storage_class =
+      static_cast<spv::StorageClass>(orig_type_inst->GetSingleWordInOperand(0));
+  assert(orig_type_inst->opcode() == spv::Op::OpTypePointer);
+  if (orig_type_inst->GetSingleWordInOperand(1) == id &&
+      input_storage_class == orig_storage_class) {
+    // The existing type is correct. Avoid the search for the type. Note that if
+    // there is a duplicate type, the search below could return a different type
+    // forcing more changes to the code than necessary.
+    return inst->type_id();
+  }
+
+  return context()->get_type_mgr()->FindPointerToType(id, input_storage_class);
 }
 
 // namespace opt
diff --git a/spirv-tools/source/opt/folding_rules.cpp b/spirv-tools/source/opt/folding_rules.cpp
index 6def9c4..2ebc385 100644
--- a/spirv-tools/source/opt/folding_rules.cpp
+++ b/spirv-tools/source/opt/folding_rules.cpp
@@ -112,6 +112,12 @@ bool IsValidResult(T val) {
   }
 }
 
+// Returns true if `type` is a cooperative matrix.
+bool IsCooperativeMatrix(const analysis::Type* type) {
+  return type->kind() == analysis::Type::kCooperativeMatrixKHR ||
+         type->kind() == analysis::Type::kCooperativeMatrixNV;
+}
+
 const analysis::Constant* ConstInput(
     const std::vector<const analysis::Constant*>& constants) {
   return constants[0] ? constants[0] : constants[1];
@@ -313,6 +319,11 @@ FoldingRule ReciprocalFDiv() {
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     if (!inst->IsFloatingPointFoldingAllowed()) return false;
 
     uint32_t width = ElementWidth(type);
@@ -394,6 +405,11 @@ FoldingRule MergeNegateMulDivArithmetic() {
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed())
       return false;
 
@@ -455,6 +471,11 @@ FoldingRule MergeNegateAddSubArithmetic() {
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed())
       return false;
 
@@ -686,6 +707,11 @@ FoldingRule MergeMulMulArithmetic() {
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed())
       return false;
 
@@ -740,6 +766,11 @@ FoldingRule MergeMulDivArithmetic() {
 
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     if (!inst->IsFloatingPointFoldingAllowed()) return false;
 
     uint32_t width = ElementWidth(type);
@@ -813,6 +844,11 @@ FoldingRule MergeMulNegateArithmetic() {
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     bool uses_float = HasFloatingPoint(type);
     if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false;
 
@@ -853,6 +889,11 @@ FoldingRule MergeDivDivArithmetic() {
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     if (!inst->IsFloatingPointFoldingAllowed()) return false;
 
     uint32_t width = ElementWidth(type);
@@ -926,6 +967,11 @@ FoldingRule MergeDivMulArithmetic() {
 
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     if (!inst->IsFloatingPointFoldingAllowed()) return false;
 
     uint32_t width = ElementWidth(type);
@@ -1068,6 +1114,11 @@ FoldingRule MergeSubNegateArithmetic() {
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     bool uses_float = HasFloatingPoint(type);
     if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false;
 
@@ -1116,6 +1167,11 @@ FoldingRule MergeAddAddArithmetic() {
            inst->opcode() == spv::Op::OpIAdd);
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     bool uses_float = HasFloatingPoint(type);
     if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false;
@@ -1164,6 +1220,11 @@ FoldingRule MergeAddSubArithmetic() {
            inst->opcode() == spv::Op::OpIAdd);
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     bool uses_float = HasFloatingPoint(type);
     if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false;
@@ -1224,6 +1285,11 @@ FoldingRule MergeSubAddArithmetic() {
            inst->opcode() == spv::Op::OpISub);
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     bool uses_float = HasFloatingPoint(type);
     if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false;
@@ -1290,6 +1356,11 @@ FoldingRule MergeSubSubArithmetic() {
            inst->opcode() == spv::Op::OpISub);
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     analysis::ConstantManager* const_mgr = context->get_constant_mgr();
     bool uses_float = HasFloatingPoint(type);
     if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false;
@@ -1383,6 +1454,11 @@ FoldingRule MergeGenericAddSubArithmetic() {
            inst->opcode() == spv::Op::OpIAdd);
     const analysis::Type* type =
         context->get_type_mgr()->GetType(inst->type_id());
+
+    if (IsCooperativeMatrix(type)) {
+      return false;
+    }
+
     bool uses_float = HasFloatingPoint(type);
     if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false;
 
diff --git a/spirv-tools/source/opt/inst_debug_printf_pass.cpp b/spirv-tools/source/opt/inst_debug_printf_pass.cpp
index abd25e9..916db7c 100644
--- a/spirv-tools/source/opt/inst_debug_printf_pass.cpp
+++ b/spirv-tools/source/opt/inst_debug_printf_pass.cpp
@@ -17,6 +17,7 @@
 #include "inst_debug_printf_pass.h"
 
 #include "source/spirv_constant.h"
+#include "source/to_string.h"
 #include "source/util/string_utils.h"
 #include "spirv/unified1/NonSemanticDebugPrintf.h"
 
@@ -396,7 +397,7 @@ uint32_t InstDebugPrintfPass::GetStreamWriteFunctionId(uint32_t param_cnt) {
     context()->AddFunction(std::move(output_func));
 
     std::string name("stream_write_");
-    name += std::to_string(param_cnt);
+    name += spvtools::to_string(param_cnt);
 
     context()->AddDebug2Inst(
         NewGlobalName(param2output_func_id_[param_cnt], name));
diff --git a/spirv-tools/source/opt/local_access_chain_convert_pass.cpp b/spirv-tools/source/opt/local_access_chain_convert_pass.cpp
index 7ba75cb..f46c913 100644
--- a/spirv-tools/source/opt/local_access_chain_convert_pass.cpp
+++ b/spirv-tools/source/opt/local_access_chain_convert_pass.cpp
@@ -428,8 +428,9 @@ void LocalAccessChainConvertPass::InitExtensions() {
        "SPV_KHR_uniform_group_instructions",
        "SPV_KHR_fragment_shader_barycentric", "SPV_KHR_vulkan_memory_model",
        "SPV_NV_bindless_texture", "SPV_EXT_shader_atomic_float_add",
-       "SPV_EXT_fragment_shader_interlock",
-       "SPV_NV_compute_shader_derivatives"});
+       "SPV_EXT_fragment_shader_interlock", "SPV_NV_compute_shader_derivatives",
+       "SPV_NV_cooperative_matrix", "SPV_KHR_cooperative_matrix",
+       "SPV_KHR_ray_tracing_position_fetch"});
 }
 
 bool LocalAccessChainConvertPass::AnyIndexIsOutOfBounds(
diff --git a/spirv-tools/source/opt/local_single_block_elim_pass.cpp b/spirv-tools/source/opt/local_single_block_elim_pass.cpp
index d7a9295..e0e4f06 100644
--- a/spirv-tools/source/opt/local_single_block_elim_pass.cpp
+++ b/spirv-tools/source/opt/local_single_block_elim_pass.cpp
@@ -291,7 +291,10 @@ void LocalSingleBlockLoadStoreElimPass::InitExtensions() {
                                 "SPV_NV_bindless_texture",
                                 "SPV_EXT_shader_atomic_float_add",
                                 "SPV_EXT_fragment_shader_interlock",
-                                "SPV_NV_compute_shader_derivatives"});
+                                "SPV_NV_compute_shader_derivatives",
+                                "SPV_NV_cooperative_matrix",
+                                "SPV_KHR_cooperative_matrix",
+                                "SPV_KHR_ray_tracing_position_fetch"});
 }
 
 }  // namespace opt
diff --git a/spirv-tools/source/opt/local_single_store_elim_pass.cpp b/spirv-tools/source/opt/local_single_store_elim_pass.cpp
index 7cd6b0e..8bdd0f4 100644
--- a/spirv-tools/source/opt/local_single_store_elim_pass.cpp
+++ b/spirv-tools/source/opt/local_single_store_elim_pass.cpp
@@ -141,7 +141,10 @@ void LocalSingleStoreElimPass::InitExtensionAllowList() {
                                 "SPV_NV_bindless_texture",
                                 "SPV_EXT_shader_atomic_float_add",
                                 "SPV_EXT_fragment_shader_interlock",
-                                "SPV_NV_compute_shader_derivatives"});
+                                "SPV_NV_compute_shader_derivatives",
+                                "SPV_NV_cooperative_matrix",
+                                "SPV_KHR_cooperative_matrix",
+                                "SPV_KHR_ray_tracing_position_fetch"});
 }
 bool LocalSingleStoreElimPass::ProcessVariable(Instruction* var_inst) {
   std::vector<Instruction*> users;
diff --git a/spirv-tools/source/opt/mem_pass.cpp b/spirv-tools/source/opt/mem_pass.cpp
index 9972c4f..65f45ec 100644
--- a/spirv-tools/source/opt/mem_pass.cpp
+++ b/spirv-tools/source/opt/mem_pass.cpp
@@ -43,6 +43,8 @@ bool MemPass::IsBaseTargetType(const Instruction* typeInst) const {
     case spv::Op::OpTypeSampler:
     case spv::Op::OpTypeSampledImage:
     case spv::Op::OpTypePointer:
+    case spv::Op::OpTypeCooperativeMatrixNV:
+    case spv::Op::OpTypeCooperativeMatrixKHR:
       return true;
     default:
       break;
@@ -413,6 +415,7 @@ void MemPass::RemoveBlock(Function::iterator* bi) {
 }
 
 bool MemPass::RemoveUnreachableBlocks(Function* func) {
+  if (func->IsDeclaration()) return false;
   bool modified = false;
 
   // Mark reachable all blocks reachable from the function's entry block.
diff --git a/spirv-tools/source/opt/optimizer.cpp b/spirv-tools/source/opt/optimizer.cpp
index 4add68a..22eb24c 100644
--- a/spirv-tools/source/opt/optimizer.cpp
+++ b/spirv-tools/source/opt/optimizer.cpp
@@ -364,6 +364,10 @@ bool Optimizer::RegisterPassFromFlag(const std::string& flag,
     RegisterPass(CreateSpreadVolatileSemanticsPass());
   } else if (pass_name == "descriptor-scalar-replacement") {
     RegisterPass(CreateDescriptorScalarReplacementPass());
+  } else if (pass_name == "descriptor-composite-scalar-replacement") {
+    RegisterPass(CreateDescriptorCompositeScalarReplacementPass());
+  } else if (pass_name == "descriptor-array-scalar-replacement") {
+    RegisterPass(CreateDescriptorArrayScalarReplacementPass());
   } else if (pass_name == "eliminate-dead-code-aggressive") {
     RegisterPass(CreateAggressiveDCEPass(preserve_interface));
   } else if (pass_name == "eliminate-insert-extract") {
@@ -567,6 +571,26 @@ bool Optimizer::RegisterPassFromFlag(const std::string& flag,
              pass_args.c_str());
       return false;
     }
+  } else if (pass_name == "struct-packing") {
+    if (pass_args.size() == 0) {
+      Error(consumer(), nullptr, {},
+            "--struct-packing requires a name:rule argument.");
+      return false;
+    }
+
+    auto separator_pos = pass_args.find(':');
+    if (separator_pos == std::string::npos || separator_pos == 0 ||
+        separator_pos + 1 == pass_args.size()) {
+      Errorf(consumer(), nullptr, {},
+             "Invalid argument for --struct-packing: %s", pass_args.c_str());
+      return false;
+    }
+
+    const std::string struct_name = pass_args.substr(0, separator_pos);
+    const std::string rule_name = pass_args.substr(separator_pos + 1);
+
+    RegisterPass(
+        CreateStructPackingPass(struct_name.c_str(), rule_name.c_str()));
   } else if (pass_name == "switch-descriptorset") {
     if (pass_args.size() == 0) {
       Error(consumer(), nullptr, {},
@@ -1059,7 +1083,20 @@ Optimizer::PassToken CreateSpreadVolatileSemanticsPass() {
 
 Optimizer::PassToken CreateDescriptorScalarReplacementPass() {
   return MakeUnique<Optimizer::PassToken::Impl>(
-      MakeUnique<opt::DescriptorScalarReplacement>());
+      MakeUnique<opt::DescriptorScalarReplacement>(
+          /* flatten_composites= */ true, /* flatten_arrays= */ true));
+}
+
+Optimizer::PassToken CreateDescriptorCompositeScalarReplacementPass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::DescriptorScalarReplacement>(
+          /* flatten_composites= */ true, /* flatten_arrays= */ false));
+}
+
+Optimizer::PassToken CreateDescriptorArrayScalarReplacementPass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::DescriptorScalarReplacement>(
+          /* flatten_composites= */ false, /* flatten_arrays= */ true));
 }
 
 Optimizer::PassToken CreateWrapOpKillPass() {
@@ -1135,6 +1172,14 @@ Optimizer::PassToken CreateTrimCapabilitiesPass() {
       MakeUnique<opt::TrimCapabilitiesPass>());
 }
 
+Optimizer::PassToken CreateStructPackingPass(const char* structToPack,
+                                             const char* packingRule) {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::StructPackingPass>(
+          structToPack,
+          opt::StructPackingPass::ParsePackingRuleFromString(packingRule)));
+}
+
 Optimizer::PassToken CreateSwitchDescriptorSetPass(uint32_t from, uint32_t to) {
   return MakeUnique<Optimizer::PassToken::Impl>(
       MakeUnique<opt::SwitchDescriptorSetPass>(from, to));
diff --git a/spirv-tools/source/opt/pass.cpp b/spirv-tools/source/opt/pass.cpp
index 75c3740..0f260e2 100644
--- a/spirv-tools/source/opt/pass.cpp
+++ b/spirv-tools/source/opt/pass.cpp
@@ -83,7 +83,6 @@ uint32_t Pass::GetNullId(uint32_t type_id) {
 
 uint32_t Pass::GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id,
                             Instruction* insertion_position) {
-  analysis::TypeManager* type_mgr = context()->get_type_mgr();
   analysis::ConstantManager* const_mgr = context()->get_constant_mgr();
 
   uint32_t original_type_id = object_to_copy->type_id();
@@ -95,57 +94,63 @@ uint32_t Pass::GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id,
       context(), insertion_position,
       IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDefUse);
 
-  analysis::Type* original_type = type_mgr->GetType(original_type_id);
-  analysis::Type* new_type = type_mgr->GetType(new_type_id);
-
-  if (const analysis::Array* original_array_type = original_type->AsArray()) {
-    uint32_t original_element_type_id =
-        type_mgr->GetId(original_array_type->element_type());
-
-    analysis::Array* new_array_type = new_type->AsArray();
-    assert(new_array_type != nullptr && "Can't copy an array to a non-array.");
-    uint32_t new_element_type_id =
-        type_mgr->GetId(new_array_type->element_type());
-
-    std::vector<uint32_t> element_ids;
-    const analysis::Constant* length_const =
-        const_mgr->FindDeclaredConstant(original_array_type->LengthId());
-    assert(length_const->AsIntConstant());
-    uint32_t array_length = length_const->AsIntConstant()->GetU32();
-    for (uint32_t i = 0; i < array_length; i++) {
-      Instruction* extract = ir_builder.AddCompositeExtract(
-          original_element_type_id, object_to_copy->result_id(), {i});
-      element_ids.push_back(
-          GenerateCopy(extract, new_element_type_id, insertion_position));
-    }
+  Instruction* original_type = get_def_use_mgr()->GetDef(original_type_id);
+  Instruction* new_type = get_def_use_mgr()->GetDef(new_type_id);
 
-    return ir_builder.AddCompositeConstruct(new_type_id, element_ids)
-        ->result_id();
-  } else if (const analysis::Struct* original_struct_type =
-                 original_type->AsStruct()) {
-    analysis::Struct* new_struct_type = new_type->AsStruct();
-
-    const std::vector<const analysis::Type*>& original_types =
-        original_struct_type->element_types();
-    const std::vector<const analysis::Type*>& new_types =
-        new_struct_type->element_types();
-    std::vector<uint32_t> element_ids;
-    for (uint32_t i = 0; i < original_types.size(); i++) {
-      Instruction* extract = ir_builder.AddCompositeExtract(
-          type_mgr->GetId(original_types[i]), object_to_copy->result_id(), {i});
-      element_ids.push_back(GenerateCopy(extract, type_mgr->GetId(new_types[i]),
-                                         insertion_position));
+  if (new_type->opcode() != original_type->opcode()) {
+    return 0;
+  }
+
+  switch (original_type->opcode()) {
+    case spv::Op::OpTypeArray: {
+      uint32_t original_element_type_id =
+          original_type->GetSingleWordInOperand(0);
+      uint32_t new_element_type_id = new_type->GetSingleWordInOperand(0);
+
+      std::vector<uint32_t> element_ids;
+      uint32_t length_id = original_type->GetSingleWordInOperand(1);
+      const analysis::Constant* length_const =
+          const_mgr->FindDeclaredConstant(length_id);
+      assert(length_const->AsIntConstant());
+      uint32_t array_length = length_const->AsIntConstant()->GetU32();
+      for (uint32_t i = 0; i < array_length; i++) {
+        Instruction* extract = ir_builder.AddCompositeExtract(
+            original_element_type_id, object_to_copy->result_id(), {i});
+        uint32_t new_id =
+            GenerateCopy(extract, new_element_type_id, insertion_position);
+        if (new_id == 0) {
+          return 0;
+        }
+        element_ids.push_back(new_id);
+      }
+
+      return ir_builder.AddCompositeConstruct(new_type_id, element_ids)
+          ->result_id();
+    }
+    case spv::Op::OpTypeStruct: {
+      std::vector<uint32_t> element_ids;
+      for (uint32_t i = 0; i < original_type->NumInOperands(); i++) {
+        uint32_t orig_member_type_id = original_type->GetSingleWordInOperand(i);
+        uint32_t new_member_type_id = new_type->GetSingleWordInOperand(i);
+        Instruction* extract = ir_builder.AddCompositeExtract(
+            orig_member_type_id, object_to_copy->result_id(), {i});
+        uint32_t new_id =
+            GenerateCopy(extract, new_member_type_id, insertion_position);
+        if (new_id == 0) {
+          return 0;
+        }
+        element_ids.push_back(new_id);
+      }
+      return ir_builder.AddCompositeConstruct(new_type_id, element_ids)
+          ->result_id();
     }
-    return ir_builder.AddCompositeConstruct(new_type_id, element_ids)
-        ->result_id();
-  } else {
-    // If we do not have an aggregate type, then we have a problem.  Either we
-    // found multiple instances of the same type, or we are copying to an
-    // incompatible type.  Either way the code is illegal.
-    assert(false &&
-           "Don't know how to copy this type.  Code is likely illegal.");
+    default:
+      // If we do not have an aggregate type, then we have a problem.  Either we
+      // found multiple instances of the same type, or we are copying to an
+      // incompatible type.  Either way the code is illegal. Leave the code as
+      // is and let the caller deal with it.
+      return 0;
   }
-  return 0;
 }
 
 }  // namespace opt
diff --git a/spirv-tools/source/opt/pass.h b/spirv-tools/source/opt/pass.h
index b2303e2..3e6c4d0 100644
--- a/spirv-tools/source/opt/pass.h
+++ b/spirv-tools/source/opt/pass.h
@@ -145,7 +145,8 @@ class Pass {
 
   // Returns the id whose value is the same as |object_to_copy| except its type
   // is |new_type_id|.  Any instructions needed to generate this value will be
-  // inserted before |insertion_position|.
+  // inserted before |insertion_position|. Returns 0 if a copy could not be
+  // done.
   uint32_t GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id,
                         Instruction* insertion_position);
 
diff --git a/spirv-tools/source/opt/passes.h b/spirv-tools/source/opt/passes.h
index ac68ccd..f830152 100644
--- a/spirv-tools/source/opt/passes.h
+++ b/spirv-tools/source/opt/passes.h
@@ -83,6 +83,7 @@
 #include "source/opt/strength_reduction_pass.h"
 #include "source/opt/strip_debug_info_pass.h"
 #include "source/opt/strip_nonsemantic_info_pass.h"
+#include "source/opt/struct_packing_pass.h"
 #include "source/opt/switch_descriptorset_pass.h"
 #include "source/opt/trim_capabilities_pass.h"
 #include "source/opt/unify_const_pass.h"
diff --git a/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp b/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp
index d4df1b2..c3a4b77 100644
--- a/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp
+++ b/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp
@@ -21,6 +21,8 @@ class RemoveUnusedInterfaceVariablesContext {
   RemoveUnusedInterfaceVariablesPass& parent_;
   Instruction& entry_;
   std::unordered_set<uint32_t> used_variables_;
+  std::vector<uint32_t> operands_to_add_;
+
   IRContext::ProcessFunction pfn_ =
       std::bind(&RemoveUnusedInterfaceVariablesContext::processFunction, this,
                 std::placeholders::_1);
@@ -38,8 +40,10 @@ class RemoveUnusedInterfaceVariablesContext {
               (parent_.get_module()->version() >=
                    SPV_SPIRV_VERSION_WORD(1, 4) ||
                storage_class == spv::StorageClass::Input ||
-               storage_class == spv::StorageClass::Output))
+               storage_class == spv::StorageClass::Output)) {
             used_variables_.insert(*id);
+            operands_to_add_.push_back(*id);
+          }
         });
     return false;
   }
@@ -71,7 +75,7 @@ class RemoveUnusedInterfaceVariablesContext {
   void Modify() {
     for (int i = entry_.NumInOperands() - 1; i >= 3; --i)
       entry_.RemoveInOperand(i);
-    for (auto id : used_variables_) {
+    for (auto id : operands_to_add_) {
       entry_.AddOperand(Operand(SPV_OPERAND_TYPE_ID, {id}));
     }
   }
diff --git a/spirv-tools/source/opt/struct_packing_pass.cpp b/spirv-tools/source/opt/struct_packing_pass.cpp
new file mode 100644
index 0000000..3bf2b2a
--- /dev/null
+++ b/spirv-tools/source/opt/struct_packing_pass.cpp
@@ -0,0 +1,482 @@
+// Copyright (c) 2024 Epic Games, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "struct_packing_pass.h"
+
+#include <algorithm>
+
+#include "source/opt/instruction.h"
+#include "source/opt/ir_context.h"
+
+namespace spvtools {
+namespace opt {
+
+/*
+Std140 packing rules from the original GLSL 140 specification (see
+https://registry.khronos.org/OpenGL/extensions/ARB/ARB_uniform_buffer_object.txt)
+
+When using the "std140" storage layout, structures will be laid out in
+buffer storage with its members stored in monotonically increasing order
+based on their location in the declaration. A structure and each
+structure member have a base offset and a base alignment, from which an
+aligned offset is computed by rounding the base offset up to a multiple of
+the base alignment. The base offset of the first member of a structure is
+taken from the aligned offset of the structure itself. The base offset of
+all other structure members is derived by taking the offset of the last
+basic machine unit consumed by the previous member and adding one. Each
+structure member is stored in memory at its aligned offset. The members
+of a top-level uniform block are laid out in buffer storage by treating
+the uniform block as a structure with a base offset of zero.
+
+(1) If the member is a scalar consuming <N> basic machine units, the
+    base alignment is <N>.
+
+(2) If the member is a two- or four-component vector with components
+    consuming <N> basic machine units, the base alignment is 2<N> or
+    4<N>, respectively.
+
+(3) If the member is a three-component vector with components consuming
+    <N> basic machine units, the base alignment is 4<N>.
+
+(4) If the member is an array of scalars or vectors, the base alignment
+    and array stride are set to match the base alignment of a single
+    array element, according to rules (1), (2), and (3), and rounded up
+    to the base alignment of a vec4. The array may have padding at the
+    end; the base offset of the member following the array is rounded up
+    to the next multiple of the base alignment.
+
+(5) If the member is a column-major matrix with <C> columns and <R>
+    rows, the matrix is stored identically to an array of <C> column
+    vectors with <R> components each, according to rule (4).
+
+(6) If the member is an array of <S> column-major matrices with <C>
+    columns and <R> rows, the matrix is stored identically to a row of
+    <S>*<C> column vectors with <R> components each, according to rule
+    (4).
+
+(7) If the member is a row-major matrix with <C> columns and <R> rows,
+    the matrix is stored identically to an array of <R> row vectors
+    with <C> components each, according to rule (4).
+
+(8) If the member is an array of <S> row-major matrices with <C> columns
+    and <R> rows, the matrix is stored identically to a row of <S>*<R>
+    row vectors with <C> components each, according to rule (4).
+
+(9) If the member is a structure, the base alignment of the structure is
+    <N>, where <N> is the largest base alignment value of any of its
+    members, and rounded up to the base alignment of a vec4. The
+    individual members of this sub-structure are then assigned offsets
+    by applying this set of rules recursively, where the base offset of
+    the first member of the sub-structure is equal to the aligned offset
+    of the structure. The structure may have padding at the end; the
+    base offset of the member following the sub-structure is rounded up
+    to the next multiple of the base alignment of the structure.
+
+(10) If the member is an array of <S> structures, the <S> elements of
+    the array are laid out in order, according to rule (9).
+*/
+
+static bool isPackingVec4Padded(StructPackingPass::PackingRules rules) {
+  switch (rules) {
+    case StructPackingPass::PackingRules::Std140:
+    case StructPackingPass::PackingRules::Std140EnhancedLayout:
+    case StructPackingPass::PackingRules::HlslCbuffer:
+    case StructPackingPass::PackingRules::HlslCbufferPackOffset:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static bool isPackingScalar(StructPackingPass::PackingRules rules) {
+  switch (rules) {
+    case StructPackingPass::PackingRules::Scalar:
+    case StructPackingPass::PackingRules::ScalarEnhancedLayout:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static bool isPackingHlsl(StructPackingPass::PackingRules rules) {
+  switch (rules) {
+    case StructPackingPass::PackingRules::HlslCbuffer:
+    case StructPackingPass::PackingRules::HlslCbufferPackOffset:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static uint32_t getPackedBaseSize(const analysis::Type& type) {
+  switch (type.kind()) {
+    case analysis::Type::kBool:
+      return 1;
+    case analysis::Type::kInteger:
+      return type.AsInteger()->width() / 8;
+    case analysis::Type::kFloat:
+      return type.AsFloat()->width() / 8;
+    case analysis::Type::kVector:
+      return getPackedBaseSize(*type.AsVector()->element_type());
+    case analysis::Type::kMatrix:
+      return getPackedBaseSize(*type.AsMatrix()->element_type());
+    default:
+      break;  // we only expect bool, int, float, vec, and mat here
+  }
+  assert(0 && "Unrecognized type to get base size");
+  return 0;
+}
+
+static uint32_t getScalarElementCount(const analysis::Type& type) {
+  switch (type.kind()) {
+    case analysis::Type::kVector:
+      return type.AsVector()->element_count();
+    case analysis::Type::kMatrix:
+      return getScalarElementCount(*type.AsMatrix()->element_type());
+    case analysis::Type::kStruct:
+      assert(0 && "getScalarElementCount() does not recognized struct types");
+      return 0;
+    default:
+      return 1;
+  }
+}
+
+// Aligns the specified value to a multiple of alignment, whereas the
+// alignment must be a power-of-two.
+static uint32_t alignPow2(uint32_t value, uint32_t alignment) {
+  return (value + alignment - 1) & ~(alignment - 1);
+}
+
+void StructPackingPass::buildConstantsMap() {
+  constantsMap_.clear();
+  for (Instruction* instr : context()->module()->GetConstants()) {
+    constantsMap_[instr->result_id()] = instr;
+  }
+}
+
+uint32_t StructPackingPass::getPackedAlignment(
+    const analysis::Type& type) const {
+  switch (type.kind()) {
+    case analysis::Type::kArray: {
+      // Get alignment of base type and round up to minimum alignment
+      const uint32_t minAlignment = isPackingVec4Padded(packingRules_) ? 16 : 1;
+      return std::max<uint32_t>(
+          minAlignment, getPackedAlignment(*type.AsArray()->element_type()));
+    }
+    case analysis::Type::kStruct: {
+      // Rule 9. Struct alignment is maximum alignmnet of its members
+      uint32_t alignment = 1;
+
+      for (const analysis::Type* elementType :
+           type.AsStruct()->element_types()) {
+        alignment =
+            std::max<uint32_t>(alignment, getPackedAlignment(*elementType));
+      }
+
+      if (isPackingVec4Padded(packingRules_))
+        alignment = std::max<uint32_t>(alignment, 16u);
+
+      return alignment;
+    }
+    default: {
+      const uint32_t baseAlignment = getPackedBaseSize(type);
+
+      // Scalar block layout always uses alignment for the most basic component
+      if (isPackingScalar(packingRules_)) return baseAlignment;
+
+      if (const analysis::Matrix* matrixType = type.AsMatrix()) {
+        // Rule 5/7
+        if (isPackingVec4Padded(packingRules_) ||
+            matrixType->element_count() == 3)
+          return baseAlignment * 4;
+        else
+          return baseAlignment * matrixType->element_count();
+      } else if (const analysis::Vector* vectorType = type.AsVector()) {
+        // Rule 1
+        if (vectorType->element_count() == 1) return baseAlignment;
+
+        // Rule 2
+        if (vectorType->element_count() == 2 ||
+            vectorType->element_count() == 4)
+          return baseAlignment * vectorType->element_count();
+
+        // Rule 3
+        if (vectorType->element_count() == 3) return baseAlignment * 4;
+      } else {
+        // Rule 1
+        return baseAlignment;
+      }
+    }
+  }
+  assert(0 && "Unrecognized type to get packed alignment");
+  return 0;
+}
+
+static uint32_t getPadAlignment(const analysis::Type& type,
+                                uint32_t packedAlignment) {
+  // The next member following a struct member is aligned to the base alignment
+  // of a previous struct member.
+  return type.kind() == analysis::Type::kStruct ? packedAlignment : 1;
+}
+
+uint32_t StructPackingPass::getPackedSize(const analysis::Type& type) const {
+  switch (type.kind()) {
+    case analysis::Type::kArray: {
+      if (const analysis::Array* arrayType = type.AsArray()) {
+        uint32_t size =
+            getPackedArrayStride(*arrayType) * getArrayLength(*arrayType);
+
+        // For arrays of vector and matrices in HLSL, the last element has a
+        // size depending on its vector/matrix size to allow packing other
+        // vectors in the last element.
+        const analysis::Type* arraySubType = arrayType->element_type();
+        if (isPackingHlsl(packingRules_) &&
+            arraySubType->kind() != analysis::Type::kStruct) {
+          size -= (4 - getScalarElementCount(*arraySubType)) *
+                  getPackedBaseSize(*arraySubType);
+        }
+        return size;
+      }
+      break;
+    }
+    case analysis::Type::kStruct: {
+      uint32_t size = 0;
+      uint32_t padAlignment = 1;
+      for (const analysis::Type* memberType :
+           type.AsStruct()->element_types()) {
+        const uint32_t packedAlignment = getPackedAlignment(*memberType);
+        const uint32_t alignment =
+            std::max<uint32_t>(packedAlignment, padAlignment);
+        padAlignment = getPadAlignment(*memberType, packedAlignment);
+        size = alignPow2(size, alignment);
+        size += getPackedSize(*memberType);
+      }
+      return size;
+    }
+    default: {
+      const uint32_t baseAlignment = getPackedBaseSize(type);
+      if (isPackingScalar(packingRules_)) {
+        return getScalarElementCount(type) * baseAlignment;
+      } else {
+        uint32_t size = 0;
+        if (const analysis::Matrix* matrixType = type.AsMatrix()) {
+          const analysis::Vector* matrixSubType =
+              matrixType->element_type()->AsVector();
+          assert(matrixSubType != nullptr &&
+                 "Matrix sub-type is expected to be a vector type");
+          if (isPackingVec4Padded(packingRules_) ||
+              matrixType->element_count() == 3)
+            size = matrixSubType->element_count() * baseAlignment * 4;
+          else
+            size = matrixSubType->element_count() * baseAlignment *
+                   matrixType->element_count();
+
+          // For matrices in HLSL, the last element has a size depending on its
+          // vector size to allow packing other vectors in the last element.
+          if (isPackingHlsl(packingRules_)) {
+            size -= (4 - matrixSubType->element_count()) *
+                    getPackedBaseSize(*matrixSubType);
+          }
+        } else if (const analysis::Vector* vectorType = type.AsVector()) {
+          size = vectorType->element_count() * baseAlignment;
+        } else {
+          size = baseAlignment;
+        }
+        return size;
+      }
+    }
+  }
+  assert(0 && "Unrecognized type to get packed size");
+  return 0;
+}
+
+uint32_t StructPackingPass::getPackedArrayStride(
+    const analysis::Array& arrayType) const {
+  // Array stride is equal to aligned size of element type
+  const uint32_t elementSize = getPackedSize(*arrayType.element_type());
+  const uint32_t alignment = getPackedAlignment(arrayType);
+  return alignPow2(elementSize, alignment);
+}
+
+uint32_t StructPackingPass::getArrayLength(
+    const analysis::Array& arrayType) const {
+  return getConstantInt(arrayType.LengthId());
+}
+
+uint32_t StructPackingPass::getConstantInt(spv::Id id) const {
+  auto it = constantsMap_.find(id);
+  assert(it != constantsMap_.end() &&
+         "Failed to map SPIR-V instruction ID to constant value");
+  [[maybe_unused]] const analysis::Type* constType =
+      context()->get_type_mgr()->GetType(it->second->type_id());
+  assert(constType != nullptr &&
+         "Failed to map SPIR-V instruction result type to definition");
+  assert(constType->kind() == analysis::Type::kInteger &&
+         "Failed to map SPIR-V instruction result type to integer type");
+  return it->second->GetOperand(2).words[0];
+}
+
+StructPackingPass::PackingRules StructPackingPass::ParsePackingRuleFromString(
+    const std::string& s) {
+  if (s == "std140") return PackingRules::Std140;
+  if (s == "std140EnhancedLayout") return PackingRules::Std140EnhancedLayout;
+  if (s == "std430") return PackingRules::Std430;
+  if (s == "std430EnhancedLayout") return PackingRules::Std430EnhancedLayout;
+  if (s == "hlslCbuffer") return PackingRules::HlslCbuffer;
+  if (s == "hlslCbufferPackOffset") return PackingRules::HlslCbufferPackOffset;
+  if (s == "scalar") return PackingRules::Scalar;
+  if (s == "scalarEnhancedLayout") return PackingRules::ScalarEnhancedLayout;
+  return PackingRules::Undefined;
+}
+
+StructPackingPass::StructPackingPass(const char* structToPack,
+                                     PackingRules rules)
+    : structToPack_{structToPack != nullptr ? structToPack : ""},
+      packingRules_{rules} {}
+
+Pass::Status StructPackingPass::Process() {
+  if (packingRules_ == PackingRules::Undefined) {
+    if (consumer()) {
+      consumer()(SPV_MSG_ERROR, "", {0, 0, 0},
+                 "Cannot pack struct with undefined rule");
+    }
+    return Status::Failure;
+  }
+
+  // Build Id-to-instruction map for easier access
+  buildConstantsMap();
+
+  // Find structure of interest
+  const uint32_t structIdToPack = findStructIdByName(structToPack_.c_str());
+
+  const Instruction* structDef =
+      context()->get_def_use_mgr()->GetDef(structIdToPack);
+  if (structDef == nullptr || structDef->opcode() != spv::Op::OpTypeStruct) {
+    if (consumer()) {
+      const std::string message =
+          "Failed to find struct with name " + structToPack_;
+      consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str());
+    }
+    return Status::Failure;
+  }
+
+  // Find all struct member types
+  std::vector<const analysis::Type*> structMemberTypes =
+      findStructMemberTypes(*structDef);
+
+  return assignStructMemberOffsets(structIdToPack, structMemberTypes);
+}
+
+uint32_t StructPackingPass::findStructIdByName(const char* structName) const {
+  for (Instruction& instr : context()->module()->debugs2()) {
+    if (instr.opcode() == spv::Op::OpName &&
+        instr.GetOperand(1).AsString() == structName) {
+      return instr.GetOperand(0).AsId();
+    }
+  }
+  return 0;
+}
+
+std::vector<const analysis::Type*> StructPackingPass::findStructMemberTypes(
+    const Instruction& structDef) const {
+  // Found struct type to pack, now collect all types of its members
+  assert(structDef.NumOperands() > 0 &&
+         "Number of operands in OpTypeStruct instruction must not be zero");
+  const uint32_t numMembers = structDef.NumOperands() - 1;
+  std::vector<const analysis::Type*> structMemberTypes;
+  structMemberTypes.resize(numMembers);
+  for (uint32_t i = 0; i < numMembers; ++i) {
+    const spv::Id memberTypeId = structDef.GetOperand(1 + i).AsId();
+    if (const analysis::Type* memberType =
+            context()->get_type_mgr()->GetType(memberTypeId)) {
+      structMemberTypes[i] = memberType;
+    }
+  }
+  return structMemberTypes;
+}
+
+Pass::Status StructPackingPass::assignStructMemberOffsets(
+    uint32_t structIdToPack,
+    const std::vector<const analysis::Type*>& structMemberTypes) {
+  // Returns true if the specified instruction is a OpMemberDecorate for the
+  // struct we're looking for with an offset decoration
+  auto isMemberOffsetDecoration =
+      [structIdToPack](const Instruction& instr) -> bool {
+    return instr.opcode() == spv::Op::OpMemberDecorate &&
+           instr.GetOperand(0).AsId() == structIdToPack &&
+           static_cast<spv::Decoration>(instr.GetOperand(2).words[0]) ==
+               spv::Decoration::Offset;
+  };
+
+  bool modified = false;
+
+  // Find and re-assign all member offset decorations
+  for (auto it = context()->module()->annotation_begin(),
+            itEnd = context()->module()->annotation_end();
+       it != itEnd; ++it) {
+    if (isMemberOffsetDecoration(*it)) {
+      // Found first member decoration with offset, we expect all other
+      // offsets right after the first one
+      uint32_t prevMemberIndex = 0;
+      uint32_t currentOffset = 0;
+      uint32_t padAlignment = 1;
+      do {
+        const uint32_t memberIndex = it->GetOperand(1).words[0];
+        if (memberIndex < prevMemberIndex) {
+          // Failure: we expect all members to appear in consecutive order
+          return Status::Failure;
+        }
+
+        // Apply alignment rules to current offset
+        const analysis::Type& memberType = *structMemberTypes[memberIndex];
+        uint32_t packedAlignment = getPackedAlignment(memberType);
+        uint32_t packedSize = getPackedSize(memberType);
+
+        if (isPackingHlsl(packingRules_)) {
+          // If a member crosses vec4 boundaries, alignment is size of vec4
+          if (currentOffset / 16 != (currentOffset + packedSize - 1) / 16)
+            packedAlignment = std::max<uint32_t>(packedAlignment, 16u);
+        }
+
+        const uint32_t alignment =
+            std::max<uint32_t>(packedAlignment, padAlignment);
+        currentOffset = alignPow2(currentOffset, alignment);
+        padAlignment = getPadAlignment(memberType, packedAlignment);
+
+        // Override packed offset in instruction
+        if (it->GetOperand(3).words[0] < currentOffset) {
+          // Failure: packing resulted in higher offset for member than
+          // previously generated
+          return Status::Failure;
+        }
+
+        it->GetOperand(3).words[0] = currentOffset;
+        modified = true;
+
+        // Move to next member
+        ++it;
+        prevMemberIndex = memberIndex;
+        currentOffset += packedSize;
+      } while (it != itEnd && isMemberOffsetDecoration(*it));
+
+      // We're done with all decorations for the struct of interest
+      break;
+    }
+  }
+
+  return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
+}
+
+}  // namespace opt
+}  // namespace spvtools
diff --git a/spirv-tools/source/opt/struct_packing_pass.h b/spirv-tools/source/opt/struct_packing_pass.h
new file mode 100644
index 0000000..3f30f98
--- /dev/null
+++ b/spirv-tools/source/opt/struct_packing_pass.h
@@ -0,0 +1,81 @@
+// Copyright (c) 2024 Epic Games, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SOURCE_OPT_STRUCT_PACKING_PASS_
+#define SOURCE_OPT_STRUCT_PACKING_PASS_
+
+#include <unordered_map>
+
+#include "source/opt/ir_context.h"
+#include "source/opt/module.h"
+#include "source/opt/pass.h"
+
+namespace spvtools {
+namespace opt {
+
+// This pass re-assigns all field offsets under the specified packing rules.
+class StructPackingPass final : public Pass {
+ public:
+  enum class PackingRules {
+    Undefined,
+    Std140,
+    Std140EnhancedLayout,
+    Std430,
+    Std430EnhancedLayout,
+    HlslCbuffer,
+    HlslCbufferPackOffset,
+    Scalar,
+    ScalarEnhancedLayout,
+  };
+
+  static PackingRules ParsePackingRuleFromString(const std::string& s);
+
+  StructPackingPass(const char* structToPack, PackingRules rules);
+  const char* name() const override { return "struct-packing"; }
+  Status Process() override;
+
+  IRContext::Analysis GetPreservedAnalyses() override {
+    return IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG |
+           IRContext::kAnalysisDominatorAnalysis |
+           IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap |
+           IRContext::kAnalysisScalarEvolution |
+           IRContext::kAnalysisStructuredCFG | IRContext::kAnalysisConstants |
+           IRContext::kAnalysisDebugInfo | IRContext::kAnalysisLiveness;
+  }
+
+ private:
+  void buildConstantsMap();
+  uint32_t findStructIdByName(const char* structName) const;
+  std::vector<const analysis::Type*> findStructMemberTypes(
+      const Instruction& structDef) const;
+  Status assignStructMemberOffsets(
+      uint32_t structIdToPack,
+      const std::vector<const analysis::Type*>& structMemberTypes);
+
+  uint32_t getPackedAlignment(const analysis::Type& type) const;
+  uint32_t getPackedSize(const analysis::Type& type) const;
+  uint32_t getPackedArrayStride(const analysis::Array& arrayType) const;
+  uint32_t getArrayLength(const analysis::Array& arrayType) const;
+  uint32_t getConstantInt(spv::Id id) const;
+
+ private:
+  std::string structToPack_;
+  PackingRules packingRules_ = PackingRules::Undefined;
+  std::unordered_map<spv::Id, Instruction*> constantsMap_;
+};
+
+}  // namespace opt
+}  // namespace spvtools
+
+#endif  // SOURCE_OPT_STRUCT_PACKING_PASS_
diff --git a/spirv-tools/source/opt/type_manager.cpp b/spirv-tools/source/opt/type_manager.cpp
index 62f9369..79648ad 100644
--- a/spirv-tools/source/opt/type_manager.cpp
+++ b/spirv-tools/source/opt/type_manager.cpp
@@ -245,6 +245,7 @@ uint32_t TypeManager::GetTypeInstruction(const Type* type) {
                {(type->AsInteger()->IsSigned() ? 1u : 0u)}}});
       break;
     case Type::kFloat:
+      // TODO: Handle FP encoding enums once actually used.
       typeInst = MakeUnique<Instruction>(
           context(), spv::Op::OpTypeFloat, 0, id,
           std::initializer_list<Operand>{
diff --git a/spirv-tools/source/text_handler.cpp b/spirv-tools/source/text_handler.cpp
index 35c4b83..a778c2c 100644
--- a/spirv-tools/source/text_handler.cpp
+++ b/spirv-tools/source/text_handler.cpp
@@ -329,8 +329,9 @@ spv_result_t AssemblyContext::recordTypeDefinition(
     types_[value] = {pInst->words[2], pInst->words[3] != 0,
                      IdTypeClass::kScalarIntegerType};
   } else if (pInst->opcode == spv::Op::OpTypeFloat) {
-    if (pInst->words.size() != 3)
+    if ((pInst->words.size() != 3) && (pInst->words.size() != 4))
       return diagnostic() << "Invalid OpTypeFloat instruction";
+    // TODO(kpet) Do we need to record the FP Encoding here?
     types_[value] = {pInst->words[2], false, IdTypeClass::kScalarFloatType};
   } else {
     types_[value] = {0, false, IdTypeClass::kOtherType};
diff --git a/spirv-tools/source/to_string.cpp b/spirv-tools/source/to_string.cpp
new file mode 100644
index 0000000..b707070
--- /dev/null
+++ b/spirv-tools/source/to_string.cpp
@@ -0,0 +1,44 @@
+// Copyright (c) 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "source/to_string.h"
+
+#include <cassert>
+
+namespace spvtools {
+
+std::string to_string(uint32_t n) {
+  // This implementation avoids using standard library features that access
+  // the locale.  Using the locale requires taking a mutex which causes
+  // annoying serialization.
+
+  constexpr int max_digits = 10;  // max uint has 10 digits
+  // Contains the resulting digits, with least significant digit in the last
+  // entry.
+  char buf[max_digits];
+  int write_index = max_digits - 1;
+  if (n == 0) {
+    buf[write_index] = '0';
+  } else {
+    while (n > 0) {
+      int units = n % 10;
+      buf[write_index--] = "0123456789"[units];
+      n = (n - units) / 10;
+    }
+    write_index++;
+  }
+  assert(write_index >= 0);
+  return std::string(buf + write_index, max_digits - write_index);
+}
+}  // namespace spvtools
diff --git a/spirv-tools/source/to_string.h b/spirv-tools/source/to_string.h
new file mode 100644
index 0000000..83702f9
--- /dev/null
+++ b/spirv-tools/source/to_string.h
@@ -0,0 +1,29 @@
+// Copyright (c) 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SOURCE_TO_STRING_H_
+#define SOURCE_TO_STRING_H_
+
+#include <cstdint>
+#include <string>
+
+namespace spvtools {
+
+// Returns the decimal representation of a number as a string,
+// without using the locale.
+std::string to_string(uint32_t n);
+
+}  // namespace spvtools
+
+#endif  // SOURCE_TO_STRING_H_
diff --git a/spirv-tools/source/util/bitutils.h b/spirv-tools/source/util/bitutils.h
index a121dc3..2763bc2 100644
--- a/spirv-tools/source/util/bitutils.h
+++ b/spirv-tools/source/util/bitutils.h
@@ -97,7 +97,7 @@ template <typename T>
 size_t CountSetBits(T word) {
   static_assert(std::is_integral<T>::value,
                 "CountSetBits requires integer type");
-  size_t count = 0;
+  uint32_t count = 0;
   while (word) {
     word &= word - 1;
     ++count;
diff --git a/spirv-tools/source/val/validate_adjacency.cpp b/spirv-tools/source/val/validate_adjacency.cpp
index e6b0042..52519bf 100644
--- a/spirv-tools/source/val/validate_adjacency.cpp
+++ b/spirv-tools/source/val/validate_adjacency.cpp
@@ -117,6 +117,15 @@ spv_result_t ValidateAdjacency(ValidationState_t& _) {
                     "first instructions in the first block.";
         }
         break;
+      case spv::Op::OpUntypedVariableKHR:
+        if (inst.GetOperandAs<spv::StorageClass>(2) ==
+                spv::StorageClass::Function &&
+            adjacency_status != IN_ENTRY_BLOCK) {
+          return _.diag(SPV_ERROR_INVALID_DATA, &inst)
+                 << "All OpUntypedVariableKHR instructions in a function must "
+                    "be the first instructions in the first block.";
+        }
+        break;
       default:
         adjacency_status = PHI_AND_VAR_INVALID;
         break;
diff --git a/spirv-tools/source/val/validate_annotation.cpp b/spirv-tools/source/val/validate_annotation.cpp
index dac3585..cf6f96b 100644
--- a/spirv-tools/source/val/validate_annotation.cpp
+++ b/spirv-tools/source/val/validate_annotation.cpp
@@ -123,12 +123,14 @@ spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec,
     case spv::Decoration::ArrayStride:
       if (target->opcode() != spv::Op::OpTypeArray &&
           target->opcode() != spv::Op::OpTypeRuntimeArray &&
-          target->opcode() != spv::Op::OpTypePointer) {
+          target->opcode() != spv::Op::OpTypePointer &&
+          target->opcode() != spv::Op::OpTypeUntypedPointerKHR) {
         return fail(0) << "must be an array or pointer type";
       }
       break;
     case spv::Decoration::BuiltIn:
       if (target->opcode() != spv::Op::OpVariable &&
+          target->opcode() != spv::Op::OpUntypedVariableKHR &&
           !spvOpcodeIsConstant(target->opcode())) {
         return _.diag(SPV_ERROR_INVALID_DATA, inst)
                << "BuiltIns can only target variables, structure members or "
@@ -139,7 +141,8 @@ spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec,
         if (!spvOpcodeIsConstant(target->opcode())) {
           return fail(0) << "must be a constant for WorkgroupSize";
         }
-      } else if (target->opcode() != spv::Op::OpVariable) {
+      } else if (target->opcode() != spv::Op::OpVariable &&
+                 target->opcode() != spv::Op::OpUntypedVariableKHR) {
         return fail(0) << "must be a variable";
       }
       break;
@@ -161,11 +164,12 @@ spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec,
     case spv::Decoration::RestrictPointer:
     case spv::Decoration::AliasedPointer:
       if (target->opcode() != spv::Op::OpVariable &&
+          target->opcode() != spv::Op::OpUntypedVariableKHR &&
           target->opcode() != spv::Op::OpFunctionParameter &&
           target->opcode() != spv::Op::OpRawAccessChainNV) {
         return fail(0) << "must be a memory object declaration";
       }
-      if (_.GetIdOpcode(target->type_id()) != spv::Op::OpTypePointer) {
+      if (!_.IsPointerType(target->type_id())) {
         return fail(0) << "must be a pointer type";
       }
       break;
@@ -176,7 +180,8 @@ spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec,
     case spv::Decoration::Binding:
     case spv::Decoration::DescriptorSet:
     case spv::Decoration::InputAttachmentIndex:
-      if (target->opcode() != spv::Op::OpVariable) {
+      if (target->opcode() != spv::Op::OpVariable &&
+          target->opcode() != spv::Op::OpUntypedVariableKHR) {
         return fail(0) << "must be a variable";
       }
       break;
diff --git a/spirv-tools/source/val/validate_atomics.cpp b/spirv-tools/source/val/validate_atomics.cpp
index 8ddef17..990ed31 100644
--- a/spirv-tools/source/val/validate_atomics.cpp
+++ b/spirv-tools/source/val/validate_atomics.cpp
@@ -183,7 +183,44 @@ spv_result_t AtomicsPass(ValidationState_t& _, const Instruction* inst) {
       if (!_.GetPointerTypeInfo(pointer_type, &data_type, &storage_class)) {
         return _.diag(SPV_ERROR_INVALID_DATA, inst)
                << spvOpcodeString(opcode)
-               << ": expected Pointer to be of type OpTypePointer";
+               << ": expected Pointer to be a pointer type";
+      }
+
+      // If the pointer is an untyped pointer, get the data type elsewhere.
+      if (data_type == 0) {
+        switch (opcode) {
+          case spv::Op::OpAtomicLoad:
+          case spv::Op::OpAtomicExchange:
+          case spv::Op::OpAtomicFAddEXT:
+          case spv::Op::OpAtomicCompareExchange:
+          case spv::Op::OpAtomicCompareExchangeWeak:
+          case spv::Op::OpAtomicIIncrement:
+          case spv::Op::OpAtomicIDecrement:
+          case spv::Op::OpAtomicIAdd:
+          case spv::Op::OpAtomicISub:
+          case spv::Op::OpAtomicSMin:
+          case spv::Op::OpAtomicUMin:
+          case spv::Op::OpAtomicFMinEXT:
+          case spv::Op::OpAtomicSMax:
+          case spv::Op::OpAtomicUMax:
+          case spv::Op::OpAtomicFMaxEXT:
+          case spv::Op::OpAtomicAnd:
+          case spv::Op::OpAtomicOr:
+          case spv::Op::OpAtomicXor:
+            data_type = inst->type_id();
+            break;
+          case spv::Op::OpAtomicFlagTestAndSet:
+          case spv::Op::OpAtomicFlagClear:
+            return _.diag(SPV_ERROR_INVALID_ID, inst)
+                   << "Untyped pointers are not supported by atomic flag "
+                      "instructions";
+            break;
+          case spv::Op::OpAtomicStore:
+            data_type = _.FindDef(inst->GetOperandAs<uint32_t>(3))->type_id();
+            break;
+          default:
+            break;
+        }
       }
 
       // Can't use result_type because OpAtomicStore doesn't have a result
diff --git a/spirv-tools/source/val/validate_builtins.cpp b/spirv-tools/source/val/validate_builtins.cpp
index 9e307fc..1305dc1 100644
--- a/spirv-tools/source/val/validate_builtins.cpp
+++ b/spirv-tools/source/val/validate_builtins.cpp
@@ -97,12 +97,16 @@ spv_result_t GetUnderlyingType(ValidationState_t& _,
 spv::StorageClass GetStorageClass(const Instruction& inst) {
   switch (inst.opcode()) {
     case spv::Op::OpTypePointer:
+    case spv::Op::OpTypeUntypedPointerKHR:
     case spv::Op::OpTypeForwardPointer: {
       return spv::StorageClass(inst.word(2));
     }
     case spv::Op::OpVariable: {
       return spv::StorageClass(inst.word(3));
     }
+    case spv::Op::OpUntypedVariableKHR: {
+      return spv::StorageClass(inst.word(4));
+    }
     case spv::Op::OpGenericCastToPtrExplicit: {
       return spv::StorageClass(inst.word(4));
     }
diff --git a/spirv-tools/source/val/validate_cfg.cpp b/spirv-tools/source/val/validate_cfg.cpp
index 9b7161f..77e4f4f 100644
--- a/spirv-tools/source/val/validate_cfg.cpp
+++ b/spirv-tools/source/val/validate_cfg.cpp
@@ -250,7 +250,8 @@ spv_result_t ValidateReturnValue(ValidationState_t& _,
   }
 
   if (_.addressing_model() == spv::AddressingModel::Logical &&
-      spv::Op::OpTypePointer == value_type->opcode() &&
+      (spv::Op::OpTypePointer == value_type->opcode() ||
+       spv::Op::OpTypeUntypedPointerKHR == value_type->opcode()) &&
       !_.features().variable_pointers && !_.options()->relax_logical_pointer) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "OpReturnValue value's type <id> "
@@ -838,6 +839,9 @@ spv_result_t StructuredControlFlowChecks(
       const auto* continue_target = next_inst.block();
       if (header->id() != continue_id) {
         for (auto pred : *continue_target->predecessors()) {
+          if (!pred->structurally_reachable()) {
+            continue;
+          }
           // Ignore back-edges from within the continue construct.
           bool is_back_edge = false;
           for (auto back_edge : back_edges) {
diff --git a/spirv-tools/source/val/validate_constants.cpp b/spirv-tools/source/val/validate_constants.cpp
index 4deaa49..1d40eed 100644
--- a/spirv-tools/source/val/validate_constants.cpp
+++ b/spirv-tools/source/val/validate_constants.cpp
@@ -324,6 +324,7 @@ bool IsTypeNullable(const std::vector<uint32_t>& instruction,
       }
       return true;
     }
+    case spv::Op::OpTypeUntypedPointerKHR:
     case spv::Op::OpTypePointer:
       if (spv::StorageClass(instruction[2]) ==
           spv::StorageClass::PhysicalStorageBuffer) {
diff --git a/spirv-tools/source/val/validate_decorations.cpp b/spirv-tools/source/val/validate_decorations.cpp
index 7364cab..e0fc098 100644
--- a/spirv-tools/source/val/validate_decorations.cpp
+++ b/spirv-tools/source/val/validate_decorations.cpp
@@ -224,6 +224,7 @@ uint32_t getBaseAlignment(uint32_t member_id, bool roundUp,
       break;
     }
     case spv::Op::OpTypePointer:
+    case spv::Op::OpTypeUntypedPointerKHR:
       baseAlignment = vstate.pointer_size_and_alignment();
       break;
     default:
@@ -270,6 +271,7 @@ uint32_t getScalarAlignment(uint32_t type_id, ValidationState_t& vstate) {
       return max_member_alignment;
     } break;
     case spv::Op::OpTypePointer:
+    case spv::Op::OpTypeUntypedPointerKHR:
       return vstate.pointer_size_and_alignment();
     default:
       assert(0);
@@ -359,6 +361,7 @@ uint32_t getSize(uint32_t member_id, const LayoutConstraints& inherited,
       return offset + getSize(lastMember, constraint, constraints, vstate);
     }
     case spv::Op::OpTypePointer:
+    case spv::Op::OpTypeUntypedPointerKHR:
       return vstate.pointer_size_and_alignment();
     default:
       assert(0);
@@ -432,9 +435,9 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str,
     return ds;
   };
 
-  // If we are checking physical storage buffer pointers, we may not actually
-  // have a struct here. Instead, pretend we have a struct with a single member
-  // at offset 0.
+  // If we are checking the layout of untyped pointers or physical storage
+  // buffer pointers, we may not actually have a struct here. Instead, pretend
+  // we have a struct with a single member at offset 0.
   const auto& struct_type = vstate.FindDef(struct_id);
   std::vector<uint32_t> members;
   if (struct_type->opcode() == spv::Op::OpTypeStruct) {
@@ -451,8 +454,8 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str,
   };
   std::vector<MemberOffsetPair> member_offsets;
 
-  // With physical storage buffers, we might be checking layouts that do not
-  // originate from a structure.
+  // With untyped pointers or physical storage buffers, we might be checking
+  // layouts that do not originate from a structure.
   if (struct_type->opcode() == spv::Op::OpTypeStruct) {
     member_offsets.reserve(members.size());
     for (uint32_t memberIdx = 0, numMembers = uint32_t(members.size());
@@ -770,14 +773,19 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) {
       std::unordered_set<spv::BuiltIn> output_var_builtin;
       for (auto interface : desc.interfaces) {
         Instruction* var_instr = vstate.FindDef(interface);
-        if (!var_instr || spv::Op::OpVariable != var_instr->opcode()) {
+        if (!var_instr ||
+            (spv::Op::OpVariable != var_instr->opcode() &&
+             spv::Op::OpUntypedVariableKHR != var_instr->opcode())) {
           return vstate.diag(SPV_ERROR_INVALID_ID, var_instr)
-                 << "Interfaces passed to OpEntryPoint must be of type "
-                    "OpTypeVariable. Found Op"
+                 << "Interfaces passed to OpEntryPoint must be variables. "
+                    "Found Op"
                  << spvOpcodeString(var_instr->opcode()) << ".";
         }
+        const bool untyped_pointers =
+            var_instr->opcode() == spv::Op::OpUntypedVariableKHR;
+        const auto sc_index = 2u;
         const spv::StorageClass storage_class =
-            var_instr->GetOperandAs<spv::StorageClass>(2);
+            var_instr->GetOperandAs<spv::StorageClass>(sc_index);
         if (vstate.version() >= SPV_SPIRV_VERSION_WORD(1, 4)) {
           // Starting in 1.4, OpEntryPoint must list all global variables
           // it statically uses and those interfaces must be unique.
@@ -804,12 +812,13 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) {
           }
         }
 
-        const uint32_t ptr_id = var_instr->word(1);
-        Instruction* ptr_instr = vstate.FindDef(ptr_id);
         // It is guaranteed (by validator ID checks) that ptr_instr is
         // OpTypePointer. Word 3 of this instruction is the type being pointed
-        // to.
-        const uint32_t type_id = ptr_instr->word(3);
+        // to. For untyped variables, the pointee type comes from the data type
+        // operand.
+        const uint32_t type_id =
+            untyped_pointers ? var_instr->word(4)
+                             : vstate.FindDef(var_instr->word(1))->word(3);
         Instruction* type_instr = vstate.FindDef(type_id);
         const bool is_struct =
             type_instr && spv::Op::OpTypeStruct == type_instr->opcode();
@@ -874,12 +883,25 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) {
 
         if (storage_class == spv::StorageClass::Workgroup) {
           ++num_workgroup_variables;
-          if (is_struct) {
-            if (hasDecoration(type_id, spv::Decoration::Block, vstate))
-              ++num_workgroup_variables_with_block;
-            if (hasDecoration(var_instr->id(), spv::Decoration::Aliased,
-                              vstate))
-              ++num_workgroup_variables_with_aliased;
+          if (type_instr) {
+            if (spv::Op::OpTypeStruct == type_instr->opcode()) {
+              if (hasDecoration(type_id, spv::Decoration::Block, vstate)) {
+                ++num_workgroup_variables_with_block;
+              } else if (untyped_pointers &&
+                         vstate.HasCapability(spv::Capability::Shader)) {
+                return vstate.diag(SPV_ERROR_INVALID_ID, var_instr)
+                       << "Untyped workgroup variables in shaders must be "
+                          "block decorated";
+              }
+              if (hasDecoration(var_instr->id(), spv::Decoration::Aliased,
+                                vstate))
+                ++num_workgroup_variables_with_aliased;
+            } else if (untyped_pointers &&
+                       vstate.HasCapability(spv::Capability::Shader)) {
+              return vstate.diag(SPV_ERROR_INVALID_ID, var_instr)
+                     << "Untyped workgroup variables in shaders must be block "
+                        "decorated structs";
+            }
           }
         }
 
@@ -960,25 +982,33 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) {
 
       const bool workgroup_blocks_allowed = vstate.HasCapability(
           spv::Capability::WorkgroupMemoryExplicitLayoutKHR);
-      if (workgroup_blocks_allowed && num_workgroup_variables > 0 &&
+      if (workgroup_blocks_allowed &&
+          !vstate.HasCapability(spv::Capability::UntypedPointersKHR) &&
+          num_workgroup_variables > 0 &&
           num_workgroup_variables_with_block > 0) {
         if (num_workgroup_variables != num_workgroup_variables_with_block) {
-          return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(entry_point))
+          return vstate.diag(SPV_ERROR_INVALID_BINARY,
+                             vstate.FindDef(entry_point))
                  << "When declaring WorkgroupMemoryExplicitLayoutKHR, "
-                    "either all or none of the Workgroup Storage Class variables "
+                    "either all or none of the Workgroup Storage Class "
+                    "variables "
                     "in the entry point interface must point to struct types "
-                    "decorated with Block.  Entry point id "
+                    "decorated with Block (unless the "
+                    "UntypedPointersKHR capability is declared).  "
+                    "Entry point id "
                  << entry_point << " does not meet this requirement.";
         }
         if (num_workgroup_variables_with_block > 1 &&
             num_workgroup_variables_with_block !=
             num_workgroup_variables_with_aliased) {
-          return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(entry_point))
+          return vstate.diag(SPV_ERROR_INVALID_BINARY,
+                             vstate.FindDef(entry_point))
                  << "When declaring WorkgroupMemoryExplicitLayoutKHR, "
                     "if more than one Workgroup Storage Class variable in "
                     "the entry point interface point to a type decorated "
-                    "with Block, all of them must be decorated with Aliased. "
-                    "Entry point id "
+                    "with Block, all of them must be decorated with Aliased "
+                    "(unless the UntypedPointerWorkgroupKHR capability is "
+                    "declared). Entry point id "
                  << entry_point << " does not meet this requirement.";
         }
       } else if (!workgroup_blocks_allowed &&
@@ -1084,11 +1114,17 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) {
     const auto& words = inst.words();
     auto type_id = inst.type_id();
     const Instruction* type_inst = vstate.FindDef(type_id);
-    if (spv::Op::OpVariable == inst.opcode()) {
+    bool scalar_block_layout = false;
+    MemberConstraints constraints;
+    if (spv::Op::OpVariable == inst.opcode() ||
+        spv::Op::OpUntypedVariableKHR == inst.opcode()) {
+      const bool untyped_pointer =
+          inst.opcode() == spv::Op::OpUntypedVariableKHR;
       const auto var_id = inst.id();
       // For storage class / decoration combinations, see Vulkan 14.5.4 "Offset
       // and Stride Assignment".
-      const auto storageClass = inst.GetOperandAs<spv::StorageClass>(2);
+      const auto storageClassVal = words[3];
+      const auto storageClass = spv::StorageClass(storageClassVal);
       const bool uniform = storageClass == spv::StorageClass::Uniform;
       const bool uniform_constant =
           storageClass == spv::StorageClass::UniformConstant;
@@ -1167,20 +1203,24 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) {
       if (uniform || push_constant || storage_buffer || phys_storage_buffer ||
           workgroup) {
         const auto ptrInst = vstate.FindDef(words[1]);
-        assert(spv::Op::OpTypePointer == ptrInst->opcode());
-        auto id = ptrInst->words()[3];
-        auto id_inst = vstate.FindDef(id);
-        // Jump through one level of arraying.
-        if (!workgroup && (id_inst->opcode() == spv::Op::OpTypeArray ||
-                           id_inst->opcode() == spv::Op::OpTypeRuntimeArray)) {
-          id = id_inst->GetOperandAs<uint32_t>(1u);
-          id_inst = vstate.FindDef(id);
+        assert(spv::Op::OpTypePointer == ptrInst->opcode() ||
+               spv::Op::OpTypeUntypedPointerKHR == ptrInst->opcode());
+        auto id = untyped_pointer ? (words.size() > 4 ? words[4] : 0)
+                                  : ptrInst->words()[3];
+        if (id != 0) {
+          auto id_inst = vstate.FindDef(id);
+          // Jump through one level of arraying.
+          if (!workgroup &&
+              (id_inst->opcode() == spv::Op::OpTypeArray ||
+               id_inst->opcode() == spv::Op::OpTypeRuntimeArray)) {
+            id = id_inst->GetOperandAs<uint32_t>(1u);
+            id_inst = vstate.FindDef(id);
+          }
+          // Struct requirement is checked on variables so just move on here.
+          if (spv::Op::OpTypeStruct != id_inst->opcode()) continue;
+          ComputeMemberConstraintsForStruct(&constraints, id,
+                                            LayoutConstraints(), vstate);
         }
-        // Struct requirement is checked on variables so just move on here.
-        if (spv::Op::OpTypeStruct != id_inst->opcode()) continue;
-        MemberConstraints constraints;
-        ComputeMemberConstraintsForStruct(&constraints, id, LayoutConstraints(),
-                                          vstate);
         // Prepare for messages
         const char* sc_str =
             uniform ? "Uniform"
@@ -1250,88 +1290,91 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) {
           }
         }
 
-        for (const auto& dec : vstate.id_decorations(id)) {
-          const bool blockDeco = spv::Decoration::Block == dec.dec_type();
-          const bool bufferDeco =
-              spv::Decoration::BufferBlock == dec.dec_type();
-          const bool blockRules = uniform && blockDeco;
-          const bool bufferRules =
-              (uniform && bufferDeco) ||
-              ((push_constant || storage_buffer ||
-                phys_storage_buffer || workgroup) && blockDeco);
-          if (uniform && blockDeco) {
-            vstate.RegisterPointerToUniformBlock(ptrInst->id());
-            vstate.RegisterStructForUniformBlock(id);
-          }
-          if ((uniform && bufferDeco) ||
-              ((storage_buffer || phys_storage_buffer) && blockDeco)) {
-            vstate.RegisterPointerToStorageBuffer(ptrInst->id());
-            vstate.RegisterStructForStorageBuffer(id);
-          }
-
-          if (blockRules || bufferRules) {
-            const char* deco_str = blockDeco ? "Block" : "BufferBlock";
-            spv_result_t recursive_status = SPV_SUCCESS;
-            const bool scalar_block_layout = workgroup ?
-                vstate.options()->workgroup_scalar_block_layout :
-                vstate.options()->scalar_block_layout;
-
-            if (isMissingOffsetInStruct(id, vstate)) {
-              return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
-                     << "Structure id " << id << " decorated as " << deco_str
-                     << " must be explicitly laid out with Offset "
-                        "decorations.";
+        if (id != 0) {
+          for (const auto& dec : vstate.id_decorations(id)) {
+            const bool blockDeco = spv::Decoration::Block == dec.dec_type();
+            const bool bufferDeco =
+                spv::Decoration::BufferBlock == dec.dec_type();
+            const bool blockRules = uniform && blockDeco;
+            const bool bufferRules = (uniform && bufferDeco) ||
+                                     ((push_constant || storage_buffer ||
+                                       phys_storage_buffer || workgroup) &&
+                                      blockDeco);
+            if (uniform && blockDeco) {
+              vstate.RegisterPointerToUniformBlock(ptrInst->id());
+              vstate.RegisterStructForUniformBlock(id);
             }
-
-            if (!checkForRequiredDecoration(
-                    id,
-                    [](spv::Decoration d) {
-                      return d == spv::Decoration::ArrayStride;
-                    },
-                    spv::Op::OpTypeArray, vstate)) {
-              return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
-                     << "Structure id " << id << " decorated as " << deco_str
-                     << " must be explicitly laid out with ArrayStride "
-                        "decorations.";
+            if ((uniform && bufferDeco) ||
+                ((storage_buffer || phys_storage_buffer) && blockDeco)) {
+              vstate.RegisterPointerToStorageBuffer(ptrInst->id());
+              vstate.RegisterStructForStorageBuffer(id);
             }
 
-            if (!checkForRequiredDecoration(
-                    id,
-                    [](spv::Decoration d) {
-                      return d == spv::Decoration::MatrixStride;
-                    },
-                    spv::Op::OpTypeMatrix, vstate)) {
-              return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
-                     << "Structure id " << id << " decorated as " << deco_str
-                     << " must be explicitly laid out with MatrixStride "
-                        "decorations.";
-            }
+            if (blockRules || bufferRules) {
+              const char* deco_str = blockDeco ? "Block" : "BufferBlock";
+              spv_result_t recursive_status = SPV_SUCCESS;
+              scalar_block_layout =
+                  workgroup ? vstate.options()->workgroup_scalar_block_layout
+                            : vstate.options()->scalar_block_layout;
+
+              if (isMissingOffsetInStruct(id, vstate)) {
+                return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
+                       << "Structure id " << id << " decorated as " << deco_str
+                       << " must be explicitly laid out with Offset "
+                          "decorations.";
+              }
 
-            if (!checkForRequiredDecoration(
-                    id,
-                    [](spv::Decoration d) {
-                      return d == spv::Decoration::RowMajor ||
-                             d == spv::Decoration::ColMajor;
-                    },
-                    spv::Op::OpTypeMatrix, vstate)) {
-              return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
-                     << "Structure id " << id << " decorated as " << deco_str
-                     << " must be explicitly laid out with RowMajor or "
-                        "ColMajor decorations.";
-            }
+              if (!checkForRequiredDecoration(
+                      id,
+                      [](spv::Decoration d) {
+                        return d == spv::Decoration::ArrayStride;
+                      },
+                      spv::Op::OpTypeArray, vstate)) {
+                return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
+                       << "Structure id " << id << " decorated as " << deco_str
+                       << " must be explicitly laid out with ArrayStride "
+                          "decorations.";
+              }
+
+              if (!checkForRequiredDecoration(
+                      id,
+                      [](spv::Decoration d) {
+                        return d == spv::Decoration::MatrixStride;
+                      },
+                      spv::Op::OpTypeMatrix, vstate)) {
+                return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
+                       << "Structure id " << id << " decorated as " << deco_str
+                       << " must be explicitly laid out with MatrixStride "
+                          "decorations.";
+              }
+
+              if (!checkForRequiredDecoration(
+                      id,
+                      [](spv::Decoration d) {
+                        return d == spv::Decoration::RowMajor ||
+                               d == spv::Decoration::ColMajor;
+                      },
+                      spv::Op::OpTypeMatrix, vstate)) {
+                return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id))
+                       << "Structure id " << id << " decorated as " << deco_str
+                       << " must be explicitly laid out with RowMajor or "
+                          "ColMajor decorations.";
+              }
 
-            if (spvIsVulkanEnv(vstate.context()->target_env)) {
-              if (blockRules && (SPV_SUCCESS != (recursive_status = checkLayout(
-                                                     id, sc_str, deco_str, true,
+              if (spvIsVulkanEnv(vstate.context()->target_env)) {
+                if (blockRules &&
+                    (SPV_SUCCESS !=
+                     (recursive_status = checkLayout(id, sc_str, deco_str, true,
                                                      scalar_block_layout, 0,
                                                      constraints, vstate)))) {
-                return recursive_status;
-              } else if (bufferRules &&
-                         (SPV_SUCCESS !=
-                          (recursive_status = checkLayout(
-                               id, sc_str, deco_str, false, scalar_block_layout,
-                               0, constraints, vstate)))) {
-                return recursive_status;
+                  return recursive_status;
+                } else if (bufferRules &&
+                           (SPV_SUCCESS != (recursive_status = checkLayout(
+                                                id, sc_str, deco_str, false,
+                                                scalar_block_layout, 0,
+                                                constraints, vstate)))) {
+                  return recursive_status;
+                }
               }
             }
           }
@@ -1340,20 +1383,98 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) {
     } else if (type_inst && type_inst->opcode() == spv::Op::OpTypePointer &&
                type_inst->GetOperandAs<spv::StorageClass>(1u) ==
                    spv::StorageClass::PhysicalStorageBuffer) {
-      const bool scalar_block_layout = vstate.options()->scalar_block_layout;
-      MemberConstraints constraints;
       const bool buffer = true;
-      const auto data_type_id = type_inst->GetOperandAs<uint32_t>(2u);
-      const auto* data_type_inst = vstate.FindDef(data_type_id);
+      const auto pointee_type_id = type_inst->GetOperandAs<uint32_t>(2u);
+      const auto* data_type_inst = vstate.FindDef(pointee_type_id);
+      scalar_block_layout = vstate.options()->scalar_block_layout;
       if (data_type_inst->opcode() == spv::Op::OpTypeStruct) {
-        ComputeMemberConstraintsForStruct(&constraints, data_type_id,
+        ComputeMemberConstraintsForStruct(&constraints, pointee_type_id,
                                           LayoutConstraints(), vstate);
       }
-      if (auto res = checkLayout(data_type_id, "PhysicalStorageBuffer", "Block",
-                                 !buffer, scalar_block_layout, 0, constraints,
-                                 vstate)) {
+      if (auto res = checkLayout(pointee_type_id, "PhysicalStorageBuffer",
+                                 "Block", !buffer, scalar_block_layout, 0,
+                                 constraints, vstate)) {
         return res;
       }
+    } else if (vstate.HasCapability(spv::Capability::UntypedPointersKHR) &&
+               spvIsVulkanEnv(vstate.context()->target_env)) {
+      // Untyped variables are checked above. Here we check that instructions
+      // using an untyped pointer have a valid layout.
+      uint32_t ptr_ty_id = 0;
+      uint32_t data_type_id = 0;
+      switch (inst.opcode()) {
+        case spv::Op::OpUntypedAccessChainKHR:
+        case spv::Op::OpUntypedInBoundsAccessChainKHR:
+        case spv::Op::OpUntypedPtrAccessChainKHR:
+        case spv::Op::OpUntypedInBoundsPtrAccessChainKHR:
+          ptr_ty_id = inst.type_id();
+          data_type_id = inst.GetOperandAs<uint32_t>(2);
+          break;
+        case spv::Op::OpLoad:
+          if (vstate.GetIdOpcode(vstate.GetOperandTypeId(&inst, 2)) ==
+              spv::Op::OpTypeUntypedPointerKHR) {
+            const auto ptr_id = inst.GetOperandAs<uint32_t>(2);
+            ptr_ty_id = vstate.FindDef(ptr_id)->type_id();
+            data_type_id = inst.type_id();
+          }
+          break;
+        case spv::Op::OpStore:
+          if (vstate.GetIdOpcode(vstate.GetOperandTypeId(&inst, 0)) ==
+              spv::Op::OpTypeUntypedPointerKHR) {
+            const auto ptr_id = inst.GetOperandAs<uint32_t>(0);
+            ptr_ty_id = vstate.FindDef(ptr_id)->type_id();
+            data_type_id = vstate.GetOperandTypeId(&inst, 1);
+          }
+          break;
+        case spv::Op::OpUntypedArrayLengthKHR:
+          ptr_ty_id = vstate.FindDef(inst.GetOperandAs<uint32_t>(3))->type_id();
+          data_type_id = inst.GetOperandAs<uint32_t>(2);
+          break;
+        default:
+          break;
+      }
+
+      if (ptr_ty_id == 0 || data_type_id == 0) {
+        // Not an untyped pointer.
+        continue;
+      }
+
+      const auto sc =
+          vstate.FindDef(ptr_ty_id)->GetOperandAs<spv::StorageClass>(1);
+
+      const char* sc_str =
+          sc == spv::StorageClass::Uniform
+              ? "Uniform"
+              : (sc == spv::StorageClass::PushConstant
+                     ? "PushConstant"
+                     : (sc == spv::StorageClass::Workgroup ? "Workgroup"
+                                                           : "StorageBuffer"));
+
+      const auto data_type = vstate.FindDef(data_type_id);
+      scalar_block_layout =
+          sc == spv::StorageClass::Workgroup
+              ? vstate.options()->workgroup_scalar_block_layout
+              : vstate.options()->scalar_block_layout;
+      // Assume uniform storage class uses block rules unless we see a
+      // BufferBlock decorated struct in the data type.
+      bool bufferRules = sc == spv::StorageClass::Uniform ? false : true;
+      if (data_type->opcode() == spv::Op::OpTypeStruct) {
+        if (sc == spv::StorageClass::Uniform) {
+          bufferRules =
+              vstate.HasDecoration(data_type_id, spv::Decoration::BufferBlock);
+        }
+        ComputeMemberConstraintsForStruct(&constraints, data_type_id,
+                                          LayoutConstraints(), vstate);
+      }
+      const char* deco_str =
+          bufferRules
+              ? (sc == spv::StorageClass::Uniform ? "BufferBlock" : "Block")
+              : "Block";
+      if (auto result =
+              checkLayout(data_type_id, sc_str, deco_str, !bufferRules,
+                          scalar_block_layout, 0, constraints, vstate)) {
+        return result;
+      }
     }
   }
   return SPV_SUCCESS;
@@ -1585,15 +1706,19 @@ spv_result_t CheckNonWritableDecoration(ValidationState_t& vstate,
     const auto opcode = inst.opcode();
     const auto type_id = inst.type_id();
     if (opcode != spv::Op::OpVariable &&
+        opcode != spv::Op::OpUntypedVariableKHR &&
         opcode != spv::Op::OpFunctionParameter &&
         opcode != spv::Op::OpRawAccessChainNV) {
       return vstate.diag(SPV_ERROR_INVALID_ID, &inst)
              << "Target of NonWritable decoration must be a memory object "
                 "declaration (a variable or a function parameter)";
     }
-    const auto var_storage_class = opcode == spv::Op::OpVariable
-                                       ? inst.GetOperandAs<spv::StorageClass>(2)
-                                       : spv::StorageClass::Max;
+    const auto var_storage_class =
+        opcode == spv::Op::OpVariable
+            ? inst.GetOperandAs<spv::StorageClass>(2)
+            : opcode == spv::Op::OpUntypedVariableKHR
+                  ? inst.GetOperandAs<spv::StorageClass>(3)
+                  : spv::StorageClass::Max;
     if ((var_storage_class == spv::StorageClass::Function ||
          var_storage_class == spv::StorageClass::Private) &&
         vstate.features().nonwritable_var_in_function_or_private) {
diff --git a/spirv-tools/source/val/validate_extensions.cpp b/spirv-tools/source/val/validate_extensions.cpp
index 05f8ca8..e26df28 100644
--- a/spirv-tools/source/val/validate_extensions.cpp
+++ b/spirv-tools/source/val/validate_extensions.cpp
@@ -2701,8 +2701,9 @@ spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) {
                     "Generic, CrossWorkgroup, Workgroup or Function";
         }
 
-        if (!_.IsFloatScalarType(p_data_type) ||
-            _.GetBitWidth(p_data_type) != 16) {
+        if ((!_.IsFloatScalarType(p_data_type) ||
+             _.GetBitWidth(p_data_type) != 16) &&
+            !_.ContainsUntypedPointer(p_type)) {
           return _.diag(SPV_ERROR_INVALID_DATA, inst)
                  << ext_inst_name() << ": "
                  << "expected operand P data type to be 16-bit float scalar";
@@ -2763,8 +2764,9 @@ spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) {
                     "Generic, CrossWorkgroup, Workgroup or Function";
         }
 
-        if (!_.IsFloatScalarType(p_data_type) ||
-            _.GetBitWidth(p_data_type) != 16) {
+        if ((!_.IsFloatScalarType(p_data_type) ||
+             _.GetBitWidth(p_data_type) != 16) &&
+            !_.ContainsUntypedPointer(p_type)) {
           return _.diag(SPV_ERROR_INVALID_DATA, inst)
                  << ext_inst_name() << ": "
                  << "expected operand P data type to be 16-bit float scalar";
@@ -2855,8 +2857,9 @@ spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) {
                     "CrossWorkgroup, Workgroup or Function";
         }
 
-        if (!_.IsFloatScalarType(p_data_type) ||
-            _.GetBitWidth(p_data_type) != 16) {
+        if ((!_.IsFloatScalarType(p_data_type) ||
+             _.GetBitWidth(p_data_type) != 16) &&
+            !_.ContainsUntypedPointer(p_type)) {
           return _.diag(SPV_ERROR_INVALID_DATA, inst)
                  << ext_inst_name() << ": "
                  << "expected operand P data type to be 16-bit float scalar";
@@ -2962,14 +2965,41 @@ spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) {
                  << "expected operand Format to be a pointer";
         }
 
-        if (format_storage_class != spv::StorageClass::UniformConstant) {
-          return _.diag(SPV_ERROR_INVALID_DATA, inst)
-                 << ext_inst_name() << ": "
-                 << "expected Format storage class to be UniformConstant";
+        if (_.HasExtension(
+                Extension::kSPV_EXT_relaxed_printf_string_address_space)) {
+          if (format_storage_class != spv::StorageClass::UniformConstant &&
+              // Extension SPV_EXT_relaxed_printf_string_address_space allows
+              // format strings in Global, Local, Private and Generic address
+              // spaces
+
+              // Global
+              format_storage_class != spv::StorageClass::CrossWorkgroup &&
+              // Local
+              format_storage_class != spv::StorageClass::Workgroup &&
+              // Private
+              format_storage_class != spv::StorageClass::Function &&
+              // Generic
+              format_storage_class != spv::StorageClass::Generic) {
+            return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                   << ext_inst_name() << ": "
+                   << "expected Format storage class to be UniformConstant, "
+                      "Crossworkgroup, Workgroup, Function, or Generic";
+          }
+        } else {
+          if (format_storage_class != spv::StorageClass::UniformConstant) {
+            return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                   << ext_inst_name() << ": "
+                   << "expected Format storage class to be UniformConstant";
+          }
         }
 
-        if (!_.IsIntScalarType(format_data_type) ||
-            _.GetBitWidth(format_data_type) != 8) {
+        // If pointer points to an array, get the type of an element
+        if (_.IsIntArrayType(format_data_type))
+          format_data_type = _.GetComponentType(format_data_type);
+
+        if ((!_.IsIntScalarType(format_data_type) ||
+             _.GetBitWidth(format_data_type) != 8) &&
+            !_.ContainsUntypedPointer(format_type)) {
           return _.diag(SPV_ERROR_INVALID_DATA, inst)
                  << ext_inst_name() << ": "
                  << "expected Format data type to be 8-bit int";
diff --git a/spirv-tools/source/val/validate_function.cpp b/spirv-tools/source/val/validate_function.cpp
index 639817f..26b3668 100644
--- a/spirv-tools/source/val/validate_function.cpp
+++ b/spirv-tools/source/val/validate_function.cpp
@@ -156,7 +156,9 @@ spv_result_t ValidateFunctionParameter(ValidationState_t& _,
     param_nonarray_type_id =
         _.FindDef(param_nonarray_type_id)->GetOperandAs<uint32_t>(1u);
   }
-  if (_.GetIdOpcode(param_nonarray_type_id) == spv::Op::OpTypePointer) {
+  if (_.GetIdOpcode(param_nonarray_type_id) == spv::Op::OpTypePointer ||
+      _.GetIdOpcode(param_nonarray_type_id) ==
+          spv::Op::OpTypeUntypedPointerKHR) {
     auto param_nonarray_type = _.FindDef(param_nonarray_type_id);
     if (param_nonarray_type->GetOperandAs<spv::StorageClass>(1u) ==
         spv::StorageClass::PhysicalStorageBuffer) {
@@ -185,7 +187,7 @@ spv_result_t ValidateFunctionParameter(ValidationState_t& _,
                << ": can't specify both Aliased and Restrict for "
                   "PhysicalStorageBuffer pointer.";
       }
-    } else {
+    } else if (param_nonarray_type->opcode() == spv::Op::OpTypePointer) {
       const auto pointee_type_id =
           param_nonarray_type->GetOperandAs<uint32_t>(2);
       const auto pointee_type = _.FindDef(pointee_type_id);
@@ -288,7 +290,8 @@ spv_result_t ValidateFunctionCall(ValidationState_t& _,
     }
 
     if (_.addressing_model() == spv::AddressingModel::Logical) {
-      if (parameter_type->opcode() == spv::Op::OpTypePointer &&
+      if ((parameter_type->opcode() == spv::Op::OpTypePointer ||
+           parameter_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) &&
           !_.options()->relax_logical_pointer) {
         spv::StorageClass sc =
             parameter_type->GetOperandAs<spv::StorageClass>(1u);
@@ -317,9 +320,11 @@ spv_result_t ValidateFunctionCall(ValidationState_t& _,
 
         // Validate memory object declaration requirements.
         if (argument->opcode() != spv::Op::OpVariable &&
+            argument->opcode() != spv::Op::OpUntypedVariableKHR &&
             argument->opcode() != spv::Op::OpFunctionParameter) {
-          const bool ssbo_vptr = _.features().variable_pointers &&
-                                 sc == spv::StorageClass::StorageBuffer;
+          const bool ssbo_vptr =
+              _.HasCapability(spv::Capability::VariablePointersStorageBuffer) &&
+              sc == spv::StorageClass::StorageBuffer;
           const bool wg_vptr =
               _.HasCapability(spv::Capability::VariablePointers) &&
               sc == spv::StorageClass::Workgroup;
diff --git a/spirv-tools/source/val/validate_id.cpp b/spirv-tools/source/val/validate_id.cpp
index 2351212..0d1e841 100644
--- a/spirv-tools/source/val/validate_id.cpp
+++ b/spirv-tools/source/val/validate_id.cpp
@@ -165,6 +165,8 @@ spv_result_t IdPass(ValidationState_t& _, Instruction* inst) {
               !spvOpcodeIsDecoration(opcode) && opcode != spv::Op::OpFunction &&
               opcode != spv::Op::OpCooperativeMatrixLengthNV &&
               opcode != spv::Op::OpCooperativeMatrixLengthKHR &&
+              !spvOpcodeGeneratesUntypedPointer(opcode) &&
+              opcode != spv::Op::OpUntypedArrayLengthKHR &&
               !(opcode == spv::Op::OpSpecConstantOp &&
                 (spv::Op(inst->word(3)) ==
                      spv::Op::OpCooperativeMatrixLengthNV ||
@@ -185,6 +187,8 @@ spv_result_t IdPass(ValidationState_t& _, Instruction* inst) {
                      opcode != spv::Op::OpFunction &&
                      opcode != spv::Op::OpCooperativeMatrixLengthNV &&
                      opcode != spv::Op::OpCooperativeMatrixLengthKHR &&
+                     !spvOpcodeGeneratesUntypedPointer(opcode) &&
+                     opcode != spv::Op::OpUntypedArrayLengthKHR &&
                      !(opcode == spv::Op::OpSpecConstantOp &&
                        (spv::Op(inst->word(3)) ==
                             spv::Op::OpCooperativeMatrixLengthNV ||
diff --git a/spirv-tools/source/val/validate_image.cpp b/spirv-tools/source/val/validate_image.cpp
index 9af97b7..e77fc12 100644
--- a/spirv-tools/source/val/validate_image.cpp
+++ b/spirv-tools/source/val/validate_image.cpp
@@ -1017,19 +1017,31 @@ spv_result_t ValidateSampledImage(ValidationState_t& _,
            << "Expected Image to be of type OpTypeImage.";
   }
 
-  if (type_inst->GetOperandAs<uint32_t>(1) != image_type) {
-    return _.diag(SPV_ERROR_INVALID_DATA, inst)
-           << "Expected Image to have the same type as Result Type Image";
-  }
-
   ImageTypeInfo info;
   if (!GetImageTypeInfo(_, image_type, &info)) {
     return _.diag(SPV_ERROR_INVALID_DATA, inst)
            << "Corrupt image type definition";
   }
 
-  // TODO(atgoo@github.com) Check compatibility of result type and received
-  // image.
+  // Image operands must match except for depth.
+  auto sampled_image_id = type_inst->GetOperandAs<uint32_t>(1);
+  if (sampled_image_id != image_type) {
+    ImageTypeInfo sampled_info;
+    if (!GetImageTypeInfo(_, sampled_image_id, &sampled_info)) {
+      return _.diag(SPV_ERROR_INVALID_DATA, inst)
+             << "Corrupt image type definition";
+    }
+    if (info.sampled_type != sampled_info.sampled_type ||
+        info.dim != sampled_info.dim || info.arrayed != sampled_info.arrayed ||
+        info.multisampled != sampled_info.multisampled ||
+        info.sampled != sampled_info.sampled ||
+        info.format != sampled_info.format ||
+        info.access_qualifier != sampled_info.access_qualifier) {
+      return _.diag(SPV_ERROR_INVALID_DATA, inst)
+             << "Image operands must match result image operands except for "
+                "depth";
+    }
+  }
 
   if (spvIsVulkanEnv(_.context()->target_env)) {
     if (info.sampled != 1) {
@@ -1121,7 +1133,8 @@ spv_result_t ValidateSampledImage(ValidationState_t& _,
 spv_result_t ValidateImageTexelPointer(ValidationState_t& _,
                                        const Instruction* inst) {
   const auto result_type = _.FindDef(inst->type_id());
-  if (result_type->opcode() != spv::Op::OpTypePointer) {
+  if (result_type->opcode() != spv::Op::OpTypePointer &&
+      result_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) {
     return _.diag(SPV_ERROR_INVALID_DATA, inst)
            << "Expected Result Type to be OpTypePointer";
   }
@@ -1133,16 +1146,20 @@ spv_result_t ValidateImageTexelPointer(ValidationState_t& _,
               "operand is Image";
   }
 
-  const auto ptr_type = result_type->GetOperandAs<uint32_t>(2);
-  const auto ptr_opcode = _.GetIdOpcode(ptr_type);
-  if (ptr_opcode != spv::Op::OpTypeInt && ptr_opcode != spv::Op::OpTypeFloat &&
-      ptr_opcode != spv::Op::OpTypeVoid &&
-      !(ptr_opcode == spv::Op::OpTypeVector &&
-        _.HasCapability(spv::Capability::AtomicFloat16VectorNV) &&
-        _.IsFloat16Vector2Or4Type(ptr_type))) {
-    return _.diag(SPV_ERROR_INVALID_DATA, inst)
-           << "Expected Result Type to be OpTypePointer whose Type operand "
-              "must be a scalar numerical type or OpTypeVoid";
+  uint32_t ptr_type = 0;
+  if (result_type->opcode() == spv::Op::OpTypePointer) {
+    ptr_type = result_type->GetOperandAs<uint32_t>(2);
+    const auto ptr_opcode = _.GetIdOpcode(ptr_type);
+    if (ptr_opcode != spv::Op::OpTypeInt &&
+        ptr_opcode != spv::Op::OpTypeFloat &&
+        ptr_opcode != spv::Op::OpTypeVoid &&
+        !(ptr_opcode == spv::Op::OpTypeVector &&
+          _.HasCapability(spv::Capability::AtomicFloat16VectorNV) &&
+          _.IsFloat16Vector2Or4Type(ptr_type))) {
+      return _.diag(SPV_ERROR_INVALID_DATA, inst)
+             << "Expected Result Type to be OpTypePointer whose Type operand "
+                "must be a scalar numerical type or OpTypeVoid";
+    }
   }
 
   const auto image_ptr = _.FindDef(_.GetOperandTypeId(inst, 2));
@@ -1163,7 +1180,8 @@ spv_result_t ValidateImageTexelPointer(ValidationState_t& _,
            << "Corrupt image type definition";
   }
 
-  if (info.sampled_type != ptr_type &&
+  if (result_type->opcode() == spv::Op::OpTypePointer &&
+      info.sampled_type != ptr_type &&
       !(_.HasCapability(spv::Capability::AtomicFloat16VectorNV) &&
         _.IsFloat16Vector2Or4Type(ptr_type) &&
         _.GetIdOpcode(info.sampled_type) == spv::Op::OpTypeFloat &&
diff --git a/spirv-tools/source/val/validate_interfaces.cpp b/spirv-tools/source/val/validate_interfaces.cpp
index 8f10b9d..8b96dc8 100644
--- a/spirv-tools/source/val/validate_interfaces.cpp
+++ b/spirv-tools/source/val/validate_interfaces.cpp
@@ -34,11 +34,13 @@ const uint32_t kMaxLocations = 4096 * 4;
 bool is_interface_variable(const Instruction* inst, bool is_spv_1_4) {
   if (is_spv_1_4) {
     // Starting in SPIR-V 1.4, all global variables are interface variables.
-    return inst->opcode() == spv::Op::OpVariable &&
+    return (inst->opcode() == spv::Op::OpVariable ||
+            inst->opcode() == spv::Op::OpUntypedVariableKHR) &&
            inst->GetOperandAs<spv::StorageClass>(2u) !=
                spv::StorageClass::Function;
   } else {
-    return inst->opcode() == spv::Op::OpVariable &&
+    return (inst->opcode() == spv::Op::OpVariable ||
+            inst->opcode() == spv::Op::OpUntypedVariableKHR) &&
            (inst->GetOperandAs<spv::StorageClass>(2u) ==
                 spv::StorageClass::Input ||
             inst->GetOperandAs<spv::StorageClass>(2u) ==
@@ -242,8 +244,9 @@ spv_result_t GetLocationsForVariable(
     std::unordered_set<uint32_t>* output_index1_locations) {
   const bool is_fragment = entry_point->GetOperandAs<spv::ExecutionModel>(0) ==
                            spv::ExecutionModel::Fragment;
-  const bool is_output =
-      variable->GetOperandAs<spv::StorageClass>(2) == spv::StorageClass::Output;
+  const auto sc_index = 2u;
+  const bool is_output = variable->GetOperandAs<spv::StorageClass>(sc_index) ==
+                         spv::StorageClass::Output;
   auto ptr_type_id = variable->GetOperandAs<uint32_t>(0);
   auto ptr_type = _.FindDef(ptr_type_id);
   auto type_id = ptr_type->GetOperandAs<uint32_t>(2);
@@ -525,7 +528,9 @@ spv_result_t ValidateLocations(ValidationState_t& _,
   for (uint32_t i = 3; i < entry_point->operands().size(); ++i) {
     auto interface_id = entry_point->GetOperandAs<uint32_t>(i);
     auto interface_var = _.FindDef(interface_id);
-    auto storage_class = interface_var->GetOperandAs<spv::StorageClass>(2);
+    const auto sc_index = 2u;
+    auto storage_class =
+        interface_var->GetOperandAs<spv::StorageClass>(sc_index);
     if (storage_class != spv::StorageClass::Input &&
         storage_class != spv::StorageClass::Output) {
       continue;
diff --git a/spirv-tools/source/val/validate_logicals.cpp b/spirv-tools/source/val/validate_logicals.cpp
index 4479e43..8a2e5d8 100644
--- a/spirv-tools/source/val/validate_logicals.cpp
+++ b/spirv-tools/source/val/validate_logicals.cpp
@@ -159,9 +159,11 @@ spv_result_t LogicalsPass(ValidationState_t& _, const Instruction* inst) {
 
         const spv::Op type_opcode = type_inst->opcode();
         switch (type_opcode) {
+          case spv::Op::OpTypeUntypedPointerKHR:
           case spv::Op::OpTypePointer: {
             if (_.addressing_model() == spv::AddressingModel::Logical &&
-                !_.features().variable_pointers)
+                !_.HasCapability(
+                    spv::Capability::VariablePointersStorageBuffer))
               return _.diag(SPV_ERROR_INVALID_DATA, inst)
                      << "Using pointers with OpSelect requires capability "
                      << "VariablePointers or VariablePointersStorageBuffer";
diff --git a/spirv-tools/source/val/validate_memory.cpp b/spirv-tools/source/val/validate_memory.cpp
index ef6676f..9bfa3c2 100644
--- a/spirv-tools/source/val/validate_memory.cpp
+++ b/spirv-tools/source/val/validate_memory.cpp
@@ -407,19 +407,58 @@ spv_result_t CheckMemoryAccess(ValidationState_t& _, const Instruction* inst,
 }
 
 spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
+  const bool untyped_pointer = inst->opcode() == spv::Op::OpUntypedVariableKHR;
+
   auto result_type = _.FindDef(inst->type_id());
-  if (!result_type || result_type->opcode() != spv::Op::OpTypePointer) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "OpVariable Result Type <id> " << _.getIdName(inst->type_id())
-           << " is not a pointer type.";
+  if (untyped_pointer) {
+    if (!result_type ||
+        result_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "Result type must be an untyped pointer";
+  } else {
+    if (!result_type || result_type->opcode() != spv::Op::OpTypePointer) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "OpVariable Result Type <id> " << _.getIdName(inst->type_id())
+             << " is not a pointer type.";
+    }
+  }
+
+  const auto storage_class_index = 2u;
+  auto storage_class =
+      inst->GetOperandAs<spv::StorageClass>(storage_class_index);
+  uint32_t value_id = 0;
+  if (untyped_pointer) {
+    const auto has_data_type = 3u < inst->operands().size();
+    if (has_data_type) {
+      value_id = inst->GetOperandAs<uint32_t>(3u);
+      auto data_type = _.FindDef(value_id);
+      if (!data_type || !spvOpcodeGeneratesType(data_type->opcode())) {
+        return _.diag(SPV_ERROR_INVALID_ID, inst)
+               << "Data type must be a type instruction";
+      }
+    } else {
+      if (storage_class == spv::StorageClass::Function ||
+          storage_class == spv::StorageClass::Private ||
+          storage_class == spv::StorageClass::Workgroup) {
+        return _.diag(SPV_ERROR_INVALID_ID, inst)
+               << "Data type must be specified for Function, Private, and "
+                  "Workgroup storage classes";
+      }
+      if (spvIsVulkanEnv(_.context()->target_env)) {
+        return _.diag(SPV_ERROR_INVALID_ID, inst)
+               << "Vulkan requires that data type be specified";
+      }
+    }
   }
 
-  const auto type_index = 2;
-  const auto value_id = result_type->GetOperandAs<uint32_t>(type_index);
-  auto value_type = _.FindDef(value_id);
+  // For OpVariable the data type comes from pointee type of the result type,
+  // while for OpUntypedVariableKHR the data type comes from the operand.
+  if (!untyped_pointer) {
+    value_id = result_type->GetOperandAs<uint32_t>(2);
+  }
+  auto value_type = value_id == 0 ? nullptr : _.FindDef(value_id);
 
-  const auto initializer_index = 3;
-  const auto storage_class_index = 2;
+  const auto initializer_index = untyped_pointer ? 4u : 3u;
   if (initializer_index < inst->operands().size()) {
     const auto initializer_id = inst->GetOperandAs<uint32_t>(initializer_index);
     const auto initializer = _.FindDef(initializer_id);
@@ -431,18 +470,15 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
         initializer && spvOpcodeIsConstant(initializer->opcode());
     if (!initializer || !(is_constant || is_module_scope_var)) {
       return _.diag(SPV_ERROR_INVALID_ID, inst)
-             << "OpVariable Initializer <id> " << _.getIdName(initializer_id)
+             << "Variable Initializer <id> " << _.getIdName(initializer_id)
              << " is not a constant or module-scope variable.";
     }
     if (initializer->type_id() != value_id) {
       return _.diag(SPV_ERROR_INVALID_ID, inst)
-             << "Initializer type must match the type pointed to by the Result "
-                "Type";
+             << "Initializer type must match the data type";
     }
   }
 
-  auto storage_class =
-      inst->GetOperandAs<spv::StorageClass>(storage_class_index);
   if (storage_class != spv::StorageClass::Workgroup &&
       storage_class != spv::StorageClass::CrossWorkgroup &&
       storage_class != spv::StorageClass::Private &&
@@ -466,7 +502,7 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
         }
       }
     }
-    if (!builtin &&
+    if (!builtin && value_type &&
         ContainsInvalidBool(_, value_type, storage_input_or_output)) {
       if (storage_input_or_output) {
         return _.diag(SPV_ERROR_INVALID_ID, inst)
@@ -495,7 +531,7 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
 
   if (storage_class == spv::StorageClass::Generic) {
     return _.diag(SPV_ERROR_INVALID_BINARY, inst)
-           << "OpVariable storage class cannot be Generic";
+           << "Variable storage class cannot be Generic";
   }
 
   if (inst->function() && storage_class != spv::StorageClass::Function) {
@@ -517,17 +553,17 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
       result_type->GetOperandAs<spv::StorageClass>(result_storage_class_index);
   if (storage_class != result_storage_class) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "From SPIR-V spec, section 3.32.8 on OpVariable:\n"
-           << "Its Storage Class operand must be the same as the Storage Class "
-           << "operand of the result type.";
+           << "Storage class must match result type storage class";
   }
 
   // Variable pointer related restrictions.
-  const auto pointee = _.FindDef(result_type->word(3));
+  const auto pointee = untyped_pointer
+                           ? value_id == 0 ? nullptr : _.FindDef(value_id)
+                           : _.FindDef(result_type->word(3));
   if (_.addressing_model() == spv::AddressingModel::Logical &&
       !_.options()->relax_logical_pointer) {
     // VariablePointersStorageBuffer is implied by VariablePointers.
-    if (pointee->opcode() == spv::Op::OpTypePointer) {
+    if (pointee && pointee->opcode() == spv::Op::OpTypePointer) {
       if (!_.HasCapability(spv::Capability::VariablePointersStorageBuffer)) {
         return _.diag(SPV_ERROR_INVALID_ID, inst)
                << "In Logical addressing, variables may not allocate a pointer "
@@ -546,7 +582,7 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
     // Vulkan Push Constant Interface section: Check type of PushConstant
     // variables.
     if (storage_class == spv::StorageClass::PushConstant) {
-      if (pointee->opcode() != spv::Op::OpTypeStruct) {
+      if (pointee && pointee->opcode() != spv::Op::OpTypeStruct) {
         return _.diag(SPV_ERROR_INVALID_ID, inst)
                << _.VkErrorID(6808) << "PushConstant OpVariable <id> "
                << _.getIdName(inst->id()) << " has illegal type.\n"
@@ -558,11 +594,11 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
     // Vulkan Descriptor Set Interface: Check type of UniformConstant and
     // Uniform variables.
     if (storage_class == spv::StorageClass::UniformConstant) {
-      if (!IsAllowedTypeOrArrayOfSame(
-              _, pointee,
-              {spv::Op::OpTypeImage, spv::Op::OpTypeSampler,
-               spv::Op::OpTypeSampledImage,
-               spv::Op::OpTypeAccelerationStructureKHR})) {
+      if (pointee && !IsAllowedTypeOrArrayOfSame(
+                         _, pointee,
+                         {spv::Op::OpTypeImage, spv::Op::OpTypeSampler,
+                          spv::Op::OpTypeSampledImage,
+                          spv::Op::OpTypeAccelerationStructureKHR})) {
         return _.diag(SPV_ERROR_INVALID_ID, inst)
                << _.VkErrorID(4655) << "UniformConstant OpVariable <id> "
                << _.getIdName(inst->id()) << " has illegal type.\n"
@@ -575,7 +611,8 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
     }
 
     if (storage_class == spv::StorageClass::Uniform) {
-      if (!IsAllowedTypeOrArrayOfSame(_, pointee, {spv::Op::OpTypeStruct})) {
+      if (pointee &&
+          !IsAllowedTypeOrArrayOfSame(_, pointee, {spv::Op::OpTypeStruct})) {
         return _.diag(SPV_ERROR_INVALID_ID, inst)
                << _.VkErrorID(6807) << "Uniform OpVariable <id> "
                << _.getIdName(inst->id()) << " has illegal type.\n"
@@ -588,7 +625,8 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
     }
 
     if (storage_class == spv::StorageClass::StorageBuffer) {
-      if (!IsAllowedTypeOrArrayOfSame(_, pointee, {spv::Op::OpTypeStruct})) {
+      if (pointee &&
+          !IsAllowedTypeOrArrayOfSame(_, pointee, {spv::Op::OpTypeStruct})) {
         return _.diag(SPV_ERROR_INVALID_ID, inst)
                << _.VkErrorID(6807) << "StorageBuffer OpVariable <id> "
                << _.getIdName(inst->id()) << " has illegal type.\n"
@@ -621,11 +659,17 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
         }
       }
     }
+  }
 
-    // Initializers in Vulkan are only allowed in some storage clases
-    if (inst->operands().size() > 3) {
+  // Vulkan Appendix A: Check that if contains initializer, then
+  // storage class is Output, Private, or Function.
+  if (inst->operands().size() > initializer_index &&
+      storage_class != spv::StorageClass::Output &&
+      storage_class != spv::StorageClass::Private &&
+      storage_class != spv::StorageClass::Function) {
+    if (spvIsVulkanEnv(_.context()->target_env)) {
       if (storage_class == spv::StorageClass::Workgroup) {
-        auto init_id = inst->GetOperandAs<uint32_t>(3);
+        auto init_id = inst->GetOperandAs<uint32_t>(initializer_index);
         auto init = _.FindDef(init_id);
         if (init->opcode() != spv::Op::OpConstantNull) {
           return _.diag(SPV_ERROR_INVALID_ID, inst)
@@ -652,7 +696,7 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
     }
   }
 
-  if (inst->operands().size() > 3) {
+  if (initializer_index < inst->operands().size()) {
     if (storage_class == spv::StorageClass::TaskPayloadWorkgroupEXT) {
       return _.diag(SPV_ERROR_INVALID_ID, inst)
              << "OpVariable, <id> " << _.getIdName(inst->id())
@@ -676,10 +720,10 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
   }
 
   auto pointee_base = pointee;
-  while (pointee_base->opcode() == spv::Op::OpTypeArray) {
+  while (pointee_base && pointee_base->opcode() == spv::Op::OpTypeArray) {
     pointee_base = _.FindDef(pointee_base->GetOperandAs<uint32_t>(1u));
   }
-  if (pointee_base->opcode() == spv::Op::OpTypePointer) {
+  if (pointee_base && pointee_base->opcode() == spv::Op::OpTypePointer) {
     if (pointee_base->GetOperandAs<spv::StorageClass>(1u) ==
         spv::StorageClass::PhysicalStorageBuffer) {
       // check for AliasedPointer/RestrictPointer
@@ -769,7 +813,7 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
   // Cooperative matrix types can only be allocated in Function or Private
   if ((storage_class != spv::StorageClass::Function &&
        storage_class != spv::StorageClass::Private) &&
-      ContainsCooperativeMatrix(_, pointee)) {
+      pointee && ContainsCooperativeMatrix(_, pointee)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "Cooperative matrix types (or types containing them) can only be "
               "allocated "
@@ -785,7 +829,8 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
         (!_.HasCapability(spv::Capability::Float16) &&
          _.ContainsSizedIntOrFloatType(value_id, spv::Op::OpTypeFloat, 16))) {
       auto underlying_type = value_type;
-      while (underlying_type->opcode() == spv::Op::OpTypePointer) {
+      while (underlying_type &&
+             underlying_type->opcode() == spv::Op::OpTypePointer) {
         storage_class = underlying_type->GetOperandAs<spv::StorageClass>(1u);
         underlying_type =
             _.FindDef(underlying_type->GetOperandAs<uint32_t>(2u));
@@ -801,7 +846,8 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
           }
           break;
         case spv::StorageClass::Uniform:
-          if (!_.HasCapability(
+          if (underlying_type &&
+              !_.HasCapability(
                   spv::Capability::UniformAndStorageBuffer16BitAccess)) {
             if (underlying_type->opcode() == spv::Op::OpTypeArray ||
                 underlying_type->opcode() == spv::Op::OpTypeRuntimeArray) {
@@ -849,7 +895,8 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
     if (!_.HasCapability(spv::Capability::Int8) &&
         _.ContainsSizedIntOrFloatType(value_id, spv::Op::OpTypeInt, 8)) {
       auto underlying_type = value_type;
-      while (underlying_type->opcode() == spv::Op::OpTypePointer) {
+      while (underlying_type &&
+             underlying_type->opcode() == spv::Op::OpTypePointer) {
         storage_class = underlying_type->GetOperandAs<spv::StorageClass>(1u);
         underlying_type =
             _.FindDef(underlying_type->GetOperandAs<uint32_t>(2u));
@@ -865,7 +912,8 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
           }
           break;
         case spv::StorageClass::Uniform:
-          if (!_.HasCapability(
+          if (underlying_type &&
+              !_.HasCapability(
                   spv::Capability::UniformAndStorageBuffer8BitAccess)) {
             if (underlying_type->opcode() == spv::Op::OpTypeArray ||
                 underlying_type->opcode() == spv::Op::OpTypeRuntimeArray) {
@@ -930,21 +978,23 @@ spv_result_t ValidateLoad(ValidationState_t& _, const Instruction* inst) {
   }
 
   const auto pointer_type = _.FindDef(pointer->type_id());
-  if (!pointer_type || pointer_type->opcode() != spv::Op::OpTypePointer) {
+  if (!pointer_type ||
+      (pointer_type->opcode() != spv::Op::OpTypePointer &&
+       pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "OpLoad type for pointer <id> " << _.getIdName(pointer_id)
            << " is not a pointer type.";
   }
 
-  uint32_t pointee_data_type;
-  spv::StorageClass storage_class;
-  if (!_.GetPointerTypeInfo(pointer_type->id(), &pointee_data_type,
-                            &storage_class) ||
-      result_type->id() != pointee_data_type) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "OpLoad Result Type <id> " << _.getIdName(inst->type_id())
-           << " does not match Pointer <id> " << _.getIdName(pointer->id())
-           << "s type.";
+  if (pointer_type->opcode() == spv::Op::OpTypePointer) {
+    const auto pointee_type =
+        _.FindDef(pointer_type->GetOperandAs<uint32_t>(2));
+    if (!pointee_type || result_type->id() != pointee_type->id()) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "OpLoad Result Type <id> " << _.getIdName(inst->type_id())
+             << " does not match Pointer <id> " << _.getIdName(pointer->id())
+             << "s type.";
+    }
   }
 
   if (!_.options()->before_hlsl_legalization &&
@@ -987,17 +1037,23 @@ spv_result_t ValidateStore(ValidationState_t& _, const Instruction* inst) {
            << " is not a logical pointer.";
   }
   const auto pointer_type = _.FindDef(pointer->type_id());
-  if (!pointer_type || pointer_type->opcode() != spv::Op::OpTypePointer) {
+  if (!pointer_type ||
+      (pointer_type->opcode() != spv::Op::OpTypePointer &&
+       pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "OpStore type for pointer <id> " << _.getIdName(pointer_id)
            << " is not a pointer type.";
   }
-  const auto type_id = pointer_type->GetOperandAs<uint32_t>(2);
-  const auto type = _.FindDef(type_id);
-  if (!type || spv::Op::OpTypeVoid == type->opcode()) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "OpStore Pointer <id> " << _.getIdName(pointer_id)
-           << "s type is void.";
+
+  Instruction* type = nullptr;
+  if (pointer_type->opcode() == spv::Op::OpTypePointer) {
+    const auto type_id = pointer_type->GetOperandAs<uint32_t>(2);
+    type = _.FindDef(type_id);
+    if (!type || spv::Op::OpTypeVoid == type->opcode()) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "OpStore Pointer <id> " << _.getIdName(pointer_id)
+             << "s type is void.";
+    }
   }
 
   // validate storage class
@@ -1074,7 +1130,7 @@ spv_result_t ValidateStore(ValidationState_t& _, const Instruction* inst) {
            << "s type is void.";
   }
 
-  if (type->id() != object_type->id()) {
+  if (type && (type->id() != object_type->id())) {
     if (!_.options()->relax_struct_store ||
         type->opcode() != spv::Op::OpTypeStruct ||
         object_type->opcode() != spv::Op::OpTypeStruct) {
@@ -1179,7 +1235,8 @@ spv_result_t ValidateCopyMemory(ValidationState_t& _, const Instruction* inst) {
 
   const auto target_pointer_type = _.FindDef(target->type_id());
   if (!target_pointer_type ||
-      target_pointer_type->opcode() != spv::Op::OpTypePointer) {
+      (target_pointer_type->opcode() != spv::Op::OpTypePointer &&
+       target_pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "Target operand <id> " << _.getIdName(target_id)
            << " is not a pointer.";
@@ -1187,35 +1244,52 @@ spv_result_t ValidateCopyMemory(ValidationState_t& _, const Instruction* inst) {
 
   const auto source_pointer_type = _.FindDef(source->type_id());
   if (!source_pointer_type ||
-      source_pointer_type->opcode() != spv::Op::OpTypePointer) {
+      (source_pointer_type->opcode() != spv::Op::OpTypePointer &&
+       source_pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "Source operand <id> " << _.getIdName(source_id)
            << " is not a pointer.";
   }
 
   if (inst->opcode() == spv::Op::OpCopyMemory) {
-    const auto target_type =
-        _.FindDef(target_pointer_type->GetOperandAs<uint32_t>(2));
-    if (!target_type || target_type->opcode() == spv::Op::OpTypeVoid) {
-      return _.diag(SPV_ERROR_INVALID_ID, inst)
-             << "Target operand <id> " << _.getIdName(target_id)
-             << " cannot be a void pointer.";
+    const bool target_typed =
+        target_pointer_type->opcode() == spv::Op::OpTypePointer;
+    const bool source_typed =
+        source_pointer_type->opcode() == spv::Op::OpTypePointer;
+    Instruction* target_type = nullptr;
+    Instruction* source_type = nullptr;
+    if (target_typed) {
+      target_type = _.FindDef(target_pointer_type->GetOperandAs<uint32_t>(2));
+
+      if (!target_type || target_type->opcode() == spv::Op::OpTypeVoid) {
+        return _.diag(SPV_ERROR_INVALID_ID, inst)
+               << "Target operand <id> " << _.getIdName(target_id)
+               << " cannot be a void pointer.";
+      }
     }
 
-    const auto source_type =
-        _.FindDef(source_pointer_type->GetOperandAs<uint32_t>(2));
-    if (!source_type || source_type->opcode() == spv::Op::OpTypeVoid) {
-      return _.diag(SPV_ERROR_INVALID_ID, inst)
-             << "Source operand <id> " << _.getIdName(source_id)
-             << " cannot be a void pointer.";
+    if (source_typed) {
+      source_type = _.FindDef(source_pointer_type->GetOperandAs<uint32_t>(2));
+      if (!source_type || source_type->opcode() == spv::Op::OpTypeVoid) {
+        return _.diag(SPV_ERROR_INVALID_ID, inst)
+               << "Source operand <id> " << _.getIdName(source_id)
+               << " cannot be a void pointer.";
+      }
     }
 
-    if (target_type->id() != source_type->id()) {
+    if (target_type && source_type && target_type->id() != source_type->id()) {
       return _.diag(SPV_ERROR_INVALID_ID, inst)
              << "Target <id> " << _.getIdName(source_id)
              << "s type does not match Source <id> "
              << _.getIdName(source_type->id()) << "s type.";
     }
+
+    if (!target_type && !source_type) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "One of Source or Target must be a typed pointer";
+    }
+
+    if (auto error = CheckMemoryAccess(_, inst, 2)) return error;
   } else {
     const auto size_id = inst->GetOperandAs<uint32_t>(2);
     const auto size = _.FindDef(size_id);
@@ -1231,7 +1305,6 @@ spv_result_t ValidateCopyMemory(ValidationState_t& _, const Instruction* inst) {
              << "Size operand <id> " << _.getIdName(size_id)
              << " must be a scalar integer type.";
     }
-
     bool is_zero = true;
     switch (size->opcode()) {
       case spv::Op::OpConstantNull:
@@ -1258,18 +1331,125 @@ spv_result_t ValidateCopyMemory(ValidationState_t& _, const Instruction* inst) {
         // Cannot infer any other opcodes.
         break;
     }
+
+    if (_.HasCapability(spv::Capability::Shader)) {
+      bool is_int = false;
+      bool is_const = false;
+      uint32_t value = 0;
+      std::tie(is_int, is_const, value) = _.EvalInt32IfConst(size_id);
+      if (is_const) {
+        if (value % 4 != 0) {
+          const auto source_sc =
+              source_pointer_type->GetOperandAs<spv::StorageClass>(1);
+          const auto target_sc =
+              target_pointer_type->GetOperandAs<spv::StorageClass>(1);
+          const bool int8 = _.HasCapability(spv::Capability::Int8);
+          const bool ubo_int8 = _.HasCapability(
+              spv::Capability::UniformAndStorageBuffer8BitAccess);
+          const bool ssbo_int8 =
+              _.HasCapability(spv::Capability::StorageBuffer8BitAccess) ||
+              ubo_int8;
+          const bool pc_int8 =
+              _.HasCapability(spv::Capability::StoragePushConstant8);
+          const bool wg_int8 = _.HasCapability(
+              spv::Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR);
+          const bool int16 = _.HasCapability(spv::Capability::Int16) || int8;
+          const bool ubo_int16 =
+              _.HasCapability(
+                  spv::Capability::UniformAndStorageBuffer16BitAccess) ||
+              ubo_int8;
+          const bool ssbo_int16 =
+              _.HasCapability(spv::Capability::StorageBuffer16BitAccess) ||
+              ubo_int16 || ssbo_int8;
+          const bool pc_int16 =
+              _.HasCapability(spv::Capability::StoragePushConstant16) ||
+              pc_int8;
+          const bool io_int16 =
+              _.HasCapability(spv::Capability::StorageInputOutput16);
+          const bool wg_int16 = _.HasCapability(
+              spv::Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR);
+
+          bool source_int16_match = false;
+          bool target_int16_match = false;
+          bool source_int8_match = false;
+          bool target_int8_match = false;
+          switch (source_sc) {
+            case spv::StorageClass::StorageBuffer:
+              source_int16_match = ssbo_int16;
+              source_int8_match = ssbo_int8;
+              break;
+            case spv::StorageClass::Uniform:
+              source_int16_match = ubo_int16;
+              source_int8_match = ubo_int8;
+              break;
+            case spv::StorageClass::PushConstant:
+              source_int16_match = pc_int16;
+              source_int8_match = pc_int8;
+              break;
+            case spv::StorageClass::Input:
+            case spv::StorageClass::Output:
+              source_int16_match = io_int16;
+              break;
+            case spv::StorageClass::Workgroup:
+              source_int16_match = wg_int16;
+              source_int8_match = wg_int8;
+              break;
+            default:
+              break;
+          }
+          switch (target_sc) {
+            case spv::StorageClass::StorageBuffer:
+              target_int16_match = ssbo_int16;
+              target_int8_match = ssbo_int8;
+              break;
+            case spv::StorageClass::Uniform:
+              target_int16_match = ubo_int16;
+              target_int8_match = ubo_int8;
+              break;
+            case spv::StorageClass::PushConstant:
+              target_int16_match = pc_int16;
+              target_int8_match = pc_int8;
+              break;
+            // Input is read-only so it cannot be the target pointer.
+            case spv::StorageClass::Output:
+              target_int16_match = io_int16;
+              break;
+            case spv::StorageClass::Workgroup:
+              target_int16_match = wg_int16;
+              target_int8_match = wg_int8;
+              break;
+            default:
+              break;
+          }
+          if (!int8 && !int16 && !(source_int16_match && target_int16_match)) {
+            return _.diag(SPV_ERROR_INVALID_ID, inst)
+                   << "Size must be a multiple of 4";
+          }
+          if (value % 2 != 0) {
+            if (!int8 && !(source_int8_match && target_int8_match)) {
+              return _.diag(SPV_ERROR_INVALID_ID, inst)
+                     << "Size must be a multiple of 2";
+            }
+          }
+        }
+      }
+    }
+
+    if (auto error = CheckMemoryAccess(_, inst, 3)) return error;
   }
   if (auto error = ValidateCopyMemoryMemoryAccess(_, inst)) return error;
 
   // Get past the pointers to avoid checking a pointer copy.
-  auto sub_type = _.FindDef(target_pointer_type->GetOperandAs<uint32_t>(2));
-  while (sub_type->opcode() == spv::Op::OpTypePointer) {
-    sub_type = _.FindDef(sub_type->GetOperandAs<uint32_t>(2));
-  }
-  if (_.HasCapability(spv::Capability::Shader) &&
-      _.ContainsLimitedUseIntOrFloatType(sub_type->id())) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "Cannot copy memory of objects containing 8- or 16-bit types";
+  if (target_pointer_type->opcode() == spv::Op::OpTypePointer) {
+    auto sub_type = _.FindDef(target_pointer_type->GetOperandAs<uint32_t>(2));
+    while (sub_type->opcode() == spv::Op::OpTypePointer) {
+      sub_type = _.FindDef(sub_type->GetOperandAs<uint32_t>(2));
+    }
+    if (_.HasCapability(spv::Capability::Shader) &&
+        _.ContainsLimitedUseIntOrFloatType(sub_type->id())) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "Cannot copy memory of objects containing 8- or 16-bit types";
+    }
   }
 
   return SPV_SUCCESS;
@@ -1280,27 +1460,50 @@ spv_result_t ValidateAccessChain(ValidationState_t& _,
   std::string instr_name =
       "Op" + std::string(spvOpcodeString(static_cast<spv::Op>(inst->opcode())));
 
-  // The result type must be OpTypePointer.
+  const bool untyped_pointer = spvOpcodeGeneratesUntypedPointer(inst->opcode());
+
+  // The result type must be OpTypePointer for regular access chains and an
+  // OpTypeUntypedPointerKHR for untyped access chains.
   auto result_type = _.FindDef(inst->type_id());
-  if (spv::Op::OpTypePointer != result_type->opcode()) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "The Result Type of " << instr_name << " <id> "
-           << _.getIdName(inst->id()) << " must be OpTypePointer. Found Op"
-           << spvOpcodeString(static_cast<spv::Op>(result_type->opcode()))
-           << ".";
+  if (untyped_pointer) {
+    if (!result_type ||
+        spv::Op::OpTypeUntypedPointerKHR != result_type->opcode()) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "The Result Type of " << instr_name << " <id> "
+             << _.getIdName(inst->id())
+             << " must be OpTypeUntypedPointerKHR. Found Op"
+             << spvOpcodeString(static_cast<spv::Op>(result_type->opcode()))
+             << ".";
+    }
+  } else {
+    if (!result_type || spv::Op::OpTypePointer != result_type->opcode()) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "The Result Type of " << instr_name << " <id> "
+             << _.getIdName(inst->id()) << " must be OpTypePointer. Found Op"
+             << spvOpcodeString(static_cast<spv::Op>(result_type->opcode()))
+             << ".";
+    }
   }
 
-  // Result type is a pointer. Find out what it's pointing to.
-  // This will be used to make sure the indexing results in the same type.
-  // OpTypePointer word 3 is the type being pointed to.
-  const auto result_type_pointee = _.FindDef(result_type->word(3));
+  if (untyped_pointer) {
+    // Base type must be a non-pointer type.
+    const auto base_type = _.FindDef(inst->GetOperandAs<uint32_t>(2));
+    if (!base_type || !spvOpcodeGeneratesType(base_type->opcode()) ||
+        base_type->opcode() == spv::Op::OpTypePointer ||
+        base_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "Base type must be a non-pointer type";
+    }
+  }
 
   // Base must be a pointer, pointing to the base of a composite object.
-  const auto base_index = 2;
+  const auto base_index = untyped_pointer ? 3 : 2;
   const auto base_id = inst->GetOperandAs<uint32_t>(base_index);
   const auto base = _.FindDef(base_id);
   const auto base_type = _.FindDef(base->type_id());
-  if (!base_type || spv::Op::OpTypePointer != base_type->opcode()) {
+  if (!base_type || !(spv::Op::OpTypePointer == base_type->opcode() ||
+                      (untyped_pointer && spv::Op::OpTypeUntypedPointerKHR ==
+                                              base_type->opcode()))) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "The Base <id> " << _.getIdName(base_id) << " in " << instr_name
            << " instruction must be a pointer.";
@@ -1318,14 +1521,18 @@ spv_result_t ValidateAccessChain(ValidationState_t& _,
   }
 
   // The type pointed to by OpTypePointer (word 3) must be a composite type.
-  auto type_pointee = _.FindDef(base_type->word(3));
+  auto type_pointee = untyped_pointer
+                          ? _.FindDef(inst->GetOperandAs<uint32_t>(2))
+                          : _.FindDef(base_type->word(3));
 
   // Check Universal Limit (SPIR-V Spec. Section 2.17).
   // The number of indexes passed to OpAccessChain may not exceed 255
   // The instruction includes 4 words + N words (for N indexes)
   size_t num_indexes = inst->words().size() - 4;
   if (inst->opcode() == spv::Op::OpPtrAccessChain ||
-      inst->opcode() == spv::Op::OpInBoundsPtrAccessChain) {
+      inst->opcode() == spv::Op::OpInBoundsPtrAccessChain ||
+      inst->opcode() == spv::Op::OpUntypedPtrAccessChainKHR ||
+      inst->opcode() == spv::Op::OpUntypedInBoundsPtrAccessChainKHR) {
     // In pointer access chains, the element operand is required, but not
     // counted as an index.
     --num_indexes;
@@ -1344,9 +1551,11 @@ spv_result_t ValidateAccessChain(ValidationState_t& _,
   // instruction. The second index will apply similarly to that result, and so
   // on. Once any non-composite type is reached, there must be no remaining
   // (unused) indexes.
-  auto starting_index = 4;
+  auto starting_index = untyped_pointer ? 5 : 4;
   if (inst->opcode() == spv::Op::OpPtrAccessChain ||
-      inst->opcode() == spv::Op::OpInBoundsPtrAccessChain) {
+      inst->opcode() == spv::Op::OpInBoundsPtrAccessChain ||
+      inst->opcode() == spv::Op::OpUntypedPtrAccessChainKHR ||
+      inst->opcode() == spv::Op::OpUntypedInBoundsPtrAccessChainKHR) {
     ++starting_index;
   }
   for (size_t i = starting_index; i < inst->words().size(); ++i) {
@@ -1411,18 +1620,25 @@ spv_result_t ValidateAccessChain(ValidationState_t& _,
       }
     }
   }
-  // At this point, we have fully walked down from the base using the indices.
-  // The type being pointed to should be the same as the result type.
-  if (type_pointee->id() != result_type_pointee->id()) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << instr_name << " result type (Op"
-           << spvOpcodeString(
-                  static_cast<spv::Op>(result_type_pointee->opcode()))
-           << ") does not match the type that results from indexing into the "
-              "base "
-              "<id> (Op"
-           << spvOpcodeString(static_cast<spv::Op>(type_pointee->opcode()))
-           << ").";
+
+  if (!untyped_pointer) {
+    // Result type is a pointer. Find out what it's pointing to.
+    // This will be used to make sure the indexing results in the same type.
+    // OpTypePointer word 3 is the type being pointed to.
+    const auto result_type_pointee = _.FindDef(result_type->word(3));
+    // At this point, we have fully walked down from the base using the indeces.
+    // The type being pointed to should be the same as the result type.
+    if (type_pointee->id() != result_type_pointee->id()) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << instr_name << " result type (Op"
+             << spvOpcodeString(
+                    static_cast<spv::Op>(result_type_pointee->opcode()))
+             << ") does not match the type that results from indexing into the "
+                "base "
+                "<id> (Op"
+             << spvOpcodeString(static_cast<spv::Op>(type_pointee->opcode()))
+             << ").";
+    }
   }
 
   return SPV_SUCCESS;
@@ -1550,7 +1766,8 @@ spv_result_t ValidateRawAccessChain(ValidationState_t& _,
 
 spv_result_t ValidatePtrAccessChain(ValidationState_t& _,
                                     const Instruction* inst) {
-  if (_.addressing_model() == spv::AddressingModel::Logical) {
+  if (_.addressing_model() == spv::AddressingModel::Logical &&
+      inst->opcode() == spv::Op::OpPtrAccessChain) {
     if (!_.features().variable_pointers) {
       return _.diag(SPV_ERROR_INVALID_DATA, inst)
              << "Generating variable pointers requires capability "
@@ -1561,9 +1778,13 @@ spv_result_t ValidatePtrAccessChain(ValidationState_t& _,
   // Need to call first, will make sure Base is a valid ID
   if (auto error = ValidateAccessChain(_, inst)) return error;
 
+  const bool untyped_pointer = spvOpcodeGeneratesUntypedPointer(inst->opcode());
+
   const auto base_id = inst->GetOperandAs<uint32_t>(2);
   const auto base = _.FindDef(base_id);
-  const auto base_type = _.FindDef(base->type_id());
+  const auto base_type = untyped_pointer
+                             ? _.FindDef(inst->GetOperandAs<uint32_t>(2))
+                             : _.FindDef(base->type_id());
   const auto base_type_storage_class =
       base_type->GetOperandAs<spv::StorageClass>(1);
 
@@ -1581,15 +1802,17 @@ spv_result_t ValidatePtrAccessChain(ValidationState_t& _,
   }
 
   if (spvIsVulkanEnv(_.context()->target_env)) {
+    const auto untyped_cap =
+        untyped_pointer && _.HasCapability(spv::Capability::UntypedPointersKHR);
     if (base_type_storage_class == spv::StorageClass::Workgroup) {
-      if (!_.HasCapability(spv::Capability::VariablePointers)) {
+      if (!_.HasCapability(spv::Capability::VariablePointers) && !untyped_cap) {
         return _.diag(SPV_ERROR_INVALID_DATA, inst)
                << _.VkErrorID(7651)
                << "OpPtrAccessChain Base operand pointing to Workgroup "
                   "storage class must use VariablePointers capability";
       }
     } else if (base_type_storage_class == spv::StorageClass::StorageBuffer) {
-      if (!_.features().variable_pointers) {
+      if (!_.features().variable_pointers && !untyped_cap) {
         return _.diag(SPV_ERROR_INVALID_DATA, inst)
                << _.VkErrorID(7652)
                << "OpPtrAccessChain Base operand pointing to StorageBuffer "
@@ -1597,7 +1820,8 @@ spv_result_t ValidatePtrAccessChain(ValidationState_t& _,
                   "VariablePointersStorageBuffer capability";
       }
     } else if (base_type_storage_class !=
-               spv::StorageClass::PhysicalStorageBuffer) {
+                   spv::StorageClass::PhysicalStorageBuffer &&
+               !untyped_cap) {
       return _.diag(SPV_ERROR_INVALID_DATA, inst)
              << _.VkErrorID(7650)
              << "OpPtrAccessChain Base operand must point to Workgroup, "
@@ -1624,18 +1848,28 @@ spv_result_t ValidateArrayLength(ValidationState_t& state,
            << " must be OpTypeInt with width 32 and signedness 0.";
   }
 
-  // The structure that is passed in must be an pointer to a structure, whose
-  // last element is a runtime array.
-  auto pointer = state.FindDef(inst->GetOperandAs<uint32_t>(2));
-  auto pointer_type = state.FindDef(pointer->type_id());
-  if (pointer_type->opcode() != spv::Op::OpTypePointer) {
+  const bool untyped = inst->opcode() == spv::Op::OpUntypedArrayLengthKHR;
+  auto pointer_ty_id = state.GetOperandTypeId(inst, (untyped ? 3 : 2));
+  auto pointer_ty = state.FindDef(pointer_ty_id);
+  if (untyped) {
+    if (pointer_ty->opcode() != spv::Op::OpTypeUntypedPointerKHR) {
+      return state.diag(SPV_ERROR_INVALID_ID, inst)
+             << "Pointer must be an untyped pointer";
+    }
+  } else if (pointer_ty->opcode() != spv::Op::OpTypePointer) {
     return state.diag(SPV_ERROR_INVALID_ID, inst)
            << "The Structure's type in " << instr_name << " <id> "
            << state.getIdName(inst->id())
            << " must be a pointer to an OpTypeStruct.";
   }
 
-  auto structure_type = state.FindDef(pointer_type->GetOperandAs<uint32_t>(2));
+  Instruction* structure_type = nullptr;
+  if (untyped) {
+    structure_type = state.FindDef(inst->GetOperandAs<uint32_t>(2));
+  } else {
+    structure_type = state.FindDef(pointer_ty->GetOperandAs<uint32_t>(2));
+  }
+
   if (structure_type->opcode() != spv::Op::OpTypeStruct) {
     return state.diag(SPV_ERROR_INVALID_ID, inst)
            << "The Structure's type in " << instr_name << " <id> "
@@ -1654,11 +1888,12 @@ spv_result_t ValidateArrayLength(ValidationState_t& state,
 
   // The array member must the index of the last element (the run time
   // array).
-  if (inst->GetOperandAs<uint32_t>(3) != num_of_members - 1) {
+  const auto index = untyped ? 4 : 3;
+  if (inst->GetOperandAs<uint32_t>(index) != num_of_members - 1) {
     return state.diag(SPV_ERROR_INVALID_ID, inst)
            << "The array member in " << instr_name << " <id> "
            << state.getIdName(inst->id())
-           << " must be an the last member of the struct.";
+           << " must be the last member of the struct.";
   }
   return SPV_SUCCESS;
 }
@@ -1843,12 +2078,16 @@ spv_result_t ValidateCooperativeMatrixLoadStoreKHR(ValidationState_t& _,
 
   const auto pointer_type_id = pointer->type_id();
   const auto pointer_type = _.FindDef(pointer_type_id);
-  if (!pointer_type || pointer_type->opcode() != spv::Op::OpTypePointer) {
+  if (!pointer_type ||
+      !(pointer_type->opcode() == spv::Op::OpTypePointer ||
+        pointer_type->opcode() == spv::Op::OpTypeUntypedPointerKHR)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << opname << " type for pointer <id> " << _.getIdName(pointer_id)
            << " is not a pointer type.";
   }
 
+  const bool untyped =
+      pointer_type->opcode() == spv::Op::OpTypeUntypedPointerKHR;
   const auto storage_class_index = 1u;
   const auto storage_class =
       pointer_type->GetOperandAs<spv::StorageClass>(storage_class_index);
@@ -1863,27 +2102,36 @@ spv_result_t ValidateCooperativeMatrixLoadStoreKHR(ValidationState_t& _,
            << " is not Workgroup, StorageBuffer, or PhysicalStorageBuffer.";
   }
 
-  const auto pointee_id = pointer_type->GetOperandAs<uint32_t>(2);
-  const auto pointee_type = _.FindDef(pointee_id);
-  if (!pointee_type || !(_.IsIntScalarOrVectorType(pointee_id) ||
-                         _.IsFloatScalarOrVectorType(pointee_id))) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << opname << " Pointer <id> " << _.getIdName(pointer->id())
-           << "s Type must be a scalar or vector type.";
+  if (!untyped) {
+    const auto pointee_id = pointer_type->GetOperandAs<uint32_t>(2);
+    const auto pointee_type = _.FindDef(pointee_id);
+    if (!pointee_type || !(_.IsIntScalarOrVectorType(pointee_id) ||
+                           _.IsFloatScalarOrVectorType(pointee_id))) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << opname << " Pointer <id> " << _.getIdName(pointer->id())
+             << "s Type must be a scalar or vector type.";
+    }
   }
 
   const auto layout_index =
       (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) ? 3u : 2u;
-  const auto colmajor_id = inst->GetOperandAs<uint32_t>(layout_index);
-  const auto colmajor = _.FindDef(colmajor_id);
-  if (!colmajor || !_.IsIntScalarType(colmajor->type_id()) ||
-      !(spvOpcodeIsConstant(colmajor->opcode()) ||
-        spvOpcodeIsSpecConstant(colmajor->opcode()))) {
+  const auto layout_id = inst->GetOperandAs<uint32_t>(layout_index);
+  const auto layout_inst = _.FindDef(layout_id);
+  if (!layout_inst || !_.IsIntScalarType(layout_inst->type_id()) ||
+      !spvOpcodeIsConstant(layout_inst->opcode())) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "MemoryLayout operand <id> " << _.getIdName(colmajor_id)
+           << "MemoryLayout operand <id> " << _.getIdName(layout_id)
            << " must be a 32-bit integer constant instruction.";
   }
 
+  bool stride_required = false;
+  uint64_t layout;
+  if (_.EvalConstantValUint64(layout_id, &layout)) {
+    stride_required =
+        (layout == (uint64_t)spv::CooperativeMatrixLayout::RowMajorKHR) ||
+        (layout == (uint64_t)spv::CooperativeMatrixLayout::ColumnMajorKHR);
+  }
+
   const auto stride_index =
       (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) ? 4u : 3u;
   if (inst->operands().size() > stride_index) {
@@ -1894,6 +2142,9 @@ spv_result_t ValidateCooperativeMatrixLoadStoreKHR(ValidationState_t& _,
              << "Stride operand <id> " << _.getIdName(stride_id)
              << " must be a scalar integer type.";
     }
+  } else if (stride_required) {
+    return _.diag(SPV_ERROR_INVALID_ID, inst)
+           << "MemoryLayout " << layout << " requires a Stride.";
   }
 
   const auto memory_access_index =
@@ -1935,7 +2186,8 @@ spv_result_t ValidatePtrComparison(ValidationState_t& _,
            << "The types of Operand 1 and Operand 2 must match";
   }
   const auto op1_type = _.FindDef(op1->type_id());
-  if (!op1_type || op1_type->opcode() != spv::Op::OpTypePointer) {
+  if (!op1_type || (op1_type->opcode() != spv::Op::OpTypePointer &&
+                    op1_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "Operand type must be a pointer";
   }
@@ -1967,6 +2219,7 @@ spv_result_t ValidatePtrComparison(ValidationState_t& _,
 spv_result_t MemoryPass(ValidationState_t& _, const Instruction* inst) {
   switch (inst->opcode()) {
     case spv::Op::OpVariable:
+    case spv::Op::OpUntypedVariableKHR:
       if (auto error = ValidateVariable(_, inst)) return error;
       break;
     case spv::Op::OpLoad:
@@ -1980,17 +2233,22 @@ spv_result_t MemoryPass(ValidationState_t& _, const Instruction* inst) {
       if (auto error = ValidateCopyMemory(_, inst)) return error;
       break;
     case spv::Op::OpPtrAccessChain:
+    case spv::Op::OpUntypedPtrAccessChainKHR:
+    case spv::Op::OpUntypedInBoundsPtrAccessChainKHR:
       if (auto error = ValidatePtrAccessChain(_, inst)) return error;
       break;
     case spv::Op::OpAccessChain:
     case spv::Op::OpInBoundsAccessChain:
     case spv::Op::OpInBoundsPtrAccessChain:
+    case spv::Op::OpUntypedAccessChainKHR:
+    case spv::Op::OpUntypedInBoundsAccessChainKHR:
       if (auto error = ValidateAccessChain(_, inst)) return error;
       break;
     case spv::Op::OpRawAccessChainNV:
       if (auto error = ValidateRawAccessChain(_, inst)) return error;
       break;
     case spv::Op::OpArrayLength:
+    case spv::Op::OpUntypedArrayLengthKHR:
       if (auto error = ValidateArrayLength(_, inst)) return error;
       break;
     case spv::Op::OpCooperativeMatrixLoadNV:
diff --git a/spirv-tools/source/val/validate_type.cpp b/spirv-tools/source/val/validate_type.cpp
index cb26a52..32024b7 100644
--- a/spirv-tools/source/val/validate_type.cpp
+++ b/spirv-tools/source/val/validate_type.cpp
@@ -36,6 +36,7 @@ spv_result_t ValidateUniqueness(ValidationState_t& _, const Instruction* inst) {
   const auto opcode = inst->opcode();
   if (opcode != spv::Op::OpTypeArray && opcode != spv::Op::OpTypeRuntimeArray &&
       opcode != spv::Op::OpTypeStruct && opcode != spv::Op::OpTypePointer &&
+      opcode != spv::Op::OpTypeUntypedPointerKHR &&
       !_.RegisterUniqueTypeDeclaration(inst)) {
     return _.diag(SPV_ERROR_INVALID_DATA, inst)
            << "Duplicate non-aggregate type declarations are not allowed. "
@@ -583,6 +584,33 @@ spv_result_t ValidateTypeCooperativeMatrix(ValidationState_t& _,
 
   return SPV_SUCCESS;
 }
+
+spv_result_t ValidateTypeUntypedPointerKHR(ValidationState_t& _,
+                                           const Instruction* inst) {
+  if (spvIsVulkanEnv(_.context()->target_env)) {
+    const auto sc = inst->GetOperandAs<spv::StorageClass>(1);
+    switch (sc) {
+      case spv::StorageClass::Workgroup:
+        if (!_.HasCapability(
+                spv::Capability::WorkgroupMemoryExplicitLayoutKHR)) {
+          return _.diag(SPV_ERROR_INVALID_ID, inst)
+                 << "Workgroup storage class untyped pointers in Vulkan "
+                    "require WorkgroupMemoryExplicitLayoutKHR be declared";
+        }
+        break;
+      case spv::StorageClass::StorageBuffer:
+      case spv::StorageClass::PhysicalStorageBuffer:
+      case spv::StorageClass::Uniform:
+      case spv::StorageClass::PushConstant:
+        break;
+      default:
+        return _.diag(SPV_ERROR_INVALID_ID, inst)
+               << "In Vulkan, untyped pointers can only be used in an "
+                  "explicitly laid out storage class";
+    }
+  }
+  return SPV_SUCCESS;
+}
 }  // namespace
 
 spv_result_t TypePass(ValidationState_t& _, const Instruction* inst) {
@@ -628,6 +656,9 @@ spv_result_t TypePass(ValidationState_t& _, const Instruction* inst) {
     case spv::Op::OpTypeCooperativeMatrixKHR:
       if (auto error = ValidateTypeCooperativeMatrix(_, inst)) return error;
       break;
+    case spv::Op::OpTypeUntypedPointerKHR:
+      if (auto error = ValidateTypeUntypedPointerKHR(_, inst)) return error;
+      break;
     default:
       break;
   }
diff --git a/spirv-tools/source/val/validation_state.cpp b/spirv-tools/source/val/validation_state.cpp
index b5ed65f..6f42531 100644
--- a/spirv-tools/source/val/validation_state.cpp
+++ b/spirv-tools/source/val/validation_state.cpp
@@ -73,6 +73,7 @@ ModuleLayoutSection InstructionLayoutSection(
     case spv::Op::OpTypeForwardPointer:
       return kLayoutTypes;
     case spv::Op::OpVariable:
+    case spv::Op::OpUntypedVariableKHR:
       if (current_section == kLayoutTypes) return kLayoutTypes;
       return kLayoutFunctionDefinitions;
     case spv::Op::OpExtInst:
@@ -869,6 +870,9 @@ uint32_t ValidationState_t::GetComponentType(uint32_t id) const {
     case spv::Op::OpTypeBool:
       return id;
 
+    case spv::Op::OpTypeArray:
+      return inst->word(2);
+
     case spv::Op::OpTypeVector:
       return inst->word(2);
 
@@ -992,6 +996,19 @@ bool ValidationState_t::IsIntScalarType(uint32_t id) const {
   return inst && inst->opcode() == spv::Op::OpTypeInt;
 }
 
+bool ValidationState_t::IsIntArrayType(uint32_t id) const {
+  const Instruction* inst = FindDef(id);
+  if (!inst) {
+    return false;
+  }
+
+  if (inst->opcode() == spv::Op::OpTypeArray) {
+    return IsIntScalarType(GetComponentType(id));
+  }
+
+  return false;
+}
+
 bool ValidationState_t::IsIntVectorType(uint32_t id) const {
   const Instruction* inst = FindDef(id);
   if (!inst) {
@@ -1169,7 +1186,9 @@ bool ValidationState_t::GetStructMemberTypes(
 
 bool ValidationState_t::IsPointerType(uint32_t id) const {
   const Instruction* inst = FindDef(id);
-  return inst && inst->opcode() == spv::Op::OpTypePointer;
+  assert(inst);
+  return inst->opcode() == spv::Op::OpTypePointer ||
+         inst->opcode() == spv::Op::OpTypeUntypedPointerKHR;
 }
 
 bool ValidationState_t::GetPointerTypeInfo(
@@ -1179,6 +1198,12 @@ bool ValidationState_t::GetPointerTypeInfo(
 
   const Instruction* inst = FindDef(id);
   assert(inst);
+  if (inst->opcode() == spv::Op::OpTypeUntypedPointerKHR) {
+    *storage_class = spv::StorageClass(inst->word(2));
+    *data_type = 0;
+    return true;
+  }
+
   if (inst->opcode() != spv::Op::OpTypePointer) return false;
 
   *storage_class = spv::StorageClass(inst->word(2));
@@ -1689,6 +1714,39 @@ bool ValidationState_t::ContainsRuntimeArray(uint32_t id) const {
   return ContainsType(id, f, /* traverse_all_types = */ false);
 }
 
+bool ValidationState_t::ContainsUntypedPointer(uint32_t id) const {
+  const auto inst = FindDef(id);
+  if (!inst) return false;
+  if (!spvOpcodeGeneratesType(inst->opcode())) return false;
+  if (inst->opcode() == spv::Op::OpTypeUntypedPointerKHR) return true;
+
+  switch (inst->opcode()) {
+    case spv::Op::OpTypeArray:
+    case spv::Op::OpTypeRuntimeArray:
+    case spv::Op::OpTypeVector:
+    case spv::Op::OpTypeMatrix:
+    case spv::Op::OpTypeImage:
+    case spv::Op::OpTypeSampledImage:
+    case spv::Op::OpTypeCooperativeMatrixNV:
+      return ContainsUntypedPointer(inst->GetOperandAs<uint32_t>(1u));
+    case spv::Op::OpTypePointer:
+      if (IsForwardPointer(id)) return false;
+      return ContainsUntypedPointer(inst->GetOperandAs<uint32_t>(2u));
+    case spv::Op::OpTypeFunction:
+    case spv::Op::OpTypeStruct: {
+      for (uint32_t i = 1; i < inst->operands().size(); ++i) {
+        if (ContainsUntypedPointer(inst->GetOperandAs<uint32_t>(i)))
+          return true;
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+
+  return false;
+}
+
 bool ValidationState_t::IsValidStorageClass(
     spv::StorageClass storage_class) const {
   if (spvIsVulkanEnv(context()->target_env)) {
diff --git a/spirv-tools/source/val/validation_state.h b/spirv-tools/source/val/validation_state.h
index 27acdcc..372b5b7 100644
--- a/spirv-tools/source/val/validation_state.h
+++ b/spirv-tools/source/val/validation_state.h
@@ -606,6 +606,7 @@ class ValidationState_t {
   bool IsFloatScalarOrVectorType(uint32_t id) const;
   bool IsFloatMatrixType(uint32_t id) const;
   bool IsIntScalarType(uint32_t id) const;
+  bool IsIntArrayType(uint32_t id) const;
   bool IsIntVectorType(uint32_t id) const;
   bool IsIntScalarOrVectorType(uint32_t id) const;
   bool IsUnsignedIntScalarType(uint32_t id) const;
@@ -648,6 +649,9 @@ class ValidationState_t {
                     const std::function<bool(const Instruction*)>& f,
                     bool traverse_all_types = true) const;
 
+  // Returns true if |id| is type id that contains an untyped pointer.
+  bool ContainsUntypedPointer(uint32_t id) const;
+
   // Returns type_id if id has type or zero otherwise.
   uint32_t GetTypeId(uint32_t id) const;
 
diff --git a/spirv-tools/spirv-tools/build-version.inc b/spirv-tools/spirv-tools/build-version.inc
index 7c0a6f7..95ca29f 100644
--- a/spirv-tools/spirv-tools/build-version.inc
+++ b/spirv-tools/spirv-tools/build-version.inc
@@ -1 +1 @@
-"v2024.3", "SPIRV-Tools v2024.3 v2024.3-0-g0cfe9e7"
+"v2024.4", "SPIRV-Tools v2024.4 v2024.4.rc1-0-g6dcc7e3"
diff --git a/spirv-tools/spirv-tools/core.insts-unified1.inc b/spirv-tools/spirv-tools/core.insts-unified1.inc
index 5550ea5..522ac17 100644
--- a/spirv-tools/spirv-tools/core.insts-unified1.inc
+++ b/spirv-tools/spirv-tools/core.insts-unified1.inc
@@ -1,5 +1,6 @@
 static const spv::Capability pygen_variable_caps_Addresses[] = {spv::Capability::Addresses};
 static const spv::Capability pygen_variable_caps_AddressesPhysicalStorageBufferAddresses[] = {spv::Capability::Addresses, spv::Capability::PhysicalStorageBufferAddresses};
+static const spv::Capability pygen_variable_caps_AddressesUntypedPointersKHR[] = {spv::Capability::Addresses, spv::Capability::UntypedPointersKHR};
 static const spv::Capability pygen_variable_caps_AddressesVariablePointersVariablePointersStorageBuffer[] = {spv::Capability::Addresses, spv::Capability::VariablePointers, spv::Capability::VariablePointersStorageBuffer};
 static const spv::Capability pygen_variable_caps_AddressesVariablePointersVariablePointersStorageBufferPhysicalStorageBufferAddresses[] = {spv::Capability::Addresses, spv::Capability::VariablePointers, spv::Capability::VariablePointersStorageBuffer, spv::Capability::PhysicalStorageBufferAddresses};
 static const spv::Capability pygen_variable_caps_ArbitraryPrecisionFixedPointINTEL[] = {spv::Capability::ArbitraryPrecisionFixedPointINTEL};
@@ -76,6 +77,7 @@ static const spv::Capability pygen_variable_caps_SubgroupAvcMotionEstimationINTE
 static const spv::Capability pygen_variable_caps_SubgroupAvcMotionEstimationINTELSubgroupAvcMotionEstimationIntraINTEL[] = {spv::Capability::SubgroupAvcMotionEstimationINTEL, spv::Capability::SubgroupAvcMotionEstimationIntraINTEL};
 static const spv::Capability pygen_variable_caps_SubgroupBallotKHR[] = {spv::Capability::SubgroupBallotKHR};
 static const spv::Capability pygen_variable_caps_SubgroupBufferBlockIOINTEL[] = {spv::Capability::SubgroupBufferBlockIOINTEL};
+static const spv::Capability pygen_variable_caps_SubgroupBufferPrefetchINTEL[] = {spv::Capability::SubgroupBufferPrefetchINTEL};
 static const spv::Capability pygen_variable_caps_SubgroupDispatch[] = {spv::Capability::SubgroupDispatch};
 static const spv::Capability pygen_variable_caps_SubgroupImageBlockIOINTEL[] = {spv::Capability::SubgroupImageBlockIOINTEL};
 static const spv::Capability pygen_variable_caps_SubgroupImageMediaBlockIOINTEL[] = {spv::Capability::SubgroupImageMediaBlockIOINTEL};
@@ -90,6 +92,7 @@ static const spv::Capability pygen_variable_caps_TileImageDepthReadAccessEXT[] =
 static const spv::Capability pygen_variable_caps_TileImageStencilReadAccessEXT[] = {spv::Capability::TileImageStencilReadAccessEXT};
 static const spv::Capability pygen_variable_caps_USMStorageClassesINTEL[] = {spv::Capability::USMStorageClassesINTEL};
 static const spv::Capability pygen_variable_caps_UnstructuredLoopControlsINTEL[] = {spv::Capability::UnstructuredLoopControlsINTEL};
+static const spv::Capability pygen_variable_caps_UntypedPointersKHR[] = {spv::Capability::UntypedPointersKHR};
 static const spv::Capability pygen_variable_caps_VariableLengthArrayINTEL[] = {spv::Capability::VariableLengthArrayINTEL};
 static const spv::Capability pygen_variable_caps_VectorComputeINTEL[] = {spv::Capability::VectorComputeINTEL};
 
@@ -143,7 +146,7 @@ static const spv_opcode_desc_t kOpcodeTableEntries[] = {
   {"TypeVoid", spv::Op::OpTypeVoid, 0, nullptr, 1, {SPV_OPERAND_TYPE_RESULT_ID}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"TypeBool", spv::Op::OpTypeBool, 0, nullptr, 1, {SPV_OPERAND_TYPE_RESULT_ID}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"TypeInt", spv::Op::OpTypeInt, 0, nullptr, 3, {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
-  {"TypeFloat", spv::Op::OpTypeFloat, 0, nullptr, 2, {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_LITERAL_INTEGER}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
+  {"TypeFloat", spv::Op::OpTypeFloat, 0, nullptr, 3, {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_OPTIONAL_FPENCODING}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"TypeVector", spv::Op::OpTypeVector, 0, nullptr, 3, {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_LITERAL_INTEGER}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"TypeMatrix", spv::Op::OpTypeMatrix, 1, pygen_variable_caps_Matrix, 3, {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_LITERAL_INTEGER}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"TypeImage", spv::Op::OpTypeImage, 0, nullptr, 9, {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_DIMENSIONALITY, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT, SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER}, 1, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
@@ -181,7 +184,7 @@ static const spv_opcode_desc_t kOpcodeTableEntries[] = {
   {"Load", spv::Op::OpLoad, 0, nullptr, 4, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS}, 1, 1, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"Store", spv::Op::OpStore, 0, nullptr, 3, {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS}, 0, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"CopyMemory", spv::Op::OpCopyMemory, 0, nullptr, 4, {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS}, 0, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
-  {"CopyMemorySized", spv::Op::OpCopyMemorySized, 1, pygen_variable_caps_Addresses, 5, {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS}, 0, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
+  {"CopyMemorySized", spv::Op::OpCopyMemorySized, 2, pygen_variable_caps_AddressesUntypedPointersKHR, 5, {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS}, 0, 0, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"AccessChain", spv::Op::OpAccessChain, 0, nullptr, 4, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}, 1, 1, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"InBoundsAccessChain", spv::Op::OpInBoundsAccessChain, 0, nullptr, 4, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}, 1, 1, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"PtrAccessChain", spv::Op::OpPtrAccessChain, 4, pygen_variable_caps_AddressesVariablePointersVariablePointersStorageBufferPhysicalStorageBufferAddresses, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}, 1, 1, 0, nullptr, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
@@ -472,8 +475,16 @@ static const spv_opcode_desc_t kOpcodeTableEntries[] = {
   {"DepthAttachmentReadEXT", spv::Op::OpDepthAttachmentReadEXT, 1, pygen_variable_caps_TileImageDepthReadAccessEXT, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"StencilAttachmentReadEXT", spv::Op::OpStencilAttachmentReadEXT, 1, pygen_variable_caps_TileImageStencilReadAccessEXT, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"TerminateInvocation", spv::Op::OpTerminateInvocation, 1, pygen_variable_caps_Shader, 0, {}, 0, 0, 1, pygen_variable_exts_SPV_KHR_terminate_invocation, SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu},
+  {"TypeUntypedPointerKHR", spv::Op::OpTypeUntypedPointerKHR, 1, pygen_variable_caps_UntypedPointersKHR, 2, {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_STORAGE_CLASS}, 1, 0, 0, nullptr, 0xffffffffu, 0xffffffffu},
+  {"UntypedVariableKHR", spv::Op::OpUntypedVariableKHR, 1, pygen_variable_caps_UntypedPointersKHR, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_STORAGE_CLASS, SPV_OPERAND_TYPE_OPTIONAL_ID, SPV_OPERAND_TYPE_OPTIONAL_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
+  {"UntypedAccessChainKHR", spv::Op::OpUntypedAccessChainKHR, 1, pygen_variable_caps_UntypedPointersKHR, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
+  {"UntypedInBoundsAccessChainKHR", spv::Op::OpUntypedInBoundsAccessChainKHR, 1, pygen_variable_caps_UntypedPointersKHR, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"SubgroupBallotKHR", spv::Op::OpSubgroupBallotKHR, 1, pygen_variable_caps_SubgroupBallotKHR, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}, 1, 1, 1, pygen_variable_exts_SPV_KHR_shader_ballot, 0xffffffffu, 0xffffffffu},
   {"SubgroupFirstInvocationKHR", spv::Op::OpSubgroupFirstInvocationKHR, 1, pygen_variable_caps_SubgroupBallotKHR, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}, 1, 1, 1, pygen_variable_exts_SPV_KHR_shader_ballot, 0xffffffffu, 0xffffffffu},
+  {"UntypedPtrAccessChainKHR", spv::Op::OpUntypedPtrAccessChainKHR, 1, pygen_variable_caps_UntypedPointersKHR, 6, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
+  {"UntypedInBoundsPtrAccessChainKHR", spv::Op::OpUntypedInBoundsPtrAccessChainKHR, 1, pygen_variable_caps_UntypedPointersKHR, 6, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
+  {"UntypedArrayLengthKHR", spv::Op::OpUntypedArrayLengthKHR, 1, pygen_variable_caps_UntypedPointersKHR, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_LITERAL_INTEGER}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
+  {"UntypedPrefetchKHR", spv::Op::OpUntypedPrefetchKHR, 1, pygen_variable_caps_UntypedPointersKHR, 5, {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_OPTIONAL_ID, SPV_OPERAND_TYPE_OPTIONAL_ID, SPV_OPERAND_TYPE_OPTIONAL_ID}, 0, 0, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"SubgroupAllKHR", spv::Op::OpSubgroupAllKHR, 1, pygen_variable_caps_SubgroupVoteKHR, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}, 1, 1, 1, pygen_variable_exts_SPV_KHR_subgroup_vote, 0xffffffffu, 0xffffffffu},
   {"SubgroupAnyKHR", spv::Op::OpSubgroupAnyKHR, 1, pygen_variable_caps_SubgroupVoteKHR, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}, 1, 1, 1, pygen_variable_exts_SPV_KHR_subgroup_vote, 0xffffffffu, 0xffffffffu},
   {"SubgroupAllEqualKHR", spv::Op::OpSubgroupAllEqualKHR, 1, pygen_variable_caps_SubgroupVoteKHR, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}, 1, 1, 1, pygen_variable_exts_SPV_KHR_subgroup_vote, 0xffffffffu, 0xffffffffu},
@@ -851,6 +862,7 @@ static const spv_opcode_desc_t kOpcodeTableEntries[] = {
   {"ConvertBF16ToFINTEL", spv::Op::OpConvertBF16ToFINTEL, 1, pygen_variable_caps_BFloat16ConversionINTEL, 3, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"ControlBarrierArriveINTEL", spv::Op::OpControlBarrierArriveINTEL, 1, pygen_variable_caps_SplitBarrierINTEL, 3, {SPV_OPERAND_TYPE_SCOPE_ID, SPV_OPERAND_TYPE_SCOPE_ID, SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID}, 0, 0, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"ControlBarrierWaitINTEL", spv::Op::OpControlBarrierWaitINTEL, 1, pygen_variable_caps_SplitBarrierINTEL, 3, {SPV_OPERAND_TYPE_SCOPE_ID, SPV_OPERAND_TYPE_SCOPE_ID, SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID}, 0, 0, 0, nullptr, 0xffffffffu, 0xffffffffu},
+  {"SubgroupBlockPrefetchINTEL", spv::Op::OpSubgroupBlockPrefetchINTEL, 1, pygen_variable_caps_SubgroupBufferPrefetchINTEL, 3, {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS}, 0, 0, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"GroupIMulKHR", spv::Op::OpGroupIMulKHR, 1, pygen_variable_caps_GroupUniformArithmeticKHR, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_SCOPE_ID, SPV_OPERAND_TYPE_GROUP_OPERATION, SPV_OPERAND_TYPE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"GroupFMulKHR", spv::Op::OpGroupFMulKHR, 1, pygen_variable_caps_GroupUniformArithmeticKHR, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_SCOPE_ID, SPV_OPERAND_TYPE_GROUP_OPERATION, SPV_OPERAND_TYPE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
   {"GroupBitwiseAndKHR", spv::Op::OpGroupBitwiseAndKHR, 1, pygen_variable_caps_GroupUniformArithmeticKHR, 5, {SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_SCOPE_ID, SPV_OPERAND_TYPE_GROUP_OPERATION, SPV_OPERAND_TYPE_ID}, 1, 1, 0, nullptr, 0xffffffffu, 0xffffffffu},
diff --git a/spirv-tools/spirv-tools/enum_string_mapping.inc b/spirv-tools/spirv-tools/enum_string_mapping.inc
index a93c413..7c97fe8 100644
--- a/spirv-tools/spirv-tools/enum_string_mapping.inc
+++ b/spirv-tools/spirv-tools/enum_string_mapping.inc
@@ -44,6 +44,8 @@ const char* ExtensionToString(Extension extension) {
       return "SPV_EXT_opacity_micromap";
     case Extension::kSPV_EXT_physical_storage_buffer:
       return "SPV_EXT_physical_storage_buffer";
+    case Extension::kSPV_EXT_relaxed_printf_string_address_space:
+      return "SPV_EXT_relaxed_printf_string_address_space";
     case Extension::kSPV_EXT_replicated_composites:
       return "SPV_EXT_replicated_composites";
     case Extension::kSPV_EXT_shader_atomic_float16_add:
@@ -140,6 +142,8 @@ const char* ExtensionToString(Extension extension) {
       return "SPV_INTEL_shader_integer_functions2";
     case Extension::kSPV_INTEL_split_barrier:
       return "SPV_INTEL_split_barrier";
+    case Extension::kSPV_INTEL_subgroup_buffer_prefetch:
+      return "SPV_INTEL_subgroup_buffer_prefetch";
     case Extension::kSPV_INTEL_subgroups:
       return "SPV_INTEL_subgroups";
     case Extension::kSPV_INTEL_unstructured_loop_controls:
@@ -156,6 +160,8 @@ const char* ExtensionToString(Extension extension) {
       return "SPV_KHR_8bit_storage";
     case Extension::kSPV_KHR_bit_instructions:
       return "SPV_KHR_bit_instructions";
+    case Extension::kSPV_KHR_compute_shader_derivatives:
+      return "SPV_KHR_compute_shader_derivatives";
     case Extension::kSPV_KHR_cooperative_matrix:
       return "SPV_KHR_cooperative_matrix";
     case Extension::kSPV_KHR_device_group:
@@ -218,6 +224,8 @@ const char* ExtensionToString(Extension extension) {
       return "SPV_KHR_terminate_invocation";
     case Extension::kSPV_KHR_uniform_group_instructions:
       return "SPV_KHR_uniform_group_instructions";
+    case Extension::kSPV_KHR_untyped_pointers:
+      return "SPV_KHR_untyped_pointers";
     case Extension::kSPV_KHR_variable_pointers:
       return "SPV_KHR_variable_pointers";
     case Extension::kSPV_KHR_vulkan_memory_model:
@@ -277,8 +285,8 @@ const char* ExtensionToString(Extension extension) {
 
 
     bool GetExtensionFromString(const char* str, Extension* extension) {
-        static const char* known_ext_strs[] = { "SPV_AMDX_shader_enqueue", "SPV_AMD_gcn_shader", "SPV_AMD_gpu_shader_half_float", "SPV_AMD_gpu_shader_half_float_fetch", "SPV_AMD_gpu_shader_int16", "SPV_AMD_shader_ballot", "SPV_AMD_shader_early_and_late_fragment_tests", "SPV_AMD_shader_explicit_vertex_parameter", "SPV_AMD_shader_fragment_mask", "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_texture_gather_bias_lod", "SPV_ARM_cooperative_matrix_layouts", "SPV_ARM_core_builtins", "SPV_EXT_demote_to_helper_invocation", "SPV_EXT_descriptor_indexing", "SPV_EXT_fragment_fully_covered", "SPV_EXT_fragment_invocation_density", "SPV_EXT_fragment_shader_interlock", "SPV_EXT_mesh_shader", "SPV_EXT_opacity_micromap", "SPV_EXT_physical_storage_buffer", "SPV_EXT_replicated_composites", "SPV_EXT_shader_atomic_float16_add", "SPV_EXT_shader_atomic_float_add", "SPV_EXT_shader_atomic_float_min_max", "SPV_EXT_shader_image_int64", "SPV_EXT_shader_stencil_export", "SPV_EXT_shader_tile_image", "SPV_EXT_shader_viewport_index_layer", "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1", "SPV_GOOGLE_user_type", "SPV_INTEL_arbitrary_precision_fixed_point", "SPV_INTEL_arbitrary_precision_floating_point", "SPV_INTEL_arbitrary_precision_integers", "SPV_INTEL_bfloat16_conversion", "SPV_INTEL_blocking_pipes", "SPV_INTEL_cache_controls", "SPV_INTEL_debug_module", "SPV_INTEL_device_side_avc_motion_estimation", "SPV_INTEL_float_controls2", "SPV_INTEL_fp_fast_math_mode", "SPV_INTEL_fp_max_error", "SPV_INTEL_fpga_argument_interfaces", "SPV_INTEL_fpga_buffer_location", "SPV_INTEL_fpga_cluster_attributes", "SPV_INTEL_fpga_dsp_control", "SPV_INTEL_fpga_invocation_pipelining_attributes", "SPV_INTEL_fpga_latency_control", "SPV_INTEL_fpga_loop_controls", "SPV_INTEL_fpga_memory_accesses", "SPV_INTEL_fpga_memory_attributes", "SPV_INTEL_fpga_reg", "SPV_INTEL_function_pointers", "SPV_INTEL_global_variable_fpga_decorations", "SPV_INTEL_global_variable_host_access", "SPV_INTEL_inline_assembly", "SPV_INTEL_io_pipes", "SPV_INTEL_kernel_attributes", "SPV_INTEL_long_composites", "SPV_INTEL_loop_fuse", "SPV_INTEL_masked_gather_scatter", "SPV_INTEL_maximum_registers", "SPV_INTEL_media_block_io", "SPV_INTEL_memory_access_aliasing", "SPV_INTEL_optnone", "SPV_INTEL_runtime_aligned", "SPV_INTEL_shader_integer_functions2", "SPV_INTEL_split_barrier", "SPV_INTEL_subgroups", "SPV_INTEL_unstructured_loop_controls", "SPV_INTEL_usm_storage_classes", "SPV_INTEL_variable_length_array", "SPV_INTEL_vector_compute", "SPV_KHR_16bit_storage", "SPV_KHR_8bit_storage", "SPV_KHR_bit_instructions", "SPV_KHR_cooperative_matrix", "SPV_KHR_device_group", "SPV_KHR_expect_assume", "SPV_KHR_float_controls", "SPV_KHR_float_controls2", "SPV_KHR_fragment_shader_barycentric", "SPV_KHR_fragment_shading_rate", "SPV_KHR_integer_dot_product", "SPV_KHR_linkonce_odr", "SPV_KHR_maximal_reconvergence", "SPV_KHR_multiview", "SPV_KHR_no_integer_wrap_decoration", "SPV_KHR_non_semantic_info", "SPV_KHR_physical_storage_buffer", "SPV_KHR_post_depth_coverage", "SPV_KHR_quad_control", "SPV_KHR_ray_cull_mask", "SPV_KHR_ray_query", "SPV_KHR_ray_tracing", "SPV_KHR_ray_tracing_position_fetch", "SPV_KHR_relaxed_extended_instruction", "SPV_KHR_shader_atomic_counter_ops", "SPV_KHR_shader_ballot", "SPV_KHR_shader_clock", "SPV_KHR_shader_draw_parameters", "SPV_KHR_storage_buffer_storage_class", "SPV_KHR_subgroup_rotate", "SPV_KHR_subgroup_uniform_control_flow", "SPV_KHR_subgroup_vote", "SPV_KHR_terminate_invocation", "SPV_KHR_uniform_group_instructions", "SPV_KHR_variable_pointers", "SPV_KHR_vulkan_memory_model", "SPV_KHR_workgroup_memory_explicit_layout", "SPV_NVX_multiview_per_view_attributes", "SPV_NV_bindless_texture", "SPV_NV_compute_shader_derivatives", "SPV_NV_cooperative_matrix", "SPV_NV_displacement_micromap", "SPV_NV_fragment_shader_barycentric", "SPV_NV_geometry_shader_passthrough", "SPV_NV_mesh_shader", "SPV_NV_raw_access_chains", "SPV_NV_ray_tracing", "SPV_NV_ray_tracing_motion_blur", "SPV_NV_sample_mask_override_coverage", "SPV_NV_shader_atomic_fp16_vector", "SPV_NV_shader_image_footprint", "SPV_NV_shader_invocation_reorder", "SPV_NV_shader_sm_builtins", "SPV_NV_shader_subgroup_partitioned", "SPV_NV_shading_rate", "SPV_NV_stereo_view_rendering", "SPV_NV_viewport_array2", "SPV_QCOM_image_processing", "SPV_QCOM_image_processing2", "SPV_VALIDATOR_ignore_type_decl_unique" };
-        static const Extension known_ext_ids[] = { Extension::kSPV_AMDX_shader_enqueue, Extension::kSPV_AMD_gcn_shader, Extension::kSPV_AMD_gpu_shader_half_float, Extension::kSPV_AMD_gpu_shader_half_float_fetch, Extension::kSPV_AMD_gpu_shader_int16, Extension::kSPV_AMD_shader_ballot, Extension::kSPV_AMD_shader_early_and_late_fragment_tests, Extension::kSPV_AMD_shader_explicit_vertex_parameter, Extension::kSPV_AMD_shader_fragment_mask, Extension::kSPV_AMD_shader_image_load_store_lod, Extension::kSPV_AMD_shader_trinary_minmax, Extension::kSPV_AMD_texture_gather_bias_lod, Extension::kSPV_ARM_cooperative_matrix_layouts, Extension::kSPV_ARM_core_builtins, Extension::kSPV_EXT_demote_to_helper_invocation, Extension::kSPV_EXT_descriptor_indexing, Extension::kSPV_EXT_fragment_fully_covered, Extension::kSPV_EXT_fragment_invocation_density, Extension::kSPV_EXT_fragment_shader_interlock, Extension::kSPV_EXT_mesh_shader, Extension::kSPV_EXT_opacity_micromap, Extension::kSPV_EXT_physical_storage_buffer, Extension::kSPV_EXT_replicated_composites, Extension::kSPV_EXT_shader_atomic_float16_add, Extension::kSPV_EXT_shader_atomic_float_add, Extension::kSPV_EXT_shader_atomic_float_min_max, Extension::kSPV_EXT_shader_image_int64, Extension::kSPV_EXT_shader_stencil_export, Extension::kSPV_EXT_shader_tile_image, Extension::kSPV_EXT_shader_viewport_index_layer, Extension::kSPV_GOOGLE_decorate_string, Extension::kSPV_GOOGLE_hlsl_functionality1, Extension::kSPV_GOOGLE_user_type, Extension::kSPV_INTEL_arbitrary_precision_fixed_point, Extension::kSPV_INTEL_arbitrary_precision_floating_point, Extension::kSPV_INTEL_arbitrary_precision_integers, Extension::kSPV_INTEL_bfloat16_conversion, Extension::kSPV_INTEL_blocking_pipes, Extension::kSPV_INTEL_cache_controls, Extension::kSPV_INTEL_debug_module, Extension::kSPV_INTEL_device_side_avc_motion_estimation, Extension::kSPV_INTEL_float_controls2, Extension::kSPV_INTEL_fp_fast_math_mode, Extension::kSPV_INTEL_fp_max_error, Extension::kSPV_INTEL_fpga_argument_interfaces, Extension::kSPV_INTEL_fpga_buffer_location, Extension::kSPV_INTEL_fpga_cluster_attributes, Extension::kSPV_INTEL_fpga_dsp_control, Extension::kSPV_INTEL_fpga_invocation_pipelining_attributes, Extension::kSPV_INTEL_fpga_latency_control, Extension::kSPV_INTEL_fpga_loop_controls, Extension::kSPV_INTEL_fpga_memory_accesses, Extension::kSPV_INTEL_fpga_memory_attributes, Extension::kSPV_INTEL_fpga_reg, Extension::kSPV_INTEL_function_pointers, Extension::kSPV_INTEL_global_variable_fpga_decorations, Extension::kSPV_INTEL_global_variable_host_access, Extension::kSPV_INTEL_inline_assembly, Extension::kSPV_INTEL_io_pipes, Extension::kSPV_INTEL_kernel_attributes, Extension::kSPV_INTEL_long_composites, Extension::kSPV_INTEL_loop_fuse, Extension::kSPV_INTEL_masked_gather_scatter, Extension::kSPV_INTEL_maximum_registers, Extension::kSPV_INTEL_media_block_io, Extension::kSPV_INTEL_memory_access_aliasing, Extension::kSPV_INTEL_optnone, Extension::kSPV_INTEL_runtime_aligned, Extension::kSPV_INTEL_shader_integer_functions2, Extension::kSPV_INTEL_split_barrier, Extension::kSPV_INTEL_subgroups, Extension::kSPV_INTEL_unstructured_loop_controls, Extension::kSPV_INTEL_usm_storage_classes, Extension::kSPV_INTEL_variable_length_array, Extension::kSPV_INTEL_vector_compute, Extension::kSPV_KHR_16bit_storage, Extension::kSPV_KHR_8bit_storage, Extension::kSPV_KHR_bit_instructions, Extension::kSPV_KHR_cooperative_matrix, Extension::kSPV_KHR_device_group, Extension::kSPV_KHR_expect_assume, Extension::kSPV_KHR_float_controls, Extension::kSPV_KHR_float_controls2, Extension::kSPV_KHR_fragment_shader_barycentric, Extension::kSPV_KHR_fragment_shading_rate, Extension::kSPV_KHR_integer_dot_product, Extension::kSPV_KHR_linkonce_odr, Extension::kSPV_KHR_maximal_reconvergence, Extension::kSPV_KHR_multiview, Extension::kSPV_KHR_no_integer_wrap_decoration, Extension::kSPV_KHR_non_semantic_info, Extension::kSPV_KHR_physical_storage_buffer, Extension::kSPV_KHR_post_depth_coverage, Extension::kSPV_KHR_quad_control, Extension::kSPV_KHR_ray_cull_mask, Extension::kSPV_KHR_ray_query, Extension::kSPV_KHR_ray_tracing, Extension::kSPV_KHR_ray_tracing_position_fetch, Extension::kSPV_KHR_relaxed_extended_instruction, Extension::kSPV_KHR_shader_atomic_counter_ops, Extension::kSPV_KHR_shader_ballot, Extension::kSPV_KHR_shader_clock, Extension::kSPV_KHR_shader_draw_parameters, Extension::kSPV_KHR_storage_buffer_storage_class, Extension::kSPV_KHR_subgroup_rotate, Extension::kSPV_KHR_subgroup_uniform_control_flow, Extension::kSPV_KHR_subgroup_vote, Extension::kSPV_KHR_terminate_invocation, Extension::kSPV_KHR_uniform_group_instructions, Extension::kSPV_KHR_variable_pointers, Extension::kSPV_KHR_vulkan_memory_model, Extension::kSPV_KHR_workgroup_memory_explicit_layout, Extension::kSPV_NVX_multiview_per_view_attributes, Extension::kSPV_NV_bindless_texture, Extension::kSPV_NV_compute_shader_derivatives, Extension::kSPV_NV_cooperative_matrix, Extension::kSPV_NV_displacement_micromap, Extension::kSPV_NV_fragment_shader_barycentric, Extension::kSPV_NV_geometry_shader_passthrough, Extension::kSPV_NV_mesh_shader, Extension::kSPV_NV_raw_access_chains, Extension::kSPV_NV_ray_tracing, Extension::kSPV_NV_ray_tracing_motion_blur, Extension::kSPV_NV_sample_mask_override_coverage, Extension::kSPV_NV_shader_atomic_fp16_vector, Extension::kSPV_NV_shader_image_footprint, Extension::kSPV_NV_shader_invocation_reorder, Extension::kSPV_NV_shader_sm_builtins, Extension::kSPV_NV_shader_subgroup_partitioned, Extension::kSPV_NV_shading_rate, Extension::kSPV_NV_stereo_view_rendering, Extension::kSPV_NV_viewport_array2, Extension::kSPV_QCOM_image_processing, Extension::kSPV_QCOM_image_processing2, Extension::kSPV_VALIDATOR_ignore_type_decl_unique };
+        static const char* known_ext_strs[] = { "SPV_AMDX_shader_enqueue", "SPV_AMD_gcn_shader", "SPV_AMD_gpu_shader_half_float", "SPV_AMD_gpu_shader_half_float_fetch", "SPV_AMD_gpu_shader_int16", "SPV_AMD_shader_ballot", "SPV_AMD_shader_early_and_late_fragment_tests", "SPV_AMD_shader_explicit_vertex_parameter", "SPV_AMD_shader_fragment_mask", "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_texture_gather_bias_lod", "SPV_ARM_cooperative_matrix_layouts", "SPV_ARM_core_builtins", "SPV_EXT_demote_to_helper_invocation", "SPV_EXT_descriptor_indexing", "SPV_EXT_fragment_fully_covered", "SPV_EXT_fragment_invocation_density", "SPV_EXT_fragment_shader_interlock", "SPV_EXT_mesh_shader", "SPV_EXT_opacity_micromap", "SPV_EXT_physical_storage_buffer", "SPV_EXT_relaxed_printf_string_address_space", "SPV_EXT_replicated_composites", "SPV_EXT_shader_atomic_float16_add", "SPV_EXT_shader_atomic_float_add", "SPV_EXT_shader_atomic_float_min_max", "SPV_EXT_shader_image_int64", "SPV_EXT_shader_stencil_export", "SPV_EXT_shader_tile_image", "SPV_EXT_shader_viewport_index_layer", "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1", "SPV_GOOGLE_user_type", "SPV_INTEL_arbitrary_precision_fixed_point", "SPV_INTEL_arbitrary_precision_floating_point", "SPV_INTEL_arbitrary_precision_integers", "SPV_INTEL_bfloat16_conversion", "SPV_INTEL_blocking_pipes", "SPV_INTEL_cache_controls", "SPV_INTEL_debug_module", "SPV_INTEL_device_side_avc_motion_estimation", "SPV_INTEL_float_controls2", "SPV_INTEL_fp_fast_math_mode", "SPV_INTEL_fp_max_error", "SPV_INTEL_fpga_argument_interfaces", "SPV_INTEL_fpga_buffer_location", "SPV_INTEL_fpga_cluster_attributes", "SPV_INTEL_fpga_dsp_control", "SPV_INTEL_fpga_invocation_pipelining_attributes", "SPV_INTEL_fpga_latency_control", "SPV_INTEL_fpga_loop_controls", "SPV_INTEL_fpga_memory_accesses", "SPV_INTEL_fpga_memory_attributes", "SPV_INTEL_fpga_reg", "SPV_INTEL_function_pointers", "SPV_INTEL_global_variable_fpga_decorations", "SPV_INTEL_global_variable_host_access", "SPV_INTEL_inline_assembly", "SPV_INTEL_io_pipes", "SPV_INTEL_kernel_attributes", "SPV_INTEL_long_composites", "SPV_INTEL_loop_fuse", "SPV_INTEL_masked_gather_scatter", "SPV_INTEL_maximum_registers", "SPV_INTEL_media_block_io", "SPV_INTEL_memory_access_aliasing", "SPV_INTEL_optnone", "SPV_INTEL_runtime_aligned", "SPV_INTEL_shader_integer_functions2", "SPV_INTEL_split_barrier", "SPV_INTEL_subgroup_buffer_prefetch", "SPV_INTEL_subgroups", "SPV_INTEL_unstructured_loop_controls", "SPV_INTEL_usm_storage_classes", "SPV_INTEL_variable_length_array", "SPV_INTEL_vector_compute", "SPV_KHR_16bit_storage", "SPV_KHR_8bit_storage", "SPV_KHR_bit_instructions", "SPV_KHR_compute_shader_derivatives", "SPV_KHR_cooperative_matrix", "SPV_KHR_device_group", "SPV_KHR_expect_assume", "SPV_KHR_float_controls", "SPV_KHR_float_controls2", "SPV_KHR_fragment_shader_barycentric", "SPV_KHR_fragment_shading_rate", "SPV_KHR_integer_dot_product", "SPV_KHR_linkonce_odr", "SPV_KHR_maximal_reconvergence", "SPV_KHR_multiview", "SPV_KHR_no_integer_wrap_decoration", "SPV_KHR_non_semantic_info", "SPV_KHR_physical_storage_buffer", "SPV_KHR_post_depth_coverage", "SPV_KHR_quad_control", "SPV_KHR_ray_cull_mask", "SPV_KHR_ray_query", "SPV_KHR_ray_tracing", "SPV_KHR_ray_tracing_position_fetch", "SPV_KHR_relaxed_extended_instruction", "SPV_KHR_shader_atomic_counter_ops", "SPV_KHR_shader_ballot", "SPV_KHR_shader_clock", "SPV_KHR_shader_draw_parameters", "SPV_KHR_storage_buffer_storage_class", "SPV_KHR_subgroup_rotate", "SPV_KHR_subgroup_uniform_control_flow", "SPV_KHR_subgroup_vote", "SPV_KHR_terminate_invocation", "SPV_KHR_uniform_group_instructions", "SPV_KHR_untyped_pointers", "SPV_KHR_variable_pointers", "SPV_KHR_vulkan_memory_model", "SPV_KHR_workgroup_memory_explicit_layout", "SPV_NVX_multiview_per_view_attributes", "SPV_NV_bindless_texture", "SPV_NV_compute_shader_derivatives", "SPV_NV_cooperative_matrix", "SPV_NV_displacement_micromap", "SPV_NV_fragment_shader_barycentric", "SPV_NV_geometry_shader_passthrough", "SPV_NV_mesh_shader", "SPV_NV_raw_access_chains", "SPV_NV_ray_tracing", "SPV_NV_ray_tracing_motion_blur", "SPV_NV_sample_mask_override_coverage", "SPV_NV_shader_atomic_fp16_vector", "SPV_NV_shader_image_footprint", "SPV_NV_shader_invocation_reorder", "SPV_NV_shader_sm_builtins", "SPV_NV_shader_subgroup_partitioned", "SPV_NV_shading_rate", "SPV_NV_stereo_view_rendering", "SPV_NV_viewport_array2", "SPV_QCOM_image_processing", "SPV_QCOM_image_processing2", "SPV_VALIDATOR_ignore_type_decl_unique" };
+        static const Extension known_ext_ids[] = { Extension::kSPV_AMDX_shader_enqueue, Extension::kSPV_AMD_gcn_shader, Extension::kSPV_AMD_gpu_shader_half_float, Extension::kSPV_AMD_gpu_shader_half_float_fetch, Extension::kSPV_AMD_gpu_shader_int16, Extension::kSPV_AMD_shader_ballot, Extension::kSPV_AMD_shader_early_and_late_fragment_tests, Extension::kSPV_AMD_shader_explicit_vertex_parameter, Extension::kSPV_AMD_shader_fragment_mask, Extension::kSPV_AMD_shader_image_load_store_lod, Extension::kSPV_AMD_shader_trinary_minmax, Extension::kSPV_AMD_texture_gather_bias_lod, Extension::kSPV_ARM_cooperative_matrix_layouts, Extension::kSPV_ARM_core_builtins, Extension::kSPV_EXT_demote_to_helper_invocation, Extension::kSPV_EXT_descriptor_indexing, Extension::kSPV_EXT_fragment_fully_covered, Extension::kSPV_EXT_fragment_invocation_density, Extension::kSPV_EXT_fragment_shader_interlock, Extension::kSPV_EXT_mesh_shader, Extension::kSPV_EXT_opacity_micromap, Extension::kSPV_EXT_physical_storage_buffer, Extension::kSPV_EXT_relaxed_printf_string_address_space, Extension::kSPV_EXT_replicated_composites, Extension::kSPV_EXT_shader_atomic_float16_add, Extension::kSPV_EXT_shader_atomic_float_add, Extension::kSPV_EXT_shader_atomic_float_min_max, Extension::kSPV_EXT_shader_image_int64, Extension::kSPV_EXT_shader_stencil_export, Extension::kSPV_EXT_shader_tile_image, Extension::kSPV_EXT_shader_viewport_index_layer, Extension::kSPV_GOOGLE_decorate_string, Extension::kSPV_GOOGLE_hlsl_functionality1, Extension::kSPV_GOOGLE_user_type, Extension::kSPV_INTEL_arbitrary_precision_fixed_point, Extension::kSPV_INTEL_arbitrary_precision_floating_point, Extension::kSPV_INTEL_arbitrary_precision_integers, Extension::kSPV_INTEL_bfloat16_conversion, Extension::kSPV_INTEL_blocking_pipes, Extension::kSPV_INTEL_cache_controls, Extension::kSPV_INTEL_debug_module, Extension::kSPV_INTEL_device_side_avc_motion_estimation, Extension::kSPV_INTEL_float_controls2, Extension::kSPV_INTEL_fp_fast_math_mode, Extension::kSPV_INTEL_fp_max_error, Extension::kSPV_INTEL_fpga_argument_interfaces, Extension::kSPV_INTEL_fpga_buffer_location, Extension::kSPV_INTEL_fpga_cluster_attributes, Extension::kSPV_INTEL_fpga_dsp_control, Extension::kSPV_INTEL_fpga_invocation_pipelining_attributes, Extension::kSPV_INTEL_fpga_latency_control, Extension::kSPV_INTEL_fpga_loop_controls, Extension::kSPV_INTEL_fpga_memory_accesses, Extension::kSPV_INTEL_fpga_memory_attributes, Extension::kSPV_INTEL_fpga_reg, Extension::kSPV_INTEL_function_pointers, Extension::kSPV_INTEL_global_variable_fpga_decorations, Extension::kSPV_INTEL_global_variable_host_access, Extension::kSPV_INTEL_inline_assembly, Extension::kSPV_INTEL_io_pipes, Extension::kSPV_INTEL_kernel_attributes, Extension::kSPV_INTEL_long_composites, Extension::kSPV_INTEL_loop_fuse, Extension::kSPV_INTEL_masked_gather_scatter, Extension::kSPV_INTEL_maximum_registers, Extension::kSPV_INTEL_media_block_io, Extension::kSPV_INTEL_memory_access_aliasing, Extension::kSPV_INTEL_optnone, Extension::kSPV_INTEL_runtime_aligned, Extension::kSPV_INTEL_shader_integer_functions2, Extension::kSPV_INTEL_split_barrier, Extension::kSPV_INTEL_subgroup_buffer_prefetch, Extension::kSPV_INTEL_subgroups, Extension::kSPV_INTEL_unstructured_loop_controls, Extension::kSPV_INTEL_usm_storage_classes, Extension::kSPV_INTEL_variable_length_array, Extension::kSPV_INTEL_vector_compute, Extension::kSPV_KHR_16bit_storage, Extension::kSPV_KHR_8bit_storage, Extension::kSPV_KHR_bit_instructions, Extension::kSPV_KHR_compute_shader_derivatives, Extension::kSPV_KHR_cooperative_matrix, Extension::kSPV_KHR_device_group, Extension::kSPV_KHR_expect_assume, Extension::kSPV_KHR_float_controls, Extension::kSPV_KHR_float_controls2, Extension::kSPV_KHR_fragment_shader_barycentric, Extension::kSPV_KHR_fragment_shading_rate, Extension::kSPV_KHR_integer_dot_product, Extension::kSPV_KHR_linkonce_odr, Extension::kSPV_KHR_maximal_reconvergence, Extension::kSPV_KHR_multiview, Extension::kSPV_KHR_no_integer_wrap_decoration, Extension::kSPV_KHR_non_semantic_info, Extension::kSPV_KHR_physical_storage_buffer, Extension::kSPV_KHR_post_depth_coverage, Extension::kSPV_KHR_quad_control, Extension::kSPV_KHR_ray_cull_mask, Extension::kSPV_KHR_ray_query, Extension::kSPV_KHR_ray_tracing, Extension::kSPV_KHR_ray_tracing_position_fetch, Extension::kSPV_KHR_relaxed_extended_instruction, Extension::kSPV_KHR_shader_atomic_counter_ops, Extension::kSPV_KHR_shader_ballot, Extension::kSPV_KHR_shader_clock, Extension::kSPV_KHR_shader_draw_parameters, Extension::kSPV_KHR_storage_buffer_storage_class, Extension::kSPV_KHR_subgroup_rotate, Extension::kSPV_KHR_subgroup_uniform_control_flow, Extension::kSPV_KHR_subgroup_vote, Extension::kSPV_KHR_terminate_invocation, Extension::kSPV_KHR_uniform_group_instructions, Extension::kSPV_KHR_untyped_pointers, Extension::kSPV_KHR_variable_pointers, Extension::kSPV_KHR_vulkan_memory_model, Extension::kSPV_KHR_workgroup_memory_explicit_layout, Extension::kSPV_NVX_multiview_per_view_attributes, Extension::kSPV_NV_bindless_texture, Extension::kSPV_NV_compute_shader_derivatives, Extension::kSPV_NV_cooperative_matrix, Extension::kSPV_NV_displacement_micromap, Extension::kSPV_NV_fragment_shader_barycentric, Extension::kSPV_NV_geometry_shader_passthrough, Extension::kSPV_NV_mesh_shader, Extension::kSPV_NV_raw_access_chains, Extension::kSPV_NV_ray_tracing, Extension::kSPV_NV_ray_tracing_motion_blur, Extension::kSPV_NV_sample_mask_override_coverage, Extension::kSPV_NV_shader_atomic_fp16_vector, Extension::kSPV_NV_shader_image_footprint, Extension::kSPV_NV_shader_invocation_reorder, Extension::kSPV_NV_shader_sm_builtins, Extension::kSPV_NV_shader_subgroup_partitioned, Extension::kSPV_NV_shading_rate, Extension::kSPV_NV_stereo_view_rendering, Extension::kSPV_NV_viewport_array2, Extension::kSPV_QCOM_image_processing, Extension::kSPV_QCOM_image_processing2, Extension::kSPV_VALIDATOR_ignore_type_decl_unique };
         const auto b = std::begin(known_ext_strs);
         const auto e = std::end(known_ext_strs);
         const auto found = std::equal_range(
@@ -498,6 +506,8 @@ const char* CapabilityToString(spv::Capability capability) {
       return "RayQueryProvisionalKHR";
     case spv::Capability::RayQueryKHR:
       return "RayQueryKHR";
+    case spv::Capability::UntypedPointersKHR:
+      return "UntypedPointersKHR";
     case spv::Capability::RayTraversalPrimitiveCullingKHR:
       return "RayTraversalPrimitiveCullingKHR";
     case spv::Capability::RayTracingKHR:
@@ -550,8 +560,8 @@ const char* CapabilityToString(spv::Capability capability) {
       return "MeshShadingEXT";
     case spv::Capability::FragmentBarycentricKHR:
       return "FragmentBarycentricKHR";
-    case spv::Capability::ComputeDerivativeGroupQuadsNV:
-      return "ComputeDerivativeGroupQuadsNV";
+    case spv::Capability::ComputeDerivativeGroupQuadsKHR:
+      return "ComputeDerivativeGroupQuadsKHR";
     case spv::Capability::FragmentDensityEXT:
       return "FragmentDensityEXT";
     case spv::Capability::GroupNonUniformPartitionedNV:
@@ -592,8 +602,8 @@ const char* CapabilityToString(spv::Capability capability) {
       return "VulkanMemoryModelDeviceScope";
     case spv::Capability::PhysicalStorageBufferAddresses:
       return "PhysicalStorageBufferAddresses";
-    case spv::Capability::ComputeDerivativeGroupLinearNV:
-      return "ComputeDerivativeGroupLinearNV";
+    case spv::Capability::ComputeDerivativeGroupLinearKHR:
+      return "ComputeDerivativeGroupLinearKHR";
     case spv::Capability::RayTracingProvisionalKHR:
       return "RayTracingProvisionalKHR";
     case spv::Capability::CooperativeMatrixNV:
@@ -758,6 +768,8 @@ const char* CapabilityToString(spv::Capability capability) {
       return "GlobalVariableHostAccessINTEL";
     case spv::Capability::GlobalVariableFPGADecorationsINTEL:
       return "GlobalVariableFPGADecorationsINTEL";
+    case spv::Capability::SubgroupBufferPrefetchINTEL:
+      return "SubgroupBufferPrefetchINTEL";
     case spv::Capability::GroupUniformArithmeticKHR:
       return "GroupUniformArithmeticKHR";
     case spv::Capability::MaskedGatherScatterINTEL:
diff --git a/spirv-tools/spirv-tools/extension_enum.inc b/spirv-tools/spirv-tools/extension_enum.inc
index ac42c58..243af26 100644
--- a/spirv-tools/spirv-tools/extension_enum.inc
+++ b/spirv-tools/spirv-tools/extension_enum.inc
@@ -20,6 +20,7 @@ kSPV_EXT_fragment_shader_interlock,
 kSPV_EXT_mesh_shader,
 kSPV_EXT_opacity_micromap,
 kSPV_EXT_physical_storage_buffer,
+kSPV_EXT_relaxed_printf_string_address_space,
 kSPV_EXT_replicated_composites,
 kSPV_EXT_shader_atomic_float16_add,
 kSPV_EXT_shader_atomic_float_add,
@@ -68,6 +69,7 @@ kSPV_INTEL_optnone,
 kSPV_INTEL_runtime_aligned,
 kSPV_INTEL_shader_integer_functions2,
 kSPV_INTEL_split_barrier,
+kSPV_INTEL_subgroup_buffer_prefetch,
 kSPV_INTEL_subgroups,
 kSPV_INTEL_unstructured_loop_controls,
 kSPV_INTEL_usm_storage_classes,
@@ -76,6 +78,7 @@ kSPV_INTEL_vector_compute,
 kSPV_KHR_16bit_storage,
 kSPV_KHR_8bit_storage,
 kSPV_KHR_bit_instructions,
+kSPV_KHR_compute_shader_derivatives,
 kSPV_KHR_cooperative_matrix,
 kSPV_KHR_device_group,
 kSPV_KHR_expect_assume,
@@ -107,6 +110,7 @@ kSPV_KHR_subgroup_uniform_control_flow,
 kSPV_KHR_subgroup_vote,
 kSPV_KHR_terminate_invocation,
 kSPV_KHR_uniform_group_instructions,
+kSPV_KHR_untyped_pointers,
 kSPV_KHR_variable_pointers,
 kSPV_KHR_vulkan_memory_model,
 kSPV_KHR_workgroup_memory_explicit_layout,
diff --git a/spirv-tools/spirv-tools/generators.inc b/spirv-tools/spirv-tools/generators.inc
index e67e575..fe7580d 100644
--- a/spirv-tools/spirv-tools/generators.inc
+++ b/spirv-tools/spirv-tools/generators.inc
@@ -20,7 +20,7 @@
 {19, "Tellusim", "Clay Shader Compiler", "Tellusim Clay Shader Compiler"},
 {20, "W3C WebGPU Group", "WHLSL Shader Translator", "W3C WebGPU Group WHLSL Shader Translator"},
 {21, "Google", "Clspv", "Google Clspv"},
-{22, "Google", "MLIR SPIR-V Serializer", "Google MLIR SPIR-V Serializer"},
+{22, "LLVM", "MLIR SPIR-V Serializer", "LLVM MLIR SPIR-V Serializer"},
 {23, "Google", "Tint Compiler", "Google Tint Compiler"},
 {24, "Google", "ANGLE Shader Compiler", "Google ANGLE Shader Compiler"},
 {25, "Netease Games", "Messiah Shader Compiler", "Netease Games Messiah Shader Compiler"},
@@ -41,4 +41,5 @@
 {40, "NVIDIA", "Slang Compiler", "NVIDIA Slang Compiler"},
 {41, "Zig Software Foundation", "Zig Compiler", "Zig Software Foundation Zig Compiler"},
 {42, "Rendong Liang", "spq", "Rendong Liang spq"},
-{43, "LLVM", "LLVM SPIR-V Backend", "LLVM LLVM SPIR-V Backend"},
\ No newline at end of file
+{43, "LLVM", "LLVM SPIR-V Backend", "LLVM LLVM SPIR-V Backend"},
+{44, "Robert Konrad", "Kongruent", "Robert Konrad Kongruent"},
\ No newline at end of file
diff --git a/spirv-tools/spirv-tools/libspirv.h b/spirv-tools/spirv-tools/libspirv.h
index 162553d..1a21cce 100644
--- a/spirv-tools/spirv-tools/libspirv.h
+++ b/spirv-tools/spirv-tools/libspirv.h
@@ -175,6 +175,7 @@ typedef enum spv_operand_type_t {
   SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS,              // SPIR-V Sec 3.29
   SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO,         // SPIR-V Sec 3.30
   SPV_OPERAND_TYPE_CAPABILITY,                    // SPIR-V Sec 3.31
+  SPV_OPERAND_TYPE_FPENCODING,                    // SPIR-V Sec 3.51
 
   // NOTE: New concrete enum values should be added at the end.
 
@@ -236,6 +237,8 @@ typedef enum spv_operand_type_t {
   // assemble regardless of where they occur -- literals, IDs, immediate
   // integers, etc.
   SPV_OPERAND_TYPE_OPTIONAL_CIV,
+  // An optional floating point encoding enum
+  SPV_OPERAND_TYPE_OPTIONAL_FPENCODING,
 
   // A variable operand represents zero or more logical operands.
   // In an instruction definition, this may only appear at the end of the
diff --git a/spirv-tools/spirv-tools/libspirv.hpp b/spirv-tools/spirv-tools/libspirv.hpp
index 59ff82b..6a64e93 100644
--- a/spirv-tools/spirv-tools/libspirv.hpp
+++ b/spirv-tools/spirv-tools/libspirv.hpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "spirv-tools/libspirv.h"
+#include "libspirv.h"
 
 namespace spvtools {
 
diff --git a/spirv-tools/spirv-tools/linker.hpp b/spirv-tools/spirv-tools/linker.hpp
index 6ba6e96..9037b94 100644
--- a/spirv-tools/spirv-tools/linker.hpp
+++ b/spirv-tools/spirv-tools/linker.hpp
@@ -16,7 +16,6 @@
 #define INCLUDE_SPIRV_TOOLS_LINKER_HPP_
 
 #include <cstdint>
-
 #include <memory>
 #include <vector>
 
@@ -63,11 +62,17 @@ class SPIRV_TOOLS_EXPORT LinkerOptions {
     use_highest_version_ = use_highest_vers;
   }
 
+  bool GetAllowPtrTypeMismatch() const { return allow_ptr_type_mismatch_; }
+  void SetAllowPtrTypeMismatch(bool allow_ptr_type_mismatch) {
+    allow_ptr_type_mismatch_ = allow_ptr_type_mismatch;
+  }
+
  private:
   bool create_library_{false};
   bool verify_ids_{false};
   bool allow_partial_linkage_{false};
   bool use_highest_version_{false};
+  bool allow_ptr_type_mismatch_{false};
 };
 
 // Links one or more SPIR-V modules into a new SPIR-V module. That is, combine
diff --git a/spirv-tools/spirv-tools/nonsemantic.vkspreflection.insts.inc b/spirv-tools/spirv-tools/nonsemantic.vkspreflection.insts.inc
index 623b9cf..2f14c05 100644
--- a/spirv-tools/spirv-tools/nonsemantic.vkspreflection.insts.inc
+++ b/spirv-tools/spirv-tools/nonsemantic.vkspreflection.insts.inc
@@ -6,7 +6,7 @@ static const spv_ext_inst_desc_t nonsemantic_vkspreflection_entries[] = {
   {"StopCounter", 3, 0, nullptr, {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_NONE}},
   {"PushConstants", 4, 0, nullptr, {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_STRING, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
   {"SpecializationMapEntry", 5, 0, nullptr, {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
-  {"DescriptorSetBuffer", 6, 0, nullptr, {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
+  {"DescriptorSetBuffer", 6, 0, nullptr, {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
   {"DescriptorSetImage", 7, 0, nullptr, {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
   {"DescriptorSetSampler", 8, 0, nullptr, {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_FLOAT, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_FLOAT, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_FLOAT, SPV_OPERAND_TYPE_LITERAL_FLOAT, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}}
 };
\ No newline at end of file
diff --git a/spirv-tools/spirv-tools/operand.kinds-unified1.inc b/spirv-tools/spirv-tools/operand.kinds-unified1.inc
index ccfd69a..3a3a8c5 100644
--- a/spirv-tools/spirv-tools/operand.kinds-unified1.inc
+++ b/spirv-tools/spirv-tools/operand.kinds-unified1.inc
@@ -5,8 +5,8 @@ static const spv::Capability pygen_variable_caps_AtomicStorage[] = {spv::Capabil
 static const spv::Capability pygen_variable_caps_BindlessTextureNV[] = {spv::Capability::BindlessTextureNV};
 static const spv::Capability pygen_variable_caps_CacheControlsINTEL[] = {spv::Capability::CacheControlsINTEL};
 static const spv::Capability pygen_variable_caps_ClipDistance[] = {spv::Capability::ClipDistance};
-static const spv::Capability pygen_variable_caps_ComputeDerivativeGroupLinearNV[] = {spv::Capability::ComputeDerivativeGroupLinearNV};
-static const spv::Capability pygen_variable_caps_ComputeDerivativeGroupQuadsNV[] = {spv::Capability::ComputeDerivativeGroupQuadsNV};
+static const spv::Capability pygen_variable_caps_ComputeDerivativeGroupLinearNVComputeDerivativeGroupLinearKHR[] = {spv::Capability::ComputeDerivativeGroupLinearNV, spv::Capability::ComputeDerivativeGroupLinearKHR};
+static const spv::Capability pygen_variable_caps_ComputeDerivativeGroupQuadsNVComputeDerivativeGroupQuadsKHR[] = {spv::Capability::ComputeDerivativeGroupQuadsNV, spv::Capability::ComputeDerivativeGroupQuadsKHR};
 static const spv::Capability pygen_variable_caps_CoreBuiltinsARM[] = {spv::Capability::CoreBuiltinsARM};
 static const spv::Capability pygen_variable_caps_CullDistance[] = {spv::Capability::CullDistance};
 static const spv::Capability pygen_variable_caps_DenormFlushToZero[] = {spv::Capability::DenormFlushToZero};
@@ -211,6 +211,7 @@ static const spvtools::Extension pygen_variable_exts_SPV_INTEL_optnone[] = {spvt
 static const spvtools::Extension pygen_variable_exts_SPV_INTEL_runtime_aligned[] = {spvtools::Extension::kSPV_INTEL_runtime_aligned};
 static const spvtools::Extension pygen_variable_exts_SPV_INTEL_shader_integer_functions2[] = {spvtools::Extension::kSPV_INTEL_shader_integer_functions2};
 static const spvtools::Extension pygen_variable_exts_SPV_INTEL_split_barrier[] = {spvtools::Extension::kSPV_INTEL_split_barrier};
+static const spvtools::Extension pygen_variable_exts_SPV_INTEL_subgroup_buffer_prefetch[] = {spvtools::Extension::kSPV_INTEL_subgroup_buffer_prefetch};
 static const spvtools::Extension pygen_variable_exts_SPV_INTEL_subgroups[] = {spvtools::Extension::kSPV_INTEL_subgroups};
 static const spvtools::Extension pygen_variable_exts_SPV_INTEL_unstructured_loop_controls[] = {spvtools::Extension::kSPV_INTEL_unstructured_loop_controls};
 static const spvtools::Extension pygen_variable_exts_SPV_INTEL_usm_storage_classes[] = {spvtools::Extension::kSPV_INTEL_usm_storage_classes};
@@ -219,6 +220,7 @@ static const spvtools::Extension pygen_variable_exts_SPV_INTEL_vector_compute[]
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_16bit_storage[] = {spvtools::Extension::kSPV_KHR_16bit_storage};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_8bit_storage[] = {spvtools::Extension::kSPV_KHR_8bit_storage};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_bit_instructions[] = {spvtools::Extension::kSPV_KHR_bit_instructions};
+static const spvtools::Extension pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives[] = {spvtools::Extension::kSPV_KHR_compute_shader_derivatives, spvtools::Extension::kSPV_NV_compute_shader_derivatives};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_cooperative_matrix[] = {spvtools::Extension::kSPV_KHR_cooperative_matrix};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_device_group[] = {spvtools::Extension::kSPV_KHR_device_group};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_expect_assume[] = {spvtools::Extension::kSPV_KHR_expect_assume};
@@ -248,13 +250,13 @@ static const spvtools::Extension pygen_variable_exts_SPV_KHR_subgroup_rotate[] =
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_subgroup_uniform_control_flow[] = {spvtools::Extension::kSPV_KHR_subgroup_uniform_control_flow};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_subgroup_vote[] = {spvtools::Extension::kSPV_KHR_subgroup_vote};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_uniform_group_instructions[] = {spvtools::Extension::kSPV_KHR_uniform_group_instructions};
+static const spvtools::Extension pygen_variable_exts_SPV_KHR_untyped_pointers[] = {spvtools::Extension::kSPV_KHR_untyped_pointers};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_variable_pointers[] = {spvtools::Extension::kSPV_KHR_variable_pointers};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_vulkan_memory_model[] = {spvtools::Extension::kSPV_KHR_vulkan_memory_model};
 static const spvtools::Extension pygen_variable_exts_SPV_KHR_workgroup_memory_explicit_layout[] = {spvtools::Extension::kSPV_KHR_workgroup_memory_explicit_layout};
 static const spvtools::Extension pygen_variable_exts_SPV_NVX_multiview_per_view_attributes[] = {spvtools::Extension::kSPV_NVX_multiview_per_view_attributes};
 static const spvtools::Extension pygen_variable_exts_SPV_NVX_multiview_per_view_attributesSPV_NV_mesh_shader[] = {spvtools::Extension::kSPV_NVX_multiview_per_view_attributes, spvtools::Extension::kSPV_NV_mesh_shader};
 static const spvtools::Extension pygen_variable_exts_SPV_NV_bindless_texture[] = {spvtools::Extension::kSPV_NV_bindless_texture};
-static const spvtools::Extension pygen_variable_exts_SPV_NV_compute_shader_derivatives[] = {spvtools::Extension::kSPV_NV_compute_shader_derivatives};
 static const spvtools::Extension pygen_variable_exts_SPV_NV_cooperative_matrix[] = {spvtools::Extension::kSPV_NV_cooperative_matrix};
 static const spvtools::Extension pygen_variable_exts_SPV_NV_displacement_micromap[] = {spvtools::Extension::kSPV_NV_displacement_micromap};
 static const spvtools::Extension pygen_variable_exts_SPV_NV_geometry_shader_passthrough[] = {spvtools::Extension::kSPV_NV_geometry_shader_passthrough};
@@ -546,8 +548,10 @@ static const spv_operand_desc_t pygen_variable_ExecutionModeEntries[] = {
   {"OutputLinesNV", 5269, 2, pygen_variable_caps_MeshShadingNVMeshShadingEXT, 2, pygen_variable_exts_SPV_EXT_mesh_shaderSPV_NV_mesh_shader, {}, 0xffffffffu, 0xffffffffu},
   {"OutputPrimitivesEXT", 5270, 2, pygen_variable_caps_MeshShadingNVMeshShadingEXT, 2, pygen_variable_exts_SPV_EXT_mesh_shaderSPV_NV_mesh_shader, {SPV_OPERAND_TYPE_LITERAL_INTEGER}, 0xffffffffu, 0xffffffffu},
   {"OutputPrimitivesNV", 5270, 2, pygen_variable_caps_MeshShadingNVMeshShadingEXT, 2, pygen_variable_exts_SPV_EXT_mesh_shaderSPV_NV_mesh_shader, {SPV_OPERAND_TYPE_LITERAL_INTEGER}, 0xffffffffu, 0xffffffffu},
-  {"DerivativeGroupQuadsNV", 5289, 1, pygen_variable_caps_ComputeDerivativeGroupQuadsNV, 1, pygen_variable_exts_SPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
-  {"DerivativeGroupLinearNV", 5290, 1, pygen_variable_caps_ComputeDerivativeGroupLinearNV, 1, pygen_variable_exts_SPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"DerivativeGroupQuadsKHR", 5289, 2, pygen_variable_caps_ComputeDerivativeGroupQuadsNVComputeDerivativeGroupQuadsKHR, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"DerivativeGroupQuadsNV", 5289, 2, pygen_variable_caps_ComputeDerivativeGroupQuadsNVComputeDerivativeGroupQuadsKHR, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"DerivativeGroupLinearKHR", 5290, 2, pygen_variable_caps_ComputeDerivativeGroupLinearNVComputeDerivativeGroupLinearKHR, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"DerivativeGroupLinearNV", 5290, 2, pygen_variable_caps_ComputeDerivativeGroupLinearNVComputeDerivativeGroupLinearKHR, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
   {"OutputTrianglesEXT", 5298, 2, pygen_variable_caps_MeshShadingNVMeshShadingEXT, 2, pygen_variable_exts_SPV_EXT_mesh_shaderSPV_NV_mesh_shader, {}, 0xffffffffu, 0xffffffffu},
   {"OutputTrianglesNV", 5298, 2, pygen_variable_caps_MeshShadingNVMeshShadingEXT, 2, pygen_variable_exts_SPV_EXT_mesh_shaderSPV_NV_mesh_shader, {}, 0xffffffffu, 0xffffffffu},
   {"PixelInterlockOrderedEXT", 5366, 1, pygen_variable_caps_FragmentShaderPixelInterlockEXT, 1, pygen_variable_exts_SPV_EXT_fragment_shader_interlock, {}, 0xffffffffu, 0xffffffffu},
@@ -725,7 +729,8 @@ static const spv_operand_desc_t pygen_variable_ImageChannelDataTypeEntries[] = {
   {"UnormInt24", 15, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"UnormInt101010_2", 16, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
   {"UnsignedIntRaw10EXT", 19, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
-  {"UnsignedIntRaw12EXT", 20, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu}
+  {"UnsignedIntRaw12EXT", 20, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu},
+  {"UnormInt2_101010EXT", 21, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu}
 };
 
 static const spv_operand_desc_t pygen_variable_FPRoundingModeEntries[] = {
@@ -1215,6 +1220,7 @@ static const spv_operand_desc_t pygen_variable_CapabilityEntries[] = {
   {"RoundingModeRTZ", 4468, 0, nullptr, 1, pygen_variable_exts_SPV_KHR_float_controls, {}, SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu},
   {"RayQueryProvisionalKHR", 4471, 1, pygen_variable_caps_Shader, 1, pygen_variable_exts_SPV_KHR_ray_query, {}, 0xffffffffu, 0xffffffffu},
   {"RayQueryKHR", 4472, 1, pygen_variable_caps_Shader, 1, pygen_variable_exts_SPV_KHR_ray_query, {}, 0xffffffffu, 0xffffffffu},
+  {"UntypedPointersKHR", 4473, 0, nullptr, 1, pygen_variable_exts_SPV_KHR_untyped_pointers, {}, 0xffffffffu, 0xffffffffu},
   {"RayTraversalPrimitiveCullingKHR", 4478, 2, pygen_variable_caps_RayQueryKHRRayTracingKHR, 2, pygen_variable_exts_SPV_KHR_ray_querySPV_KHR_ray_tracing, {}, 0xffffffffu, 0xffffffffu},
   {"RayTracingKHR", 4479, 1, pygen_variable_caps_Shader, 1, pygen_variable_exts_SPV_KHR_ray_tracing, {}, 0xffffffffu, 0xffffffffu},
   {"TextureSampleWeightedQCOM", 4484, 0, nullptr, 1, pygen_variable_exts_SPV_QCOM_image_processing, {}, 0xffffffffu, 0xffffffffu},
@@ -1243,7 +1249,8 @@ static const spv_operand_desc_t pygen_variable_CapabilityEntries[] = {
   {"MeshShadingEXT", 5283, 1, pygen_variable_caps_Shader, 1, pygen_variable_exts_SPV_EXT_mesh_shader, {}, 0xffffffffu, 0xffffffffu},
   {"FragmentBarycentricKHR", 5284, 0, nullptr, 2, pygen_variable_exts_SPV_KHR_fragment_shader_barycentricSPV_NV_fragment_shader_barycentric, {}, 0xffffffffu, 0xffffffffu},
   {"FragmentBarycentricNV", 5284, 0, nullptr, 2, pygen_variable_exts_SPV_KHR_fragment_shader_barycentricSPV_NV_fragment_shader_barycentric, {}, 0xffffffffu, 0xffffffffu},
-  {"ComputeDerivativeGroupQuadsNV", 5288, 0, nullptr, 1, pygen_variable_exts_SPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"ComputeDerivativeGroupQuadsKHR", 5288, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"ComputeDerivativeGroupQuadsNV", 5288, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
   {"FragmentDensityEXT", 5291, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_EXT_fragment_invocation_densitySPV_NV_shading_rate, {}, 0xffffffffu, 0xffffffffu},
   {"ShadingRateNV", 5291, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_EXT_fragment_invocation_densitySPV_NV_shading_rate, {}, 0xffffffffu, 0xffffffffu},
   {"GroupNonUniformPartitionedNV", 5297, 0, nullptr, 1, pygen_variable_exts_SPV_NV_shader_subgroup_partitioned, {}, 0xffffffffu, 0xffffffffu},
@@ -1280,7 +1287,8 @@ static const spv_operand_desc_t pygen_variable_CapabilityEntries[] = {
   {"VulkanMemoryModelDeviceScopeKHR", 5346, 0, nullptr, 1, pygen_variable_exts_SPV_KHR_vulkan_memory_model, {}, SPV_SPIRV_VERSION_WORD(1,5), 0xffffffffu},
   {"PhysicalStorageBufferAddresses", 5347, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_EXT_physical_storage_bufferSPV_KHR_physical_storage_buffer, {}, SPV_SPIRV_VERSION_WORD(1,5), 0xffffffffu},
   {"PhysicalStorageBufferAddressesEXT", 5347, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_EXT_physical_storage_bufferSPV_KHR_physical_storage_buffer, {}, SPV_SPIRV_VERSION_WORD(1,5), 0xffffffffu},
-  {"ComputeDerivativeGroupLinearNV", 5350, 0, nullptr, 1, pygen_variable_exts_SPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"ComputeDerivativeGroupLinearKHR", 5350, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
+  {"ComputeDerivativeGroupLinearNV", 5350, 1, pygen_variable_caps_Shader, 2, pygen_variable_exts_SPV_KHR_compute_shader_derivativesSPV_NV_compute_shader_derivatives, {}, 0xffffffffu, 0xffffffffu},
   {"RayTracingProvisionalKHR", 5353, 1, pygen_variable_caps_Shader, 1, pygen_variable_exts_SPV_KHR_ray_tracing, {}, 0xffffffffu, 0xffffffffu},
   {"CooperativeMatrixNV", 5357, 1, pygen_variable_caps_Shader, 1, pygen_variable_exts_SPV_NV_cooperative_matrix, {}, 0xffffffffu, 0xffffffffu},
   {"FragmentShaderSampleInterlockEXT", 5363, 1, pygen_variable_caps_Shader, 1, pygen_variable_exts_SPV_EXT_fragment_shader_interlock, {}, 0xffffffffu, 0xffffffffu},
@@ -1368,6 +1376,7 @@ static const spv_operand_desc_t pygen_variable_CapabilityEntries[] = {
   {"FPGAArgumentInterfacesINTEL", 6174, 0, nullptr, 1, pygen_variable_exts_SPV_INTEL_fpga_argument_interfaces, {}, 0xffffffffu, 0xffffffffu},
   {"GlobalVariableHostAccessINTEL", 6187, 0, nullptr, 1, pygen_variable_exts_SPV_INTEL_global_variable_host_access, {}, 0xffffffffu, 0xffffffffu},
   {"GlobalVariableFPGADecorationsINTEL", 6189, 0, nullptr, 1, pygen_variable_exts_SPV_INTEL_global_variable_fpga_decorations, {}, 0xffffffffu, 0xffffffffu},
+  {"SubgroupBufferPrefetchINTEL", 6220, 0, nullptr, 1, pygen_variable_exts_SPV_INTEL_subgroup_buffer_prefetch, {}, 0xffffffffu, 0xffffffffu},
   {"GroupUniformArithmeticKHR", 6400, 0, nullptr, 1, pygen_variable_exts_SPV_KHR_uniform_group_instructions, {}, 0xffffffffu, 0xffffffffu},
   {"MaskedGatherScatterINTEL", 6427, 0, nullptr, 1, pygen_variable_exts_SPV_INTEL_masked_gather_scatter, {}, 0xffffffffu, 0xffffffffu},
   {"CacheControlsINTEL", 6441, 0, nullptr, 1, pygen_variable_exts_SPV_INTEL_cache_controls, {}, 0xffffffffu, 0xffffffffu},
@@ -1441,6 +1450,10 @@ static const spv_operand_desc_t pygen_variable_NamedMaximumNumberOfRegistersEntr
   {"AutoINTEL", 0, 1, pygen_variable_caps_RegisterLimitsINTEL, 0, nullptr, {}, 0xffffffffu, 0xffffffffu}
 };
 
+static const spv_operand_desc_t pygen_variable_FPEncodingEntries[] = {
+  {"place holder", 0, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(999,0), 0}
+};
+
 static const spv_operand_desc_t pygen_variable_DebugInfoFlagsEntries[] = {
   {"None", 0x0000, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1, 0), 0xffffffffu},
   {"FlagIsProtected", 0x01, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(1, 0), 0xffffffffu},
@@ -1609,6 +1622,7 @@ static const spv_operand_desc_group_t pygen_variable_OperandInfoTable[] = {
   {SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL, ARRAY_SIZE(pygen_variable_LoadCacheControlEntries), pygen_variable_LoadCacheControlEntries},
   {SPV_OPERAND_TYPE_STORE_CACHE_CONTROL, ARRAY_SIZE(pygen_variable_StoreCacheControlEntries), pygen_variable_StoreCacheControlEntries},
   {SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS, ARRAY_SIZE(pygen_variable_NamedMaximumNumberOfRegistersEntries), pygen_variable_NamedMaximumNumberOfRegistersEntries},
+  {SPV_OPERAND_TYPE_FPENCODING, ARRAY_SIZE(pygen_variable_FPEncodingEntries), pygen_variable_FPEncodingEntries},
   {SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, ARRAY_SIZE(pygen_variable_DebugInfoFlagsEntries), pygen_variable_DebugInfoFlagsEntries},
   {SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING, ARRAY_SIZE(pygen_variable_DebugBaseTypeAttributeEncodingEntries), pygen_variable_DebugBaseTypeAttributeEncodingEntries},
   {SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE, ARRAY_SIZE(pygen_variable_DebugCompositeTypeEntries), pygen_variable_DebugCompositeTypeEntries},
@@ -1625,5 +1639,6 @@ static const spv_operand_desc_group_t pygen_variable_OperandInfoTable[] = {
   {SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS, ARRAY_SIZE(pygen_variable_RawAccessChainOperandsEntries), pygen_variable_RawAccessChainOperandsEntries},
   {SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER, ARRAY_SIZE(pygen_variable_AccessQualifierEntries), pygen_variable_AccessQualifierEntries},
   {SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT, ARRAY_SIZE(pygen_variable_PackedVectorFormatEntries), pygen_variable_PackedVectorFormatEntries},
-  {SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS, ARRAY_SIZE(pygen_variable_CooperativeMatrixOperandsEntries), pygen_variable_CooperativeMatrixOperandsEntries}
+  {SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS, ARRAY_SIZE(pygen_variable_CooperativeMatrixOperandsEntries), pygen_variable_CooperativeMatrixOperandsEntries},
+  {SPV_OPERAND_TYPE_OPTIONAL_FPENCODING, ARRAY_SIZE(pygen_variable_FPEncodingEntries), pygen_variable_FPEncodingEntries}
 };
\ No newline at end of file
diff --git a/spirv-tools/spirv-tools/optimizer.hpp b/spirv-tools/spirv-tools/optimizer.hpp
index 216e68a..9677b15 100644
--- a/spirv-tools/spirv-tools/optimizer.hpp
+++ b/spirv-tools/spirv-tools/optimizer.hpp
@@ -827,14 +827,19 @@ Optimizer::PassToken CreateReplaceDescArrayAccessUsingVarIndexPass();
 
 // Create descriptor scalar replacement pass.
 // This pass replaces every array variable |desc| that has a DescriptorSet and
-// Binding decorations with a new variable for each element of the array.
-// Suppose |desc| was bound at binding |b|.  Then the variable corresponding to
-// |desc[i]| will have binding |b+i|.  The descriptor set will be the same.  It
-// is assumed that no other variable already has a binding that will used by one
-// of the new variables.  If not, the pass will generate invalid Spir-V.  All
-// accesses to |desc| must be OpAccessChain instructions with a literal index
-// for the first index.
+// Binding decorations with a new variable for each element of the
+// array/composite. Suppose |desc| was bound at binding |b|.  Then the variable
+// corresponding to |desc[i]| will have binding |b+i|.  The descriptor set will
+// be the same.  It is assumed that no other variable already has a binding that
+// will used by one of the new variables.  If not, the pass will generate
+// invalid Spir-V.  All accesses to |desc| must be OpAccessChain instructions
+// with a literal index for the first index. This variant flattens both
+// composites and arrays.
 Optimizer::PassToken CreateDescriptorScalarReplacementPass();
+// This variant flattens only composites.
+Optimizer::PassToken CreateDescriptorCompositeScalarReplacementPass();
+// This variant flattens only arrays.
+Optimizer::PassToken CreateDescriptorArrayScalarReplacementPass();
 
 // Create a pass to replace each OpKill instruction with a function call to a
 // function that has a single OpKill.  Also replace each OpTerminateInvocation
@@ -951,6 +956,15 @@ Optimizer::PassToken CreateFixFuncCallArgumentsPass();
 // the unknown capability interacts with one of the trimmed capabilities.
 Optimizer::PassToken CreateTrimCapabilitiesPass();
 
+// Creates a struct-packing pass.
+// This pass re-assigns all offset layout decorators to tightly pack
+// the struct with OpName matching `structToPack` according to the given packing
+// rule. Accepted packing rules are: std140, std140EnhancedLayout, std430,
+// std430EnhancedLayout, hlslCbuffer, hlslCbufferPackOffset, scalar,
+// scalarEnhancedLayout.
+Optimizer::PassToken CreateStructPackingPass(const char* structToPack,
+                                             const char* packingRule);
+
 // Creates a switch-descriptorset pass.
 // This pass changes any DescriptorSet decorations with the value |ds_from| to
 // use the new value |ds_to|.