diff --git a/external/CMakeLists.txt b/external/CMakeLists.txt
index 3190f4b..8bde13c 100644
--- a/external/CMakeLists.txt
+++ b/external/CMakeLists.txt
@@ -108,6 +108,9 @@
   set(protobuf_BUILD_TESTS OFF CACHE BOOL "Disable protobuf tests")
   set(protobuf_MSVC_STATIC_RUNTIME OFF CACHE BOOL "Do not build protobuf static runtime")
   if (IS_DIRECTORY ${PROTOBUF_DIR})
+    if (${CMAKE_CXX_COMPILER_ID} MATCHES Clang)
+      add_definitions(-Wno-inconsistent-missing-override)
+    endif()
     add_subdirectory(${PROTOBUF_DIR} EXCLUDE_FROM_ALL)
   else()
     message(FATAL_ERROR
diff --git a/include/spirv-tools/libspirv.h b/include/spirv-tools/libspirv.h
index 2f4c7d6..723de05 100644
--- a/include/spirv-tools/libspirv.h
+++ b/include/spirv-tools/libspirv.h
@@ -249,6 +249,11 @@
   SPV_EXT_INST_TYPE_SPV_AMD_SHADER_BALLOT,
   SPV_EXT_INST_TYPE_DEBUGINFO,
 
+  // Multiple distinct extended instruction set types could return this
+  // value, if they are prefixed with NonSemantic. and are otherwise
+  // unrecognised
+  SPV_EXT_INST_TYPE_NONSEMANTIC_UNKNOWN,
+
   SPV_FORCE_32_BIT_ENUM(spv_ext_inst_type_t)
 } spv_ext_inst_type_t;
 
diff --git a/source/binary.cpp b/source/binary.cpp
index 1d31283..8229e53 100644
--- a/source/binary.cpp
+++ b/source/binary.cpp
@@ -477,9 +477,22 @@
       assert(SpvOpExtInst == opcode);
       assert(inst->ext_inst_type != SPV_EXT_INST_TYPE_NONE);
       spv_ext_inst_desc ext_inst;
-      if (grammar_.lookupExtInst(inst->ext_inst_type, word, &ext_inst))
-        return diagnostic() << "Invalid extended instruction number: " << word;
-      spvPushOperandTypes(ext_inst->operandTypes, expected_operands);
+      if (grammar_.lookupExtInst(inst->ext_inst_type, word, &ext_inst) ==
+          SPV_SUCCESS) {
+        // if we know about this ext inst, push the expected operands
+        spvPushOperandTypes(ext_inst->operandTypes, expected_operands);
+      } else {
+        // if we don't know this extended instruction and the set isn't
+        // non-semantic, we cannot process further
+        if (!spvExtInstIsNonSemantic(inst->ext_inst_type)) {
+          return diagnostic()
+                 << "Invalid extended instruction number: " << word;
+        } else {
+          // for non-semantic instruction sets, we know the form of all such
+          // extended instructions contains a series of IDs as parameters
+          expected_operands->push_back(SPV_OPERAND_TYPE_VARIABLE_ID);
+        }
+      }
     } break;
 
     case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: {
diff --git a/source/disassemble.cpp b/source/disassemble.cpp
index c116f50..2ba0d3d 100644
--- a/source/disassemble.cpp
+++ b/source/disassemble.cpp
@@ -217,10 +217,18 @@
       break;
     case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: {
       spv_ext_inst_desc ext_inst;
-      if (grammar_.lookupExtInst(inst.ext_inst_type, word, &ext_inst))
-        assert(false && "should have caught this earlier");
       SetRed();
-      stream_ << ext_inst->name;
+      if (grammar_.lookupExtInst(inst.ext_inst_type, word, &ext_inst) ==
+          SPV_SUCCESS) {
+        stream_ << ext_inst->name;
+      } else {
+        if (!spvExtInstIsNonSemantic(inst.ext_inst_type)) {
+          assert(false && "should have caught this earlier");
+        } else {
+          // for non-semantic instruction sets we can just print the number
+          stream_ << word;
+        }
+      }
     } break;
     case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: {
       spv_opcode_desc opcode_desc;
diff --git a/source/ext_inst.cpp b/source/ext_inst.cpp
index 0499e23..6ac5756 100644
--- a/source/ext_inst.cpp
+++ b/source/ext_inst.cpp
@@ -116,9 +116,21 @@
   if (!strcmp("DebugInfo", name)) {
     return SPV_EXT_INST_TYPE_DEBUGINFO;
   }
+  // ensure to add any known non-semantic extended instruction sets
+  // above this point, and update spvExtInstIsNonSemantic()
+  if (!strncmp("NonSemantic.", name, 12)) {
+    return SPV_EXT_INST_TYPE_NONSEMANTIC_UNKNOWN;
+  }
   return SPV_EXT_INST_TYPE_NONE;
 }
 
+bool spvExtInstIsNonSemantic(const spv_ext_inst_type_t type) {
+  if (type == SPV_EXT_INST_TYPE_NONSEMANTIC_UNKNOWN) {
+    return true;
+  }
+  return false;
+}
+
 spv_result_t spvExtInstTableNameLookup(const spv_ext_inst_table table,
                                        const spv_ext_inst_type_t type,
                                        const char* name,
diff --git a/source/ext_inst.h b/source/ext_inst.h
index a821cc2..b42d82b 100644
--- a/source/ext_inst.h
+++ b/source/ext_inst.h
@@ -21,6 +21,9 @@
 // Gets the type of the extended instruction set with the specified name.
 spv_ext_inst_type_t spvExtInstImportTypeGet(const char* name);
 
+// Returns true if the extended instruction set is non-semantic
+bool spvExtInstIsNonSemantic(const spv_ext_inst_type_t type);
+
 // Finds the named extented instruction of the given type in the given extended
 // instruction table. On success, returns SPV_SUCCESS and writes a handle of
 // the instruction entry into *entry.
diff --git a/source/opt/ir_loader.cpp b/source/opt/ir_loader.cpp
index c68b3e2..e21e680 100644
--- a/source/opt/ir_loader.cpp
+++ b/source/opt/ir_loader.cpp
@@ -16,6 +16,7 @@
 
 #include <utility>
 
+#include "source/ext_inst.h"
 #include "source/opt/log.h"
 #include "source/opt/reflect.h"
 #include "source/util/make_unique.h"
@@ -113,11 +114,14 @@
       } else if (IsTypeInst(opcode)) {
         module_->AddType(std::move(spv_inst));
       } else if (IsConstantInst(opcode) || opcode == SpvOpVariable ||
-                 opcode == SpvOpUndef) {
+                 opcode == SpvOpUndef ||
+                 (opcode == SpvOpExtInst &&
+                  spvExtInstIsNonSemantic(inst->ext_inst_type))) {
         module_->AddGlobalValue(std::move(spv_inst));
       } else {
         Errorf(consumer_, src, loc,
-               "Unhandled inst type (opcode: %d) found outside function definition.",
+               "Unhandled inst type (opcode: %d) found outside function "
+               "definition.",
                opcode);
         return false;
       }
diff --git a/source/opt/strip_debug_info_pass.cpp b/source/opt/strip_debug_info_pass.cpp
index 9e7fad0..936c966 100644
--- a/source/opt/strip_debug_info_pass.cpp
+++ b/source/opt/strip_debug_info_pass.cpp
@@ -19,12 +19,60 @@
 namespace opt {
 
 Pass::Status StripDebugInfoPass::Process() {
-  bool modified = !context()->debugs1().empty() ||
-                  !context()->debugs2().empty() ||
-                  !context()->debugs3().empty();
+  bool uses_non_semantic_info = false;
+  for (auto& inst : context()->module()->extensions()) {
+    const char* ext_name =
+        reinterpret_cast<const char*>(&inst.GetInOperand(0).words[0]);
+    if (0 == std::strcmp(ext_name, "SPV_KHR_non_semantic_info")) {
+      uses_non_semantic_info = true;
+    }
+  }
 
   std::vector<Instruction*> to_kill;
-  for (auto& dbg : context()->debugs1()) to_kill.push_back(&dbg);
+
+  // if we use non-semantic info, it may reference OpString. Do a more
+  // expensive pass checking the uses of the OpString to see if any are
+  // OpExtInst on a non-semantic instruction set. If we're not using the
+  // extension then we can do a simpler pass and kill all debug1 instructions
+  if (uses_non_semantic_info) {
+    for (auto& inst : context()->module()->debugs1()) {
+      switch (inst.opcode()) {
+        case SpvOpString: {
+          analysis::DefUseManager* def_use = context()->get_def_use_mgr();
+
+          // see if this string is used anywhere by a non-semantic instruction
+          bool no_nonsemantic_use =
+              def_use->WhileEachUser(&inst, [def_use](Instruction* use) {
+                if (use->opcode() == SpvOpExtInst) {
+                  auto ext_inst_set =
+                      def_use->GetDef(use->GetSingleWordInOperand(0u));
+                  const char* extension_name = reinterpret_cast<const char*>(
+                      &ext_inst_set->GetInOperand(0).words[0]);
+                  if (0 == std::strncmp(extension_name, "NonSemantic.", 12)) {
+                    // found a non-semantic use, return false as we cannot
+                    // remove this OpString
+                    return false;
+                  }
+                }
+
+                // other instructions can't be a non-semantic use
+                return true;
+              });
+
+          if (no_nonsemantic_use) to_kill.push_back(&inst);
+
+          break;
+        }
+
+        default:
+          to_kill.push_back(&inst);
+          break;
+      }
+    }
+  } else {
+    for (auto& dbg : context()->debugs1()) to_kill.push_back(&dbg);
+  }
+
   for (auto& dbg : context()->debugs2()) to_kill.push_back(&dbg);
   for (auto& dbg : context()->debugs3()) to_kill.push_back(&dbg);
 
@@ -38,8 +86,11 @@
               return false;
             });
 
+  bool modified = !to_kill.empty();
+
   for (auto* inst : to_kill) context()->KillInst(inst);
 
+  // clear OpLine information
   context()->module()->ForEachInst([&modified](Instruction* inst) {
     modified |= !inst->dbg_line_insts().empty();
     inst->dbg_line_insts().clear();
diff --git a/source/opt/strip_reflect_info_pass.cpp b/source/opt/strip_reflect_info_pass.cpp
index 984073f..c231ead 100644
--- a/source/opt/strip_reflect_info_pass.cpp
+++ b/source/opt/strip_reflect_info_pass.cpp
@@ -67,9 +67,54 @@
     } else if (!other_uses_for_decorate_string &&
                0 == std::strcmp(ext_name, "SPV_GOOGLE_decorate_string")) {
       to_remove.push_back(&inst);
+    } else if (0 == std::strcmp(ext_name, "SPV_KHR_non_semantic_info")) {
+      to_remove.push_back(&inst);
     }
   }
 
+  // clear all debug data now if it hasn't been cleared already, to remove any
+  // remaining OpString that may have been referenced by non-semantic extinsts
+  for (auto& dbg : context()->debugs1()) to_remove.push_back(&dbg);
+  for (auto& dbg : context()->debugs2()) to_remove.push_back(&dbg);
+  for (auto& dbg : context()->debugs3()) to_remove.push_back(&dbg);
+
+  // remove any extended inst imports that are non semantic
+  std::unordered_set<uint32_t> non_semantic_sets;
+  for (auto& inst : context()->module()->ext_inst_imports()) {
+    assert(inst.opcode() == SpvOpExtInstImport &&
+           "Expecting an import of an extension's instruction set.");
+    const char* extension_name =
+        reinterpret_cast<const char*>(&inst.GetInOperand(0).words[0]);
+    if (0 == std::strncmp(extension_name, "NonSemantic.", 12)) {
+      non_semantic_sets.insert(inst.result_id());
+      to_remove.push_back(&inst);
+    }
+  }
+
+  // if we removed some non-semantic sets, then iterate over the instructions in
+  // the module to remove any OpExtInst that referenced those sets
+  if (!non_semantic_sets.empty()) {
+    context()->module()->ForEachInst(
+        [&non_semantic_sets, &to_remove](Instruction* inst) {
+          if (inst->opcode() == SpvOpExtInst) {
+            if (non_semantic_sets.find(inst->GetSingleWordInOperand(0)) !=
+                non_semantic_sets.end()) {
+              to_remove.push_back(inst);
+            }
+          }
+        });
+  }
+
+  // OpName must come first, since they may refer to other debug instructions.
+  // If they are after the instructions that refer to, then they will be killed
+  // when that instruction is killed, which will lead to a double kill.
+  std::sort(to_remove.begin(), to_remove.end(),
+            [](Instruction* lhs, Instruction* rhs) -> bool {
+              if (lhs->opcode() == SpvOpName && rhs->opcode() != SpvOpName)
+                return true;
+              return false;
+            });
+
   for (auto* inst : to_remove) {
     modified = true;
     context()->KillInst(inst);
diff --git a/source/text.cpp b/source/text.cpp
index d88d4f7..fb475d8 100644
--- a/source/text.cpp
+++ b/source/text.cpp
@@ -242,14 +242,37 @@
       // The assembler accepts the symbolic name for an extended instruction,
       // and emits its corresponding number.
       spv_ext_inst_desc extInst;
-      if (grammar.lookupExtInst(pInst->extInstType, textValue, &extInst)) {
-        return context->diagnostic()
-               << "Invalid extended instruction name '" << textValue << "'.";
-      }
-      spvInstructionAddWord(pInst, extInst->ext_inst);
+      if (grammar.lookupExtInst(pInst->extInstType, textValue, &extInst) ==
+          SPV_SUCCESS) {
+        // if we know about this extended instruction, push the numeric value
+        spvInstructionAddWord(pInst, extInst->ext_inst);
 
-      // Prepare to parse the operands for the extended instructions.
-      spvPushOperandTypes(extInst->operandTypes, pExpectedOperands);
+        // Prepare to parse the operands for the extended instructions.
+        spvPushOperandTypes(extInst->operandTypes, pExpectedOperands);
+      } else {
+        // if we don't know this extended instruction and the set isn't
+        // non-semantic, we cannot process further
+        if (!spvExtInstIsNonSemantic(pInst->extInstType)) {
+          return context->diagnostic()
+                 << "Invalid extended instruction name '" << textValue << "'.";
+        } else {
+          // for non-semantic instruction sets, as long as the text name is an
+          // integer value we can encode it since we know the form of all such
+          // extended instructions
+          spv_literal_t extInstValue;
+          if (spvTextToLiteral(textValue, &extInstValue) ||
+              extInstValue.type != SPV_LITERAL_TYPE_UINT_32) {
+            return context->diagnostic()
+                   << "Couldn't translate unknown extended instruction name '"
+                   << textValue << "' to unsigned integer.";
+          }
+
+          spvInstructionAddWord(pInst, extInstValue.value.u32);
+
+          // opcode contains an unknown number of IDs.
+          pExpectedOperands->push_back(SPV_OPERAND_TYPE_VARIABLE_ID);
+        }
+      }
     } break;
 
     case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: {
diff --git a/source/val/instruction.h b/source/val/instruction.h
index 1fa855f..e30bfbc 100644
--- a/source/val/instruction.h
+++ b/source/val/instruction.h
@@ -21,6 +21,7 @@
 #include <utility>
 #include <vector>
 
+#include "source/ext_inst.h"
 #include "source/table.h"
 #include "spirv-tools/libspirv.h"
 
@@ -85,6 +86,11 @@
     return inst_.ext_inst_type;
   }
 
+  bool IsNonSemantic() const {
+    return opcode() == SpvOp::SpvOpExtInst &&
+           spvExtInstIsNonSemantic(inst_.ext_inst_type);
+  }
+
   // Casts the words belonging to the operand under |index| to |T| and returns.
   template <typename T>
   T GetOperandAs(size_t index) const {
diff --git a/source/val/validate_annotation.cpp b/source/val/validate_annotation.cpp
index 2695280..df38f1b 100644
--- a/source/val/validate_annotation.cpp
+++ b/source/val/validate_annotation.cpp
@@ -286,7 +286,8 @@
     auto use = pair.first;
     if (use->opcode() != SpvOpDecorate && use->opcode() != SpvOpGroupDecorate &&
         use->opcode() != SpvOpGroupMemberDecorate &&
-        use->opcode() != SpvOpName && use->opcode() != SpvOpDecorateId) {
+        use->opcode() != SpvOpName && use->opcode() != SpvOpDecorateId &&
+        !use->IsNonSemantic()) {
       return _.diag(SPV_ERROR_INVALID_ID, inst)
              << "Result id of OpDecorationGroup can only "
              << "be targeted by OpName, OpGroupDecorate, "
diff --git a/source/val/validate_decorations.cpp b/source/val/validate_decorations.cpp
index d513a25..3b44833 100644
--- a/source/val/validate_decorations.cpp
+++ b/source/val/validate_decorations.cpp
@@ -1275,6 +1275,7 @@
     const auto store = use.first;
     if (store->opcode() == SpvOpFConvert) continue;
     if (spvOpcodeIsDebug(store->opcode())) continue;
+    if (store->IsNonSemantic()) continue;
     if (spvOpcodeIsDecoration(store->opcode())) continue;
     if (store->opcode() != SpvOpStore) {
       return vstate.diag(SPV_ERROR_INVALID_ID, &inst)
diff --git a/source/val/validate_extensions.cpp b/source/val/validate_extensions.cpp
index 1a64605..070cc4c 100644
--- a/source/val/validate_extensions.cpp
+++ b/source/val/validate_extensions.cpp
@@ -61,8 +61,8 @@
 
 spv_result_t ValidateExtInstImport(ValidationState_t& _,
                                    const Instruction* inst) {
+  const auto name_id = 1;
   if (spvIsWebGPUEnv(_.context()->target_env)) {
-    const auto name_id = 1;
     const std::string name(reinterpret_cast<const char*>(
         inst->words().data() + inst->operands()[name_id].offset));
     if (name != "GLSL.std.450") {
@@ -72,6 +72,16 @@
     }
   }
 
+  if (!_.HasExtension(kSPV_KHR_non_semantic_info)) {
+    const std::string name(reinterpret_cast<const char*>(
+        inst->words().data() + inst->operands()[name_id].offset));
+    if (name.find("NonSemantic.") == 0) {
+      return _.diag(SPV_ERROR_INVALID_DATA, inst)
+             << "NonSemantic extended instruction sets cannot be declared "
+                "without SPV_KHR_non_semantic_info.";
+    }
+  }
+
   return SPV_SUCCESS;
 }
 
diff --git a/source/val/validate_function.cpp b/source/val/validate_function.cpp
index b983194..f995ab3 100644
--- a/source/val/validate_function.cpp
+++ b/source/val/validate_function.cpp
@@ -87,7 +87,8 @@
   for (auto& pair : inst->uses()) {
     const auto* use = pair.first;
     if (std::find(acceptable.begin(), acceptable.end(), use->opcode()) ==
-        acceptable.end()) {
+            acceptable.end() &&
+        !use->IsNonSemantic()) {
       return _.diag(SPV_ERROR_INVALID_ID, use)
              << "Invalid use of function result id " << _.getIdName(inst->id())
              << ".";
diff --git a/source/val/validate_id.cpp b/source/val/validate_id.cpp
index d80e1b8..7406330 100644
--- a/source/val/validate_id.cpp
+++ b/source/val/validate_id.cpp
@@ -167,7 +167,8 @@
           const auto opcode = inst->opcode();
           if (spvOpcodeGeneratesType(def->opcode()) &&
               !spvOpcodeGeneratesType(opcode) && !spvOpcodeIsDebug(opcode) &&
-              !spvOpcodeIsDecoration(opcode) && opcode != SpvOpFunction &&
+              !inst->IsNonSemantic() && !spvOpcodeIsDecoration(opcode) &&
+              opcode != SpvOpFunction &&
               opcode != SpvOpCooperativeMatrixLengthNV &&
               !(opcode == SpvOpSpecConstantOp &&
                 inst->word(3) == SpvOpCooperativeMatrixLengthNV)) {
@@ -175,7 +176,7 @@
                    << "Operand " << _.getIdName(operand_word)
                    << " cannot be a type";
           } else if (def->type_id() == 0 && !spvOpcodeGeneratesType(opcode) &&
-                     !spvOpcodeIsDebug(opcode) &&
+                     !spvOpcodeIsDebug(opcode) && !inst->IsNonSemantic() &&
                      !spvOpcodeIsDecoration(opcode) &&
                      !spvOpcodeIsBranch(opcode) && opcode != SpvOpPhi &&
                      opcode != SpvOpExtInst && opcode != SpvOpExtInstImport &&
@@ -187,6 +188,11 @@
             return _.diag(SPV_ERROR_INVALID_ID, inst)
                    << "Operand " << _.getIdName(operand_word)
                    << " requires a type";
+          } else if (def->IsNonSemantic() && !inst->IsNonSemantic()) {
+            return _.diag(SPV_ERROR_INVALID_ID, inst)
+                   << "Operand " << _.getIdName(operand_word)
+                   << " in semantic instruction cannot be a non-semantic "
+                      "instruction";
           } else {
             ret = SPV_SUCCESS;
           }
diff --git a/source/val/validate_layout.cpp b/source/val/validate_layout.cpp
index 53c2835..259befe 100644
--- a/source/val/validate_layout.cpp
+++ b/source/val/validate_layout.cpp
@@ -34,6 +34,30 @@
 // checked.
 spv_result_t ModuleScopedInstructions(ValidationState_t& _,
                                       const Instruction* inst, SpvOp opcode) {
+  switch (opcode) {
+    case SpvOpExtInst:
+      if (spvExtInstIsNonSemantic(inst->ext_inst_type())) {
+        // non-semantic extinst opcodes are allowed beginning in the types
+        // section, but since they must name a return type they cannot be the
+        // first instruction in the types section. Therefore check that we are
+        // already in it.
+        if (_.current_layout_section() < kLayoutTypes) {
+          return _.diag(SPV_ERROR_INVALID_LAYOUT, inst)
+                 << "Non-semantic OpExtInst must not appear before types "
+                 << "section";
+        }
+      } else {
+        // otherwise they must be used in a block
+        if (_.current_layout_section() < kLayoutFunctionDefinitions) {
+          return _.diag(SPV_ERROR_INVALID_LAYOUT, inst)
+                 << spvOpcodeString(opcode) << " must appear in a block";
+        }
+      }
+      break;
+    default:
+      break;
+  }
+
   while (_.IsOpcodeInCurrentLayoutSection(opcode) == false) {
     _.ProgressToNextLayoutSectionOrder();
 
@@ -144,6 +168,29 @@
         }
         break;
 
+      case SpvOpExtInst:
+        if (spvExtInstIsNonSemantic(inst->ext_inst_type())) {
+          // non-semantic extinst opcodes are allowed beginning in the types
+          // section, but must either be placed outside a function declaration,
+          // or inside a block.
+          if (_.current_layout_section() < kLayoutTypes) {
+            return _.diag(SPV_ERROR_INVALID_LAYOUT, inst)
+                   << "Non-semantic OpExtInst must not appear before types "
+                   << "section";
+          } else if (_.in_function_body() && _.in_block() == false) {
+            return _.diag(SPV_ERROR_INVALID_LAYOUT, inst)
+                   << "Non-semantic OpExtInst within function definition must "
+                      "appear in a block";
+          }
+        } else {
+          // otherwise they must be used in a block
+          if (_.in_block() == false) {
+            return _.diag(SPV_ERROR_INVALID_LAYOUT, inst)
+                   << spvOpcodeString(opcode) << " must appear in a block";
+          }
+        }
+        break;
+
       default:
         if (_.current_layout_section() == kLayoutFunctionDeclarations &&
             _.in_function_body()) {
diff --git a/source/val/validate_type.cpp b/source/val/validate_type.cpp
index 1f171cf..5924c69 100644
--- a/source/val/validate_type.cpp
+++ b/source/val/validate_type.cpp
@@ -536,7 +536,7 @@
   for (auto& pair : inst->uses()) {
     const auto* use = pair.first;
     if (use->opcode() != SpvOpFunction && !spvOpcodeIsDebug(use->opcode()) &&
-        !spvOpcodeIsDecoration(use->opcode())) {
+        !use->IsNonSemantic() && !spvOpcodeIsDecoration(use->opcode())) {
       return _.diag(SPV_ERROR_INVALID_ID, use)
              << "Invalid use of function type result id "
              << _.getIdName(inst->id()) << ".";
diff --git a/source/val/validation_state.cpp b/source/val/validation_state.cpp
index 20eaf88..51aebbe 100644
--- a/source/val/validation_state.cpp
+++ b/source/val/validation_state.cpp
@@ -93,6 +93,9 @@
         case SpvOpLine:
         case SpvOpNoLine:
         case SpvOpUndef:
+        // SpvOpExtInst is only allowed here for certain extended instruction
+        // sets. This will be checked separately
+        case SpvOpExtInst:
           out = true;
           break;
         default: break;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3dca430..e6857e0 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -102,6 +102,7 @@
   enum_set_test.cpp
   ext_inst.debuginfo_test.cpp
   ext_inst.glsl_test.cpp
+  ext_inst.non_semantic_test.cpp
   ext_inst.opencl_test.cpp
   fix_word_test.cpp
   generator_magic_number_test.cpp
diff --git a/test/ext_inst.non_semantic_test.cpp b/test/ext_inst.non_semantic_test.cpp
new file mode 100644
index 0000000..870684e
--- /dev/null
+++ b/test/ext_inst.non_semantic_test.cpp
@@ -0,0 +1,90 @@
+// Copyright (c) 2015-2016 The Khronos Group 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.
+
+// Assembler tests for non-semantic extended instructions
+
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "test/test_fixture.h"
+#include "test/unit_spirv.h"
+
+using ::testing::Eq;
+
+namespace spvtools {
+namespace {
+
+using NonSemanticRoundTripTest = RoundTripTest;
+using NonSemanticTextToBinaryTest = spvtest::TextToBinaryTest;
+
+TEST_F(NonSemanticRoundTripTest, NonSemanticInsts) {
+  std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info"
+%1 = OpExtInstImport "NonSemantic.Testing.ExtInst"
+%2 = OpTypeVoid
+%3 = OpExtInst %2 %1 132384681 %2
+%4 = OpTypeInt 32 0
+%5 = OpConstant %4 123
+%6 = OpString "Test string"
+%7 = OpExtInst %4 %1 82198732 %5 %6
+%8 = OpExtInstImport "NonSemantic.Testing.AnotherUnknownExtInstSet"
+%9 = OpExtInst %4 %8 613874321 %7 %5 %6
+)";
+  std::string disassembly = EncodeAndDecodeSuccessfully(
+      spirv, SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_ENV_UNIVERSAL_1_0);
+  EXPECT_THAT(disassembly, Eq(spirv));
+}
+
+TEST_F(NonSemanticTextToBinaryTest, InvalidExtInstSetName) {
+  std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info"
+%1 = OpExtInstImport "NonSemantic_Testing_ExtInst"
+)";
+
+  EXPECT_THAT(
+      CompileFailure(spirv),
+      Eq("Invalid extended instruction import 'NonSemantic_Testing_ExtInst'"));
+}
+
+TEST_F(NonSemanticTextToBinaryTest, NonSemanticIntParameter) {
+  std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info"
+%1 = OpExtInstImport "NonSemantic.Testing.ExtInst"
+%2 = OpTypeVoid
+%3 = OpExtInst %2 %1 1 99999
+)";
+
+  EXPECT_THAT(CompileFailure(spirv), Eq("Expected id to start with %."));
+}
+
+TEST_F(NonSemanticTextToBinaryTest, NonSemanticFloatParameter) {
+  std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info"
+%1 = OpExtInstImport "NonSemantic.Testing.ExtInst"
+%2 = OpTypeVoid
+%3 = OpExtInst %2 %1 1 3.141592
+)";
+
+  EXPECT_THAT(CompileFailure(spirv), Eq("Expected id to start with %."));
+}
+
+TEST_F(NonSemanticTextToBinaryTest, NonSemanticStringParameter) {
+  std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info"
+%1 = OpExtInstImport "NonSemantic.Testing.ExtInst"
+%2 = OpTypeVoid
+%3 = OpExtInst %2 %1 1 "foobar"
+)";
+
+  EXPECT_THAT(CompileFailure(spirv), Eq("Expected id to start with %."));
+}
+
+}  // namespace
+}  // namespace spvtools
diff --git a/test/opt/strip_debug_info_test.cpp b/test/opt/strip_debug_info_test.cpp
index 2f2ff46..088bba9 100644
--- a/test/opt/strip_debug_info_test.cpp
+++ b/test/opt/strip_debug_info_test.cpp
@@ -152,6 +152,53 @@
                                             /* do_validation */ true);
 }
 
+TEST_F(StripDebugStringTest, OpStringRemovedWithNonSemantic) {
+  std::vector<const char*> input{
+      // clang-format off
+                     "OpCapability Shader",
+                     "OpExtension \"SPV_KHR_non_semantic_info\"",
+                "%1 = OpExtInstImport \"NonSemantic.Testing.Set\"",
+                     "OpMemoryModel Logical GLSL450",
+                     "OpEntryPoint Vertex %2 \"main\"",
+                // this string is not referenced, should be removed fully
+                "%3 = OpString \"minimal.vert\"",
+                     "OpName %3 \"bob\"",
+                // this string is referenced and cannot be removed,
+                // but the name should be
+                "%4 = OpString \"secondary.inc\"",
+                     "OpName %4 \"sue\"",
+             "%void = OpTypeVoid",
+                "%6 = OpTypeFunction %void",
+                "%2 = OpFunction %void None %6",
+                "%7 = OpLabel",
+                "%8 = OpExtInst %void %1 5 %4",
+                     "OpReturn",
+                     "OpFunctionEnd",
+      // clang-format on
+  };
+  std::vector<const char*> output{
+      // clang-format off
+                     "OpCapability Shader",
+                     "OpExtension \"SPV_KHR_non_semantic_info\"",
+                "%1 = OpExtInstImport \"NonSemantic.Testing.Set\"",
+                     "OpMemoryModel Logical GLSL450",
+                     "OpEntryPoint Vertex %2 \"main\"",
+                "%4 = OpString \"secondary.inc\"",
+             "%void = OpTypeVoid",
+                "%6 = OpTypeFunction %void",
+                "%2 = OpFunction %void None %6",
+                "%7 = OpLabel",
+                "%8 = OpExtInst %void %1 5 %4",
+                     "OpReturn",
+                     "OpFunctionEnd",
+      // clang-format on
+  };
+  SinglePassRunAndCheck<StripDebugInfoPass>(JoinAllInsts(input),
+                                            JoinAllInsts(output),
+                                            /* skip_nop = */ false,
+                                            /* do_validation */ true);
+}
+
 using StripDebugInfoTest = PassTest<::testing::TestWithParam<const char*>>;
 
 TEST_P(StripDebugInfoTest, Kind) {
diff --git a/test/val/CMakeLists.txt b/test/val/CMakeLists.txt
index d4bfe1d..138e711 100644
--- a/test/val/CMakeLists.txt
+++ b/test/val/CMakeLists.txt
@@ -70,6 +70,7 @@
        val_memory_test.cpp
        val_misc_test.cpp
        val_modes_test.cpp
+       val_non_semantic_test.cpp
        val_non_uniform_test.cpp
        val_opencl_test.cpp
        val_primitives_test.cpp
diff --git a/test/val/val_adjacency_test.cpp b/test/val/val_adjacency_test.cpp
index e61c03d..0b09de0 100644
--- a/test/val/val_adjacency_test.cpp
+++ b/test/val/val_adjacency_test.cpp
@@ -315,6 +315,243 @@
                         "non-OpPhi instructions"));
 }
 
+TEST_F(ValidateAdjacency, NonSemanticBeforeOpPhiBad) {
+  const std::string body = R"(
+OpSelectionMerge %end_label None
+OpBranchConditional %true %true_label %false_label
+%true_label = OpLabel
+OpBranch %end_label
+%false_label = OpLabel
+OpBranch %end_label
+%end_label = OpLabel
+%dummy = OpExtInst %void %extinst 123 %int_1
+%result = OpPhi %bool %true %true_label %false %false_label
+)";
+
+  const std::string extra = R"(OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+)";
+
+  CompileSuccessfully(GenerateShaderCode(body, extra));
+  EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("OpPhi must appear within a non-entry block before all "
+                        "non-OpPhi instructions"));
+}
+
+TEST_F(ValidateAdjacency, NonSemanticBetweenOpPhiBad) {
+  const std::string body = R"(
+OpSelectionMerge %end_label None
+OpBranchConditional %true %true_label %false_label
+%true_label = OpLabel
+OpBranch %end_label
+%false_label = OpLabel
+OpBranch %end_label
+%end_label = OpLabel
+%result1 = OpPhi %bool %true %true_label %false %false_label
+%dummy = OpExtInst %void %extinst 123 %int_1
+%result2 = OpPhi %bool %true %true_label %false %false_label
+)";
+
+  const std::string extra = R"(OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+)";
+
+  CompileSuccessfully(GenerateShaderCode(body, extra));
+  EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("OpPhi must appear within a non-entry block before all "
+                        "non-OpPhi instructions"));
+}
+
+TEST_F(ValidateAdjacency, NonSemanticAfterOpPhiGood) {
+  const std::string body = R"(
+OpSelectionMerge %end_label None
+OpBranchConditional %true %true_label %false_label
+%true_label = OpLabel
+OpBranch %end_label
+%false_label = OpLabel
+OpBranch %end_label
+%end_label = OpLabel
+OpLine %string 0 0
+%result = OpPhi %bool %true %true_label %false %false_label
+%dummy = OpExtInst %void %extinst 123 %int_1
+)";
+
+  const std::string extra = R"(OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+)";
+
+  CompileSuccessfully(GenerateShaderCode(body, extra));
+  EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
+TEST_F(ValidateAdjacency, NonSemanticBeforeOpFunctionParameterBad) {
+  const std::string body = R"(
+OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+OpMemoryModel Logical GLSL450
+OpEntryPoint Fragment %main "main"
+OpExecutionMode %main OriginUpperLeft
+
+%string = OpString ""
+%void = OpTypeVoid
+%bool = OpTypeBool
+%int = OpTypeInt 32 0
+%true = OpConstantTrue %bool
+%false = OpConstantFalse %bool
+%zero = OpConstant %int 0
+%int_1 = OpConstant %int 1
+%func = OpTypeFunction %void
+%func_int = OpTypePointer Function %int
+%paramfunc_type = OpTypeFunction %void %int %int
+
+%paramfunc = OpFunction %void None %paramfunc_type
+%dummy = OpExtInst %void %extinst 123 %int_1
+%a = OpFunctionParameter %int
+%b = OpFunctionParameter %int
+%paramfunc_entry = OpLabel
+OpReturn
+OpFunctionEnd
+
+%main = OpFunction %void None %func
+%main_entry = OpLabel
+OpReturn
+OpFunctionEnd
+)";
+
+  CompileSuccessfully(body);
+  EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions());
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("Non-semantic OpExtInst within function definition "
+                        "must appear in a block"));
+}
+
+TEST_F(ValidateAdjacency, NonSemanticBetweenOpFunctionParameterBad) {
+  const std::string body = R"(
+OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+OpMemoryModel Logical GLSL450
+OpEntryPoint Fragment %main "main"
+OpExecutionMode %main OriginUpperLeft
+
+%string = OpString ""
+%void = OpTypeVoid
+%bool = OpTypeBool
+%int = OpTypeInt 32 0
+%true = OpConstantTrue %bool
+%false = OpConstantFalse %bool
+%zero = OpConstant %int 0
+%int_1 = OpConstant %int 1
+%func = OpTypeFunction %void
+%func_int = OpTypePointer Function %int
+%paramfunc_type = OpTypeFunction %void %int %int
+
+%paramfunc = OpFunction %void None %paramfunc_type
+%a = OpFunctionParameter %int
+%dummy = OpExtInst %void %extinst 123 %int_1
+%b = OpFunctionParameter %int
+%paramfunc_entry = OpLabel
+OpReturn
+OpFunctionEnd
+
+%main = OpFunction %void None %func
+%main_entry = OpLabel
+OpReturn
+OpFunctionEnd
+)";
+
+  CompileSuccessfully(body);
+  EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions());
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("Non-semantic OpExtInst within function definition "
+                        "must appear in a block"));
+}
+
+TEST_F(ValidateAdjacency, NonSemanticAfterOpFunctionParameterGood) {
+  const std::string body = R"(
+OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+OpMemoryModel Logical GLSL450
+OpEntryPoint Fragment %main "main"
+OpExecutionMode %main OriginUpperLeft
+
+%string = OpString ""
+%void = OpTypeVoid
+%bool = OpTypeBool
+%int = OpTypeInt 32 0
+%true = OpConstantTrue %bool
+%false = OpConstantFalse %bool
+%zero = OpConstant %int 0
+%int_1 = OpConstant %int 1
+%func = OpTypeFunction %void
+%func_int = OpTypePointer Function %int
+%paramfunc_type = OpTypeFunction %void %int %int
+
+%paramfunc = OpFunction %void None %paramfunc_type
+%a = OpFunctionParameter %int
+%b = OpFunctionParameter %int
+%paramfunc_entry = OpLabel
+%dummy = OpExtInst %void %extinst 123 %int_1
+OpReturn
+OpFunctionEnd
+
+%main = OpFunction %void None %func
+%main_entry = OpLabel
+OpReturn
+OpFunctionEnd
+)";
+
+  CompileSuccessfully(body);
+  EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
+TEST_F(ValidateAdjacency, NonSemanticBetweenFunctionsGood) {
+  const std::string body = R"(
+OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+OpMemoryModel Logical GLSL450
+OpEntryPoint Fragment %main "main"
+OpExecutionMode %main OriginUpperLeft
+
+%string = OpString ""
+%void = OpTypeVoid
+%bool = OpTypeBool
+%int = OpTypeInt 32 0
+%true = OpConstantTrue %bool
+%false = OpConstantFalse %bool
+%zero = OpConstant %int 0
+%int_1 = OpConstant %int 1
+%func = OpTypeFunction %void
+%func_int = OpTypePointer Function %int
+%paramfunc_type = OpTypeFunction %void %int %int
+
+%paramfunc = OpFunction %void None %paramfunc_type
+%a = OpFunctionParameter %int
+%b = OpFunctionParameter %int
+%paramfunc_entry = OpLabel
+OpReturn
+OpFunctionEnd
+
+%dummy = OpExtInst %void %extinst 123 %int_1
+
+%main = OpFunction %void None %func
+%main_entry = OpLabel
+OpReturn
+OpFunctionEnd
+)";
+
+  CompileSuccessfully(body);
+  EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
 TEST_F(ValidateAdjacency, OpVariableInFunctionGood) {
   const std::string body = R"(
 OpLine %string 1 1
diff --git a/test/val/val_non_semantic_test.cpp b/test/val/val_non_semantic_test.cpp
new file mode 100644
index 0000000..b80bb1a
--- /dev/null
+++ b/test/val/val_non_semantic_test.cpp
@@ -0,0 +1,195 @@
+// Copyright (c) 2019 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.
+
+// Validation tests for non-semantic instructions
+
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "test/unit_spirv.h"
+#include "test/val/val_code_generator.h"
+#include "test/val/val_fixtures.h"
+
+namespace spvtools {
+namespace val {
+namespace {
+
+struct TestResult {
+  TestResult(spv_result_t in_validation_result = SPV_SUCCESS,
+             const char* in_error_str = nullptr,
+             const char* in_error_str2 = nullptr)
+      : validation_result(in_validation_result),
+        error_str(in_error_str),
+        error_str2(in_error_str2) {}
+  spv_result_t validation_result;
+  const char* error_str;
+  const char* error_str2;
+};
+
+using ::testing::Combine;
+using ::testing::HasSubstr;
+using ::testing::Values;
+using ::testing::ValuesIn;
+
+using ValidateNonSemanticGenerated = spvtest::ValidateBase<
+    std::tuple<bool, bool, const char*, const char*, TestResult>>;
+using ValidateNonSemanticString = spvtest::ValidateBase<bool>;
+
+CodeGenerator GetNonSemanticCodeGenerator(const bool declare_ext,
+                                          const bool declare_extinst,
+                                          const char* const global_extinsts,
+                                          const char* const function_extinsts) {
+  CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
+
+  if (declare_ext) {
+    generator.extensions_ += "OpExtension \"SPV_KHR_non_semantic_info\"\n";
+  }
+  if (declare_extinst) {
+    generator.extensions_ +=
+        "%extinst = OpExtInstImport \"NonSemantic.Testing.Set\"\n";
+  }
+
+  generator.after_types_ = global_extinsts;
+
+  generator.before_types_ = "%decorate_group = OpDecorationGroup";
+
+  EntryPoint entry_point;
+  entry_point.name = "main";
+  entry_point.execution_model = "Vertex";
+
+  entry_point.body = R"(
+)";
+  entry_point.body += function_extinsts;
+  generator.entry_points_.push_back(std::move(entry_point));
+
+  return generator;
+}
+
+TEST_P(ValidateNonSemanticGenerated, InTest) {
+  const bool declare_ext = std::get<0>(GetParam());
+  const bool declare_extinst = std::get<1>(GetParam());
+  const char* const global_extinsts = std::get<2>(GetParam());
+  const char* const function_extinsts = std::get<3>(GetParam());
+  const TestResult& test_result = std::get<4>(GetParam());
+
+  CodeGenerator generator = GetNonSemanticCodeGenerator(
+      declare_ext, declare_extinst, global_extinsts, function_extinsts);
+
+  CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
+  ASSERT_EQ(test_result.validation_result,
+            ValidateInstructions(SPV_ENV_VULKAN_1_0));
+  if (test_result.error_str) {
+    EXPECT_THAT(getDiagnosticString(),
+                testing::ContainsRegex(test_result.error_str));
+  }
+  if (test_result.error_str2) {
+    EXPECT_THAT(getDiagnosticString(),
+                testing::ContainsRegex(test_result.error_str2));
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(OnlyOpExtension, ValidateNonSemanticGenerated,
+                         Combine(Values(true), Values(false), Values(""),
+                                 Values(""), Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    MissingOpExtension, ValidateNonSemanticGenerated,
+    Combine(Values(false), Values(true), Values(""), Values(""),
+            Values(TestResult(
+                SPV_ERROR_INVALID_DATA,
+                "NonSemantic extended instruction sets cannot be declared "
+                "without SPV_KHR_non_semantic_info."))));
+
+INSTANTIATE_TEST_SUITE_P(NoExtInst, ValidateNonSemanticGenerated,
+                         Combine(Values(true), Values(true), Values(""),
+                                 Values(""), Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    SimpleGlobalExtInst, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true),
+            Values("%result = OpExtInst %void %extinst 123 %i32"), Values(""),
+            Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    ComplexGlobalExtInst, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true),
+            Values("%result = OpExtInst %void %extinst  123 %i32 %u32_2 "
+                   "%f32vec4_1234 %u32_0"),
+            Values(""), Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    SimpleFunctionLevelExtInst, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true), Values(""),
+            Values("%result = OpExtInst %void %extinst 123 %i32"),
+            Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    FunctionTypeReference, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true),
+            Values("%result = OpExtInst %void %extinst 123 %func"), Values(""),
+            Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    EntryPointReference, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true), Values(""),
+            Values("%result = OpExtInst %void %extinst 123 %main"),
+            Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    DecorationGroupReference, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true), Values(""),
+            Values("%result = OpExtInst %void %extinst 123 %decorate_group"),
+            Values(TestResult())));
+
+INSTANTIATE_TEST_SUITE_P(
+    UnknownIDReference, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true),
+            Values("%result = OpExtInst %void %extinst 123 %undefined_id"),
+            Values(""),
+            Values(TestResult(SPV_ERROR_INVALID_ID,
+                              "ID .* has not been defined"))));
+
+INSTANTIATE_TEST_SUITE_P(
+    NonSemanticUseInSemantic, ValidateNonSemanticGenerated,
+    Combine(Values(true), Values(true),
+            Values("%result = OpExtInst %f32 %extinst 123 %i32\n"
+                   "%invalid = OpConstantComposite %f32vec2 %f32_0 %result"),
+            Values(""),
+            Values(TestResult(SPV_ERROR_INVALID_ID,
+                              "in semantic instruction cannot be a "
+                              "non-semantic instruction"))));
+
+TEST_F(ValidateNonSemanticString, InvalidSectionOpExtInst) {
+  const std::string spirv = R"(
+OpCapability Shader
+OpExtension "SPV_KHR_non_semantic_info"
+%extinst = OpExtInstImport "NonSemantic.Testing.Set"
+%test = OpExtInst %void %extinst 4 %void
+OpMemoryModel Logical GLSL450
+OpEntryPoint Vertex %main "main"
+)";
+
+  CompileSuccessfully(spirv);
+  EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0));
+
+  // there's no specific error for using an OpExtInst too early, it requires a
+  // type so by definition any use of a type in it will be an undefined ID
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("ID 2[%2] has not been defined"));
+}
+
+}  // namespace
+}  // namespace val
+}  // namespace spvtools
diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp
index 4364e3e..0ff937a 100644
--- a/tools/opt/opt.cpp
+++ b/tools/opt/opt.cpp
@@ -467,7 +467,8 @@
   printf(R"(
   --strip-reflect
                Remove all reflection information.  For now, this covers
-               reflection information defined by SPV_GOOGLE_hlsl_functionality1.)");
+               reflection information defined by SPV_GOOGLE_hlsl_functionality1
+               and SPV_KHR_non_semantic_info)");
   printf(R"(
   --target-env=<env>
                Set the target environment. Without this flag the target
diff --git a/utils/generate_grammar_tables.py b/utils/generate_grammar_tables.py
index ed24bd0..f6c671e 100755
--- a/utils/generate_grammar_tables.py
+++ b/utils/generate_grammar_tables.py
@@ -30,6 +30,7 @@
 SPV_AMD_gpu_shader_half_float
 SPV_AMD_gpu_shader_int16
 SPV_AMD_shader_trinary_minmax
+SPV_KHR_non_semantic_info
 """