Re-format files in source, source/opt, source/util, source/val and tools.

NFC. This just makes sure every file is formatted following the
formatting definition in .clang-format.

Re-formatted with:

$ clang-format -i $(find source tools include -name '*.cpp')
$ clang-format -i $(find source tools include -name '*.h')

111 files changed, 2186 insertions, 2588 deletions

diff --git a/source/binary.cpp b/source/binary.cpp
index 2ade2546..24a2b923 100644
--- a/source/binary.cpp
+++ b/source/binary.cpp
@@ -179,12 +179,11 @@ class Parser {
           word_index(0),
           endian(),
           requires_endian_conversion(false) {
-
-        // Temporary storage for parser state within a single instruction.
-        // Most instructions require fewer than 25 words or operands.
-        operands.reserve(25);
-        endian_converted_words.reserve(25);
-        expected_operands.reserve(25);
+      // Temporary storage for parser state within a single instruction.
+      // Most instructions require fewer than 25 words or operands.
+      operands.reserve(25);
+      endian_converted_words.reserve(25);
+      expected_operands.reserve(25);
     }
     State() : State(0, 0, nullptr) {}
     const uint32_t* words;       // Words in the binary SPIR-V module.
@@ -310,7 +309,8 @@ spv_result_t Parser::parseInstruction() {
   // own operands depending on the selected extended instruction.
   _.expected_operands.clear();
   for (auto i = 0; i < opcode_desc->numTypes; i++)
-      _.expected_operands.push_back(opcode_desc->operandTypes[opcode_desc->numTypes - i - 1]);
+    _.expected_operands.push_back(
+        opcode_desc->operandTypes[opcode_desc->numTypes - i - 1]);
 
   while (_.word_index < inst_offset + inst_word_count) {
     const uint16_t inst_word_index = uint16_t(_.word_index - inst_offset);
@@ -323,7 +323,8 @@ spv_result_t Parser::parseInstruction() {
                           << inst_word_count << ".";
     }
 
-    spv_operand_type_t type = spvTakeFirstMatchableOperand(&_.expected_operands);
+    spv_operand_type_t type =
+        spvTakeFirstMatchableOperand(&_.expected_operands);
 
     if (auto error =
             parseOperand(inst_offset, &inst, type, &_.endian_converted_words,
@@ -355,7 +356,8 @@ spv_result_t Parser::parseInstruction() {
   // word.
   assert(!_.requires_endian_conversion ||
          (inst_word_count == _.endian_converted_words.size()));
-  assert(_.requires_endian_conversion || (_.endian_converted_words.size() == 1));
+  assert(_.requires_endian_conversion ||
+         (_.endian_converted_words.size() == 1));
 
   recordNumberType(inst_offset, &inst);
 
@@ -430,8 +432,8 @@ spv_result_t Parser::parseOperand(size_t inst_offset,
       // Save the result ID to type ID mapping.
       // In the grammar, type ID always appears before result ID.
       if (_.id_to_type_id.find(inst->result_id) != _.id_to_type_id.end())
-        return diagnostic(SPV_ERROR_INVALID_ID) << "Id " << inst->result_id
-                                                << " is defined more than once";
+        return diagnostic(SPV_ERROR_INVALID_ID)
+               << "Id " << inst->result_id << " is defined more than once";
       // Record it.
       // A regular value maps to its type.  Some instructions (e.g. OpLabel)
       // have no type Id, and will map to 0.  The result Id for a
@@ -477,8 +479,8 @@ spv_result_t Parser::parseOperand(size_t inst_offset,
     case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: {
       assert(SpvOpSpecConstantOp == opcode);
       if (grammar_.lookupSpecConstantOpcode(SpvOp(word))) {
-        return diagnostic() << "Invalid " << spvOperandTypeStr(type) << ": "
-                            << word;
+        return diagnostic()
+               << "Invalid " << spvOperandTypeStr(type) << ": " << word;
       }
       spv_opcode_desc opcode_entry = nullptr;
       if (grammar_.lookupOpcode(SpvOp(word), &opcode_entry)) {
@@ -581,8 +583,8 @@ spv_result_t Parser::parseOperand(size_t inst_offset,
         const spv_ext_inst_type_t ext_inst_type =
             spvExtInstImportTypeGet(string);
         if (SPV_EXT_INST_TYPE_NONE == ext_inst_type) {
-          return diagnostic() << "Invalid extended instruction import '"
-                              << string << "'";
+          return diagnostic()
+                 << "Invalid extended instruction import '" << string << "'";
         }
         // We must have parsed a valid result ID.  It's a condition
         // of the grammar, and we only accept non-zero result Ids.
@@ -620,9 +622,9 @@ spv_result_t Parser::parseOperand(size_t inst_offset,
 
       spv_operand_desc entry;
       if (grammar_.lookupOperand(type, word, &entry)) {
-        return diagnostic() << "Invalid "
-                            << spvOperandTypeStr(parsed_operand.type)
-                            << " operand: " << word;
+        return diagnostic()
+               << "Invalid " << spvOperandTypeStr(parsed_operand.type)
+               << " operand: " << word;
       }
       // Prepare to accept operands to this operand, if needed.
       spvPushOperandTypes(entry->operandTypes, expected_operands);
diff --git a/source/cfa.h b/source/cfa.h
index 6cba06ab..56f8f118 100644
--- a/source/cfa.h
+++ b/source/cfa.h
@@ -17,9 +17,9 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstdint>
 #include <functional>
 #include <map>
-#include <cstdint>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -36,12 +36,12 @@ using std::vector;
 namespace spvtools {
 
 // Control Flow Analysis of control flow graphs of basic block nodes |BB|.
-template<class BB> class CFA {
+template <class BB>
+class CFA {
   using bb_ptr = BB*;
   using cbb_ptr = const BB*;
   using bb_iter = typename std::vector<BB*>::const_iterator;
-  using get_blocks_func =
-    std::function<const std::vector<BB*>*(const BB*)>;
+  using get_blocks_func = std::function<const std::vector<BB*>*(const BB*)>;
 
   struct block_info {
     cbb_ptr block;  ///< pointer to the block
@@ -50,15 +50,16 @@ template<class BB> class CFA {
 
   /// Returns true if a block with @p id is found in the @p work_list vector
   ///
-  /// @param[in] work_list  Set of blocks visited in the the depth first traversal
+  /// @param[in] work_list  Set of blocks visited in the the depth first
+  /// traversal
   ///                       of the CFG
   /// @param[in] id         The ID of the block being checked
   ///
   /// @return true if the edge work_list.back().block->id() => id is a back-edge
-  static bool FindInWorkList(
-      const std::vector<block_info>& work_list, uint32_t id);
+  static bool FindInWorkList(const std::vector<block_info>& work_list,
+                             uint32_t id);
 
-public:
+ public:
   /// @brief Depth first traversal starting from the \p entry BasicBlock
   ///
   /// This function performs a depth first traversal from the \p entry
@@ -75,15 +76,16 @@ public:
   ///                       CFG following postorder traversal semantics
   /// @param[in] backedge   A function that will be called when a backedge is
   ///                       encountered during a traversal
-  /// NOTE: The @p successor_func and predecessor_func each return a pointer to a
+  /// NOTE: The @p successor_func and predecessor_func each return a pointer to
+  /// a
   /// collection such that iterators to that collection remain valid for the
   /// lifetime of the algorithm.
-  static void DepthFirstTraversal(const BB* entry,
-    get_blocks_func successor_func,
-    std::function<void(cbb_ptr)> preorder,
-    std::function<void(cbb_ptr)> postorder,
-    std::function<void(cbb_ptr, cbb_ptr)> backedge);
-  
+  static void DepthFirstTraversal(
+      const BB* entry, get_blocks_func successor_func,
+      std::function<void(cbb_ptr)> preorder,
+      std::function<void(cbb_ptr)> postorder,
+      std::function<void(cbb_ptr, cbb_ptr)> backedge);
+
   /// @brief Calculates dominator edges for a set of blocks
   ///
   /// Computes dominators using the algorithm of Cooper, Harvey, and Kennedy
@@ -92,54 +94,58 @@ public:
   /// The algorithm assumes there is a unique root node (a node without
   /// predecessors), and it is therefore at the end of the postorder vector.
   ///
-  /// This function calculates the dominator edges for a set of blocks in the CFG.
+  /// This function calculates the dominator edges for a set of blocks in the
+  /// CFG.
   /// Uses the dominator algorithm by Cooper et al.
   ///
-  /// @param[in] postorder        A vector of blocks in post order traversal order
+  /// @param[in] postorder        A vector of blocks in post order traversal
+  /// order
   ///                             in a CFG
-  /// @param[in] predecessor_func Function used to get the predecessor nodes of a
+  /// @param[in] predecessor_func Function used to get the predecessor nodes of
+  /// a
   ///                             block
   ///
   /// @return the dominator tree of the graph, as a vector of pairs of nodes.
   /// The first node in the pair is a node in the graph. The second node in the
-  /// pair is its immediate dominator in the sense of Cooper et.al., where a block
-  /// without predecessors (such as the root node) is its own immediate dominator.
+  /// pair is its immediate dominator in the sense of Cooper et.al., where a
+  /// block
+  /// without predecessors (such as the root node) is its own immediate
+  /// dominator.
   static vector<pair<BB*, BB*>> CalculateDominators(
-    const vector<cbb_ptr>& postorder, get_blocks_func predecessor_func);
+      const vector<cbb_ptr>& postorder, get_blocks_func predecessor_func);
 
   // Computes a minimal set of root nodes required to traverse, in the forward
   // direction, the CFG represented by the given vector of blocks, and successor
   // and predecessor functions.  When considering adding two nodes, each having
   // predecessors, favour using the one that appears earlier on the input blocks
   // list.
-  static std::vector<BB*> TraversalRoots(
-    const std::vector<BB*>& blocks,
-    get_blocks_func succ_func,
-    get_blocks_func pred_func);
+  static std::vector<BB*> TraversalRoots(const std::vector<BB*>& blocks,
+                                         get_blocks_func succ_func,
+                                         get_blocks_func pred_func);
 
   static void ComputeAugmentedCFG(
-    std::vector<BB*>& ordered_blocks,
-    BB* pseudo_entry_block,
-    BB* pseudo_exit_block,
-    std::unordered_map<const BB*, std::vector<BB*>>* augmented_successors_map,
-    std::unordered_map<const BB*, std::vector<BB*>>* augmented_predecessors_map,
-    get_blocks_func succ_func,
-    get_blocks_func pred_func);
+      std::vector<BB*>& ordered_blocks, BB* pseudo_entry_block,
+      BB* pseudo_exit_block,
+      std::unordered_map<const BB*, std::vector<BB*>>* augmented_successors_map,
+      std::unordered_map<const BB*, std::vector<BB*>>*
+          augmented_predecessors_map,
+      get_blocks_func succ_func, get_blocks_func pred_func);
 };
 
-template<class BB> bool CFA<BB>::FindInWorkList(const vector<block_info>& work_list,
-                                                uint32_t id) {
+template <class BB>
+bool CFA<BB>::FindInWorkList(const vector<block_info>& work_list, uint32_t id) {
   for (const auto b : work_list) {
     if (b.block->id() == id) return true;
   }
   return false;
 }
 
-template<class BB> void CFA<BB>::DepthFirstTraversal(const BB* entry,
-  get_blocks_func successor_func,
-  function<void(cbb_ptr)> preorder,
-  function<void(cbb_ptr)> postorder,
-  function<void(cbb_ptr, cbb_ptr)> backedge) {
+template <class BB>
+void CFA<BB>::DepthFirstTraversal(const BB* entry,
+                                  get_blocks_func successor_func,
+                                  function<void(cbb_ptr)> preorder,
+                                  function<void(cbb_ptr)> postorder,
+                                  function<void(cbb_ptr, cbb_ptr)> backedge) {
   unordered_set<uint32_t> processed;
 
   /// NOTE: work_list is the sequence of nodes from the root node to the node
@@ -147,7 +153,7 @@ template<class BB> void CFA<BB>::DepthFirstTraversal(const BB* entry,
   vector<block_info> work_list;
   work_list.reserve(10);
 
-  work_list.push_back({ entry, begin(*successor_func(entry)) });
+  work_list.push_back({entry, begin(*successor_func(entry))});
   preorder(entry);
   processed.insert(entry->id());
 
@@ -156,8 +162,7 @@ template<class BB> void CFA<BB>::DepthFirstTraversal(const BB* entry,
     if (top.iter == end(*successor_func(top.block))) {
       postorder(top.block);
       work_list.pop_back();
-    }
-    else {
+    } else {
       BB* child = *top.iter;
       top.iter++;
       if (FindInWorkList(work_list, child->id())) {
@@ -166,16 +171,16 @@ template<class BB> void CFA<BB>::DepthFirstTraversal(const BB* entry,
       if (processed.count(child->id()) == 0) {
         preorder(child);
         work_list.emplace_back(
-          block_info{ child, begin(*successor_func(child)) });
+            block_info{child, begin(*successor_func(child))});
         processed.insert(child->id());
       }
     }
   }
 }
 
-template<class BB>
+template <class BB>
 vector<pair<BB*, BB*>> CFA<BB>::CalculateDominators(
-  const vector<cbb_ptr>& postorder, get_blocks_func predecessor_func) {
+    const vector<cbb_ptr>& postorder, get_blocks_func predecessor_func) {
   struct block_detail {
     size_t dominator;  ///< The index of blocks's dominator in post order array
     size_t postorder_index;  ///< The index of the block in the post order array
@@ -184,7 +189,7 @@ vector<pair<BB*, BB*>> CFA<BB>::CalculateDominators(
 
   unordered_map<cbb_ptr, block_detail> idoms;
   for (size_t i = 0; i < postorder.size(); i++) {
-    idoms[postorder[i]] = { undefined_dom, i };
+    idoms[postorder[i]] = {undefined_dom, i};
   }
   idoms[postorder.back()].dominator = idoms[postorder.back()].postorder_index;
 
@@ -196,10 +201,10 @@ vector<pair<BB*, BB*>> CFA<BB>::CalculateDominators(
       // Find the first processed/reachable predecessor that is reachable
       // in the forward traversal.
       auto res = find_if(begin(predecessors), end(predecessors),
-        [&idoms, undefined_dom](BB* pred) {
-        return idoms.count(pred) &&
-          idoms[pred].dominator != undefined_dom;
-      });
+                         [&idoms, undefined_dom](BB* pred) {
+                           return idoms.count(pred) &&
+                                  idoms[pred].dominator != undefined_dom;
+                         });
       if (res == end(predecessors)) continue;
       const BB* idom = *res;
       size_t idom_idx = idoms[idom].postorder_index;
@@ -236,17 +241,16 @@ vector<pair<BB*, BB*>> CFA<BB>::CalculateDominators(
   for (auto idom : idoms) {
     // NOTE: performing a const cast for convenient usage with
     // UpdateImmediateDominators
-    out.push_back({ const_cast<BB*>(get<0>(idom)),
-      const_cast<BB*>(postorder[get<1>(idom).dominator]) });
+    out.push_back({const_cast<BB*>(get<0>(idom)),
+                   const_cast<BB*>(postorder[get<1>(idom).dominator])});
   }
   return out;
 }
 
-template<class BB>
-std::vector<BB*> CFA<BB>::TraversalRoots(
-    const std::vector<BB*>& blocks,
-    get_blocks_func succ_func,
-    get_blocks_func pred_func) {
+template <class BB>
+std::vector<BB*> CFA<BB>::TraversalRoots(const std::vector<BB*>& blocks,
+                                         get_blocks_func succ_func,
+                                         get_blocks_func pred_func) {
   // The set of nodes which have been visited from any of the roots so far.
   std::unordered_set<const BB*> visited;
 
@@ -254,11 +258,10 @@ std::vector<BB*> CFA<BB>::TraversalRoots(
   auto ignore_block = [](const BB*) {};
   auto ignore_blocks = [](const BB*, const BB*) {};
 
-
   auto traverse_from_root = [&mark_visited, &succ_func, &ignore_block,
-    &ignore_blocks](const BB* entry) {
-    DepthFirstTraversal(
-      entry, succ_func, mark_visited, ignore_block, ignore_blocks);
+                             &ignore_blocks](const BB* entry) {
+    DepthFirstTraversal(entry, succ_func, mark_visited, ignore_block,
+                        ignore_blocks);
   };
 
   std::vector<BB*> result;
@@ -283,15 +286,13 @@ std::vector<BB*> CFA<BB>::TraversalRoots(
   return result;
 }
 
-template<class BB>
+template <class BB>
 void CFA<BB>::ComputeAugmentedCFG(
-    std::vector<BB*>& ordered_blocks,
-    BB* pseudo_entry_block, BB* pseudo_exit_block,
+    std::vector<BB*>& ordered_blocks, BB* pseudo_entry_block,
+    BB* pseudo_exit_block,
     std::unordered_map<const BB*, std::vector<BB*>>* augmented_successors_map,
     std::unordered_map<const BB*, std::vector<BB*>>* augmented_predecessors_map,
-    get_blocks_func succ_func,
-    get_blocks_func pred_func) {
-
+    get_blocks_func succ_func, get_blocks_func pred_func) {
   // Compute the successors of the pseudo-entry block, and
   // the predecessors of the pseudo exit block.
   auto sources = TraversalRoots(ordered_blocks, succ_func, pred_func);
@@ -308,7 +309,7 @@ void CFA<BB>::ComputeAugmentedCFG(
   // constraint when A is a loop header that points to itself as its
   // own continue target, and B is the latch block for the loop.
   std::vector<BB*> reversed_blocks(ordered_blocks.rbegin(),
-    ordered_blocks.rend());
+                                   ordered_blocks.rend());
   auto sinks = TraversalRoots(reversed_blocks, pred_func, succ_func);
 
   // Wire up the pseudo entry block.
@@ -332,6 +333,6 @@ void CFA<BB>::ComputeAugmentedCFG(
   }
 };
 
-} // namespace spvtools
+}  // namespace spvtools
 
 #endif  // SPVTOOLS_CFA_H_
diff --git a/source/comp/markv.h b/source/comp/markv.h
index b3e27bbd..288e6808 100644
--- a/source/comp/markv.h
+++ b/source/comp/markv.h
@@ -38,9 +38,9 @@ struct MarkvCodecOptions {
 // |bits| is a textual representation of the MARK-V bit sequence used to encode
 // the instruction (char '0' for 0, char '1' for 1).
 // |comment| contains all logs generated while processing the instruction.
-using MarkvDebugConsumer = std::function<bool(
-    const std::vector<uint32_t>& words, const std::string& bits,
-    const std::string& comment)>;
+using MarkvDebugConsumer =
+    std::function<bool(const std::vector<uint32_t>& words,
+                       const std::string& bits, const std::string& comment)>;
 
 // Logging callback. Called often (if decoder reads a single bit, the log
 // consumer will receive 1 character string with that bit).
@@ -54,26 +54,20 @@ using MarkvLogConsumer = std::function<void(const std::string& snippet)>;
 // Encodes the given SPIR-V binary to MARK-V binary.
 // |log_consumer| is optional (pass MarkvLogConsumer() to disable).
 // |debug_consumer| is optional (pass MarkvDebugConsumer() to disable).
-spv_result_t SpirvToMarkv(spv_const_context context,
-                          const std::vector<uint32_t>& spirv,
-                          const MarkvCodecOptions& options,
-                          const MarkvModel& markv_model,
-                          MessageConsumer message_consumer,
-                          MarkvLogConsumer log_consumer,
-                          MarkvDebugConsumer debug_consumer,
-                          std::vector<uint8_t>* markv);
+spv_result_t SpirvToMarkv(
+    spv_const_context context, const std::vector<uint32_t>& spirv,
+    const MarkvCodecOptions& options, const MarkvModel& markv_model,
+    MessageConsumer message_consumer, MarkvLogConsumer log_consumer,
+    MarkvDebugConsumer debug_consumer, std::vector<uint8_t>* markv);
 
 // Decodes a SPIR-V binary from the given MARK-V binary.
 // |log_consumer| is optional (pass MarkvLogConsumer() to disable).
 // |debug_consumer| is optional (pass MarkvDebugConsumer() to disable).
-spv_result_t MarkvToSpirv(spv_const_context context,
-                          const std::vector<uint8_t>& markv,
-                          const MarkvCodecOptions& options,
-                          const MarkvModel& markv_model,
-                          MessageConsumer message_consumer,
-                          MarkvLogConsumer log_consumer,
-                          MarkvDebugConsumer debug_consumer,
-                          std::vector<uint32_t>* spirv);
+spv_result_t MarkvToSpirv(
+    spv_const_context context, const std::vector<uint8_t>& markv,
+    const MarkvCodecOptions& options, const MarkvModel& markv_model,
+    MessageConsumer message_consumer, MarkvLogConsumer log_consumer,
+    MarkvDebugConsumer debug_consumer, std::vector<uint32_t>* spirv);
 
 }  // namespace spvtools
 
diff --git a/source/comp/markv_codec.cpp b/source/comp/markv_codec.cpp
index b5df2b06..ae89cccb 100644
--- a/source/comp/markv_codec.cpp
+++ b/source/comp/markv_codec.cpp
@@ -30,9 +30,9 @@
 #include <memory>
 #include <numeric>
 #include <string>
-#include <vector>
 #include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 #include "spirv/1.2/GLSL.std.450.h"
 #include "spirv/1.2/OpenCL.std.h"
@@ -41,8 +41,8 @@
 #include "binary.h"
 #include "diagnostic.h"
 #include "enum_string_mapping.h"
-#include "extensions.h"
 #include "ext_inst.h"
+#include "extensions.h"
 #include "id_descriptor.h"
 #include "instruction.h"
 #include "markv.h"
@@ -56,9 +56,9 @@
 #include "util/huffman_codec.h"
 #include "util/move_to_front.h"
 #include "util/parse_number.h"
-#include "validate.h"
 #include "val/instruction.h"
 #include "val/validation_state.h"
+#include "validate.h"
 
 using libspirv::IdDescriptorCollection;
 using libspirv::Instruction;
@@ -161,31 +161,31 @@ GetMtfHuffmanCodecs() {
   std::unique_ptr<HuffmanCodec<uint32_t>> codec;
 
   codec.reset(new HuffmanCodec<uint32_t>(std::map<uint32_t, uint32_t>({
-    { 0, 5 },
-    { 1, 40 },
-    { 2, 10 },
-    { 3, 5 },
-    { 4, 5 },
-    { 5, 5 },
-    { 6, 3 },
-    { 7, 3 },
-    { 8, 3 },
-    { 9, 3 },
-    { kMtfRankEncodedByValueSignal, 10 },
+      {0, 5},
+      {1, 40},
+      {2, 10},
+      {3, 5},
+      {4, 5},
+      {5, 5},
+      {6, 3},
+      {7, 3},
+      {8, 3},
+      {9, 3},
+      {kMtfRankEncodedByValueSignal, 10},
   })));
   codecs.emplace(kMtfAll, std::move(codec));
 
   codec.reset(new HuffmanCodec<uint32_t>(std::map<uint32_t, uint32_t>({
-    { 1, 50 },
-    { 2, 20 },
-    { 3, 5 },
-    { 4, 5 },
-    { 5, 2 },
-    { 6, 1 },
-    { 7, 1 },
-    { 8, 1 },
-    { 9, 1 },
-    { kMtfRankEncodedByValueSignal, 10 },
+      {1, 50},
+      {2, 20},
+      {3, 5},
+      {4, 5},
+      {5, 2},
+      {6, 1},
+      {7, 1},
+      {8, 1},
+      {9, 1},
+      {kMtfRankEncodedByValueSignal, 10},
   })));
   codecs.emplace(kMtfGenericNonZeroRank, std::move(codec));
 
@@ -258,9 +258,7 @@ bool OpcodeHasFixedNumberOfOperands(SpvOp opcode) {
   return false;
 }
 
-size_t GetNumBitsToNextByte(size_t bit_pos) {
-  return (8 - (bit_pos % 8)) % 8;
-}
+size_t GetNumBitsToNextByte(size_t bit_pos) { return (8 - (bit_pos % 8)) % 8; }
 
 // Defines and returns current MARK-V version.
 uint32_t GetMarkvVersion() {
@@ -286,10 +284,8 @@ class MarkvLogger {
   }
 
   void AppendBitSequence(const std::string& str) {
-    if (debug_consumer_)
-      instruction_bits_ << str;
-    if (use_delimiter_)
-      Append("-");
+    if (debug_consumer_) instruction_bits_ << str;
+    if (use_delimiter_) Append("-");
     Append(str);
     use_delimiter_ = true;
   }
@@ -323,10 +319,8 @@ class MarkvLogger {
   MarkvLogger& operator=(MarkvLogger&&) = delete;
 
   void Append(const std::string& str) {
-    if (log_consumer_)
-      log_consumer_(str);
-    if (debug_consumer_)
-      instruction_comment_ << str;
+    if (log_consumer_) log_consumer_(str);
+    if (debug_consumer_) instruction_comment_ << str;
   }
 
   MarkvLogConsumer log_consumer_;
@@ -346,9 +340,7 @@ class MarkvLogger {
 // - SPIR-V grammar and helper functions.
 class MarkvCodecBase {
  public:
-  virtual ~MarkvCodecBase() {
-    spvValidatorOptionsDestroy(validator_options_);
-  }
+  virtual ~MarkvCodecBase() { spvValidatorOptionsDestroy(validator_options_); }
 
   MarkvCodecBase() = delete;
 
@@ -377,17 +369,19 @@ class MarkvCodecBase {
   explicit MarkvCodecBase(spv_const_context context,
                           spv_validator_options validator_options,
                           const MarkvModel* model)
-      : validator_options_(validator_options), grammar_(context),
-        model_(model), mtf_huffman_codecs_(GetMtfHuffmanCodecs()),
+      : validator_options_(validator_options),
+        grammar_(context),
+        model_(model),
+        mtf_huffman_codecs_(GetMtfHuffmanCodecs()),
         context_(context),
-        vstate_(validator_options ?
-                new ValidationState_t(context, validator_options_) : nullptr) {}
+        vstate_(validator_options
+                    ? new ValidationState_t(context, validator_options_)
+                    : nullptr) {}
 
   // Validates a single instruction and updates validation state of the module.
   // Does nothing and returns SPV_SUCCESS if validator was not created.
   spv_result_t UpdateValidationState(const spv_parsed_instruction_t& inst) {
-    if (!vstate_)
-      return SPV_SUCCESS;
+    if (!vstate_) return SPV_SUCCESS;
 
     return ValidateInstructionAndUpdateValidationState(vstate_.get(), &inst);
   }
@@ -396,8 +390,7 @@ class MarkvCodecBase {
   // not registered.
   const Instruction* FindDef(uint32_t id) const {
     const auto it = id_to_def_instruction_.find(id);
-    if (it == id_to_def_instruction_.end())
-      return nullptr;
+    if (it == id_to_def_instruction_.end()) return nullptr;
     return it->second;
   }
 
@@ -473,44 +466,38 @@ class MarkvCodecBase {
   // Returns words of the current instruction. Decoder has a different
   // implementation and the array is valid only until the previously decoded
   // word.
-  virtual const uint32_t* GetInstWords() const {
-    return inst_.words;
-  }
+  virtual const uint32_t* GetInstWords() const { return inst_.words; }
 
   // Returns the opcode of the previous instruction.
   SpvOp GetPrevOpcode() const {
-    if (instructions_.empty())
-      return SpvOpNop;
+    if (instructions_.empty()) return SpvOpNop;
 
     return instructions_.back()->opcode();
   }
 
   // Returns diagnostic stream, position index is set to instruction number.
   DiagnosticStream Diag(spv_result_t error_code) const {
-    return DiagnosticStream({0, 0, instructions_.size()},
-                            context_->consumer, error_code);
+    return DiagnosticStream({0, 0, instructions_.size()}, context_->consumer,
+                            error_code);
   }
 
   // Returns current id bound.
-  uint32_t GetIdBound() const {
-    return id_bound_;
-  }
+  uint32_t GetIdBound() const { return id_bound_; }
 
   // Sets current id bound, expected to be no lower than the previous one.
   void SetIdBound(uint32_t id_bound) {
     assert(id_bound >= id_bound_);
     id_bound_ = id_bound;
-    if (vstate_)
-      vstate_->setIdBound(id_bound);
+    if (vstate_) vstate_->setIdBound(id_bound);
   }
 
   // Returns Huffman codec for ranks of the mtf with given |handle|.
   // Different mtfs can use different rank distributions.
   // May return nullptr if the codec doesn't exist.
-  const spvutils::HuffmanCodec<uint32_t>* GetMtfHuffmanCodec(uint64_t handle) const {
+  const spvutils::HuffmanCodec<uint32_t>* GetMtfHuffmanCodec(
+      uint64_t handle) const {
     const auto it = mtf_huffman_codecs_.find(handle);
-    if (it == mtf_huffman_codecs_.end())
-      return nullptr;
+    if (it == mtf_huffman_codecs_.end()) return nullptr;
     return it->second.get();
   }
 
@@ -586,19 +573,17 @@ class MarkvEncoder : public MarkvCodecBase {
  public:
   // |model| is owned by the caller, must be not null and valid during the
   // lifetime of MarkvEncoder.
-  MarkvEncoder(spv_const_context context,
-               const MarkvCodecOptions& options,
+  MarkvEncoder(spv_const_context context, const MarkvCodecOptions& options,
                const MarkvModel* model)
       : MarkvCodecBase(context, GetValidatorOptions(options), model),
         options_(options) {
-    (void) options_;
+    (void)options_;
   }
 
   // Writes data from SPIR-V header to MARK-V header.
-  spv_result_t EncodeHeader(
-      spv_endianness_t /* endian */, uint32_t /* magic */,
-      uint32_t version, uint32_t generator, uint32_t id_bound,
-      uint32_t /* schema */) {
+  spv_result_t EncodeHeader(spv_endianness_t /* endian */, uint32_t /* magic */,
+                            uint32_t version, uint32_t generator,
+                            uint32_t id_bound, uint32_t /* schema */) {
     SetIdBound(id_bound);
     header_.spirv_version = version;
     header_.spirv_generator = generator;
@@ -609,9 +594,8 @@ class MarkvEncoder : public MarkvCodecBase {
   void CreateLogger(MarkvLogConsumer log_consumer,
                     MarkvDebugConsumer debug_consumer) {
     logger_.reset(new MarkvLogger(log_consumer, debug_consumer));
-    writer_.SetCallback([this](const std::string& str){
-      logger_->AppendBitSequence(str);
-    });
+    writer_.SetCallback(
+        [this](const std::string& str) { logger_->AppendBitSequence(str); });
   }
 
   // Encodes SPIR-V instruction to MARK-V and writes to bit stream.
@@ -634,8 +618,8 @@ class MarkvEncoder : public MarkvCodecBase {
 
     assert(writer_.GetData());
     std::memcpy(markv.data(), &header_, sizeof(header_));
-    std::memcpy(markv.data() + sizeof(header_),
-                writer_.GetData(), writer_.GetDataSizeBytes());
+    std::memcpy(markv.data() + sizeof(header_), writer_.GetData(),
+                writer_.GetDataSizeBytes());
     return markv;
   }
 
@@ -659,8 +643,8 @@ class MarkvEncoder : public MarkvCodecBase {
   // Creates and returns validator options. Returned value owned by the caller.
   static spv_validator_options GetValidatorOptions(
       const MarkvCodecOptions& options) {
-    return options.validate_spirv_binary ?
-        spvValidatorOptionsCreate() : nullptr;
+    return options.validate_spirv_binary ? spvValidatorOptionsCreate()
+                                         : nullptr;
   }
 
   // Writes a single word to bit stream. operand_.type determines if the word is
@@ -669,7 +653,8 @@ class MarkvEncoder : public MarkvCodecBase {
 
   // Writes both opcode and num_operands as a single code.
   // Returns SPV_UNSUPPORTED iff no suitable codec was found.
-  spv_result_t EncodeOpcodeAndNumOperands(uint32_t opcode, uint32_t num_operands);
+  spv_result_t EncodeOpcodeAndNumOperands(uint32_t opcode,
+                                          uint32_t num_operands);
 
   // Writes mtf rank to bit stream. |mtf| is used to determine the codec
   // scheme. |fallback_method| is used if no codec defined for |mtf|.
@@ -715,13 +700,12 @@ class MarkvDecoder : public MarkvCodecBase {
  public:
   // |model| is owned by the caller, must be not null and valid during the
   // lifetime of MarkvEncoder.
-  MarkvDecoder(spv_const_context context,
-               const std::vector<uint8_t>& markv,
-               const MarkvCodecOptions& options,
-               const MarkvModel* model)
+  MarkvDecoder(spv_const_context context, const std::vector<uint8_t>& markv,
+               const MarkvCodecOptions& options, const MarkvModel* model)
       : MarkvCodecBase(context, GetValidatorOptions(options), model),
-        options_(options), reader_(markv) {
-    (void) options_;
+        options_(options),
+        reader_(markv) {
+    (void)options_;
     SetIdBound(1);
     parsed_operands_.reserve(25);
     inst_words_.reserve(25);
@@ -748,8 +732,8 @@ class MarkvDecoder : public MarkvCodecBase {
   // Creates and returns validator options. Returned value owned by the caller.
   static spv_validator_options GetValidatorOptions(
       const MarkvCodecOptions& options) {
-    return options.validate_spirv_binary ?
-        spvValidatorOptionsCreate() : nullptr;
+    return options.validate_spirv_binary ? spvValidatorOptionsCreate()
+                                         : nullptr;
   }
 
   // Reads a single bit from reader_. The read bit is stored in |bit|.
@@ -757,8 +741,7 @@ class MarkvDecoder : public MarkvCodecBase {
   bool ReadBit(bool* bit) {
     uint64_t bits = 0;
     const bool result = reader_.ReadBits(&bits, 1);
-    if (result)
-      *bit = bits ? true : false;
+    if (result) *bit = bits ? true : false;
     return result;
   };
 
@@ -803,9 +786,7 @@ class MarkvDecoder : public MarkvCodecBase {
   bool ReadToByteBreak(size_t byte_break_if_less_than);
 
   // Returns instruction words decoded up to this point.
-  const uint32_t* GetInstWords() const override {
-    return inst_words_.data();
-  }
+  const uint32_t* GetInstWords() const override { return inst_words_.data(); }
 
   // Reads a literal number as it is described in |operand| from the bit stream,
   // decodes and writes it to spirv_.
@@ -866,7 +847,7 @@ void MarkvCodecBase::ProcessCurInstruction() {
     id_to_def_instruction_.emplace(inst_.result_id, instructions_.back().get());
 
     // Collect ids local to the current function.
-    if (cur_function_id_){
+    if (cur_function_id_) {
       ids_local_to_cur_function_.push_back(inst_.result_id);
     }
 
@@ -891,14 +872,12 @@ void MarkvCodecBase::ProcessCurInstruction() {
   // Remove local ids from MTFs if function end.
   if (opcode == SpvOpFunctionEnd) {
     cur_function_id_ = 0;
-    for (uint32_t id : ids_local_to_cur_function_)
-      multi_mtf_.RemoveFromAll(id);
+    for (uint32_t id : ids_local_to_cur_function_) multi_mtf_.RemoveFromAll(id);
     ids_local_to_cur_function_.clear();
     assert(remaining_function_parameter_types_.empty());
   }
 
-  if (!inst_.result_id)
-    return;
+  if (!inst_.result_id) return;
 
   {
     // Save the result ID to type ID mapping.
@@ -908,8 +887,8 @@ void MarkvCodecBase::ProcessCurInstruction() {
     // type-generating instruction (e.g. OpTypeInt) maps to itself.
     auto insertion_result = id_to_type_id_.emplace(
         inst_.result_id,
-        spvOpcodeGeneratesType(SpvOp(inst_.opcode)) ?
-        inst_.result_id : inst_.type_id);
+        spvOpcodeGeneratesType(SpvOp(inst_.opcode)) ? inst_.result_id
+                                                    : inst_.type_id);
     (void)insertion_result;
     assert(insertion_result.second);
   }
@@ -962,10 +941,10 @@ void MarkvCodecBase::ProcessCurInstruction() {
                             component_type_id)) {
       multi_mtf_.Insert(kMtfTypeFloatScalarOrVector, inst_.result_id);
     } else if (multi_mtf_.HasValue(GetMtfIdGeneratedByOpcode(SpvOpTypeInt),
-                            component_type_id)) {
+                                   component_type_id)) {
       multi_mtf_.Insert(kMtfTypeIntScalarOrVector, inst_.result_id);
     } else if (multi_mtf_.HasValue(GetMtfIdGeneratedByOpcode(SpvOpTypeBool),
-                            component_type_id)) {
+                                   component_type_id)) {
       multi_mtf_.Insert(kMtfTypeBoolScalarOrVector, inst_.result_id);
     }
     multi_mtf_.Insert(GetMtfTypeVectorOfSize(size), inst_.result_id);
@@ -1007,8 +986,9 @@ void MarkvCodecBase::ProcessCurInstruction() {
       case SpvOpTypeImage:
       case SpvOpTypeSampledImage:
       case SpvOpTypeSampler:
-        multi_mtf_.Insert(GetMtfIdWithTypeGeneratedByOpcode(
-            type_inst->opcode()), inst_.result_id);
+        multi_mtf_.Insert(
+            GetMtfIdWithTypeGeneratedByOpcode(type_inst->opcode()),
+            inst_.result_id);
         break;
       default:
         break;
@@ -1056,7 +1036,7 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
       (inst_.opcode == SpvOpSelectionMerge && operand_index_ == 0) ||
       (inst_.opcode == SpvOpBranch && operand_index_ == 0) ||
       (inst_.opcode == SpvOpBranchConditional &&
-       (operand_index_ == 1 || operand_index_ == 2 )) ||
+       (operand_index_ == 1 || operand_index_ == 2)) ||
       (inst_.opcode == SpvOpPhi && operand_index_ >= 3 &&
        operand_index_ % 2 == 1) ||
       (inst_.opcode == SpvOpSwitch && operand_index_ > 0)) {
@@ -1071,8 +1051,7 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     case SpvOpFRem:
     case SpvOpFMod:
     case SpvOpFNegate: {
-      if (operand_index_ == 0)
-        return kMtfTypeFloatScalarOrVector;
+      if (operand_index_ == 0) return kMtfTypeFloatScalarOrVector;
 
       return GetMtfIdOfType(inst_.type_id);
     }
@@ -1086,8 +1065,7 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     case SpvOpUMod:
     case SpvOpSRem:
     case SpvOpSNegate: {
-      if (operand_index_ == 0)
-        return kMtfTypeIntScalarOrVector;
+      if (operand_index_ == 0) return kMtfTypeIntScalarOrVector;
 
       return kMtfIntScalarOrVector;
     }
@@ -1106,14 +1084,11 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     case SpvOpFUnordLessThanEqual:
     case SpvOpFOrdGreaterThanEqual:
     case SpvOpFUnordGreaterThanEqual: {
-      if (operand_index_ == 0)
-        return kMtfTypeBoolScalarOrVector;
-      if (operand_index_ == 2)
-        return kMtfFloatScalarOrVector;
+      if (operand_index_ == 0) return kMtfTypeBoolScalarOrVector;
+      if (operand_index_ == 2) return kMtfFloatScalarOrVector;
       if (operand_index_ == 3) {
         const uint32_t first_operand_id = GetInstWords()[3];
-        const uint32_t first_operand_type =
-            id_to_type_id_.at(first_operand_id);
+        const uint32_t first_operand_type = id_to_type_id_.at(first_operand_id);
         return GetMtfIdOfType(first_operand_type);
       }
       break;
@@ -1139,16 +1114,14 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
       }
 
       assert(inst_.type_id);
-      if (operand_index_ == 2)
-        return GetMtfIdOfType(inst_.type_id);
+      if (operand_index_ == 2) return GetMtfIdOfType(inst_.type_id);
       if (operand_index_ == 3)
         return GetMtfIdOfType(GetVectorComponentType(inst_.type_id));
       break;
     }
 
     case SpvOpDot: {
-      if (operand_index_ == 0)
-        return GetMtfIdGeneratedByOpcode(SpvOpTypeFloat);
+      if (operand_index_ == 0) return GetMtfIdGeneratedByOpcode(SpvOpTypeFloat);
 
       assert(inst_.type_id);
       if (operand_index_ == 2)
@@ -1201,8 +1174,7 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     }
 
     case SpvOpLoad: {
-      if (operand_index_ == 0)
-        return kMtfTypeNonFunction;
+      if (operand_index_ == 0) return kMtfTypeNonFunction;
 
       if (operand_index_ == 2) {
         assert(inst_.type_id);
@@ -1236,16 +1208,14 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     case SpvOpAccessChain: {
       if (operand_index_ == 0)
         return GetMtfIdGeneratedByOpcode(SpvOpTypePointer);
-      if (operand_index_ == 2)
-        return kMtfTypePointerToComposite;
+      if (operand_index_ == 2) return kMtfTypePointerToComposite;
       if (operand_index_ >= 3)
         return GetMtfIdWithTypeGeneratedByOpcode(SpvOpTypeInt);
       break;
     }
 
     case SpvOpCompositeConstruct: {
-      if (operand_index_ == 0)
-        return kMtfTypeComposite;
+      if (operand_index_ == 0) return kMtfTypeComposite;
       if (operand_index_ >= 2) {
         const uint32_t composite_type = GetInstWords()[1];
         if (multi_mtf_.HasValue(kMtfTypeFloatScalarOrVector, composite_type))
@@ -1259,14 +1229,12 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     }
 
     case SpvOpCompositeExtract: {
-      if (operand_index_ == 2)
-        return kMtfComposite;
+      if (operand_index_ == 2) return kMtfComposite;
       break;
     }
 
     case SpvOpConstantComposite: {
-      if (operand_index_ == 0)
-        return kMtfTypeComposite;
+      if (operand_index_ == 0) return kMtfTypeComposite;
       if (operand_index_ >= 2) {
         const Instruction* composite_type_inst = FindDef(inst_.type_id);
         assert(composite_type_inst);
@@ -1383,8 +1351,7 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     }
 
     case SpvOpFunction: {
-      if (operand_index_ == 0)
-        return kMtfTypeReturnedByFunction;
+      if (operand_index_ == 0) return kMtfTypeReturnedByFunction;
 
       if (operand_index_ == 3) {
         const uint32_t return_type = GetInstWords()[1];
@@ -1394,8 +1361,7 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
     }
 
     case SpvOpFunctionCall: {
-      if (operand_index_ == 0)
-        return kMtfTypeReturnedByFunction;
+      if (operand_index_ == 0) return kMtfTypeReturnedByFunction;
 
       if (operand_index_ == 2) {
         const uint32_t return_type = GetInstWords()[1];
@@ -1405,8 +1371,7 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
       if (operand_index_ >= 3) {
         const uint32_t function_id = GetInstWords()[3];
         const Instruction* function_inst = FindDef(function_id);
-        if (!function_inst)
-          return kMtfObject;
+        if (!function_inst) return kMtfObject;
 
         assert(function_inst->opcode() == SpvOpFunction);
 
@@ -1415,16 +1380,14 @@ uint64_t MarkvCodecBase::GetRuleBasedMtf() {
         assert(function_type_inst);
         assert(function_type_inst->opcode() == SpvOpTypeFunction);
 
-        const uint32_t argument_type =
-            function_type_inst->word(operand_index_);
+        const uint32_t argument_type = function_type_inst->word(operand_index_);
         return GetMtfIdOfType(argument_type);
       }
       break;
     }
 
     case SpvOpReturnValue: {
-      if (operand_index_ == 0)
-        return GetMtfIdOfType(cur_function_return_type_);
+      if (operand_index_ == 0) return GetMtfIdOfType(cur_function_return_type_);
       break;
     }
 
@@ -1475,10 +1438,9 @@ spv_result_t MarkvEncoder::EncodeNonIdWord(uint32_t word) {
       // Encoding failed, write kMarkvNoneOfTheAbove flag.
       if (!codec->Encode(kMarkvNoneOfTheAbove, &bits, &num_bits))
         return Diag(SPV_ERROR_INTERNAL)
-            << "Non-id word Huffman table for "
-            << spvOpcodeString(SpvOp(inst_.opcode))
-            << " operand index " << operand_index_
-            << " is missing kMarkvNoneOfTheAbove";
+               << "Non-id word Huffman table for "
+               << spvOpcodeString(SpvOp(inst_.opcode)) << " operand index "
+               << operand_index_ << " is missing kMarkvNoneOfTheAbove";
       writer_.WriteBits(bits, num_bits);
     }
   }
@@ -1501,7 +1463,7 @@ spv_result_t MarkvDecoder::DecodeNonIdWord(uint32_t* word) {
     uint64_t decoded_value = 0;
     if (!codec->DecodeFromStream(GetReadBitCallback(), &decoded_value))
       return Diag(SPV_ERROR_INVALID_BINARY)
-          << "Failed to decode non-id word with Huffman";
+             << "Failed to decode non-id word with Huffman";
 
     if (decoded_value != kMarkvNoneOfTheAbove) {
       // The word decoded successfully.
@@ -1518,24 +1480,25 @@ spv_result_t MarkvDecoder::DecodeNonIdWord(uint32_t* word) {
   if (chunk_length) {
     if (!reader_.ReadVariableWidthU32(word, chunk_length))
       return Diag(SPV_ERROR_INVALID_BINARY)
-          << "Failed to decode non-id word with varint";
+             << "Failed to decode non-id word with varint";
   } else {
     if (!reader_.ReadUnencoded(word))
       return Diag(SPV_ERROR_INVALID_BINARY)
-          << "Failed to read unencoded non-id word";
+             << "Failed to read unencoded non-id word";
   }
   return SPV_SUCCESS;
 }
 
-spv_result_t MarkvEncoder::EncodeOpcodeAndNumOperands(
-    uint32_t opcode, uint32_t num_operands) {
+spv_result_t MarkvEncoder::EncodeOpcodeAndNumOperands(uint32_t opcode,
+                                                      uint32_t num_operands) {
   uint64_t bits = 0;
   size_t num_bits = 0;
 
   const uint32_t word = opcode | (num_operands << 16);
 
   // First try to use the Markov chain codec.
-  auto* codec = model_->GetOpcodeAndNumOperandsMarkovHuffmanCodec(GetPrevOpcode());
+  auto* codec =
+      model_->GetOpcodeAndNumOperandsMarkovHuffmanCodec(GetPrevOpcode());
   if (codec) {
     if (codec->Encode(word, &bits, &num_bits)) {
       // The word was successfully encoded into bits/num_bits.
@@ -1546,9 +1509,9 @@ spv_result_t MarkvEncoder::EncodeOpcodeAndNumOperands(
       // and use fallback encoding.
       if (!codec->Encode(kMarkvNoneOfTheAbove, &bits, &num_bits))
         return Diag(SPV_ERROR_INTERNAL)
-            << "opcode_and_num_operands Huffman table for "
-            << spvOpcodeString(GetPrevOpcode())
-            << "is missing kMarkvNoneOfTheAbove";
+               << "opcode_and_num_operands Huffman table for "
+               << spvOpcodeString(GetPrevOpcode())
+               << "is missing kMarkvNoneOfTheAbove";
       writer_.WriteBits(bits, num_bits);
     }
   }
@@ -1565,8 +1528,8 @@ spv_result_t MarkvEncoder::EncodeOpcodeAndNumOperands(
     // and return false.
     if (!codec->Encode(kMarkvNoneOfTheAbove, &bits, &num_bits))
       return Diag(SPV_ERROR_INTERNAL)
-          << "Global opcode_and_num_operands Huffman table is missing "
-          << "kMarkvNoneOfTheAbove";
+             << "Global opcode_and_num_operands Huffman table is missing "
+             << "kMarkvNoneOfTheAbove";
     writer_.WriteBits(bits, num_bits);
     return SPV_UNSUPPORTED;
   }
@@ -1575,13 +1538,14 @@ spv_result_t MarkvEncoder::EncodeOpcodeAndNumOperands(
 spv_result_t MarkvDecoder::DecodeOpcodeAndNumberOfOperands(
     uint32_t* opcode, uint32_t* num_operands) {
   // First try to use the Markov chain codec.
-  auto* codec = model_->GetOpcodeAndNumOperandsMarkovHuffmanCodec(GetPrevOpcode());
+  auto* codec =
+      model_->GetOpcodeAndNumOperandsMarkovHuffmanCodec(GetPrevOpcode());
   if (codec) {
     uint64_t decoded_value = 0;
     if (!codec->DecodeFromStream(GetReadBitCallback(), &decoded_value))
       return Diag(SPV_ERROR_INTERNAL)
-          << "Failed to decode opcode_and_num_operands, previous opcode is "
-          << spvOpcodeString(GetPrevOpcode());
+             << "Failed to decode opcode_and_num_operands, previous opcode is "
+             << spvOpcodeString(GetPrevOpcode());
 
     if (decoded_value != kMarkvNoneOfTheAbove) {
       // The word was successfully decoded.
@@ -1599,7 +1563,7 @@ spv_result_t MarkvDecoder::DecodeOpcodeAndNumberOfOperands(
   uint64_t decoded_value = 0;
   if (!codec->DecodeFromStream(GetReadBitCallback(), &decoded_value))
     return Diag(SPV_ERROR_INTERNAL)
-        << "Failed to decode opcode_and_num_operands with global codec";
+           << "Failed to decode opcode_and_num_operands with global codec";
 
   if (decoded_value == kMarkvNoneOfTheAbove) {
     // Received kMarkvNoneOfTheAbove signal, fallback further.
@@ -1619,8 +1583,7 @@ spv_result_t MarkvEncoder::EncodeMtfRankHuffman(uint32_t rank, uint64_t mtf,
     codec = GetMtfHuffmanCodec(fallback_method);
   }
 
-  if (!codec)
-    return Diag(SPV_ERROR_INTERNAL) << "No codec to encode MTF rank";
+  if (!codec) return Diag(SPV_ERROR_INTERNAL) << "No codec to encode MTF rank";
 
   uint64_t bits = 0;
   size_t num_bits = 0;
@@ -1628,14 +1591,14 @@ spv_result_t MarkvEncoder::EncodeMtfRankHuffman(uint32_t rank, uint64_t mtf,
     // Encode using Huffman coding.
     if (!codec->Encode(rank, &bits, &num_bits))
       return Diag(SPV_ERROR_INTERNAL)
-          << "Failed to encode MTF rank with Huffman";
+             << "Failed to encode MTF rank with Huffman";
 
     writer_.WriteBits(bits, num_bits);
   } else {
     // Encode by value.
     if (!codec->Encode(kMtfRankEncodedByValueSignal, &bits, &num_bits))
       return Diag(SPV_ERROR_INTERNAL)
-          << "Failed to encode kMtfRankEncodedByValueSignal";
+             << "Failed to encode kMtfRankEncodedByValueSignal";
 
     writer_.WriteBits(bits, num_bits);
     writer_.WriteVariableWidthU32(rank - kMtfSmallestRankEncodedByValue,
@@ -1644,27 +1607,26 @@ spv_result_t MarkvEncoder::EncodeMtfRankHuffman(uint32_t rank, uint64_t mtf,
   return SPV_SUCCESS;
 }
 
-spv_result_t MarkvDecoder::DecodeMtfRankHuffman(
-    uint64_t mtf, uint32_t fallback_method, uint32_t* rank) {
+spv_result_t MarkvDecoder::DecodeMtfRankHuffman(uint64_t mtf,
+                                                uint32_t fallback_method,
+                                                uint32_t* rank) {
   const auto* codec = GetMtfHuffmanCodec(mtf);
   if (!codec) {
     assert(fallback_method != kMtfNone);
     codec = GetMtfHuffmanCodec(fallback_method);
   }
 
-  if (!codec)
-    return Diag(SPV_ERROR_INTERNAL) << "No codec to decode MTF rank";
+  if (!codec) return Diag(SPV_ERROR_INTERNAL) << "No codec to decode MTF rank";
 
   uint32_t decoded_value = 0;
   if (!codec->DecodeFromStream(GetReadBitCallback(), &decoded_value))
-    return Diag(SPV_ERROR_INTERNAL)
-        << "Failed to decode MTF rank with Huffman";
+    return Diag(SPV_ERROR_INTERNAL) << "Failed to decode MTF rank with Huffman";
 
   if (decoded_value == kMtfRankEncodedByValueSignal) {
     // Decode by value.
     if (!reader_.ReadVariableWidthU32(rank, model_->mtf_rank_chunk_length()))
       return Diag(SPV_ERROR_INTERNAL)
-          << "Failed to decode MTF rank with varint";
+             << "Failed to decode MTF rank with varint";
     *rank += kMtfSmallestRankEncodedByValue;
   } else {
     // Decode using Huffman coding.
@@ -1675,10 +1637,9 @@ spv_result_t MarkvDecoder::DecodeMtfRankHuffman(
 }
 
 spv_result_t MarkvEncoder::EncodeIdWithDescriptor(uint32_t id) {
-  auto* codec = model_->GetIdDescriptorHuffmanCodec(inst_.opcode,
-                                                    operand_index_);
-  if (!codec)
-    return SPV_UNSUPPORTED;
+  auto* codec =
+      model_->GetIdDescriptorHuffmanCodec(inst_.opcode, operand_index_);
+  if (!codec) return SPV_UNSUPPORTED;
 
   uint64_t bits = 0;
   size_t num_bits = 0;
@@ -1695,10 +1656,9 @@ spv_result_t MarkvEncoder::EncodeIdWithDescriptor(uint32_t id) {
     // kMarkvNoneOfTheAbove and go to fallback method.
     if (!codec->Encode(kMarkvNoneOfTheAbove, &bits, &num_bits))
       return Diag(SPV_ERROR_INTERNAL)
-          << "Descriptor Huffman table for "
-          << spvOpcodeString(SpvOp(inst_.opcode))
-          << " operand index " << operand_index_
-          << " is missing kMarkvNoneOfTheAbove";
+             << "Descriptor Huffman table for "
+             << spvOpcodeString(SpvOp(inst_.opcode)) << " operand index "
+             << operand_index_ << " is missing kMarkvNoneOfTheAbove";
 
     writer_.WriteBits(bits, num_bits);
     return SPV_UNSUPPORTED;
@@ -1711,18 +1671,16 @@ spv_result_t MarkvEncoder::EncodeIdWithDescriptor(uint32_t id) {
 }
 
 spv_result_t MarkvDecoder::DecodeIdWithDescriptor(uint32_t* id) {
-  auto* codec = model_->GetIdDescriptorHuffmanCodec(inst_.opcode,
-                                                    operand_index_);
-  if (!codec)
-    return SPV_UNSUPPORTED;
+  auto* codec =
+      model_->GetIdDescriptorHuffmanCodec(inst_.opcode, operand_index_);
+  if (!codec) return SPV_UNSUPPORTED;
 
   uint64_t decoded_value = 0;
   if (!codec->DecodeFromStream(GetReadBitCallback(), &decoded_value))
     return Diag(SPV_ERROR_INTERNAL)
-        << "Failed to decode descriptor with Huffman";
+           << "Failed to decode descriptor with Huffman";
 
-  if (decoded_value == kMarkvNoneOfTheAbove)
-    return SPV_UNSUPPORTED;
+  if (decoded_value == kMarkvNoneOfTheAbove) return SPV_UNSUPPORTED;
 
   // If descriptor exists then the id was encoded through descriptor mtf.
   const uint32_t descriptor = uint32_t(decoded_value);
@@ -1743,8 +1701,7 @@ spv_result_t MarkvEncoder::EncodeExistingId(uint64_t mtf, uint32_t id) {
 
   uint32_t rank = 0;
   if (!multi_mtf_.RankFromValue(mtf, id, &rank))
-    return Diag(SPV_ERROR_INTERNAL)
-        << "Id is not in the MTF sequence";
+    return Diag(SPV_ERROR_INTERNAL) << "Id is not in the MTF sequence";
 
   return EncodeMtfRankHuffman(rank, mtf, kMtfGenericNonZeroRank);
 }
@@ -1760,14 +1717,12 @@ spv_result_t MarkvDecoder::DecodeExistingId(uint64_t mtf, uint32_t* id) {
   } else {
     const spv_result_t result =
         DecodeMtfRankHuffman(mtf, kMtfGenericNonZeroRank, &rank);
-    if (result != SPV_SUCCESS)
-      return result;
+    if (result != SPV_SUCCESS) return result;
   }
 
   assert(rank);
   if (!multi_mtf_.ValueFromRank(mtf, rank, id))
-    return Diag(SPV_ERROR_INTERNAL)
-        << "MTF rank is out of bounds";
+    return Diag(SPV_ERROR_INTERNAL) << "MTF rank is out of bounds";
 
   return SPV_SUCCESS;
 }
@@ -1776,24 +1731,21 @@ spv_result_t MarkvEncoder::EncodeRefId(uint32_t id) {
   {
     // Try to encode using id descriptor mtfs.
     const spv_result_t result = EncodeIdWithDescriptor(id);
-    if (result != SPV_UNSUPPORTED)
-      return result;
+    if (result != SPV_UNSUPPORTED) return result;
     // If can't be done continue with other methods.
   }
 
   // Encode using rule-based mtf.
   uint64_t mtf = GetRuleBasedMtf();
-  const bool can_forward_declare =
-      spvOperandCanBeForwardDeclaredFunction(
-          SpvOp(inst_.opcode))(operand_index_);
+  const bool can_forward_declare = spvOperandCanBeForwardDeclaredFunction(
+      SpvOp(inst_.opcode))(operand_index_);
 
   if (mtf != kMtfNone && !can_forward_declare) {
     assert(multi_mtf_.HasValue(kMtfAll, id));
     return EncodeExistingId(mtf, id);
   }
 
-  if (mtf == kMtfNone)
-    mtf = kMtfAll;
+  if (mtf == kMtfNone) mtf = kMtfAll;
 
   uint32_t rank = 0;
 
@@ -1801,8 +1753,7 @@ spv_result_t MarkvEncoder::EncodeRefId(uint32_t id) {
     // This is the first occurrence of a forward declared id.
     multi_mtf_.Insert(kMtfAll, id);
     multi_mtf_.Insert(kMtfForwardDeclared, id);
-    if (mtf != kMtfAll)
-      multi_mtf_.Insert(mtf, id);
+    if (mtf != kMtfAll) multi_mtf_.Insert(mtf, id);
     rank = 0;
   }
 
@@ -1812,21 +1763,18 @@ spv_result_t MarkvEncoder::EncodeRefId(uint32_t id) {
 spv_result_t MarkvDecoder::DecodeRefId(uint32_t* id) {
   {
     const spv_result_t result = DecodeIdWithDescriptor(id);
-    if (result != SPV_UNSUPPORTED)
-      return result;
+    if (result != SPV_UNSUPPORTED) return result;
   }
 
   uint64_t mtf = GetRuleBasedMtf();
-  const bool can_forward_declare =
-      spvOperandCanBeForwardDeclaredFunction(
-          SpvOp(inst_.opcode))(operand_index_);
+  const bool can_forward_declare = spvOperandCanBeForwardDeclaredFunction(
+      SpvOp(inst_.opcode))(operand_index_);
 
   if (mtf != kMtfNone && !can_forward_declare) {
     return DecodeExistingId(mtf, id);
   }
 
-  if (mtf == kMtfNone)
-    mtf = kMtfAll;
+  if (mtf == kMtfNone) mtf = kMtfAll;
 
   *id = 0;
 
@@ -1834,8 +1782,7 @@ spv_result_t MarkvDecoder::DecodeRefId(uint32_t* id) {
 
   {
     const spv_result_t result = DecodeMtfRankHuffman(mtf, kMtfAll, &rank);
-    if (result != SPV_SUCCESS)
-      return result;
+    if (result != SPV_SUCCESS) return result;
   }
 
   if (rank == 0) {
@@ -1844,8 +1791,7 @@ spv_result_t MarkvDecoder::DecodeRefId(uint32_t* id) {
     SetIdBound(*id + 1);
     multi_mtf_.Insert(kMtfAll, *id);
     multi_mtf_.Insert(kMtfForwardDeclared, *id);
-    if (mtf != kMtfAll)
-      multi_mtf_.Insert(mtf, *id);
+    if (mtf != kMtfAll) multi_mtf_.Insert(mtf, *id);
   } else {
     if (!multi_mtf_.ValueFromRank(mtf, rank, id))
       return Diag(SPV_ERROR_INTERNAL) << "MTF rank out of bounds";
@@ -1866,14 +1812,13 @@ spv_result_t MarkvEncoder::EncodeTypeId() {
   {
     // Try to encode using id descriptor mtfs.
     const spv_result_t result = EncodeIdWithDescriptor(inst_.type_id);
-    if (result != SPV_UNSUPPORTED)
-      return result;
+    if (result != SPV_UNSUPPORTED) return result;
     // If can't be done continue with other methods.
   }
 
   uint64_t mtf = GetRuleBasedMtf();
-  assert(!spvOperandCanBeForwardDeclaredFunction(
-      SpvOp(inst_.opcode))(operand_index_));
+  assert(!spvOperandCanBeForwardDeclaredFunction(SpvOp(inst_.opcode))(
+      operand_index_));
 
   if (mtf == kMtfNone) {
     mtf = kMtfTypeNonFunction;
@@ -1894,13 +1839,12 @@ spv_result_t MarkvDecoder::DecodeTypeId() {
 
   {
     const spv_result_t result = DecodeIdWithDescriptor(&inst_.type_id);
-    if (result != SPV_UNSUPPORTED)
-      return result;
+    if (result != SPV_UNSUPPORTED) return result;
   }
 
   uint64_t mtf = GetRuleBasedMtf();
-  assert(!spvOperandCanBeForwardDeclaredFunction(
-      SpvOp(inst_.opcode))(operand_index_));
+  assert(!spvOperandCanBeForwardDeclaredFunction(SpvOp(inst_.opcode))(
+      operand_index_));
 
   if (mtf == kMtfNone) {
     mtf = kMtfTypeNonFunction;
@@ -1920,16 +1864,14 @@ spv_result_t MarkvEncoder::EncodeResultId() {
   if (num_still_forward_declared) {
     // We write the rank only if kMtfForwardDeclared is not empty. If it is
     // empty the decoder knows that there are no forward declared ids to expect.
-    if (multi_mtf_.RankFromValue(kMtfForwardDeclared,
-                                 inst_.result_id, &rank)) {
+    if (multi_mtf_.RankFromValue(kMtfForwardDeclared, inst_.result_id, &rank)) {
       // This is a definition of a forward declared id. We can remove the id
       // from kMtfForwardDeclared.
       if (!multi_mtf_.Remove(kMtfForwardDeclared, inst_.result_id))
         return Diag(SPV_ERROR_INTERNAL)
-            << "Failed to remove id from kMtfForwardDeclared";
+               << "Failed to remove id from kMtfForwardDeclared";
       writer_.WriteBits(1, 1);
-      writer_.WriteVariableWidthU32(
-          rank, model_->mtf_rank_chunk_length());
+      writer_.WriteVariableWidthU32(rank, model_->mtf_rank_chunk_length());
     } else {
       rank = 0;
       writer_.WriteBits(0, 1);
@@ -1954,25 +1896,24 @@ spv_result_t MarkvDecoder::DecodeResultId() {
     uint64_t id_was_forward_declared;
     if (!reader_.ReadBits(&id_was_forward_declared, 1))
       return Diag(SPV_ERROR_INVALID_BINARY)
-          << "Failed to read id_was_forward_declared flag";
+             << "Failed to read id_was_forward_declared flag";
 
     if (id_was_forward_declared) {
-      if (!reader_.ReadVariableWidthU32(
-          &rank, model_->mtf_rank_chunk_length()))
+      if (!reader_.ReadVariableWidthU32(&rank, model_->mtf_rank_chunk_length()))
         return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Failed to read MTF rank of forward declared id";
+               << "Failed to read MTF rank of forward declared id";
 
       if (rank) {
         // The id was forward declared, recover it from kMtfForwardDeclared.
-        if (!multi_mtf_.ValueFromRank(kMtfForwardDeclared,
-                                     rank, &inst_.result_id))
+        if (!multi_mtf_.ValueFromRank(kMtfForwardDeclared, rank,
+                                      &inst_.result_id))
           return Diag(SPV_ERROR_INTERNAL)
-              << "Forward declared MTF rank is out of bounds";
+                 << "Forward declared MTF rank is out of bounds";
 
         // We can now remove the id from kMtfForwardDeclared.
         if (!multi_mtf_.Remove(kMtfForwardDeclared, inst_.result_id))
           return Diag(SPV_ERROR_INTERNAL)
-              << "Failed to remove id from kMtfForwardDeclared";
+                 << "Failed to remove id from kMtfForwardDeclared";
       }
     }
   }
@@ -1997,9 +1938,8 @@ spv_result_t MarkvEncoder::EncodeLiteralNumber(
     return EncodeNonIdWord(word);
   } else {
     assert(operand.number_bit_width <= 64);
-    const uint64_t word =
-        uint64_t(inst_.words[operand.offset]) |
-        (uint64_t(inst_.words[operand.offset + 1]) << 32);
+    const uint64_t word = uint64_t(inst_.words[operand.offset]) |
+                          (uint64_t(inst_.words[operand.offset + 1]) << 32);
     if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
       writer_.WriteVariableWidthU64(word, model_->u64_chunk_length());
     } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
@@ -2021,27 +1961,23 @@ spv_result_t MarkvDecoder::DecodeLiteralNumber(
   if (operand.number_bit_width <= 32) {
     uint32_t word = 0;
     const spv_result_t result = DecodeNonIdWord(&word);
-    if (result != SPV_SUCCESS)
-      return result;
+    if (result != SPV_SUCCESS) return result;
     inst_words_.push_back(word);
   } else {
     assert(operand.number_bit_width <= 64);
     uint64_t word = 0;
     if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
       if (!reader_.ReadVariableWidthU64(&word, model_->u64_chunk_length()))
-        return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Failed to read literal U64";
+        return Diag(SPV_ERROR_INVALID_BINARY) << "Failed to read literal U64";
     } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
       int64_t val = 0;
       if (!reader_.ReadVariableWidthS64(&val, model_->s64_chunk_length(),
                                         model_->s64_block_exponent()))
-        return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Failed to read literal S64";
+        return Diag(SPV_ERROR_INVALID_BINARY) << "Failed to read literal S64";
       std::memcpy(&word, &val, 8);
     } else if (operand.number_kind == SPV_NUMBER_FLOATING) {
       if (!reader_.ReadUnencoded(&word))
-        return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Failed to read literal F64";
+        return Diag(SPV_ERROR_INVALID_BINARY) << "Failed to read literal F64";
     } else {
       return Diag(SPV_ERROR_INTERNAL) << "Unsupported bit length";
     }
@@ -2073,14 +2009,11 @@ bool MarkvDecoder::ReadToByteBreak(size_t byte_break_if_less_than) {
       num_bits_to_next_byte > byte_break_if_less_than)
     return true;
 
-
   uint64_t bits = 0;
-  if (!reader_.ReadBits(&bits, num_bits_to_next_byte))
-    return false;
+  if (!reader_.ReadBits(&bits, num_bits_to_next_byte)) return false;
 
   assert(bits == 0);
-  if (bits != 0)
-    return false;
+  if (bits != 0) return false;
 
   return true;
 }
@@ -2091,15 +2024,13 @@ spv_result_t MarkvEncoder::EncodeInstruction(
   inst_ = inst;
 
   const spv_result_t validation_result = UpdateValidationState(inst);
-  if (validation_result != SPV_SUCCESS)
-    return validation_result;
+  if (validation_result != SPV_SUCCESS) return validation_result;
 
   LogDisassemblyInstruction();
 
   const spv_result_t opcode_encodig_result =
       EncodeOpcodeAndNumOperands(opcode, inst.num_operands);
-  if (opcode_encodig_result < 0)
-    return opcode_encodig_result;
+  if (opcode_encodig_result < 0) return opcode_encodig_result;
 
   if (opcode_encodig_result != SPV_SUCCESS) {
     // Fallback encoding for opcode and num_operands.
@@ -2109,8 +2040,7 @@ spv_result_t MarkvEncoder::EncodeInstruction(
       // If the opcode has a variable number of operands, encode the number of
       // operands with the instruction.
 
-      if (logger_)
-        logger_->AppendWhitespaces(kCommentNumWhitespaces);
+      if (logger_) logger_->AppendWhitespaces(kCommentNumWhitespaces);
 
       writer_.WriteVariableWidthU16(inst.num_operands,
                                     model_->num_operands_chunk_length());
@@ -2139,16 +2069,13 @@ spv_result_t MarkvEncoder::EncodeInstruction(
         const uint32_t id = inst_.words[operand_.offset];
         if (operand_.type == SPV_OPERAND_TYPE_TYPE_ID) {
           const spv_result_t result = EncodeTypeId();
-          if (result != SPV_SUCCESS)
-            return result;
+          if (result != SPV_SUCCESS) return result;
         } else if (operand_.type == SPV_OPERAND_TYPE_RESULT_ID) {
           const spv_result_t result = EncodeResultId();
-          if (result != SPV_SUCCESS)
-            return result;
+          if (result != SPV_SUCCESS) return result;
         } else {
           const spv_result_t result = EncodeRefId(id);
-          if (result != SPV_SUCCESS)
-            return result;
+          if (result != SPV_SUCCESS) return result;
         }
 
         multi_mtf_.Promote(id);
@@ -2158,21 +2085,19 @@ spv_result_t MarkvEncoder::EncodeInstruction(
       case SPV_OPERAND_TYPE_LITERAL_INTEGER: {
         const spv_result_t result =
             EncodeNonIdWord(inst_.words[operand_.offset]);
-        if (result != SPV_SUCCESS)
-          return result;
+        if (result != SPV_SUCCESS) return result;
         break;
       }
 
       case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER: {
         const spv_result_t result = EncodeLiteralNumber(operand_);
-        if (result != SPV_SUCCESS)
-          return result;
+        if (result != SPV_SUCCESS) return result;
         break;
       }
 
       case SPV_OPERAND_TYPE_LITERAL_STRING: {
-        const char* src = reinterpret_cast<const char*>(
-            &inst_.words[operand_.offset]);
+        const char* src =
+            reinterpret_cast<const char*>(&inst_.words[operand_.offset]);
 
         auto* codec = model_->GetLiteralStringHuffmanCodec(opcode);
         if (codec) {
@@ -2183,8 +2108,8 @@ spv_result_t MarkvEncoder::EncodeInstruction(
             writer_.WriteBits(bits, num_bits);
             break;
           } else {
-            bool result = codec->Encode("kMarkvNoneOfTheAbove",
-                                        &bits, &num_bits);
+            bool result =
+                codec->Encode("kMarkvNoneOfTheAbove", &bits, &num_bits);
             (void)result;
             assert(result);
             writer_.WriteBits(bits, num_bits);
@@ -2194,9 +2119,8 @@ spv_result_t MarkvEncoder::EncodeInstruction(
         const size_t length = spv_strnlen_s(src, operand_.num_words * 4);
         if (length == operand_.num_words * 4)
           return Diag(SPV_ERROR_INVALID_BINARY)
-              << "Failed to find terminal character of literal string";
-        for (size_t i = 0; i < length + 1; ++i)
-          writer_.WriteUnencoded(src[i]);
+                 << "Failed to find terminal character of literal string";
+        for (size_t i = 0; i < length + 1; ++i) writer_.WriteUnencoded(src[i]);
         break;
       }
 
@@ -2204,8 +2128,7 @@ spv_result_t MarkvEncoder::EncodeInstruction(
         for (int i = 0; i < operand_.num_words; ++i) {
           const uint32_t word = inst_.words[operand_.offset + i];
           const spv_result_t result = EncodeNonIdWord(word);
-          if (result != SPV_SUCCESS)
-            return result;
+          if (result != SPV_SUCCESS) return result;
         }
         break;
       }
@@ -2217,8 +2140,7 @@ spv_result_t MarkvEncoder::EncodeInstruction(
   if (logger_) {
     logger_->NewLine();
     logger_->NewLine();
-    if (!logger_->DebugInstruction(inst_))
-      return SPV_REQUESTED_TERMINATION;
+    if (!logger_->DebugInstruction(inst_)) return SPV_REQUESTED_TERMINATION;
   }
 
   ProcessCurInstruction();
@@ -2236,62 +2158,57 @@ spv_result_t MarkvDecoder::DecodeModule(std::vector<uint32_t>* spirv_binary) {
       reader_.ReadUnencoded(&header_.spirv_generator);
 
   if (!header_read_success)
-    return Diag(SPV_ERROR_INVALID_BINARY)
-        << "Unable to read MARK-V header";
+    return Diag(SPV_ERROR_INVALID_BINARY) << "Unable to read MARK-V header";
 
   if (header_.markv_length_in_bits == 0)
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "Header markv_length_in_bits field is zero";
+           << "Header markv_length_in_bits field is zero";
 
   if (header_.magic_number != kMarkvMagicNumber)
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "MARK-V binary has incorrect magic number";
+           << "MARK-V binary has incorrect magic number";
 
   // TODO(atgoo@github.com): Print version strings.
   if (header_.markv_version != GetMarkvVersion())
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "MARK-V binary and the codec have different versions";
+           << "MARK-V binary and the codec have different versions";
 
   const uint32_t model_type = header_.markv_model >> 16;
   const uint32_t model_version = header_.markv_model & 0xFFFF;
   if (model_type != model_->model_type())
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "MARK-V binary and the codec use different MARK-V models";
+           << "MARK-V binary and the codec use different MARK-V models";
 
   if (model_version != model_->model_version())
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "MARK-V binary and the codec use different versions if the same "
-        << "MARK-V model";
+           << "MARK-V binary and the codec use different versions if the same "
+           << "MARK-V model";
 
-  spirv_.reserve(header_.markv_length_in_bits / 2); // Heuristic.
+  spirv_.reserve(header_.markv_length_in_bits / 2);  // Heuristic.
   spirv_.resize(5, 0);
   spirv_[0] = kSpirvMagicNumber;
   spirv_[1] = header_.spirv_version;
   spirv_[2] = header_.spirv_generator;
 
   if (logger_) {
-    reader_.SetCallback([this](const std::string& str){
-      logger_->AppendBitSequence(str);
-    });
+    reader_.SetCallback(
+        [this](const std::string& str) { logger_->AppendBitSequence(str); });
   }
 
   while (reader_.GetNumReadBits() < header_.markv_length_in_bits) {
     inst_ = {};
     const spv_result_t decode_result = DecodeInstruction();
-    if (decode_result != SPV_SUCCESS)
-      return decode_result;
+    if (decode_result != SPV_SUCCESS) return decode_result;
 
     const spv_result_t validation_result = UpdateValidationState(inst_);
-    if (validation_result != SPV_SUCCESS)
-      return validation_result;
+    if (validation_result != SPV_SUCCESS) return validation_result;
   }
 
-
   if (reader_.GetNumReadBits() != header_.markv_length_in_bits ||
       !reader_.OnlyZeroesLeft()) {
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "MARK-V binary has wrong stated bit length "
-        << reader_.GetNumReadBits() << " " << header_.markv_length_in_bits;
+           << "MARK-V binary has wrong stated bit length "
+           << reader_.GetNumReadBits() << " " << header_.markv_length_in_bits;
   }
 
   // Decoding of the module is finished, validation state should have correct
@@ -2308,8 +2225,7 @@ spv_result_t MarkvDecoder::DecodeModule(std::vector<uint32_t>* spirv_binary) {
 // For now it's better to keep the code independent for experimentation
 // purposes.
 spv_result_t MarkvDecoder::DecodeOperand(
-    size_t operand_offset,
-    const spv_operand_type_t type,
+    size_t operand_offset, const spv_operand_type_t type,
     spv_operand_pattern_t* expected_operands) {
   const SpvOp opcode = static_cast<SpvOp>(inst_.opcode);
 
@@ -2328,8 +2244,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
   switch (type) {
     case SPV_OPERAND_TYPE_RESULT_ID: {
       const spv_result_t result = DecodeResultId();
-      if (result != SPV_SUCCESS)
-        return result;
+      if (result != SPV_SUCCESS) return result;
 
       inst_words_.push_back(inst_.result_id);
       SetIdBound(std::max(GetIdBound(), inst_.result_id + 1));
@@ -2339,8 +2254,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
 
     case SPV_OPERAND_TYPE_TYPE_ID: {
       const spv_result_t result = DecodeTypeId();
-      if (result != SPV_SUCCESS)
-        return result;
+      if (result != SPV_SUCCESS) return result;
 
       inst_words_.push_back(inst_.type_id);
       SetIdBound(std::max(GetIdBound(), inst_.type_id + 1));
@@ -2354,15 +2268,11 @@ spv_result_t MarkvDecoder::DecodeOperand(
     case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: {
       uint32_t id = 0;
       const spv_result_t result = DecodeRefId(&id);
-      if (result != SPV_SUCCESS)
-        return result;
-
-      if (id == 0)
-        return Diag(SPV_ERROR_INVALID_BINARY) << "Decoded id is 0";
+      if (result != SPV_SUCCESS) return result;
 
-      if (type == SPV_OPERAND_TYPE_ID ||
-          type == SPV_OPERAND_TYPE_OPTIONAL_ID) {
+      if (id == 0) return Diag(SPV_ERROR_INVALID_BINARY) << "Decoded id is 0";
 
+      if (type == SPV_OPERAND_TYPE_ID || type == SPV_OPERAND_TYPE_OPTIONAL_ID) {
         operand_.type = SPV_OPERAND_TYPE_ID;
 
         if (opcode == SpvOpExtInst && operand_.offset == 3) {
@@ -2372,8 +2282,8 @@ spv_result_t MarkvDecoder::DecodeOperand(
           auto ext_inst_type_iter = import_id_to_ext_inst_type_.find(id);
           if (ext_inst_type_iter == import_id_to_ext_inst_type_.end()) {
             return Diag(SPV_ERROR_INVALID_ID)
-                << "OpExtInst set id " << id
-                << " does not reference an OpExtInstImport result Id";
+                   << "OpExtInst set id " << id
+                   << " does not reference an OpExtInstImport result Id";
           }
           inst_.ext_inst_type = ext_inst_type_iter->second;
         }
@@ -2388,8 +2298,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
     case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: {
       uint32_t word = 0;
       const spv_result_t result = DecodeNonIdWord(&word);
-      if (result != SPV_SUCCESS)
-        return result;
+      if (result != SPV_SUCCESS) return result;
 
       inst_words_.push_back(word);
 
@@ -2398,7 +2307,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
       spv_ext_inst_desc ext_inst;
       if (grammar_.lookupExtInst(inst_.ext_inst_type, word, &ext_inst))
         return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Invalid extended instruction number: " << word;
+               << "Invalid extended instruction number: " << word;
       spvPushOperandTypes(ext_inst->operandTypes, expected_operands);
       break;
     }
@@ -2414,8 +2323,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
 
       uint32_t word = 0;
       const spv_result_t result = DecodeNonIdWord(&word);
-      if (result != SPV_SUCCESS)
-        return result;
+      if (result != SPV_SUCCESS) return result;
 
       inst_words_.push_back(word);
       break;
@@ -2429,11 +2337,10 @@ spv_result_t MarkvDecoder::DecodeOperand(
         // referenced by the selector Id.
         const uint32_t selector_id = inst_words_.at(1);
         const auto type_id_iter = id_to_type_id_.find(selector_id);
-        if (type_id_iter == id_to_type_id_.end() ||
-            type_id_iter->second == 0) {
+        if (type_id_iter == id_to_type_id_.end() || type_id_iter->second == 0) {
           return Diag(SPV_ERROR_INVALID_BINARY)
-              << "Invalid OpSwitch: selector id " << selector_id
-              << " has no type";
+                 << "Invalid OpSwitch: selector id " << selector_id
+                 << " has no type";
         }
         uint32_t type_id = type_id_iter->second;
 
@@ -2441,16 +2348,16 @@ spv_result_t MarkvDecoder::DecodeOperand(
           // Recall that by convention, a result ID that is a type definition
           // maps to itself.
           return Diag(SPV_ERROR_INVALID_BINARY)
-              << "Invalid OpSwitch: selector id " << selector_id
-              << " is a type, not a value";
+                 << "Invalid OpSwitch: selector id " << selector_id
+                 << " is a type, not a value";
         }
         if (auto error = SetNumericTypeInfoForType(&operand_, type_id))
           return error;
         if (operand_.number_kind != SPV_NUMBER_UNSIGNED_INT &&
             operand_.number_kind != SPV_NUMBER_SIGNED_INT) {
           return Diag(SPV_ERROR_INVALID_BINARY)
-              << "Invalid OpSwitch: selector id " << selector_id
-              << " is not a scalar integer";
+                 << "Invalid OpSwitch: selector id " << selector_id
+                 << " is not a scalar integer";
         }
       } else {
         assert(opcode == SpvOpConstant || opcode == SpvOpSpecConstant);
@@ -2461,8 +2368,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
           return error;
       }
 
-      if (auto error = DecodeLiteralNumber(operand_))
-        return error;
+      if (auto error = DecodeLiteralNumber(operand_)) return error;
 
       break;
     }
@@ -2480,7 +2386,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
         assert(huffman_result);
         if (!huffman_result)
           return Diag(SPV_ERROR_INVALID_BINARY)
-              << "Failed to read literal string";
+                 << "Failed to read literal string";
 
         if (decoded_string != "kMarkvNoneOfTheAbove") {
           std::copy(decoded_string.begin(), decoded_string.end(),
@@ -2496,17 +2402,15 @@ spv_result_t MarkvDecoder::DecodeOperand(
           char ch = 0;
           if (!reader_.ReadUnencoded(&ch))
             return Diag(SPV_ERROR_INVALID_BINARY)
-                << "Failed to read literal string";
+                   << "Failed to read literal string";
 
           str.push_back(ch);
 
-          if (ch == '\0')
-            break;
+          if (ch == '\0') break;
         }
       }
 
-      while (str.size() % 4 != 0)
-        str.push_back('\0');
+      while (str.size() % 4 != 0) str.push_back('\0');
 
       inst_words_.resize(inst_words_.size() + str.size() / 4);
       std::memcpy(&inst_words_[first_word_index], str.data(), str.size());
@@ -2519,13 +2423,15 @@ spv_result_t MarkvDecoder::DecodeOperand(
             spvExtInstImportTypeGet(str.data());
         if (SPV_EXT_INST_TYPE_NONE == ext_inst_type) {
           return Diag(SPV_ERROR_INVALID_BINARY)
-              << "Invalid extended instruction import '" << str.data() << "'";
+                 << "Invalid extended instruction import '" << str.data()
+                 << "'";
         }
         // We must have parsed a valid result ID.  It's a condition
         // of the grammar, and we only accept non-zero result Ids.
         assert(inst_.result_id);
-        const bool inserted = import_id_to_ext_inst_type_.emplace(
-            inst_.result_id, ext_inst_type).second;
+        const bool inserted =
+            import_id_to_ext_inst_type_.emplace(inst_.result_id, ext_inst_type)
+                .second;
         (void)inserted;
         assert(inserted);
       }
@@ -2556,8 +2462,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
       // A single word that is a plain enum value.
       uint32_t word = 0;
       const spv_result_t result = DecodeNonIdWord(&word);
-      if (result != SPV_SUCCESS)
-        return result;
+      if (result != SPV_SUCCESS) return result;
 
       inst_words_.push_back(word);
 
@@ -2568,9 +2473,8 @@ spv_result_t MarkvDecoder::DecodeOperand(
       spv_operand_desc entry;
       if (grammar_.lookupOperand(type, word, &entry)) {
         return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Invalid "
-            << spvOperandTypeStr(operand_.type)
-            << " operand: " << word;
+               << "Invalid " << spvOperandTypeStr(operand_.type)
+               << " operand: " << word;
       }
 
       // Prepare to accept operands to this operand, if needed.
@@ -2588,8 +2492,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
       // This operand is a mask.
       uint32_t word = 0;
       const spv_result_t result = DecodeNonIdWord(&word);
-      if (result != SPV_SUCCESS)
-        return result;
+      if (result != SPV_SUCCESS) return result;
 
       inst_words_.push_back(word);
 
@@ -2631,7 +2534,7 @@ spv_result_t MarkvDecoder::DecodeOperand(
     }
     default:
       return Diag(SPV_ERROR_INVALID_BINARY)
-          << "Internal error: Unhandled operand type: " << type;
+             << "Internal error: Unhandled operand type: " << type;
   }
 
   operand_.num_words = uint16_t(inst_words_.size() - first_word_index);
@@ -2658,17 +2561,16 @@ spv_result_t MarkvDecoder::DecodeInstruction() {
 
     const spv_result_t opcode_decoding_result =
         DecodeOpcodeAndNumberOfOperands(&opcode, &num_operands);
-    if (opcode_decoding_result < 0)
-      return opcode_decoding_result;
+    if (opcode_decoding_result < 0) return opcode_decoding_result;
 
     if (opcode_decoding_result == SPV_SUCCESS) {
       inst_.num_operands = static_cast<uint16_t>(num_operands);
       num_operands_still_unknown = false;
     } else {
-      if (!reader_.ReadVariableWidthU32(
-          &opcode, model_->opcode_chunk_length())) {
+      if (!reader_.ReadVariableWidthU32(&opcode,
+                                        model_->opcode_chunk_length())) {
         return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Failed to read opcode of instruction";
+               << "Failed to read opcode of instruction";
       }
     }
 
@@ -2694,7 +2596,7 @@ spv_result_t MarkvDecoder::DecodeInstruction() {
       if (!reader_.ReadVariableWidthU16(&inst_.num_operands,
                                         model_->num_operands_chunk_length()))
         return Diag(SPV_ERROR_INVALID_BINARY)
-            << "Failed to read num_operands of instruction";
+               << "Failed to read num_operands of instruction";
     } else {
       inst_.num_operands = static_cast<uint16_t>(expected_operands.size());
     }
@@ -2709,14 +2611,12 @@ spv_result_t MarkvDecoder::DecodeInstruction() {
 
     const size_t operand_offset = inst_words_.size();
 
-    const spv_result_t decode_result = DecodeOperand(
-        operand_offset, type, &expected_operands);
+    const spv_result_t decode_result =
+        DecodeOperand(operand_offset, type, &expected_operands);
 
-    if (decode_result != SPV_SUCCESS)
-      return decode_result;
+    if (decode_result != SPV_SUCCESS) return decode_result;
   }
 
-
   assert(inst_.num_operands == parsed_operands_.size());
 
   // Only valid while inst_words_ and parsed_operands_ remain unchanged (until
@@ -2728,19 +2628,20 @@ spv_result_t MarkvDecoder::DecodeInstruction() {
 
   std::copy(inst_words_.begin(), inst_words_.end(), std::back_inserter(spirv_));
 
-  assert(inst_.num_words == std::accumulate(
-      parsed_operands_.begin(), parsed_operands_.end(), 1,
-      [](int num_words, const spv_parsed_operand_t& operand) {
-        return num_words += operand.num_words;
-  }) && "num_words in instruction doesn't correspond to the sum of num_words"
-        "in the operands");
+  assert(inst_.num_words ==
+             std::accumulate(
+                 parsed_operands_.begin(), parsed_operands_.end(), 1,
+                 [](int num_words, const spv_parsed_operand_t& operand) {
+                   return num_words += operand.num_words;
+                 }) &&
+         "num_words in instruction doesn't correspond to the sum of num_words"
+         "in the operands");
 
   RecordNumberType();
   ProcessCurInstruction();
 
   if (!ReadToByteBreak(kByteBreakAfterInstIfLessThanUntilNextByte))
-    return Diag(SPV_ERROR_INVALID_BINARY)
-        << "Failed to read to byte break";
+    return Diag(SPV_ERROR_INVALID_BINARY) << "Failed to read to byte break";
 
   if (logger_) {
     logger_->NewLine();
@@ -2751,8 +2652,7 @@ spv_result_t MarkvDecoder::DecodeInstruction() {
     logger_->AppendText(ss.str());
     logger_->NewLine();
     logger_->NewLine();
-    if (!logger_->DebugInstruction(inst_))
-      return SPV_REQUESTED_TERMINATION;
+    if (!logger_->DebugInstruction(inst_)) return SPV_REQUESTED_TERMINATION;
   }
 
   return SPV_SUCCESS;
@@ -2764,14 +2664,14 @@ spv_result_t MarkvDecoder::SetNumericTypeInfoForType(
   auto type_info_iter = type_id_to_number_type_info_.find(type_id);
   if (type_info_iter == type_id_to_number_type_info_.end()) {
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "Type Id " << type_id << " is not a type";
+           << "Type Id " << type_id << " is not a type";
   }
 
   const NumberType& info = type_info_iter->second;
   if (info.type == SPV_NUMBER_NONE) {
     // This is a valid type, but for something other than a scalar number.
     return Diag(SPV_ERROR_INVALID_BINARY)
-        << "Type Id " << type_id << " is not a scalar numeric type";
+           << "Type Id " << type_id << " is not a scalar numeric type";
   }
 
   parsed_operand->number_kind = info.type;
@@ -2787,8 +2687,9 @@ void MarkvDecoder::RecordNumberType() {
     NumberType info = {SPV_NUMBER_NONE, 0};
     if (SpvOpTypeInt == opcode) {
       info.bit_width = inst_.words[inst_.operands[1].offset];
-      info.type = inst_.words[inst_.operands[2].offset] ?
-          SPV_NUMBER_SIGNED_INT : SPV_NUMBER_UNSIGNED_INT;
+      info.type = inst_.words[inst_.operands[2].offset]
+                      ? SPV_NUMBER_SIGNED_INT
+                      : SPV_NUMBER_UNSIGNED_INT;
     } else if (SpvOpTypeFloat == opcode) {
       info.bit_width = inst_.words[inst_.operands[1].offset];
       info.type = SPV_NUMBER_FLOATING;
@@ -2798,31 +2699,27 @@ void MarkvDecoder::RecordNumberType() {
   }
 }
 
-spv_result_t EncodeHeader(
-    void* user_data, spv_endianness_t endian, uint32_t magic,
-    uint32_t version, uint32_t generator, uint32_t id_bound,
-    uint32_t schema) {
+spv_result_t EncodeHeader(void* user_data, spv_endianness_t endian,
+                          uint32_t magic, uint32_t version, uint32_t generator,
+                          uint32_t id_bound, uint32_t schema) {
   MarkvEncoder* encoder = reinterpret_cast<MarkvEncoder*>(user_data);
-  return encoder->EncodeHeader(
-      endian, magic, version, generator, id_bound, schema);
+  return encoder->EncodeHeader(endian, magic, version, generator, id_bound,
+                               schema);
 }
 
-spv_result_t EncodeInstruction(
-    void* user_data, const spv_parsed_instruction_t* inst) {
+spv_result_t EncodeInstruction(void* user_data,
+                               const spv_parsed_instruction_t* inst) {
   MarkvEncoder* encoder = reinterpret_cast<MarkvEncoder*>(user_data);
   return encoder->EncodeInstruction(*inst);
 }
 
 }  // namespace
 
-spv_result_t SpirvToMarkv(spv_const_context context,
-                          const std::vector<uint32_t>& spirv,
-                          const MarkvCodecOptions& options,
-                          const MarkvModel& markv_model,
-                          MessageConsumer message_consumer,
-                          MarkvLogConsumer log_consumer,
-                          MarkvDebugConsumer debug_consumer,
-                          std::vector<uint8_t>* markv) {
+spv_result_t SpirvToMarkv(
+    spv_const_context context, const std::vector<uint32_t>& spirv,
+    const MarkvCodecOptions& options, const MarkvModel& markv_model,
+    MessageConsumer message_consumer, MarkvLogConsumer log_consumer,
+    MarkvDebugConsumer debug_consumer, std::vector<uint8_t>* markv) {
   spv_context_t hijack_context = *context;
   SetContextMessageConsumer(&hijack_context, message_consumer);
 
@@ -2832,15 +2729,15 @@ spv_result_t SpirvToMarkv(spv_const_context context,
   spv_position_t position = {};
   if (spvBinaryEndianness(&spirv_binary, &endian)) {
     return DiagnosticStream(position, hijack_context.consumer,
-                                      SPV_ERROR_INVALID_BINARY)
-        << "Invalid SPIR-V magic number.";
+                            SPV_ERROR_INVALID_BINARY)
+           << "Invalid SPIR-V magic number.";
   }
 
   spv_header_t header;
   if (spvBinaryHeaderGet(&spirv_binary, endian, &header)) {
     return DiagnosticStream(position, hijack_context.consumer,
                             SPV_ERROR_INVALID_BINARY)
-        << "Invalid SPIR-V header.";
+           << "Invalid SPIR-V header.";
   }
 
   MarkvEncoder encoder(&hijack_context, options, &markv_model);
@@ -2850,37 +2747,33 @@ spv_result_t SpirvToMarkv(spv_const_context context,
 
     spv_text text = nullptr;
     if (spvBinaryToText(&hijack_context, spirv.data(), spirv.size(),
-                        SPV_BINARY_TO_TEXT_OPTION_NO_HEADER, &text, nullptr)
-        != SPV_SUCCESS) {
+                        SPV_BINARY_TO_TEXT_OPTION_NO_HEADER, &text,
+                        nullptr) != SPV_SUCCESS) {
       return DiagnosticStream(position, hijack_context.consumer,
                               SPV_ERROR_INVALID_BINARY)
-          << "Failed to disassemble SPIR-V binary.";
+             << "Failed to disassemble SPIR-V binary.";
     }
     assert(text);
     encoder.SetDisassembly(std::string(text->str, text->length));
     spvTextDestroy(text);
   }
 
-  if (spvBinaryParse(
-      &hijack_context, &encoder, spirv.data(), spirv.size(), EncodeHeader,
-      EncodeInstruction, nullptr) != SPV_SUCCESS) {
+  if (spvBinaryParse(&hijack_context, &encoder, spirv.data(), spirv.size(),
+                     EncodeHeader, EncodeInstruction, nullptr) != SPV_SUCCESS) {
     return DiagnosticStream(position, hijack_context.consumer,
                             SPV_ERROR_INVALID_BINARY)
-        << "Unable to encode to MARK-V.";
+           << "Unable to encode to MARK-V.";
   }
 
   *markv = encoder.GetMarkvBinary();
   return SPV_SUCCESS;
 }
 
-spv_result_t MarkvToSpirv(spv_const_context context,
-                          const std::vector<uint8_t>& markv,
-                          const MarkvCodecOptions& options,
-                          const MarkvModel& markv_model,
-                          MessageConsumer message_consumer,
-                          MarkvLogConsumer log_consumer,
-                          MarkvDebugConsumer debug_consumer,
-                          std::vector<uint32_t>* spirv) {
+spv_result_t MarkvToSpirv(
+    spv_const_context context, const std::vector<uint8_t>& markv,
+    const MarkvCodecOptions& options, const MarkvModel& markv_model,
+    MessageConsumer message_consumer, MarkvLogConsumer log_consumer,
+    MarkvDebugConsumer debug_consumer, std::vector<uint32_t>* spirv) {
   spv_position_t position = {};
   spv_context_t hijack_context = *context;
   SetContextMessageConsumer(&hijack_context, message_consumer);
@@ -2893,7 +2786,7 @@ spv_result_t MarkvToSpirv(spv_const_context context,
   if (decoder.DecodeModule(spirv) != SPV_SUCCESS) {
     return DiagnosticStream(position, hijack_context.consumer,
                             SPV_ERROR_INVALID_BINARY)
-        << "Unable to decode MARK-V.";
+           << "Unable to decode MARK-V.";
   }
 
   assert(!spirv->empty());
diff --git a/source/comp/markv_model.h b/source/comp/markv_model.h
index f656df45..cfdf95c9 100644
--- a/source/comp/markv_model.h
+++ b/source/comp/markv_model.h
@@ -19,8 +19,8 @@
 #include <unordered_set>
 #include <vector>
 
-#include "spirv/1.2/spirv.h"
 #include "spirv-tools/libspirv.h"
+#include "spirv/1.2/spirv.h"
 #include "util/huffman_codec.h"
 
 namespace spvtools {
@@ -30,14 +30,17 @@ namespace spvtools {
 // codecs used by the compression algorithm.
 class MarkvModel {
  public:
-  MarkvModel() : operand_chunk_lengths_(
-      static_cast<size_t>(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES), 0) {}
+  MarkvModel()
+      : operand_chunk_lengths_(
+            static_cast<size_t>(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES), 0) {}
 
   uint32_t model_type() const { return model_type_; }
   uint32_t model_version() const { return model_version_; }
 
   uint32_t opcode_chunk_length() const { return opcode_chunk_length_; }
-  uint32_t num_operands_chunk_length() const { return num_operands_chunk_length_; }
+  uint32_t num_operands_chunk_length() const {
+    return num_operands_chunk_length_;
+  }
   uint32_t mtf_rank_chunk_length() const { return mtf_rank_chunk_length_; }
 
   uint32_t u64_chunk_length() const { return u64_chunk_length_; }
@@ -46,8 +49,8 @@ class MarkvModel {
 
   // Returns a codec for common opcode_and_num_operands words for the given
   // previous opcode. May return nullptr if the codec doesn't exist.
-  const spvutils::HuffmanCodec<uint64_t>* GetOpcodeAndNumOperandsMarkovHuffmanCodec(
-      uint32_t prev_opcode) const {
+  const spvutils::HuffmanCodec<uint64_t>*
+  GetOpcodeAndNumOperandsMarkovHuffmanCodec(uint32_t prev_opcode) const {
     if (prev_opcode == SpvOpNop)
       return opcode_and_num_operands_huffman_codec_.get();
 
@@ -65,8 +68,7 @@ class MarkvModel {
       uint32_t opcode, uint32_t operand_index) const {
     const auto it = non_id_word_huffman_codecs_.find(
         std::pair<uint32_t, uint32_t>(opcode, operand_index));
-    if (it == non_id_word_huffman_codecs_.end())
-      return nullptr;
+    if (it == non_id_word_huffman_codecs_.end()) return nullptr;
     return it->second.get();
   }
 
@@ -77,8 +79,7 @@ class MarkvModel {
       uint32_t opcode, uint32_t operand_index) const {
     const auto it = id_descriptor_huffman_codecs_.find(
         std::pair<uint32_t, uint32_t>(opcode, operand_index));
-    if (it == id_descriptor_huffman_codecs_.end())
-      return nullptr;
+    if (it == id_descriptor_huffman_codecs_.end()) return nullptr;
     return it->second.get();
   }
 
@@ -88,8 +89,7 @@ class MarkvModel {
   const spvutils::HuffmanCodec<std::string>* GetLiteralStringHuffmanCodec(
       uint32_t opcode) const {
     const auto it = literal_string_huffman_codecs_.find(opcode);
-    if (it == literal_string_huffman_codecs_.end())
-      return nullptr;
+    if (it == literal_string_huffman_codecs_.end()) return nullptr;
     return it->second.get();
   }
 
@@ -106,9 +106,7 @@ class MarkvModel {
   }
 
   // Sets model type.
-  void SetModelType(uint32_t in_model_type) {
-    model_type_ = in_model_type;
-  }
+  void SetModelType(uint32_t in_model_type) { model_type_ = in_model_type; }
 
   // Sets model version.
   void SetModelVersion(uint32_t in_model_version) {
@@ -137,12 +135,14 @@ class MarkvModel {
   // Huffman codecs for non-id single-word operand values.
   // The map key is pair <opcode, operand_index>.
   std::map<std::pair<uint32_t, uint32_t>,
-      std::unique_ptr<spvutils::HuffmanCodec<uint64_t>>> non_id_word_huffman_codecs_;
+           std::unique_ptr<spvutils::HuffmanCodec<uint64_t>>>
+      non_id_word_huffman_codecs_;
 
   // Huffman codecs for id descriptors. The map key is pair
   // <opcode, operand_index>.
   std::map<std::pair<uint32_t, uint32_t>,
-      std::unique_ptr<spvutils::HuffmanCodec<uint64_t>>> id_descriptor_huffman_codecs_;
+           std::unique_ptr<spvutils::HuffmanCodec<uint64_t>>>
+      id_descriptor_huffman_codecs_;
 
   // Set of all descriptors which have a coding scheme in any of
   // id_descriptor_huffman_codecs_.
@@ -160,7 +160,7 @@ class MarkvModel {
   std::vector<uint32_t> operand_chunk_lengths_;
 
   uint32_t opcode_chunk_length_ = 7;
-  uint32_t num_operands_chunk_length_ =  3;
+  uint32_t num_operands_chunk_length_ = 3;
   uint32_t mtf_rank_chunk_length_ = 5;
 
   uint32_t u64_chunk_length_ = 8;
diff --git a/source/extensions.cpp b/source/extensions.cpp
index 260a15b6..065543c1 100644
--- a/source/extensions.cpp
+++ b/source/extensions.cpp
@@ -23,8 +23,7 @@
 namespace libspirv {
 
 std::string GetExtensionString(const spv_parsed_instruction_t* inst) {
-  if (inst->opcode != SpvOpExtension)
-    return "ERROR_not_op_extension";
+  if (inst->opcode != SpvOpExtension) return "ERROR_not_op_extension";
 
   assert(inst->num_operands == 1);
 
@@ -37,9 +36,8 @@ std::string GetExtensionString(const spv_parsed_instruction_t* inst) {
 
 std::string ExtensionSetToString(const ExtensionSet& extensions) {
   std::stringstream ss;
-  extensions.ForEach([&ss](Extension ext) {
-      ss << ExtensionToString(ext) << " ";
-  });
+  extensions.ForEach(
+      [&ss](Extension ext) { ss << ExtensionToString(ext) << " "; });
   return ss.str();
 }
 
diff --git a/source/id_descriptor.cpp b/source/id_descriptor.cpp
index d2c6220b..2384c634 100644
--- a/source/id_descriptor.cpp
+++ b/source/id_descriptor.cpp
@@ -40,15 +40,14 @@ uint32_t HashU32Array(const std::vector<uint32_t>& words) {
 
 uint32_t IdDescriptorCollection::ProcessInstruction(
     const spv_parsed_instruction_t& inst) {
-  if (!inst.result_id)
-    return 0;
+  if (!inst.result_id) return 0;
 
   assert(words_.empty());
   words_.push_back(inst.words[0]);
 
   for (size_t operand_index = 0; operand_index < inst.num_operands;
        ++operand_index) {
-    const auto &operand = inst.operands[operand_index];
+    const auto& operand = inst.operands[operand_index];
     if (spvIsIdType(operand.type)) {
       const uint32_t id = inst.words[operand.offset];
       const auto it = id_to_descriptor_.find(id);
diff --git a/source/id_descriptor.h b/source/id_descriptor.h
index b4947a78..d177eb98 100644
--- a/source/id_descriptor.h
+++ b/source/id_descriptor.h
@@ -28,9 +28,7 @@ namespace libspirv {
 // were substituted with previously computed descriptors.
 class IdDescriptorCollection {
  public:
-  IdDescriptorCollection() {
-    words_.reserve(16);
-  }
+  IdDescriptorCollection() { words_.reserve(16); }
 
   // Computes descriptor for the result id of the given instruction and
   // registers it in id_to_descriptor_. Returns the computed descriptor.
@@ -41,8 +39,7 @@ class IdDescriptorCollection {
   // Returns a previously computed descriptor id.
   uint32_t GetDescriptor(uint32_t id) const {
     const auto it = id_to_descriptor_.find(id);
-    if (it == id_to_descriptor_.end())
-      return 0;
+    if (it == id_to_descriptor_.end()) return 0;
     return it->second;
   }
 
@@ -56,4 +53,3 @@ class IdDescriptorCollection {
 }  // namespace libspirv
 
 #endif  // LIBSPIRV_ID_DESCRIPTOR_H_
-
diff --git a/source/link/linker.cpp b/source/link/linker.cpp
index 79d48727..35cba981 100644
--- a/source/link/linker.cpp
+++ b/source/link/linker.cpp
@@ -497,7 +497,7 @@ static spv_result_t GetImportExportPairs(
     // Ignore if the targeted symbol is a built-in
     bool is_built_in = false;
     for (const auto& id_decoration :
-        decoration_manager.GetDecorationsFor(id, false)) {
+         decoration_manager.GetDecorationsFor(id, false)) {
       if (id_decoration->GetSingleWordInOperand(1u) == SpvDecorationBuiltIn) {
         is_built_in = true;
         break;
diff --git a/source/name_mapper.cpp b/source/name_mapper.cpp
index 1accc943..a169621f 100644
--- a/source/name_mapper.cpp
+++ b/source/name_mapper.cpp
@@ -14,8 +14,8 @@
 
 #include "name_mapper.h"
 
-#include <cassert>
 #include <algorithm>
+#include <cassert>
 #include <iterator>
 #include <sstream>
 #include <string>
@@ -234,26 +234,30 @@ spv_result_t FriendlyNameMapper::ParseInstruction(
       }
     } break;
     case SpvOpTypeVector:
-      SaveName(result_id, std::string("v") + to_string(inst.words[3]) +
-                              NameForId(inst.words[2]));
+      SaveName(result_id,
+               std::string("v") + to_string(inst.words[3]) +
+                   NameForId(inst.words[2]));
       break;
     case SpvOpTypeMatrix:
-      SaveName(result_id, std::string("mat") + to_string(inst.words[3]) +
-                              NameForId(inst.words[2]));
+      SaveName(result_id,
+               std::string("mat") + to_string(inst.words[3]) +
+                   NameForId(inst.words[2]));
       break;
     case SpvOpTypeArray:
-      SaveName(result_id, std::string("_arr_") + NameForId(inst.words[2]) +
-                              "_" + NameForId(inst.words[3]));
+      SaveName(result_id,
+               std::string("_arr_") + NameForId(inst.words[2]) + "_" +
+                   NameForId(inst.words[3]));
       break;
     case SpvOpTypeRuntimeArray:
       SaveName(result_id,
                std::string("_runtimearr_") + NameForId(inst.words[2]));
       break;
     case SpvOpTypePointer:
-      SaveName(result_id, std::string("_ptr_") +
-                              NameForEnumOperand(SPV_OPERAND_TYPE_STORAGE_CLASS,
-                                                 inst.words[2]) +
-                              "_" + NameForId(inst.words[3]));
+      SaveName(result_id,
+               std::string("_ptr_") +
+                   NameForEnumOperand(SPV_OPERAND_TYPE_STORAGE_CLASS,
+                                      inst.words[2]) +
+                   "_" + NameForId(inst.words[3]));
       break;
     case SpvOpTypePipe:
       SaveName(result_id,
diff --git a/source/name_mapper.h b/source/name_mapper.h
index 12078b66..8afac424 100644
--- a/source/name_mapper.h
+++ b/source/name_mapper.h
@@ -20,8 +20,8 @@
 #include <unordered_map>
 #include <unordered_set>
 
-#include "spirv-tools/libspirv.h"
 #include "assembly_grammar.h"
+#include "spirv-tools/libspirv.h"
 
 namespace libspirv {
 
@@ -41,7 +41,8 @@ NameMapper GetTrivialNameMapper();
 //  - If an Id has a debug name (via OpName), then that will be used when
 //    possible.
 //  - Well known scalar types map to friendly names.  For example,
-//    OpTypeVoid should be %void.  Scalar types map to their names in OpenCL when
+//    OpTypeVoid should be %void.  Scalar types map to their names in OpenCL
+//    when
 //    there is a correspondence, and otherwise as follows:
 //    - unsigned integer type of n bits map to "u" followed by n
 //    - signed integer type of n bits map to "i" followed by n
diff --git a/source/opcode.cpp b/source/opcode.cpp
index 62ea1d17..1d229e08 100644
--- a/source/opcode.cpp
+++ b/source/opcode.cpp
@@ -147,7 +147,7 @@ spv_result_t spvOpcodeTableValueLookup(const spv_opcode_table table,
     return lhs.opcode < rhs.opcode;
   };
   auto it = std::lower_bound(beg, end, value, comp);
-  if (it!=end && it->opcode == opcode) {
+  if (it != end && it->opcode == opcode) {
     *pEntry = it;
     return SPV_SUCCESS;
   }
@@ -177,13 +177,14 @@ const char* spvOpcodeString(const SpvOp opcode) {
   // previous ones.
 
   const auto beg = kOpcodeTableEntries_1_2;
-  const auto end = kOpcodeTableEntries_1_2 + ARRAY_SIZE(kOpcodeTableEntries_1_2);
+  const auto end =
+      kOpcodeTableEntries_1_2 + ARRAY_SIZE(kOpcodeTableEntries_1_2);
   spv_opcode_desc_t value{"", opcode, 0, nullptr, 0, {}, 0, 0};
   auto comp = [](const spv_opcode_desc_t& lhs, const spv_opcode_desc_t& rhs) {
     return lhs.opcode < rhs.opcode;
   };
   auto it = std::lower_bound(beg, end, value, comp);
-  if (it!=end && it->opcode == opcode) {
+  if (it != end && it->opcode == opcode) {
     return it->name;
   }
 
diff --git a/source/opt/aggressive_dead_code_elim_pass.cpp b/source/opt/aggressive_dead_code_elim_pass.cpp
index 54e930aa..fb11f13a 100644
--- a/source/opt/aggressive_dead_code_elim_pass.cpp
+++ b/source/opt/aggressive_dead_code_elim_pass.cpp
@@ -36,29 +36,25 @@ const uint32_t kLoopMergeMergeBlockIdInIdx = 0;
 
 }  // namespace anonymous
 
-bool AggressiveDCEPass::IsVarOfStorage(uint32_t varId, 
-      uint32_t storageClass) {
+bool AggressiveDCEPass::IsVarOfStorage(uint32_t varId, uint32_t storageClass) {
   const ir::Instruction* varInst = get_def_use_mgr()->GetDef(varId);
   const SpvOp op = varInst->opcode();
-  if (op != SpvOpVariable) 
-    return false;
+  if (op != SpvOpVariable) return false;
   const uint32_t varTypeId = varInst->type_id();
   const ir::Instruction* varTypeInst = get_def_use_mgr()->GetDef(varTypeId);
-  if (varTypeInst->opcode() != SpvOpTypePointer)
-    return false;
+  if (varTypeInst->opcode() != SpvOpTypePointer) return false;
   return varTypeInst->GetSingleWordInOperand(kTypePointerStorageClassInIdx) ==
-      storageClass;
+         storageClass;
 }
 
 bool AggressiveDCEPass::IsLocalVar(uint32_t varId) {
- return IsVarOfStorage(varId, SpvStorageClassFunction) ||
-        (IsVarOfStorage(varId, SpvStorageClassPrivate) && private_like_local_);
+  return IsVarOfStorage(varId, SpvStorageClassFunction) ||
+         (IsVarOfStorage(varId, SpvStorageClassPrivate) && private_like_local_);
 }
 
 void AggressiveDCEPass::AddStores(uint32_t ptrId) {
   const analysis::UseList* uses = get_def_use_mgr()->GetUses(ptrId);
-  if (uses == nullptr)
-    return;
+  if (uses == nullptr) return;
   for (const auto u : *uses) {
     const SpvOp op = u.inst->opcode();
     switch (op) {
@@ -72,8 +68,7 @@ void AggressiveDCEPass::AddStores(uint32_t ptrId) {
       // If default, assume it stores eg frexp, modf, function call
       case SpvOpStore:
       default: {
-        if (!IsLive(u.inst))
-          AddToWorklist(u.inst);
+        if (!IsLive(u.inst)) AddToWorklist(u.inst);
       } break;
     }
   }
@@ -88,17 +83,16 @@ bool AggressiveDCEPass::IsCombinatorExt(ir::Instruction* inst) const {
   if (inst->GetSingleWordInOperand(kExtInstSetIdInIndx) == glsl_std_450_id_) {
     uint32_t op = inst->GetSingleWordInOperand(kExtInstInstructionInIndx);
     return combinator_ops_glsl_std_450_.find(op) !=
-        combinator_ops_glsl_std_450_.end();
-  }
-  else
+           combinator_ops_glsl_std_450_.end();
+  } else
     return false;
 }
 
 bool AggressiveDCEPass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -117,11 +111,9 @@ bool AggressiveDCEPass::KillInstIfTargetDead(ir::Instruction* inst) {
 
 void AggressiveDCEPass::ProcessLoad(uint32_t varId) {
   // Only process locals
-  if (!IsLocalVar(varId))
-    return;
+  if (!IsLocalVar(varId)) return;
   // Return if already processed
-  if (live_local_vars_.find(varId) != live_local_vars_.end()) 
-    return;
+  if (live_local_vars_.find(varId) != live_local_vars_.end()) return;
   // Mark all stores to varId as live
   AddStores(varId);
   // Cache varId as processed
@@ -129,20 +121,17 @@ void AggressiveDCEPass::ProcessLoad(uint32_t varId) {
 }
 
 bool AggressiveDCEPass::IsStructuredIfHeader(ir::BasicBlock* bp,
-      ir::Instruction** mergeInst, ir::Instruction** branchInst,
-      uint32_t* mergeBlockId) {
+                                             ir::Instruction** mergeInst,
+                                             ir::Instruction** branchInst,
+                                             uint32_t* mergeBlockId) {
   auto ii = bp->end();
   --ii;
-  if (ii->opcode() != SpvOpBranchConditional)
-    return false;
-  if (ii == bp->begin())
-    return false;
+  if (ii->opcode() != SpvOpBranchConditional) return false;
+  if (ii == bp->begin()) return false;
   if (branchInst != nullptr) *branchInst = &*ii;
   --ii;
-  if (ii->opcode() != SpvOpSelectionMerge)
-    return false;
-  if (mergeInst != nullptr)
-    *mergeInst = &*ii;
+  if (ii->opcode() != SpvOpSelectionMerge) return false;
+  if (mergeInst != nullptr) *mergeInst = &*ii;
   if (mergeBlockId != nullptr)
     *mergeBlockId =
         ii->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx);
@@ -150,7 +139,7 @@ bool AggressiveDCEPass::IsStructuredIfHeader(ir::BasicBlock* bp,
 }
 
 void AggressiveDCEPass::ComputeBlock2HeaderMaps(
-      std::list<ir::BasicBlock*>& structuredOrder) {
+    std::list<ir::BasicBlock*>& structuredOrder) {
   block2headerMerge_.clear();
   block2headerBranch_.clear();
   std::stack<ir::Instruction*> currentMergeInst;
@@ -180,16 +169,15 @@ void AggressiveDCEPass::ComputeBlock2HeaderMaps(
 
 void AggressiveDCEPass::ComputeInst2BlockMap(ir::Function* func) {
   for (auto& blk : *func) {
-    blk.ForEachInst([&blk,this](ir::Instruction* ip) {
-      inst2block_[ip] = &blk;
-    });
+    blk.ForEachInst(
+        [&blk, this](ir::Instruction* ip) { inst2block_[ip] = &blk; });
   }
 }
 
 void AggressiveDCEPass::AddBranch(uint32_t labelId, ir::BasicBlock* bp) {
-  std::unique_ptr<ir::Instruction> newBranch(
-    new ir::Instruction(SpvOpBranch, 0, 0,
-        {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}}}));
+  std::unique_ptr<ir::Instruction> newBranch(new ir::Instruction(
+      SpvOpBranch, 0, 0,
+      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}}}));
   get_def_use_mgr()->AnalyzeInstDefUse(&*newBranch);
   bp->AddInstruction(std::move(newBranch));
 }
@@ -209,7 +197,7 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
   func_is_entry_point_ = false;
   private_stores_.clear();
   // Stacks to keep track of when we are inside an if-construct. When not
-  // immediately inside an in-construct,  we must assume all branches are live. 
+  // immediately inside an in-construct,  we must assume all branches are live.
   std::stack<bool> assume_branches_live;
   std::stack<uint32_t> currentMergeBlockId;
   // Push sentinel values on stack for when outside of any control flow.
@@ -225,7 +213,7 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
       switch (op) {
         case SpvOpStore: {
           uint32_t varId;
-          (void) GetPtr(&*ii, &varId);
+          (void)GetPtr(&*ii, &varId);
           // Mark stores as live if their variable is not function scope
           // and is not private scope. Remember private stores for possible
           // later inclusion
@@ -236,8 +224,7 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
         } break;
         case SpvOpExtInst: {
           // eg. GLSL frexp, modf
-          if (!IsCombinatorExt(&*ii))
-            AddToWorklist(&*ii);
+          if (!IsCombinatorExt(&*ii)) AddToWorklist(&*ii);
         } break;
         case SpvOpLoopMerge: {
           // Assume loops live (for now)
@@ -254,22 +241,18 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
           assume_branches_live.push(!is_structured_if);
           currentMergeBlockId.push(
               ii->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx));
-          if (!is_structured_if)
-            AddToWorklist(&*ii);
+          if (!is_structured_if) AddToWorklist(&*ii);
         } break;
         case SpvOpBranch:
         case SpvOpBranchConditional: {
-          if (assume_branches_live.top())
-            AddToWorklist(&*ii);
+          if (assume_branches_live.top()) AddToWorklist(&*ii);
         } break;
         default: {
           // Function calls, atomics, function params, function returns, etc.
           // TODO(greg-lunarg): function calls live only if write to non-local
-          if (!IsCombinator(op))
-            AddToWorklist(&*ii);
+          if (!IsCombinator(op)) AddToWorklist(&*ii);
           // Remember function calls
-          if (op == SpvOpFunctionCall)
-            call_in_func_ = true;
+          if (op == SpvOpFunctionCall) call_in_func_ = true;
         } break;
       }
     }
@@ -287,23 +270,20 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
   private_like_local_ = func_is_entry_point_ && !call_in_func_;
   // If privates are not like local, add their stores to worklist
   if (!private_like_local_)
-    for (auto& ps : private_stores_)
-      AddToWorklist(ps);
+    for (auto& ps : private_stores_) AddToWorklist(ps);
   // Add OpGroupDecorates to worklist because they are a pain to remove
   // ids from.
   // TODO(greg-lunarg): Handle dead ids in OpGroupDecorate
   for (auto& ai : get_module()->annotations()) {
-    if (ai.opcode() == SpvOpGroupDecorate)
-      AddToWorklist(&ai);
+    if (ai.opcode() == SpvOpGroupDecorate) AddToWorklist(&ai);
   }
-  // Perform closure on live instruction set. 
+  // Perform closure on live instruction set.
   while (!worklist_.empty()) {
     ir::Instruction* liveInst = worklist_.front();
     // Add all operand instructions if not already live
     liveInst->ForEachInId([this](const uint32_t* iid) {
       ir::Instruction* inInst = get_def_use_mgr()->GetDef(*iid);
-      if (!IsLive(inInst))
-        AddToWorklist(inInst);
+      if (!IsLive(inInst)) AddToWorklist(inInst);
     });
     // If in a structured if construct, add the controlling conditional branch
     // and its merge. Any containing if construct is marked live when the
@@ -317,7 +297,7 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
     // If local load, add all variable's stores if variable not already live
     if (liveInst->opcode() == SpvOpLoad) {
       uint32_t varId;
-      (void) GetPtr(liveInst, &varId);
+      (void)GetPtr(liveInst, &varId);
       ProcessLoad(varId);
     }
     // If function call, treat as if it loads from all pointer arguments
@@ -326,7 +306,7 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
         // Skip non-ptr args
         if (!IsPtr(*iid)) return;
         uint32_t varId;
-        (void) GetPtr(*iid, &varId);
+        (void)GetPtr(*iid, &varId);
         ProcessLoad(varId);
       });
     }
@@ -340,8 +320,7 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
   // at the end of an if-header, which indicate a dead if.
   for (auto bi = structuredOrder.begin(); bi != structuredOrder.end(); ++bi) {
     for (auto ii = (*bi)->begin(); ii != (*bi)->end(); ++ii) {
-      if (IsLive(&*ii))
-        continue;
+      if (IsLive(&*ii)) continue;
       if (IsBranch(ii->opcode()) &&
           !IsStructuredIfHeader(*bi, nullptr, nullptr, nullptr))
         continue;
@@ -352,27 +331,23 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
   // This must be done before killing the instructions, otherwise there are
   // dead objects in the def/use database.
   for (auto& di : get_module()->debugs2()) {
-    if (di.opcode() != SpvOpName)
-      continue;
-    if (KillInstIfTargetDead(&di))
-      modified = true;
+    if (di.opcode() != SpvOpName) continue;
+    if (KillInstIfTargetDead(&di)) modified = true;
   }
   for (auto& ai : get_module()->annotations()) {
     if (ai.opcode() != SpvOpDecorate && ai.opcode() != SpvOpDecorateId)
       continue;
-    if (KillInstIfTargetDead(&ai))
-      modified = true;
+    if (KillInstIfTargetDead(&ai)) modified = true;
   }
   // Kill dead instructions and remember dead blocks
   for (auto bi = structuredOrder.begin(); bi != structuredOrder.end();) {
     uint32_t mergeBlockId = 0;
     for (auto ii = (*bi)->begin(); ii != (*bi)->end(); ++ii) {
-      if (dead_insts_.find(&*ii) == dead_insts_.end())
-        continue;
+      if (dead_insts_.find(&*ii) == dead_insts_.end()) continue;
       // If dead instruction is selection merge, remember merge block
       // for new branch at end of block
       if (ii->opcode() == SpvOpSelectionMerge)
-        mergeBlockId = 
+        mergeBlockId =
             ii->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx);
       context()->KillInst(&*ii);
       modified = true;
@@ -384,8 +359,7 @@ bool AggressiveDCEPass::AggressiveDCE(ir::Function* func) {
       AddBranch(mergeBlockId, *bi);
       for (++bi; (*bi)->id() != mergeBlockId; ++bi) {
       }
-    }
-    else {
+    } else {
       ++bi;
     }
   }
@@ -412,7 +386,7 @@ void AggressiveDCEPass::Initialize(ir::IRContext* c) {
 }
 
 Pass::Status AggressiveDCEPass::ProcessImpl() {
-  // Current functionality assumes shader capability 
+  // Current functionality assumes shader capability
   // TODO(greg-lunarg): Handle additional capabilities
   if (!get_module()->HasCapability(SpvCapabilityShader))
     return Status::SuccessWithoutChange;
@@ -421,15 +395,12 @@ Pass::Status AggressiveDCEPass::ProcessImpl() {
   if (get_module()->HasCapability(SpvCapabilityAddresses))
     return Status::SuccessWithoutChange;
   // If any extensions in the module are not explicitly supported,
-  // return unmodified. 
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  // return unmodified.
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Initialize combinator whitelists
   InitCombinatorSets();
   // Process all entry point functions
-  ProcessFunction pfn = [this](ir::Function* fp) {
-    return AggressiveDCE(fp);
-  };
+  ProcessFunction pfn = [this](ir::Function* fp) { return AggressiveDCE(fp); };
   bool modified = ProcessEntryPointCallTree(pfn, get_module());
   return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
 }
@@ -443,258 +414,246 @@ Pass::Status AggressiveDCEPass::Process(ir::IRContext* c) {
 
 void AggressiveDCEPass::InitCombinatorSets() {
   combinator_ops_shader_ = {
-    SpvOpNop,
-    SpvOpUndef,
-    SpvOpVariable,
-    SpvOpImageTexelPointer,
-    SpvOpLoad,
-    SpvOpAccessChain,
-    SpvOpInBoundsAccessChain,
-    SpvOpArrayLength,
-    SpvOpVectorExtractDynamic,
-    SpvOpVectorInsertDynamic,
-    SpvOpVectorShuffle,
-    SpvOpCompositeConstruct,
-    SpvOpCompositeExtract,
-    SpvOpCompositeInsert,
-    SpvOpCopyObject,
-    SpvOpTranspose,
-    SpvOpSampledImage,
-    SpvOpImageSampleImplicitLod,
-    SpvOpImageSampleExplicitLod,
-    SpvOpImageSampleDrefImplicitLod,
-    SpvOpImageSampleDrefExplicitLod,
-    SpvOpImageSampleProjImplicitLod,
-    SpvOpImageSampleProjExplicitLod,
-    SpvOpImageSampleProjDrefImplicitLod,
-    SpvOpImageSampleProjDrefExplicitLod,
-    SpvOpImageFetch,
-    SpvOpImageGather,
-    SpvOpImageDrefGather,
-    SpvOpImageRead,
-    SpvOpImage,
-    SpvOpConvertFToU,
-    SpvOpConvertFToS,
-    SpvOpConvertSToF,
-    SpvOpConvertUToF,
-    SpvOpUConvert,
-    SpvOpSConvert,
-    SpvOpFConvert,
-    SpvOpQuantizeToF16,
-    SpvOpBitcast,
-    SpvOpSNegate,
-    SpvOpFNegate,
-    SpvOpIAdd,
-    SpvOpFAdd,
-    SpvOpISub,
-    SpvOpFSub,
-    SpvOpIMul,
-    SpvOpFMul,
-    SpvOpUDiv,
-    SpvOpSDiv,
-    SpvOpFDiv,
-    SpvOpUMod,
-    SpvOpSRem,
-    SpvOpSMod,
-    SpvOpFRem,
-    SpvOpFMod,
-    SpvOpVectorTimesScalar,
-    SpvOpMatrixTimesScalar,
-    SpvOpVectorTimesMatrix,
-    SpvOpMatrixTimesVector,
-    SpvOpMatrixTimesMatrix,
-    SpvOpOuterProduct,
-    SpvOpDot,
-    SpvOpIAddCarry,
-    SpvOpISubBorrow,
-    SpvOpUMulExtended,
-    SpvOpSMulExtended,
-    SpvOpAny,
-    SpvOpAll,
-    SpvOpIsNan,
-    SpvOpIsInf,
-    SpvOpLogicalEqual,
-    SpvOpLogicalNotEqual,
-    SpvOpLogicalOr,
-    SpvOpLogicalAnd,
-    SpvOpLogicalNot,
-    SpvOpSelect,
-    SpvOpIEqual,
-    SpvOpINotEqual,
-    SpvOpUGreaterThan,
-    SpvOpSGreaterThan,
-    SpvOpUGreaterThanEqual,
-    SpvOpSGreaterThanEqual,
-    SpvOpULessThan,
-    SpvOpSLessThan,
-    SpvOpULessThanEqual,
-    SpvOpSLessThanEqual,
-    SpvOpFOrdEqual,
-    SpvOpFUnordEqual,
-    SpvOpFOrdNotEqual,
-    SpvOpFUnordNotEqual,
-    SpvOpFOrdLessThan,
-    SpvOpFUnordLessThan,
-    SpvOpFOrdGreaterThan,
-    SpvOpFUnordGreaterThan,
-    SpvOpFOrdLessThanEqual,
-    SpvOpFUnordLessThanEqual,
-    SpvOpFOrdGreaterThanEqual,
-    SpvOpFUnordGreaterThanEqual,
-    SpvOpShiftRightLogical,
-    SpvOpShiftRightArithmetic,
-    SpvOpShiftLeftLogical,
-    SpvOpBitwiseOr,
-    SpvOpBitwiseXor,
-    SpvOpBitwiseAnd,
-    SpvOpNot,
-    SpvOpBitFieldInsert,
-    SpvOpBitFieldSExtract,
-    SpvOpBitFieldUExtract,
-    SpvOpBitReverse,
-    SpvOpBitCount,
-    SpvOpDPdx,
-    SpvOpDPdy,
-    SpvOpFwidth,
-    SpvOpDPdxFine,
-    SpvOpDPdyFine,
-    SpvOpFwidthFine,
-    SpvOpDPdxCoarse,
-    SpvOpDPdyCoarse,
-    SpvOpFwidthCoarse,
-    SpvOpPhi,
-    SpvOpImageSparseSampleImplicitLod,
-    SpvOpImageSparseSampleExplicitLod,
-    SpvOpImageSparseSampleDrefImplicitLod,
-    SpvOpImageSparseSampleDrefExplicitLod,
-    SpvOpImageSparseSampleProjImplicitLod,
-    SpvOpImageSparseSampleProjExplicitLod,
-    SpvOpImageSparseSampleProjDrefImplicitLod,
-    SpvOpImageSparseSampleProjDrefExplicitLod,
-    SpvOpImageSparseFetch,
-    SpvOpImageSparseGather,
-    SpvOpImageSparseDrefGather,
-    SpvOpImageSparseTexelsResident,
-    SpvOpImageSparseRead,
-    SpvOpSizeOf
-    // TODO(dneto): Add instructions enabled by ImageQuery
+      SpvOpNop,
+      SpvOpUndef,
+      SpvOpVariable,
+      SpvOpImageTexelPointer,
+      SpvOpLoad,
+      SpvOpAccessChain,
+      SpvOpInBoundsAccessChain,
+      SpvOpArrayLength,
+      SpvOpVectorExtractDynamic,
+      SpvOpVectorInsertDynamic,
+      SpvOpVectorShuffle,
+      SpvOpCompositeConstruct,
+      SpvOpCompositeExtract,
+      SpvOpCompositeInsert,
+      SpvOpCopyObject,
+      SpvOpTranspose,
+      SpvOpSampledImage,
+      SpvOpImageSampleImplicitLod,
+      SpvOpImageSampleExplicitLod,
+      SpvOpImageSampleDrefImplicitLod,
+      SpvOpImageSampleDrefExplicitLod,
+      SpvOpImageSampleProjImplicitLod,
+      SpvOpImageSampleProjExplicitLod,
+      SpvOpImageSampleProjDrefImplicitLod,
+      SpvOpImageSampleProjDrefExplicitLod,
+      SpvOpImageFetch,
+      SpvOpImageGather,
+      SpvOpImageDrefGather,
+      SpvOpImageRead,
+      SpvOpImage,
+      SpvOpConvertFToU,
+      SpvOpConvertFToS,
+      SpvOpConvertSToF,
+      SpvOpConvertUToF,
+      SpvOpUConvert,
+      SpvOpSConvert,
+      SpvOpFConvert,
+      SpvOpQuantizeToF16,
+      SpvOpBitcast,
+      SpvOpSNegate,
+      SpvOpFNegate,
+      SpvOpIAdd,
+      SpvOpFAdd,
+      SpvOpISub,
+      SpvOpFSub,
+      SpvOpIMul,
+      SpvOpFMul,
+      SpvOpUDiv,
+      SpvOpSDiv,
+      SpvOpFDiv,
+      SpvOpUMod,
+      SpvOpSRem,
+      SpvOpSMod,
+      SpvOpFRem,
+      SpvOpFMod,
+      SpvOpVectorTimesScalar,
+      SpvOpMatrixTimesScalar,
+      SpvOpVectorTimesMatrix,
+      SpvOpMatrixTimesVector,
+      SpvOpMatrixTimesMatrix,
+      SpvOpOuterProduct,
+      SpvOpDot,
+      SpvOpIAddCarry,
+      SpvOpISubBorrow,
+      SpvOpUMulExtended,
+      SpvOpSMulExtended,
+      SpvOpAny,
+      SpvOpAll,
+      SpvOpIsNan,
+      SpvOpIsInf,
+      SpvOpLogicalEqual,
+      SpvOpLogicalNotEqual,
+      SpvOpLogicalOr,
+      SpvOpLogicalAnd,
+      SpvOpLogicalNot,
+      SpvOpSelect,
+      SpvOpIEqual,
+      SpvOpINotEqual,
+      SpvOpUGreaterThan,
+      SpvOpSGreaterThan,
+      SpvOpUGreaterThanEqual,
+      SpvOpSGreaterThanEqual,
+      SpvOpULessThan,
+      SpvOpSLessThan,
+      SpvOpULessThanEqual,
+      SpvOpSLessThanEqual,
+      SpvOpFOrdEqual,
+      SpvOpFUnordEqual,
+      SpvOpFOrdNotEqual,
+      SpvOpFUnordNotEqual,
+      SpvOpFOrdLessThan,
+      SpvOpFUnordLessThan,
+      SpvOpFOrdGreaterThan,
+      SpvOpFUnordGreaterThan,
+      SpvOpFOrdLessThanEqual,
+      SpvOpFUnordLessThanEqual,
+      SpvOpFOrdGreaterThanEqual,
+      SpvOpFUnordGreaterThanEqual,
+      SpvOpShiftRightLogical,
+      SpvOpShiftRightArithmetic,
+      SpvOpShiftLeftLogical,
+      SpvOpBitwiseOr,
+      SpvOpBitwiseXor,
+      SpvOpBitwiseAnd,
+      SpvOpNot,
+      SpvOpBitFieldInsert,
+      SpvOpBitFieldSExtract,
+      SpvOpBitFieldUExtract,
+      SpvOpBitReverse,
+      SpvOpBitCount,
+      SpvOpDPdx,
+      SpvOpDPdy,
+      SpvOpFwidth,
+      SpvOpDPdxFine,
+      SpvOpDPdyFine,
+      SpvOpFwidthFine,
+      SpvOpDPdxCoarse,
+      SpvOpDPdyCoarse,
+      SpvOpFwidthCoarse,
+      SpvOpPhi,
+      SpvOpImageSparseSampleImplicitLod,
+      SpvOpImageSparseSampleExplicitLod,
+      SpvOpImageSparseSampleDrefImplicitLod,
+      SpvOpImageSparseSampleDrefExplicitLod,
+      SpvOpImageSparseSampleProjImplicitLod,
+      SpvOpImageSparseSampleProjExplicitLod,
+      SpvOpImageSparseSampleProjDrefImplicitLod,
+      SpvOpImageSparseSampleProjDrefExplicitLod,
+      SpvOpImageSparseFetch,
+      SpvOpImageSparseGather,
+      SpvOpImageSparseDrefGather,
+      SpvOpImageSparseTexelsResident,
+      SpvOpImageSparseRead,
+      SpvOpSizeOf
+      // TODO(dneto): Add instructions enabled by ImageQuery
   };
 
   // Find supported extension instruction set ids
   glsl_std_450_id_ = get_module()->GetExtInstImportId("GLSL.std.450");
 
-  combinator_ops_glsl_std_450_ = {
-    GLSLstd450Round,
-    GLSLstd450RoundEven,
-    GLSLstd450Trunc,
-    GLSLstd450FAbs,
-    GLSLstd450SAbs,
-    GLSLstd450FSign,
-    GLSLstd450SSign,
-    GLSLstd450Floor,
-    GLSLstd450Ceil,
-    GLSLstd450Fract,
-    GLSLstd450Radians,
-    GLSLstd450Degrees,
-    GLSLstd450Sin,
-    GLSLstd450Cos,
-    GLSLstd450Tan,
-    GLSLstd450Asin,
-    GLSLstd450Acos,
-    GLSLstd450Atan,
-    GLSLstd450Sinh,
-    GLSLstd450Cosh,
-    GLSLstd450Tanh,
-    GLSLstd450Asinh,
-    GLSLstd450Acosh,
-    GLSLstd450Atanh,
-    GLSLstd450Atan2,
-    GLSLstd450Pow,
-    GLSLstd450Exp,
-    GLSLstd450Log,
-    GLSLstd450Exp2,
-    GLSLstd450Log2,
-    GLSLstd450Sqrt,
-    GLSLstd450InverseSqrt,
-    GLSLstd450Determinant,
-    GLSLstd450MatrixInverse,
-    GLSLstd450ModfStruct,
-    GLSLstd450FMin,
-    GLSLstd450UMin,
-    GLSLstd450SMin,
-    GLSLstd450FMax,
-    GLSLstd450UMax,
-    GLSLstd450SMax,
-    GLSLstd450FClamp,
-    GLSLstd450UClamp,
-    GLSLstd450SClamp,
-    GLSLstd450FMix,
-    GLSLstd450IMix,
-    GLSLstd450Step,
-    GLSLstd450SmoothStep,
-    GLSLstd450Fma,
-    GLSLstd450FrexpStruct,
-    GLSLstd450Ldexp,
-    GLSLstd450PackSnorm4x8,
-    GLSLstd450PackUnorm4x8,
-    GLSLstd450PackSnorm2x16,
-    GLSLstd450PackUnorm2x16,
-    GLSLstd450PackHalf2x16,
-    GLSLstd450PackDouble2x32,
-    GLSLstd450UnpackSnorm2x16,
-    GLSLstd450UnpackUnorm2x16,
-    GLSLstd450UnpackHalf2x16,
-    GLSLstd450UnpackSnorm4x8,
-    GLSLstd450UnpackUnorm4x8,
-    GLSLstd450UnpackDouble2x32,
-    GLSLstd450Length,
-    GLSLstd450Distance,
-    GLSLstd450Cross,
-    GLSLstd450Normalize,
-    GLSLstd450FaceForward,
-    GLSLstd450Reflect,
-    GLSLstd450Refract,
-    GLSLstd450FindILsb,
-    GLSLstd450FindSMsb,
-    GLSLstd450FindUMsb,
-    GLSLstd450InterpolateAtCentroid,
-    GLSLstd450InterpolateAtSample,
-    GLSLstd450InterpolateAtOffset,
-    GLSLstd450NMin,
-    GLSLstd450NMax,
-    GLSLstd450NClamp
-  };
+  combinator_ops_glsl_std_450_ = {GLSLstd450Round,
+                                  GLSLstd450RoundEven,
+                                  GLSLstd450Trunc,
+                                  GLSLstd450FAbs,
+                                  GLSLstd450SAbs,
+                                  GLSLstd450FSign,
+                                  GLSLstd450SSign,
+                                  GLSLstd450Floor,
+                                  GLSLstd450Ceil,
+                                  GLSLstd450Fract,
+                                  GLSLstd450Radians,
+                                  GLSLstd450Degrees,
+                                  GLSLstd450Sin,
+                                  GLSLstd450Cos,
+                                  GLSLstd450Tan,
+                                  GLSLstd450Asin,
+                                  GLSLstd450Acos,
+                                  GLSLstd450Atan,
+                                  GLSLstd450Sinh,
+                                  GLSLstd450Cosh,
+                                  GLSLstd450Tanh,
+                                  GLSLstd450Asinh,
+                                  GLSLstd450Acosh,
+                                  GLSLstd450Atanh,
+                                  GLSLstd450Atan2,
+                                  GLSLstd450Pow,
+                                  GLSLstd450Exp,
+                                  GLSLstd450Log,
+                                  GLSLstd450Exp2,
+                                  GLSLstd450Log2,
+                                  GLSLstd450Sqrt,
+                                  GLSLstd450InverseSqrt,
+                                  GLSLstd450Determinant,
+                                  GLSLstd450MatrixInverse,
+                                  GLSLstd450ModfStruct,
+                                  GLSLstd450FMin,
+                                  GLSLstd450UMin,
+                                  GLSLstd450SMin,
+                                  GLSLstd450FMax,
+                                  GLSLstd450UMax,
+                                  GLSLstd450SMax,
+                                  GLSLstd450FClamp,
+                                  GLSLstd450UClamp,
+                                  GLSLstd450SClamp,
+                                  GLSLstd450FMix,
+                                  GLSLstd450IMix,
+                                  GLSLstd450Step,
+                                  GLSLstd450SmoothStep,
+                                  GLSLstd450Fma,
+                                  GLSLstd450FrexpStruct,
+                                  GLSLstd450Ldexp,
+                                  GLSLstd450PackSnorm4x8,
+                                  GLSLstd450PackUnorm4x8,
+                                  GLSLstd450PackSnorm2x16,
+                                  GLSLstd450PackUnorm2x16,
+                                  GLSLstd450PackHalf2x16,
+                                  GLSLstd450PackDouble2x32,
+                                  GLSLstd450UnpackSnorm2x16,
+                                  GLSLstd450UnpackUnorm2x16,
+                                  GLSLstd450UnpackHalf2x16,
+                                  GLSLstd450UnpackSnorm4x8,
+                                  GLSLstd450UnpackUnorm4x8,
+                                  GLSLstd450UnpackDouble2x32,
+                                  GLSLstd450Length,
+                                  GLSLstd450Distance,
+                                  GLSLstd450Cross,
+                                  GLSLstd450Normalize,
+                                  GLSLstd450FaceForward,
+                                  GLSLstd450Reflect,
+                                  GLSLstd450Refract,
+                                  GLSLstd450FindILsb,
+                                  GLSLstd450FindSMsb,
+                                  GLSLstd450FindUMsb,
+                                  GLSLstd450InterpolateAtCentroid,
+                                  GLSLstd450InterpolateAtSample,
+                                  GLSLstd450InterpolateAtOffset,
+                                  GLSLstd450NMin,
+                                  GLSLstd450NMax,
+                                  GLSLstd450NClamp};
 }
 
 void AggressiveDCEPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    // SPV_KHR_variable_pointers
-    //   Currently do not support extended pointer expressions
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
+      "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      // SPV_KHR_variable_pointers
+      //   Currently do not support extended pointer expressions
+      "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/aggressive_dead_code_elim_pass.h b/source/opt/aggressive_dead_code_elim_pass.h
index 7e0bf378..b19e3755 100644
--- a/source/opt/aggressive_dead_code_elim_pass.h
+++ b/source/opt/aggressive_dead_code_elim_pass.h
@@ -26,20 +26,19 @@
 
 #include "basic_block.h"
 #include "def_use_manager.h"
-#include "module.h"
 #include "mem_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
 
 // See optimizer.hpp for documentation.
 class AggressiveDCEPass : public MemPass {
-
   using cbb_ptr = const ir::BasicBlock*;
 
  public:
-   using GetBlocksFunction =
-     std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
+  using GetBlocksFunction =
+      std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
 
   AggressiveDCEPass();
   const char* name() const override { return "eliminate-dead-code-aggressive"; }
@@ -102,9 +101,9 @@ class AggressiveDCEPass : public MemPass {
 
   // If |bp| is structured if header block, return true and set |branchInst|
   // to the conditional branch and |mergeBlockId| to the merge block.
-  bool IsStructuredIfHeader(ir::BasicBlock* bp,
-    ir::Instruction** mergeInst, ir::Instruction** branchInst,
-    uint32_t* mergeBlockId);
+  bool IsStructuredIfHeader(ir::BasicBlock* bp, ir::Instruction** mergeInst,
+                            ir::Instruction** branchInst,
+                            uint32_t* mergeBlockId);
 
   // Initialize block2branch_ and block2merge_ using |structuredOrder| to
   // order blocks.
@@ -120,7 +119,7 @@ class AggressiveDCEPass : public MemPass {
   // and block terminating instructions as live. Recursively mark the values
   // they use. When complete, delete any non-live instructions. Return true
   // if the function has been modified.
-  // 
+  //
   // Note: This function does not delete useless control structures. All
   // existing control structures will remain. This can leave not-insignificant
   // sequences of ultimately useless code.
@@ -160,7 +159,7 @@ class AggressiveDCEPass : public MemPass {
   // Map from block's label id to block.
   std::unordered_map<uint32_t, ir::BasicBlock*> id2block_;
 
-  // Map from block to its structured successor blocks. See 
+  // Map from block to its structured successor blocks. See
   // ComputeStructuredSuccessors() for definition.
   std::unordered_map<const ir::BasicBlock*, std::vector<ir::BasicBlock*>>
       block2structured_succs_;
@@ -200,4 +199,3 @@ class AggressiveDCEPass : public MemPass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_AGGRESSIVE_DCE_PASS_H_
-
diff --git a/source/opt/block_merge_pass.cpp b/source/opt/block_merge_pass.cpp
index 4b06a2eb..c0da5d70 100644
--- a/source/opt/block_merge_pass.cpp
+++ b/source/opt/block_merge_pass.cpp
@@ -16,8 +16,8 @@
 
 #include "block_merge_pass.h"
 
-#include "iterator.h"
 #include "ir_context.h"
+#include "iterator.h"
 
 namespace spvtools {
 namespace opt {
@@ -27,10 +27,8 @@ bool BlockMergePass::HasMultipleRefs(uint32_t labId) {
   int rcnt = 0;
   for (const auto u : *uses) {
     // Don't count OpName
-    if (u.inst->opcode() == SpvOpName)
-      continue;
-    if (rcnt == 1)
-      return true;
+    if (u.inst->opcode() == SpvOpName) continue;
+    if (rcnt == 1) return true;
     ++rcnt;
   }
   return false;
@@ -52,7 +50,7 @@ void BlockMergePass::KillInstAndName(ir::Instruction* inst) {
 
 bool BlockMergePass::MergeBlocks(ir::Function* func) {
   bool modified = false;
-  for (auto bi = func->begin(); bi != func->end(); ) {
+  for (auto bi = func->begin(); bi != func->end();) {
     // Do not merge loop header blocks, at least for now.
     if (bi->IsLoopHeader()) {
       ++bi;
@@ -81,14 +79,13 @@ bool BlockMergePass::MergeBlocks(ir::Function* func) {
     context()->KillInst(br);
     auto sbi = bi;
     for (; sbi != func->end(); ++sbi)
-      if (sbi->id() == labId)
-        break;
+      if (sbi->id() == labId) break;
     // If bi is sbi's only predecessor, it dominates sbi and thus
     // sbi must follow bi in func's ordering.
     assert(sbi != func->end());
     bi->AddInstructions(&*sbi);
     KillInstAndName(sbi->GetLabelInst());
-    (void) sbi.Erase();
+    (void)sbi.Erase();
     // reprocess block
     modified = true;
   }
@@ -105,8 +102,8 @@ void BlockMergePass::Initialize(ir::IRContext* c) {
 bool BlockMergePass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -115,12 +112,9 @@ bool BlockMergePass::AllExtensionsSupported() const {
 
 Pass::Status BlockMergePass::ProcessImpl() {
   // Do not process if any disallowed extensions are enabled
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Process all entry point functions.
-  ProcessFunction pfn = [this](ir::Function* fp) {
-    return MergeBlocks(fp);
-  };
+  ProcessFunction pfn = [this](ir::Function* fp) { return MergeBlocks(fp); };
   bool modified = ProcessEntryPointCallTree(pfn, get_module());
   return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
 }
@@ -135,31 +129,30 @@ Pass::Status BlockMergePass::Process(ir::IRContext* c) {
 void BlockMergePass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    "SPV_KHR_variable_pointers",
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax",
+      "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot",
+      "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float",
+      "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote",
+      "SPV_KHR_16bit_storage",
+      "SPV_KHR_device_group",
+      "SPV_KHR_multiview",
+      "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2",
+      "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough",
+      "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      "SPV_KHR_variable_pointers",
+      "SPV_AMD_gpu_shader_int16",
+      "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/block_merge_pass.h b/source/opt/block_merge_pass.h
index 3ebd358c..92921a5b 100644
--- a/source/opt/block_merge_pass.h
+++ b/source/opt/block_merge_pass.h
@@ -26,9 +26,9 @@
 
 #include "basic_block.h"
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
@@ -68,4 +68,3 @@ class BlockMergePass : public Pass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_BLOCK_MERGE_PASS_H_
-
diff --git a/source/opt/build_module.cpp b/source/opt/build_module.cpp
index 766dbb52..e3439f3d 100644
--- a/source/opt/build_module.cpp
+++ b/source/opt/build_module.cpp
@@ -27,8 +27,8 @@ namespace {
 spv_result_t SetSpvHeader(void* builder, spv_endianness_t, uint32_t magic,
                           uint32_t version, uint32_t generator,
                           uint32_t id_bound, uint32_t reserved) {
-  reinterpret_cast<ir::IrLoader*>(builder)
-      ->SetModuleHeader(magic, version, generator, id_bound, reserved);
+  reinterpret_cast<ir::IrLoader*>(builder)->SetModuleHeader(
+      magic, version, generator, id_bound, reserved);
   return SPV_SUCCESS;
 };
 
diff --git a/source/opt/build_module.h b/source/opt/build_module.h
index c27b1aeb..36ea74f2 100644
--- a/source/opt/build_module.h
+++ b/source/opt/build_module.h
@@ -27,9 +27,9 @@ namespace spvtools {
 // specifies number of words in |binary|. The |binary| will be decoded
 // according to the given target |env|. Returns nullptr if erors occur and
 // sends the errors to |consumer|.
-std::unique_ptr<ir::Module> BuildModule(
-    spv_target_env env, MessageConsumer consumer, const uint32_t* binary,
-    size_t size);
+std::unique_ptr<ir::Module> BuildModule(spv_target_env env,
+                                        MessageConsumer consumer,
+                                        const uint32_t* binary, size_t size);
 
 // Builds and returns an ir::Module from the given SPIR-V assembly |text|.
 // The |text| will be encoded according to the given target |env|. Returns
diff --git a/source/opt/common_uniform_elim_pass.cpp b/source/opt/common_uniform_elim_pass.cpp
index aafc5f1a..5c3d8725 100644
--- a/source/opt/common_uniform_elim_pass.cpp
+++ b/source/opt/common_uniform_elim_pass.cpp
@@ -574,31 +574,21 @@ void CommonUniformElimPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
       "SPV_AMD_shader_explicit_vertex_parameter",
-      "SPV_AMD_shader_trinary_minmax",
-      "SPV_AMD_gcn_shader",
-      "SPV_KHR_shader_ballot",
-      "SPV_AMD_shader_ballot",
-      "SPV_AMD_gpu_shader_half_float",
-      "SPV_KHR_shader_draw_parameters",
-      "SPV_KHR_subgroup_vote",
-      "SPV_KHR_16bit_storage",
-      "SPV_KHR_device_group",
-      "SPV_KHR_multiview",
-      "SPV_NVX_multiview_per_view_attributes",
-      "SPV_NV_viewport_array2",
-      "SPV_NV_stereo_view_rendering",
+      "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
+      "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
       "SPV_NV_sample_mask_override_coverage",
-      "SPV_NV_geometry_shader_passthrough",
-      "SPV_AMD_texture_gather_bias_lod",
+      "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
       "SPV_KHR_storage_buffer_storage_class",
       // SPV_KHR_variable_pointers
       //   Currently do not support extended pointer expressions
-      "SPV_AMD_gpu_shader_int16",
-      "SPV_KHR_post_depth_coverage",
+      "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
       "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/common_uniform_elim_pass.h b/source/opt/common_uniform_elim_pass.h
index ccafd313..0e626600 100644
--- a/source/opt/common_uniform_elim_pass.h
+++ b/source/opt/common_uniform_elim_pass.h
@@ -24,23 +24,23 @@
 #include <unordered_set>
 #include <utility>
 
-#include "def_use_manager.h"
+#include "basic_block.h"
 #include "decoration_manager.h"
+#include "def_use_manager.h"
+#include "ir_context.h"
 #include "module.h"
-#include "basic_block.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
 
 // See optimizer.hpp for documentation.
 class CommonUniformElimPass : public Pass {
- using cbb_ptr = const ir::BasicBlock*;
+  using cbb_ptr = const ir::BasicBlock*;
 
  public:
-   using GetBlocksFunction =
-     std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
+  using GetBlocksFunction =
+      std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
 
   CommonUniformElimPass();
   const char* name() const override { return "eliminate-common-uniform"; }
@@ -72,7 +72,8 @@ class CommonUniformElimPass : public Pass {
   // Given an OpAccessChain instruction, return true
   // if the accessed variable belongs to a volatile
   // decorated object or member of a struct type
-  bool IsAccessChainToVolatileStructType(const ir::Instruction &AccessChainInst);
+  bool IsAccessChainToVolatileStructType(
+      const ir::Instruction& AccessChainInst);
 
   // Given an OpLoad instruction, return true if
   // OpLoad has a Volatile Memory Access flag or if
@@ -96,15 +97,14 @@ class CommonUniformElimPass : public Pass {
 
   // Replace all instances of load's id with replId and delete load
   // and its access chain, if any
-  void ReplaceAndDeleteLoad(ir::Instruction* loadInst,
-    uint32_t replId,
-    ir::Instruction* ptrInst);
+  void ReplaceAndDeleteLoad(ir::Instruction* loadInst, uint32_t replId,
+                            ir::Instruction* ptrInst);
 
   // For the (constant index) access chain ptrInst, create an
   // equivalent load and extract
   void GenACLoadRepl(const ir::Instruction* ptrInst,
-      std::vector<std::unique_ptr<ir::Instruction>>* newInsts,
-      uint32_t* resultId);
+                     std::vector<std::unique_ptr<ir::Instruction>>* newInsts,
+                     uint32_t* resultId);
 
   // Return true if all indices are constant
   bool IsConstantIndexAccessChain(ir::Instruction* acp);
@@ -132,14 +132,15 @@ class CommonUniformElimPass : public Pass {
   // TODO(dnovillo): This pass computes structured order slightly different
   // than the implementation in class Pass. Can this be re-factored?
   void ComputeStructuredOrder(ir::Function* func,
-      std::list<ir::BasicBlock*>* order);
+                              std::list<ir::BasicBlock*>* order);
 
   // Eliminate loads of uniform variables which have previously been loaded.
   // If first load is in control flow, move it to first block of function.
   // Most effective if preceded by UniformAccessChainRemoval().
   bool CommonUniformLoadElimination(ir::Function* func);
 
-  // Eliminate loads of uniform sampler and image variables which have previously
+  // Eliminate loads of uniform sampler and image variables which have
+  // previously
   // been loaded in the same block for types whose loads cannot cross blocks.
   bool CommonUniformLoadElimBlock(ir::Function* func);
 
@@ -150,11 +151,11 @@ class CommonUniformElimPass : public Pass {
   bool CommonExtractElimination(ir::Function* func);
 
   // For function |func|, first change all uniform constant index
-  // access chain loads into equivalent composite extracts. Then consolidate 
+  // access chain loads into equivalent composite extracts. Then consolidate
   // identical uniform loads into one uniform load. Finally, consolidate
   // identical uniform extracts into one uniform extract. This may require
   // moving a load or extract to a point which dominates all uses.
-  // Return true if func is modified. 
+  // Return true if func is modified.
   //
   // This pass requires the function to have structured control flow ie shader
   // capability. It also requires logical addressing ie Addresses capability
@@ -185,8 +186,9 @@ class CommonUniformElimPass : public Pass {
 
   // Map of extract composite ids to map of indices to insts
   // TODO(greg-lunarg): Consider std::vector.
-  std::unordered_map<uint32_t, std::unordered_map<uint32_t,
-      std::list<ir::Instruction*>>> comp2idx2inst_;
+  std::unordered_map<uint32_t,
+                     std::unordered_map<uint32_t, std::list<ir::Instruction*>>>
+      comp2idx2inst_;
 
   // Extensions supported by this pass.
   std::unordered_set<std::string> extensions_whitelist_;
@@ -201,4 +203,3 @@ class CommonUniformElimPass : public Pass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_SSAMEM_PASS_H_
-
diff --git a/source/opt/compact_ids_pass.cpp b/source/opt/compact_ids_pass.cpp
index 5a7c4855..380b75cc 100644
--- a/source/opt/compact_ids_pass.cpp
+++ b/source/opt/compact_ids_pass.cpp
@@ -30,35 +30,38 @@ Pass::Status CompactIdsPass::Process(ir::IRContext* c) {
   bool modified = false;
   std::unordered_map<uint32_t, uint32_t> result_id_mapping;
 
-  c->module()->ForEachInst([&result_id_mapping, &modified] (Instruction* inst) {
-    auto operand = inst->begin();
-    while (operand != inst->end()) {
-      const auto type = operand->type;
-      if (spvIsIdType(type)) {
-        assert(operand->words.size() == 1);
-        uint32_t& id = operand->words[0];
-        auto it = result_id_mapping.find(id);
-        if (it == result_id_mapping.end()) {
-          const uint32_t new_id =
-              static_cast<uint32_t>(result_id_mapping.size()) + 1;
-          const auto insertion_result = result_id_mapping.emplace(id, new_id);
-          it = insertion_result.first;
-          assert(insertion_result.second);
-        }
-        if (id != it->second) {
-          modified = true;
-          id = it->second;
-          // Update data cached in the instruction object.
-          if (type == SPV_OPERAND_TYPE_RESULT_ID) {
-            inst->SetResultId(id);
-          } else if (type == SPV_OPERAND_TYPE_TYPE_ID) {
-            inst->SetResultType(id);
+  c->module()->ForEachInst(
+      [&result_id_mapping, &modified](Instruction* inst) {
+        auto operand = inst->begin();
+        while (operand != inst->end()) {
+          const auto type = operand->type;
+          if (spvIsIdType(type)) {
+            assert(operand->words.size() == 1);
+            uint32_t& id = operand->words[0];
+            auto it = result_id_mapping.find(id);
+            if (it == result_id_mapping.end()) {
+              const uint32_t new_id =
+                  static_cast<uint32_t>(result_id_mapping.size()) + 1;
+              const auto insertion_result =
+                  result_id_mapping.emplace(id, new_id);
+              it = insertion_result.first;
+              assert(insertion_result.second);
+            }
+            if (id != it->second) {
+              modified = true;
+              id = it->second;
+              // Update data cached in the instruction object.
+              if (type == SPV_OPERAND_TYPE_RESULT_ID) {
+                inst->SetResultId(id);
+              } else if (type == SPV_OPERAND_TYPE_TYPE_ID) {
+                inst->SetResultType(id);
+              }
+            }
           }
+          ++operand;
         }
-      }
-      ++operand;
-    }
-  }, true);
+      },
+      true);
 
   if (modified)
     c->SetIdBound(static_cast<uint32_t>(result_id_mapping.size() + 1));
diff --git a/source/opt/compact_ids_pass.h b/source/opt/compact_ids_pass.h
index 702620ea..cf7c3fb7 100644
--- a/source/opt/compact_ids_pass.h
+++ b/source/opt/compact_ids_pass.h
@@ -15,9 +15,9 @@
 #ifndef LIBSPIRV_OPT_COMPACT_IDS_PASS_H_
 #define LIBSPIRV_OPT_COMPACT_IDS_PASS_H_
 
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/dead_branch_elim_pass.cpp b/source/opt/dead_branch_elim_pass.cpp
index ebca89e5..7d543f98 100644
--- a/source/opt/dead_branch_elim_pass.cpp
+++ b/source/opt/dead_branch_elim_pass.cpp
@@ -29,7 +29,7 @@ const uint32_t kBranchCondTrueLabIdInIdx = 1;
 const uint32_t kBranchCondFalseLabIdInIdx = 2;
 const uint32_t kSelectionMergeMergeBlockIdInIdx = 0;
 
-} // anonymous namespace
+}  // anonymous namespace
 
 bool DeadBranchElimPass::GetConstCondition(uint32_t condId, bool* condVal) {
   bool condIsConst;
@@ -45,14 +45,11 @@ bool DeadBranchElimPass::GetConstCondition(uint32_t condId, bool* condVal) {
     } break;
     case SpvOpLogicalNot: {
       bool negVal;
-      condIsConst = GetConstCondition(cInst->GetSingleWordInOperand(0),
-          &negVal);
-      if (condIsConst)
-        *condVal = !negVal;
-    } break;
-    default: {
-      condIsConst = false;
+      condIsConst =
+          GetConstCondition(cInst->GetSingleWordInOperand(0), &negVal);
+      if (condIsConst) *condVal = !negVal;
     } break;
+    default: { condIsConst = false; } break;
   }
   return condIsConst;
 }
@@ -63,13 +60,11 @@ bool DeadBranchElimPass::GetConstInteger(uint32_t selId, uint32_t* selVal) {
   ir::Instruction* typeInst = get_def_use_mgr()->GetDef(typeId);
   if (!typeInst || (typeInst->opcode() != SpvOpTypeInt)) return false;
   // TODO(greg-lunarg): Support non-32 bit ints
-  if (typeInst->GetSingleWordInOperand(0) != 32)
-    return false;
+  if (typeInst->GetSingleWordInOperand(0) != 32) return false;
   if (sInst->opcode() == SpvOpConstant) {
     *selVal = sInst->GetSingleWordInOperand(0);
     return true;
-  }
-  else if (sInst->opcode() == SpvOpConstantNull) {
+  } else if (sInst->opcode() == SpvOpConstantNull) {
     *selVal = 0;
     return true;
   }
@@ -77,46 +72,47 @@ bool DeadBranchElimPass::GetConstInteger(uint32_t selId, uint32_t* selVal) {
 }
 
 void DeadBranchElimPass::AddBranch(uint32_t labelId, ir::BasicBlock* bp) {
-  std::unique_ptr<ir::Instruction> newBranch(
-    new ir::Instruction(SpvOpBranch, 0, 0,
-        {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}}}));
+  std::unique_ptr<ir::Instruction> newBranch(new ir::Instruction(
+      SpvOpBranch, 0, 0,
+      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}}}));
   get_def_use_mgr()->AnalyzeInstDefUse(&*newBranch);
   bp->AddInstruction(std::move(newBranch));
 }
 
 void DeadBranchElimPass::AddSelectionMerge(uint32_t labelId,
-    ir::BasicBlock* bp) {
-  std::unique_ptr<ir::Instruction> newMerge(
-    new ir::Instruction(SpvOpSelectionMerge, 0, 0,
-        {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}},
-         {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {0}}}));
+                                           ir::BasicBlock* bp) {
+  std::unique_ptr<ir::Instruction> newMerge(new ir::Instruction(
+      SpvOpSelectionMerge, 0, 0,
+      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}},
+       {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {0}}}));
   get_def_use_mgr()->AnalyzeInstDefUse(&*newMerge);
   bp->AddInstruction(std::move(newMerge));
 }
 
 void DeadBranchElimPass::AddBranchConditional(uint32_t condId,
-    uint32_t trueLabId, uint32_t falseLabId, ir::BasicBlock* bp) {
-  std::unique_ptr<ir::Instruction> newBranchCond(
-    new ir::Instruction(SpvOpBranchConditional, 0, 0,
-        {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {condId}},
-         {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {trueLabId}},
-         {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {falseLabId}}}));
+                                              uint32_t trueLabId,
+                                              uint32_t falseLabId,
+                                              ir::BasicBlock* bp) {
+  std::unique_ptr<ir::Instruction> newBranchCond(new ir::Instruction(
+      SpvOpBranchConditional, 0, 0,
+      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {condId}},
+       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {trueLabId}},
+       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {falseLabId}}}));
   get_def_use_mgr()->AnalyzeInstDefUse(&*newBranchCond);
   bp->AddInstruction(std::move(newBranchCond));
 }
 
 bool DeadBranchElimPass::GetSelectionBranch(ir::BasicBlock* bp,
-    ir::Instruction** branchInst, ir::Instruction** mergeInst,
-    uint32_t *condId) {
+                                            ir::Instruction** branchInst,
+                                            ir::Instruction** mergeInst,
+                                            uint32_t* condId) {
   auto ii = bp->end();
   --ii;
   *branchInst = &*ii;
-  if (ii == bp->begin())
-    return false;
+  if (ii == bp->begin()) return false;
   --ii;
   *mergeInst = &*ii;
-  if ((*mergeInst)->opcode() != SpvOpSelectionMerge)
-    return false;
+  if ((*mergeInst)->opcode() != SpvOpSelectionMerge) return false;
   // SPIR-V says the terminator for an OpSelectionMerge must be
   // either a conditional branch or a switch.
   assert((*branchInst)->opcode() == SpvOpBranchConditional ||
@@ -128,8 +124,7 @@ bool DeadBranchElimPass::GetSelectionBranch(ir::BasicBlock* bp,
 
 bool DeadBranchElimPass::HasNonPhiNonBackedgeRef(uint32_t labelId) {
   analysis::UseList* uses = get_def_use_mgr()->GetUses(labelId);
-  if (uses == nullptr)
-    return false;
+  if (uses == nullptr) return false;
   for (auto u : *uses) {
     if (u.inst->opcode() != SpvOpPhi &&
         backedges_.find(u.inst) == backedges_.end())
@@ -147,24 +142,22 @@ void DeadBranchElimPass::ComputeBackEdges(
     visited.insert((*bi)->id());
     auto ii = (*bi)->end();
     --ii;
-    switch(ii->opcode()) {
+    switch (ii->opcode()) {
       case SpvOpBranch: {
-        const uint32_t labId = ii->GetSingleWordInOperand(
-            kBranchTargetLabIdInIdx);
-        if (visited.find(labId) != visited.end())
-          backedges_.insert(&*ii);
+        const uint32_t labId =
+            ii->GetSingleWordInOperand(kBranchTargetLabIdInIdx);
+        if (visited.find(labId) != visited.end()) backedges_.insert(&*ii);
       } break;
       case SpvOpBranchConditional: {
-        const uint32_t tLabId = ii->GetSingleWordInOperand(
-            kBranchCondTrueLabIdInIdx);
+        const uint32_t tLabId =
+            ii->GetSingleWordInOperand(kBranchCondTrueLabIdInIdx);
         if (visited.find(tLabId) != visited.end()) {
           backedges_.insert(&*ii);
           break;
         }
-        const uint32_t fLabId = ii->GetSingleWordInOperand(
-            kBranchCondFalseLabIdInIdx);
-        if (visited.find(fLabId) != visited.end())
-          backedges_.insert(&*ii);
+        const uint32_t fLabId =
+            ii->GetSingleWordInOperand(kBranchCondFalseLabIdInIdx);
+        if (visited.find(fLabId) != visited.end()) backedges_.insert(&*ii);
       } break;
       default:
         break;
@@ -181,53 +174,45 @@ bool DeadBranchElimPass::EliminateDeadBranches(ir::Function* func) {
   bool modified = false;
   for (auto bi = structuredOrder.begin(); bi != structuredOrder.end(); ++bi) {
     // Skip blocks that are already in the elimination set
-    if (elimBlocks.find(*bi) != elimBlocks.end())
-      continue;
+    if (elimBlocks.find(*bi) != elimBlocks.end()) continue;
     // Skip blocks that don't have conditional branch preceded
     // by OpSelectionMerge
     ir::Instruction* br;
     ir::Instruction* mergeInst;
     uint32_t condId;
-    if (!GetSelectionBranch(*bi, &br, &mergeInst, &condId))
-      continue;
+    if (!GetSelectionBranch(*bi, &br, &mergeInst, &condId)) continue;
 
     // If constant condition/selector, replace conditional branch/switch
     // with unconditional branch and delete merge
     uint32_t liveLabId;
     if (br->opcode() == SpvOpBranchConditional) {
       bool condVal;
-      if (!GetConstCondition(condId, &condVal))
-        continue;
-      liveLabId = (condVal == true) ? 
-          br->GetSingleWordInOperand(kBranchCondTrueLabIdInIdx) :
-          br->GetSingleWordInOperand(kBranchCondFalseLabIdInIdx);
-    }
-    else {
+      if (!GetConstCondition(condId, &condVal)) continue;
+      liveLabId = (condVal == true)
+                      ? br->GetSingleWordInOperand(kBranchCondTrueLabIdInIdx)
+                      : br->GetSingleWordInOperand(kBranchCondFalseLabIdInIdx);
+    } else {
       assert(br->opcode() == SpvOpSwitch);
       // Search switch operands for selector value, set liveLabId to
       // corresponding label, use default if not found
       uint32_t selVal;
-      if (!GetConstInteger(condId, &selVal))
-        continue;
+      if (!GetConstInteger(condId, &selVal)) continue;
       uint32_t icnt = 0;
       uint32_t caseVal;
       br->ForEachInOperand(
-            [&icnt,&caseVal,&selVal,&liveLabId](const uint32_t* idp) {
-        if (icnt == 1) {
-          // Start with default label
-          liveLabId = *idp;
-        }
-        else if (icnt > 1) {
-          if (icnt % 2 == 0) {
-            caseVal = *idp;
-          }
-          else {
-            if (caseVal == selVal)
+          [&icnt, &caseVal, &selVal, &liveLabId](const uint32_t* idp) {
+            if (icnt == 1) {
+              // Start with default label
               liveLabId = *idp;
-          }
-        }
-        ++icnt;
-      });
+            } else if (icnt > 1) {
+              if (icnt % 2 == 0) {
+                caseVal = *idp;
+              } else {
+                if (caseVal == selVal) liveLabId = *idp;
+              }
+            }
+            ++icnt;
+          });
     }
 
     const uint32_t mergeLabId =
@@ -258,36 +243,30 @@ bool DeadBranchElimPass::EliminateDeadBranches(ir::Function* func) {
       KillAllInsts(*dbi);
       elimBlocks.insert(*dbi);
       ++dbi;
-      if (dbi == structuredOrder.end())
-        break;
+      if (dbi == structuredOrder.end()) break;
       dLabId = (*dbi)->id();
     }
 
     // If last block reached, look for next dead branch
-    if (dbi == structuredOrder.end())
-      continue;
+    if (dbi == structuredOrder.end()) continue;
 
     // Create set of dead predecessors in preparation for phi update.
     // Add the header block if the live branch is not the merge block.
     std::unordered_set<ir::BasicBlock*> deadPreds(elimBlocks);
-    if (liveLabId != dLabId)
-      deadPreds.insert(*bi);
+    if (liveLabId != dLabId) deadPreds.insert(*bi);
 
     // Update phi instructions in terminating block.
-    for (auto pii = (*dbi)->begin(); ; ++pii) {
+    for (auto pii = (*dbi)->begin();; ++pii) {
       // Skip NoOps, break at end of phis
       SpvOp op = pii->opcode();
-      if (op == SpvOpNop)
-        continue;
-      if (op != SpvOpPhi)
-        break;
+      if (op == SpvOpNop) continue;
+      if (op != SpvOpPhi) break;
       // Count phi's live predecessors with lcnt and remember last one
       // with lidx.
       uint32_t lcnt = 0;
       uint32_t lidx = 0;
       uint32_t icnt = 0;
-      pii->ForEachInId(
-          [&deadPreds,&icnt,&lcnt,&lidx,this](uint32_t* idp) {
+      pii->ForEachInId([&deadPreds, &icnt, &lcnt, &lidx, this](uint32_t* idp) {
         if (icnt % 2 == 1) {
           if (deadPreds.find(cfg()->block(*idp)) == deadPreds.end()) {
             ++lcnt;
@@ -300,8 +279,7 @@ bool DeadBranchElimPass::EliminateDeadBranches(ir::Function* func) {
       uint32_t replId;
       if (lcnt == 1) {
         replId = pii->GetSingleWordInOperand(lidx);
-      }
-      else {
+      } else {
         // Otherwise create new phi eliminating dead predecessor entries
         assert(lcnt > 1);
         replId = TakeNextId();
@@ -309,20 +287,19 @@ bool DeadBranchElimPass::EliminateDeadBranches(ir::Function* func) {
         icnt = 0;
         uint32_t lastId;
         pii->ForEachInId(
-            [&deadPreds,&icnt,&phi_in_opnds,&lastId,this](uint32_t* idp) {
-          if (icnt % 2 == 1) {
-            if (deadPreds.find(cfg()->block(*idp)) == deadPreds.end()) {
-              phi_in_opnds.push_back(
-                  {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {lastId}});
-              phi_in_opnds.push_back(
-                  {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {*idp}});
-            }
-          }
-          else {
-            lastId = *idp;
-          }
-          ++icnt;
-        });
+            [&deadPreds, &icnt, &phi_in_opnds, &lastId, this](uint32_t* idp) {
+              if (icnt % 2 == 1) {
+                if (deadPreds.find(cfg()->block(*idp)) == deadPreds.end()) {
+                  phi_in_opnds.push_back(
+                      {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {lastId}});
+                  phi_in_opnds.push_back(
+                      {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {*idp}});
+                }
+              } else {
+                lastId = *idp;
+              }
+              ++icnt;
+            });
         std::unique_ptr<ir::Instruction> newPhi(new ir::Instruction(
             SpvOpPhi, pii->type_id(), replId, phi_in_opnds));
         get_def_use_mgr()->AnalyzeInstDefUse(&*newPhi);
@@ -337,7 +314,7 @@ bool DeadBranchElimPass::EliminateDeadBranches(ir::Function* func) {
   }
 
   // Erase dead blocks
-  for (auto ebi = func->begin(); ebi != func->end(); )
+  for (auto ebi = func->begin(); ebi != func->end();)
     if (elimBlocks.find(&*ebi) != elimBlocks.end())
       ebi = ebi.Erase();
     else
@@ -355,8 +332,8 @@ void DeadBranchElimPass::Initialize(ir::IRContext* c) {
 bool DeadBranchElimPass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -364,7 +341,7 @@ bool DeadBranchElimPass::AllExtensionsSupported() const {
 }
 
 Pass::Status DeadBranchElimPass::ProcessImpl() {
-  // Current functionality assumes structured control flow. 
+  // Current functionality assumes structured control flow.
   // TODO(greg-lunarg): Handle non-structured control-flow.
   if (!get_module()->HasCapability(SpvCapabilityShader))
     return Status::SuccessWithoutChange;
@@ -372,11 +349,9 @@ Pass::Status DeadBranchElimPass::ProcessImpl() {
   // support required in KillNamesAndDecorates().
   // TODO(greg-lunarg): Add support for OpGroupDecorate
   for (auto& ai : get_module()->annotations())
-    if (ai.opcode() == SpvOpGroupDecorate)
-      return Status::SuccessWithoutChange;
+    if (ai.opcode() == SpvOpGroupDecorate) return Status::SuccessWithoutChange;
   // Do not process if any disallowed extensions are enabled
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Process all entry point functions
   ProcessFunction pfn = [this](ir::Function* fp) {
     return EliminateDeadBranches(fp);
@@ -395,31 +370,30 @@ Pass::Status DeadBranchElimPass::Process(ir::IRContext* module) {
 void DeadBranchElimPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    "SPV_KHR_variable_pointers",
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax",
+      "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot",
+      "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float",
+      "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote",
+      "SPV_KHR_16bit_storage",
+      "SPV_KHR_device_group",
+      "SPV_KHR_multiview",
+      "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2",
+      "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough",
+      "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      "SPV_KHR_variable_pointers",
+      "SPV_AMD_gpu_shader_int16",
+      "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/dead_branch_elim_pass.h b/source/opt/dead_branch_elim_pass.h
index a27c5716..e7b648e8 100644
--- a/source/opt/dead_branch_elim_pass.h
+++ b/source/opt/dead_branch_elim_pass.h
@@ -17,7 +17,6 @@
 #ifndef LIBSPIRV_OPT_DEAD_BRANCH_ELIM_PASS_H_
 #define LIBSPIRV_OPT_DEAD_BRANCH_ELIM_PASS_H_
 
-
 #include <algorithm>
 #include <map>
 #include <queue>
@@ -27,20 +26,19 @@
 
 #include "basic_block.h"
 #include "def_use_manager.h"
-#include "module.h"
 #include "mem_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
 
 // See optimizer.hpp for documentation.
 class DeadBranchElimPass : public MemPass {
-
   using cbb_ptr = const ir::BasicBlock*;
 
  public:
-   using GetBlocksFunction =
-     std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
+  using GetBlocksFunction =
+      std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
 
   DeadBranchElimPass();
   const char* name() const override { return "eliminate-dead-branches"; }
@@ -64,13 +62,13 @@ class DeadBranchElimPass : public MemPass {
   // Add conditional branch of |condId|, |trueLabId| and |falseLabId| to end
   // of block |bp|.
   void AddBranchConditional(uint32_t condId, uint32_t trueLabId,
-      uint32_t falseLabId, ir::BasicBlock* bp);
+                            uint32_t falseLabId, ir::BasicBlock* bp);
 
   // If block |bp| contains conditional branch or switch preceeded by an
   // OpSelctionMerge, return true and return branch and merge instructions
-  // in |branchInst| and |mergeInst| and the conditional id in |condId|. 
+  // in |branchInst| and |mergeInst| and the conditional id in |condId|.
   bool GetSelectionBranch(ir::BasicBlock* bp, ir::Instruction** branchInst,
-    ir::Instruction** mergeInst, uint32_t *condId);
+                          ir::Instruction** mergeInst, uint32_t* condId);
 
   // Return true if |labelId| has any non-phi, non-backedge references
   bool HasNonPhiNonBackedgeRef(uint32_t labelId);
@@ -106,4 +104,3 @@ class DeadBranchElimPass : public MemPass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_DEAD_BRANCH_ELIM_PASS_H_
-
diff --git a/source/opt/dead_variable_elimination.cpp b/source/opt/dead_variable_elimination.cpp
index 4fd6b2d0..70d2eb5b 100644
--- a/source/opt/dead_variable_elimination.cpp
+++ b/source/opt/dead_variable_elimination.cpp
@@ -24,7 +24,8 @@ namespace opt {
 Pass::Status DeadVariableElimination::Process(ir::IRContext* c) {
   // The algorithm will compute the reference count for every global variable.
   // Anything with a reference count of 0 will then be deleted.  For variables
-  // that might have references that are not explicit in this context, we use the
+  // that might have references that are not explicit in this context, we use
+  // the
   // value kMustKeep as the reference count.
   InitializeProcessing(c);
 
@@ -61,7 +62,7 @@ Pass::Status DeadVariableElimination::Process(ir::IRContext* c) {
         count = std::count_if(
             uses->begin(), uses->end(), [](const analysis::Use& u) {
               return (!ir::IsAnnotationInst(u.inst->opcode()) &&
-                  u.inst->opcode() != SpvOpName);
+                      u.inst->opcode() != SpvOpName);
             });
       }
     }
@@ -85,7 +86,7 @@ Pass::Status DeadVariableElimination::Process(ir::IRContext* c) {
 void DeadVariableElimination::DeleteVariable(uint32_t result_id) {
   ir::Instruction* inst = get_def_use_mgr()->GetDef(result_id);
   assert(inst->opcode() == SpvOpVariable &&
-      "Should not be trying to delete anything other than an OpVariable.");
+         "Should not be trying to delete anything other than an OpVariable.");
 
   // Look for an initializer that references another variable.  We need to know
   // if that variable can be deleted after the reference is removed.
diff --git a/source/opt/dead_variable_elimination.h b/source/opt/dead_variable_elimination.h
index 8412b1ee..8b6a27fa 100644
--- a/source/opt/dead_variable_elimination.h
+++ b/source/opt/dead_variable_elimination.h
@@ -15,8 +15,8 @@
 #ifndef SPIRV_TOOLS_DEAD_VARIABLE_ELIMINATION_H
 #define SPIRV_TOOLS_DEAD_VARIABLE_ELIMINATION_H
 
-#include <unordered_map>
 #include <climits>
+#include <unordered_map>
 
 #include "decoration_manager.h"
 #include "mem_pass.h"
diff --git a/source/opt/decoration_manager.cpp b/source/opt/decoration_manager.cpp
index b12670bf..b1c43d5a 100644
--- a/source/opt/decoration_manager.cpp
+++ b/source/opt/decoration_manager.cpp
@@ -29,8 +29,9 @@ void DecorationManager::RemoveDecorationsFrom(uint32_t id, bool keep_linkage) {
       case SpvOpDecorate:
       case SpvOpDecorateId:
       case SpvOpMemberDecorate:
-        if (!(keep_linkage && inst->GetSingleWordInOperand(1u) ==
-                                  SpvDecorationLinkageAttributes))
+        if (!(keep_linkage &&
+              inst->GetSingleWordInOperand(1u) ==
+                  SpvDecorationLinkageAttributes))
           inst->ToNop();
         break;
       case SpvOpGroupDecorate:
@@ -229,9 +230,9 @@ std::vector<T> DecorationManager::InternalGetDecorationsFor(
   return decorations;
 }
 
-void DecorationManager::ForEachDecoration(uint32_t id,
-                                          uint32_t decoration,
-                                          std::function<void(const ir::Instruction&)> f) const {
+void DecorationManager::ForEachDecoration(
+    uint32_t id, uint32_t decoration,
+    std::function<void(const ir::Instruction&)> f) const {
   auto decoration_list = id_to_decoration_insts_.find(id);
   if (decoration_list != id_to_decoration_insts_.end()) {
     for (const ir::Instruction* inst : decoration_list->second) {
diff --git a/source/opt/def_use_manager.cpp b/source/opt/def_use_manager.cpp
index 1444a27f..d3c050ca 100644
--- a/source/opt/def_use_manager.cpp
+++ b/source/opt/def_use_manager.cpp
@@ -31,8 +31,7 @@ void DefUseManager::AnalyzeInstDef(ir::Instruction* inst) {
       ClearInst(iter->second);
     }
     id_to_def_[def_id] = inst;
-  }
-  else {
+  } else {
     ClearInst(inst);
   }
 }
@@ -46,16 +45,16 @@ void DefUseManager::AnalyzeInstUse(ir::Instruction* inst) {
   for (uint32_t i = 0; i < inst->NumOperands(); ++i) {
     switch (inst->GetOperand(i).type) {
       // For any id type but result id type
-    case SPV_OPERAND_TYPE_ID:
-    case SPV_OPERAND_TYPE_TYPE_ID:
-    case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
-    case SPV_OPERAND_TYPE_SCOPE_ID: {
-      uint32_t use_id = inst->GetSingleWordOperand(i);
-      id_to_uses_[use_id].push_back({ inst, i });
-      inst_to_used_ids_[inst].push_back(use_id);
-    } break;
-    default:
-      break;
+      case SPV_OPERAND_TYPE_ID:
+      case SPV_OPERAND_TYPE_TYPE_ID:
+      case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
+      case SPV_OPERAND_TYPE_SCOPE_ID: {
+        uint32_t use_id = inst->GetSingleWordOperand(i);
+        id_to_uses_[use_id].push_back({inst, i});
+        inst_to_used_ids_[inst].push_back(use_id);
+      } break;
+      default:
+        break;
     }
   }
 }
@@ -101,7 +100,6 @@ std::vector<ir::Instruction*> DefUseManager::GetAnnotations(uint32_t id) const {
   return annos;
 }
 
-
 void DefUseManager::AnalyzeDefUse(ir::Module* module) {
   if (!module) return;
   module->ForEachInst(std::bind(&DefUseManager::AnalyzeInstDefUse, this,
diff --git a/source/opt/def_use_manager.h b/source/opt/def_use_manager.h
index d4b7fc26..1b9f41ea 100644
--- a/source/opt/def_use_manager.h
+++ b/source/opt/def_use_manager.h
@@ -49,9 +49,7 @@ class DefUseManager {
   // will be communicated to the outside via the given message |consumer|. This
   // instance only keeps a reference to the |consumer|, so the |consumer| should
   // outlive this instance.
-  DefUseManager(ir::Module* module) {
-    AnalyzeDefUse(module);
-  }
+  DefUseManager(ir::Module* module) { AnalyzeDefUse(module); }
 
   DefUseManager(const DefUseManager&) = delete;
   DefUseManager(DefUseManager&&) = delete;
@@ -105,8 +103,8 @@ class DefUseManager {
   // structures in this class. Does nothing if |module| is nullptr.
   void AnalyzeDefUse(ir::Module* module);
 
-  IdToDefMap id_to_def_;             // Mapping from ids to their definitions
-  IdToUsesMap id_to_uses_;           // Mapping from ids to their uses
+  IdToDefMap id_to_def_;    // Mapping from ids to their definitions
+  IdToUsesMap id_to_uses_;  // Mapping from ids to their uses
   // Mapping from instructions to the ids used in the instruction.
   InstToUsedIdsMap inst_to_used_ids_;
 };
diff --git a/source/opt/eliminate_dead_constant_pass.cpp b/source/opt/eliminate_dead_constant_pass.cpp
index 4d33ccf1..32fc5da5 100644
--- a/source/opt/eliminate_dead_constant_pass.cpp
+++ b/source/opt/eliminate_dead_constant_pass.cpp
@@ -19,9 +19,9 @@
 #include <unordered_set>
 
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "log.h"
 #include "reflect.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
@@ -36,7 +36,8 @@ Pass::Status EliminateDeadConstantPass::Process(ir::IRContext* irContext) {
   for (auto* c : constants) {
     uint32_t const_id = c->result_id();
     size_t count = 0;
-    if (analysis::UseList* uses = irContext->get_def_use_mgr()->GetUses(const_id)) {
+    if (analysis::UseList* uses =
+            irContext->get_def_use_mgr()->GetUses(const_id)) {
       count =
           std::count_if(uses->begin(), uses->end(), [](const analysis::Use& u) {
             return !(ir::IsAnnotationInst(u.inst->opcode()) ||
@@ -68,7 +69,8 @@ Pass::Status EliminateDeadConstantPass::Process(ir::IRContext* irContext) {
             continue;
           }
           uint32_t operand_id = inst->GetSingleWordInOperand(i);
-          ir::Instruction* def_inst = irContext->get_def_use_mgr()->GetDef(operand_id);
+          ir::Instruction* def_inst =
+              irContext->get_def_use_mgr()->GetDef(operand_id);
           // If the use_count does not have any count for the def_inst,
           // def_inst must not be a constant, and should be ignored here.
           if (!use_counts.count(def_inst)) {
@@ -94,7 +96,8 @@ Pass::Status EliminateDeadConstantPass::Process(ir::IRContext* irContext) {
   // constants.
   std::unordered_set<ir::Instruction*> dead_others;
   for (auto* dc : dead_consts) {
-    if (analysis::UseList* uses = irContext->get_def_use_mgr()->GetUses(dc->result_id())) {
+    if (analysis::UseList* uses =
+            irContext->get_def_use_mgr()->GetUses(dc->result_id())) {
       for (const auto& u : *uses) {
         if (ir::IsAnnotationInst(u.inst->opcode()) ||
             ir::IsDebug1Inst(u.inst->opcode()) ||
diff --git a/source/opt/eliminate_dead_constant_pass.h b/source/opt/eliminate_dead_constant_pass.h
index cf6957f9..3ff69f5c 100644
--- a/source/opt/eliminate_dead_constant_pass.h
+++ b/source/opt/eliminate_dead_constant_pass.h
@@ -15,9 +15,9 @@
 #ifndef LIBSPIRV_OPT_ELIMINATE_DEAD_CONSTANT_PASS_H_
 #define LIBSPIRV_OPT_ELIMINATE_DEAD_CONSTANT_PASS_H_
 
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/flatten_decoration_pass.cpp b/source/opt/flatten_decoration_pass.cpp
index 094c5803..e92935d8 100644
--- a/source/opt/flatten_decoration_pass.cpp
+++ b/source/opt/flatten_decoration_pass.cpp
@@ -16,9 +16,9 @@
 #include "ir_context.h"
 
 #include <cassert>
-#include <vector>
 #include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/flatten_decoration_pass.h b/source/opt/flatten_decoration_pass.h
index 345b39b4..7db6f864 100644
--- a/source/opt/flatten_decoration_pass.h
+++ b/source/opt/flatten_decoration_pass.h
@@ -15,9 +15,9 @@
 #ifndef LIBSPIRV_OPT_FLATTEN_DECORATION_PASS_H_
 #define LIBSPIRV_OPT_FLATTEN_DECORATION_PASS_H_
 
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/fold.h b/source/opt/fold.h
index c6e61d68..f1e5ea1a 100644
--- a/source/opt/fold.h
+++ b/source/opt/fold.h
@@ -15,8 +15,8 @@
 #ifndef LIBSPIRV_UTIL_FOLD_H_
 #define LIBSPIRV_UTIL_FOLD_H_
 
-#include "def_use_manager.h"
 #include "constants.h"
+#include "def_use_manager.h"
 
 #include <cstdint>
 #include <vector>
diff --git a/source/opt/fold_spec_constant_op_and_composite_pass.cpp b/source/opt/fold_spec_constant_op_and_composite_pass.cpp
index ad078fd9..a630d8a3 100644
--- a/source/opt/fold_spec_constant_op_and_composite_pass.cpp
+++ b/source/opt/fold_spec_constant_op_and_composite_pass.cpp
@@ -19,8 +19,8 @@
 #include <tuple>
 
 #include "constants.h"
-#include "make_unique.h"
 #include "ir_context.h"
+#include "make_unique.h"
 
 namespace spvtools {
 namespace opt {
@@ -245,7 +245,8 @@ std::vector<uint32_t> OperateVectors(
 FoldSpecConstantOpAndCompositePass::FoldSpecConstantOpAndCompositePass()
     : max_id_(0), type_mgr_(nullptr), id_to_const_val_() {}
 
-Pass::Status FoldSpecConstantOpAndCompositePass::Process(ir::IRContext* irContext) {
+Pass::Status FoldSpecConstantOpAndCompositePass::Process(
+    ir::IRContext* irContext) {
   Initialize(irContext);
   return ProcessImpl(irContext);
 }
diff --git a/source/opt/fold_spec_constant_op_and_composite_pass.h b/source/opt/fold_spec_constant_op_and_composite_pass.h
index fd1ff6b3..b1cfd0c8 100644
--- a/source/opt/fold_spec_constant_op_and_composite_pass.h
+++ b/source/opt/fold_spec_constant_op_and_composite_pass.h
@@ -21,10 +21,10 @@
 
 #include "constants.h"
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
 #include "type_manager.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/freeze_spec_constant_value_pass.h b/source/opt/freeze_spec_constant_value_pass.h
index 8d163d0d..fc7f44e7 100644
--- a/source/opt/freeze_spec_constant_value_pass.h
+++ b/source/opt/freeze_spec_constant_value_pass.h
@@ -15,9 +15,9 @@
 #ifndef LIBSPIRV_OPT_FREEZE_SPEC_CONSTANT_VALUE_PASS_H_
 #define LIBSPIRV_OPT_FREEZE_SPEC_CONSTANT_VALUE_PASS_H_
 
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/function.h b/source/opt/function.h
index a67c3299..618eb7d2 100644
--- a/source/opt/function.h
+++ b/source/opt/function.h
@@ -64,8 +64,9 @@ class Function {
   // Returns function's id
   inline uint32_t result_id() const { return def_inst_->result_id(); }
 
-//  // Returns function's type id
-//  inline uint32_t type_id() const { return def_inst_->GetSingleWordInOperand(1u); }
+  //  // Returns function's type id
+  //  inline uint32_t type_id() const { return
+  //  def_inst_->GetSingleWordInOperand(1u); }
 
   // Returns function's return type id
   inline uint32_t type_id() const { return def_inst_->type_id(); }
diff --git a/source/opt/inline_exhaustive_pass.cpp b/source/opt/inline_exhaustive_pass.cpp
index 5be0329b..d829f36c 100644
--- a/source/opt/inline_exhaustive_pass.cpp
+++ b/source/opt/inline_exhaustive_pass.cpp
@@ -31,13 +31,13 @@ bool InlineExhaustivePass::InlineExhaustive(ir::Function* func) {
         GenInlineCode(&newBlocks, &newVars, ii, bi);
         // If call block is replaced with more than one block, point
         // succeeding phis at new last block.
-        if (newBlocks.size() > 1)
-          UpdateSucceedingPhis(newBlocks);
+        if (newBlocks.size() > 1) UpdateSucceedingPhis(newBlocks);
         // Replace old calling block with new block(s).
         bi = bi.Erase();
         bi = bi.InsertBefore(&newBlocks);
         // Insert new function variables.
-        if (newVars.size() > 0) func->begin()->begin().InsertBefore(std::move(newVars));
+        if (newVars.size() > 0)
+          func->begin()->begin().InsertBefore(std::move(newVars));
         // Restart inlining at beginning of calling block.
         ii = bi->begin();
         modified = true;
diff --git a/source/opt/inline_exhaustive_pass.h b/source/opt/inline_exhaustive_pass.h
index 9d3076b9..08b4387b 100644
--- a/source/opt/inline_exhaustive_pass.h
+++ b/source/opt/inline_exhaustive_pass.h
@@ -20,19 +20,18 @@
 #include <algorithm>
 #include <list>
 #include <memory>
-#include <vector>
 #include <unordered_map>
+#include <vector>
 
 #include "def_use_manager.h"
-#include "module.h"
 #include "inline_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
 
 // See optimizer.hpp for documentation.
 class InlineExhaustivePass : public InlinePass {
-
  public:
   InlineExhaustivePass();
   Status Process(ir::IRContext* c) override;
diff --git a/source/opt/inline_opaque_pass.cpp b/source/opt/inline_opaque_pass.cpp
index e4762eb5..2f6c6692 100644
--- a/source/opt/inline_opaque_pass.cpp
+++ b/source/opt/inline_opaque_pass.cpp
@@ -21,9 +21,9 @@ namespace opt {
 
 namespace {
 
-  const uint32_t kTypePointerTypeIdInIdx = 1;
+const uint32_t kTypePointerTypeIdInIdx = 1;
 
-} // anonymous namespace
+}  // anonymous namespace
 
 bool InlineOpaquePass::IsOpaqueType(uint32_t typeId) {
   const ir::Instruction* typeInst = get_def_use_mgr()->GetDef(typeId);
@@ -33,17 +33,16 @@ bool InlineOpaquePass::IsOpaqueType(uint32_t typeId) {
     case SpvOpTypeSampledImage:
       return true;
     case SpvOpTypePointer:
-      return IsOpaqueType(typeInst->GetSingleWordInOperand(
-          kTypePointerTypeIdInIdx));
+      return IsOpaqueType(
+          typeInst->GetSingleWordInOperand(kTypePointerTypeIdInIdx));
     default:
       break;
   }
   // TODO(greg-lunarg): Handle arrays containing opaque type
-  if (typeInst->opcode() != SpvOpTypeStruct)
-    return false;
+  if (typeInst->opcode() != SpvOpTypeStruct) return false;
   // Return true if any member is opaque
   int ocnt = 0;
-  typeInst->ForEachInId([&ocnt,this](const uint32_t* tid) {
+  typeInst->ForEachInId([&ocnt, this](const uint32_t* tid) {
     if (ocnt == 0 && IsOpaqueType(*tid)) ++ocnt;
   });
   return ocnt > 0;
@@ -51,16 +50,14 @@ bool InlineOpaquePass::IsOpaqueType(uint32_t typeId) {
 
 bool InlineOpaquePass::HasOpaqueArgsOrReturn(const ir::Instruction* callInst) {
   // Check return type
-  if (IsOpaqueType(callInst->type_id()))
-    return true;
+  if (IsOpaqueType(callInst->type_id())) return true;
   // Check args
   int icnt = 0;
   int ocnt = 0;
-  callInst->ForEachInId([&icnt,&ocnt,this](const uint32_t *iid) {
+  callInst->ForEachInId([&icnt, &ocnt, this](const uint32_t* iid) {
     if (icnt > 0) {
       const ir::Instruction* argInst = get_def_use_mgr()->GetDef(*iid);
-      if (IsOpaqueType(argInst->type_id()))
-        ++ocnt;
+      if (IsOpaqueType(argInst->type_id())) ++ocnt;
     }
     ++icnt;
   });
@@ -79,13 +76,13 @@ bool InlineOpaquePass::InlineOpaque(ir::Function* func) {
         GenInlineCode(&newBlocks, &newVars, ii, bi);
         // If call block is replaced with more than one block, point
         // succeeding phis at new last block.
-        if (newBlocks.size() > 1)
-          UpdateSucceedingPhis(newBlocks);
+        if (newBlocks.size() > 1) UpdateSucceedingPhis(newBlocks);
         // Replace old calling block with new block(s).
         bi = bi.Erase();
         bi = bi.InsertBefore(&newBlocks);
         // Insert new function variables.
-        if (newVars.size() > 0) func->begin()->begin().InsertBefore(std::move(newVars));
+        if (newVars.size() > 0)
+          func->begin()->begin().InsertBefore(std::move(newVars));
         // Restart inlining at beginning of calling block.
         ii = bi->begin();
         modified = true;
@@ -97,15 +94,11 @@ bool InlineOpaquePass::InlineOpaque(ir::Function* func) {
   return modified;
 }
 
-void InlineOpaquePass::Initialize(ir::IRContext* c) {
-  InitializeInline(c);
-};
+void InlineOpaquePass::Initialize(ir::IRContext* c) { InitializeInline(c); };
 
 Pass::Status InlineOpaquePass::ProcessImpl() {
   // Do opaque inlining on each function in entry point call tree
-  ProcessFunction pfn = [this](ir::Function* fp) {
-    return InlineOpaque(fp);
-  };
+  ProcessFunction pfn = [this](ir::Function* fp) { return InlineOpaque(fp); };
   bool modified = ProcessEntryPointCallTree(pfn, get_module());
   return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
 }
diff --git a/source/opt/inline_opaque_pass.h b/source/opt/inline_opaque_pass.h
index 6ad1a362..0a6cf0ec 100644
--- a/source/opt/inline_opaque_pass.h
+++ b/source/opt/inline_opaque_pass.h
@@ -20,19 +20,18 @@
 #include <algorithm>
 #include <list>
 #include <memory>
-#include <vector>
 #include <unordered_map>
+#include <vector>
 
 #include "def_use_manager.h"
-#include "module.h"
 #include "inline_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
 
 // See optimizer.hpp for documentation.
 class InlineOpaquePass : public InlinePass {
-
  public:
   InlineOpaquePass();
   Status Process(ir::IRContext* c) override;
diff --git a/source/opt/inline_pass.cpp b/source/opt/inline_pass.cpp
index 83d365cd..706af448 100644
--- a/source/opt/inline_pass.cpp
+++ b/source/opt/inline_pass.cpp
@@ -58,25 +58,26 @@ uint32_t InlinePass::AddPointerToType(uint32_t type_id,
 }
 
 void InlinePass::AddBranch(uint32_t label_id,
-  std::unique_ptr<ir::BasicBlock>* block_ptr) {
+                           std::unique_ptr<ir::BasicBlock>* block_ptr) {
   std::unique_ptr<ir::Instruction> newBranch(new ir::Instruction(
-    SpvOpBranch, 0, 0,
-    {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {label_id}}}));
+      SpvOpBranch, 0, 0,
+      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {label_id}}}));
   (*block_ptr)->AddInstruction(std::move(newBranch));
 }
 
 void InlinePass::AddBranchCond(uint32_t cond_id, uint32_t true_id,
-  uint32_t false_id, std::unique_ptr<ir::BasicBlock>* block_ptr) {
+                               uint32_t false_id,
+                               std::unique_ptr<ir::BasicBlock>* block_ptr) {
   std::unique_ptr<ir::Instruction> newBranch(new ir::Instruction(
-    SpvOpBranchConditional, 0, 0,
-    {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {cond_id}},
-     {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {true_id}},
-     {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {false_id}}}));
+      SpvOpBranchConditional, 0, 0,
+      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {cond_id}},
+       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {true_id}},
+       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {false_id}}}));
   (*block_ptr)->AddInstruction(std::move(newBranch));
 }
 
 void InlinePass::AddLoopMerge(uint32_t merge_id, uint32_t continue_id,
-                           std::unique_ptr<ir::BasicBlock>* block_ptr) {
+                              std::unique_ptr<ir::BasicBlock>* block_ptr) {
   std::unique_ptr<ir::Instruction> newLoopMerge(new ir::Instruction(
       SpvOpLoopMerge, 0, 0,
       {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {merge_id}},
@@ -88,8 +89,9 @@ void InlinePass::AddLoopMerge(uint32_t merge_id, uint32_t continue_id,
 void InlinePass::AddStore(uint32_t ptr_id, uint32_t val_id,
                           std::unique_ptr<ir::BasicBlock>* block_ptr) {
   std::unique_ptr<ir::Instruction> newStore(new ir::Instruction(
-      SpvOpStore, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ptr_id}},
-                         {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {val_id}}}));
+      SpvOpStore, 0, 0,
+      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ptr_id}},
+       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {val_id}}}));
   (*block_ptr)->AddInstruction(std::move(newStore));
 }
 
@@ -108,11 +110,9 @@ std::unique_ptr<ir::Instruction> InlinePass::NewLabel(uint32_t label_id) {
 }
 
 uint32_t InlinePass::GetFalseId() {
-  if (false_id_ != 0)
-    return false_id_;
+  if (false_id_ != 0) return false_id_;
   false_id_ = get_module()->GetGlobalValue(SpvOpConstantFalse);
-  if (false_id_ != 0)
-    return false_id_;
+  if (false_id_ != 0) return false_id_;
   uint32_t boolId = get_module()->GetGlobalValue(SpvOpTypeBool);
   if (boolId == 0) {
     boolId = TakeNextId();
@@ -124,8 +124,7 @@ uint32_t InlinePass::GetFalseId() {
 }
 
 void InlinePass::MapParams(
-    ir::Function* calleeFn,
-    ir::BasicBlock::iterator call_inst_itr,
+    ir::Function* calleeFn, ir::BasicBlock::iterator call_inst_itr,
     std::unordered_map<uint32_t, uint32_t>* callee2caller) {
   int param_idx = 0;
   calleeFn->ForEachParam(
@@ -186,8 +185,8 @@ void InlinePass::CloneSameBlockOps(
     std::unordered_map<uint32_t, uint32_t>* postCallSB,
     std::unordered_map<uint32_t, ir::Instruction*>* preCallSB,
     std::unique_ptr<ir::BasicBlock>* block_ptr) {
-  (*inst)
-      ->ForEachInId([&postCallSB, &preCallSB, &block_ptr, this](uint32_t* iid) {
+  (*inst)->ForEachInId(
+      [&postCallSB, &preCallSB, &block_ptr, this](uint32_t* iid) {
         const auto mapItr = (*postCallSB).find(*iid);
         if (mapItr == (*postCallSB).end()) {
           const auto mapItr2 = (*preCallSB).find(*iid);
@@ -242,11 +241,9 @@ void InlinePass::GenInlineCode(
 
   // Create set of callee result ids. Used to detect forward references
   std::unordered_set<uint32_t> callee_result_ids;
-  calleeFn->ForEachInst([&callee_result_ids](
-      const ir::Instruction* cpi) {
+  calleeFn->ForEachInst([&callee_result_ids](const ir::Instruction* cpi) {
     const uint32_t rid = cpi->result_id();
-    if (rid != 0)
-      callee_result_ids.insert(rid);
+    if (rid != 0) callee_result_ids.insert(rid);
   });
 
   // If the caller is in a single-block loop, and the callee has multiple
@@ -333,8 +330,7 @@ void InlinePass::GenInlineCode(
             }
             new_blk_ptr->AddInstruction(std::move(cp_inst));
           }
-          if (caller_is_loop_header &&
-              callee_begins_with_structured_header) {
+          if (caller_is_loop_header && callee_begins_with_structured_header) {
             // We can't place both the caller's merge instruction and another
             // merge instruction in the same block.  So split the calling block.
             // Insert an unconditional branch to a new guard block.  Later,
@@ -366,8 +362,8 @@ void InlinePass::GenInlineCode(
             singleTripLoopHeaderId = this->TakeNextId();
             AddBranch(singleTripLoopHeaderId, &new_blk_ptr);
             new_blocks->push_back(std::move(new_blk_ptr));
-            new_blk_ptr.reset(new ir::BasicBlock(NewLabel(
-                singleTripLoopHeaderId)));
+            new_blk_ptr.reset(
+                new ir::BasicBlock(NewLabel(singleTripLoopHeaderId)));
             returnLabelId = this->TakeNextId();
             singleTripLoopContinueId = this->TakeNextId();
             AddLoopMerge(returnLabelId, singleTripLoopContinueId, &new_blk_ptr);
@@ -475,8 +471,7 @@ void InlinePass::GenInlineCode(
           uint32_t nid;
           if (mapItr != callee2caller.end()) {
             nid = mapItr->second;
-          }
-          else {
+          } else {
             nid = this->TakeNextId();
             callee2caller[rid] = nid;
           }
@@ -530,15 +525,14 @@ void InlinePass::UpdateSucceedingPhis(
   const auto lastBlk = new_blocks.end() - 1;
   const uint32_t firstId = (*firstBlk)->id();
   const uint32_t lastId = (*lastBlk)->id();
-  (*lastBlk)->ForEachSuccessorLabel(
-      [&firstId, &lastId, this](uint32_t succ) {
-        ir::BasicBlock* sbp = this->id2block_[succ];
-        sbp->ForEachPhiInst([&firstId, &lastId](ir::Instruction* phi) {
-          phi->ForEachInId([&firstId, &lastId](uint32_t* id) {
-            if (*id == firstId) *id = lastId;
-          });
-        });
+  (*lastBlk)->ForEachSuccessorLabel([&firstId, &lastId, this](uint32_t succ) {
+    ir::BasicBlock* sbp = this->id2block_[succ];
+    sbp->ForEachPhiInst([&firstId, &lastId](ir::Instruction* phi) {
+      phi->ForEachInId([&firstId, &lastId](uint32_t* id) {
+        if (*id == firstId) *id = lastId;
       });
+    });
+  });
 }
 
 bool InlinePass::HasMultipleReturns(ir::Function* func) {
@@ -547,7 +541,7 @@ bool InlinePass::HasMultipleReturns(ir::Function* func) {
   for (auto& blk : *func) {
     auto terminal_ii = blk.cend();
     --terminal_ii;
-    if (terminal_ii->opcode() == SpvOpReturn || 
+    if (terminal_ii->opcode() == SpvOpReturn ||
         terminal_ii->opcode() == SpvOpReturnValue) {
       if (seenReturn) {
         multipleReturns = true;
@@ -559,7 +553,6 @@ bool InlinePass::HasMultipleReturns(ir::Function* func) {
   return multipleReturns;
 }
 
-
 void InlinePass::ComputeStructuredSuccessors(ir::Function* func) {
   // If header, make merge block first successor.
   for (auto& blk : *func) {
@@ -584,8 +577,7 @@ InlinePass::GetBlocksFunction InlinePass::StructuredSuccessorsFunction() {
 bool InlinePass::HasNoReturnInLoop(ir::Function* func) {
   // If control not structured, do not do loop/return analysis
   // TODO: Analyze returns in non-structured control flow
-  if (!get_module()->HasCapability(SpvCapabilityShader))
-    return false;
+  if (!get_module()->HasCapability(SpvCapabilityShader)) return false;
   // Compute structured block order. This order has the property
   // that dominators are before all blocks they dominate and merge blocks
   // are after all blocks that are in the control constructs of their header.
@@ -594,32 +586,30 @@ bool InlinePass::HasNoReturnInLoop(ir::Function* func) {
   auto ignore_edge = [](cbb_ptr, cbb_ptr) {};
   std::list<const ir::BasicBlock*> structuredOrder;
   spvtools::CFA<ir::BasicBlock>::DepthFirstTraversal(
-    &*func->begin(), StructuredSuccessorsFunction(), ignore_block,
-    [&](cbb_ptr b) { structuredOrder.push_front(b); }, ignore_edge);
+      &*func->begin(), StructuredSuccessorsFunction(), ignore_block,
+      [&](cbb_ptr b) { structuredOrder.push_front(b); }, ignore_edge);
   // Search for returns in loops. Only need to track outermost loop
   bool return_in_loop = false;
   uint32_t outerLoopMergeId = 0;
   for (auto& blk : structuredOrder) {
     // Exiting current outer loop
-    if (blk->id() == outerLoopMergeId)
-      outerLoopMergeId = 0;
+    if (blk->id() == outerLoopMergeId) outerLoopMergeId = 0;
     // Return block
     auto terminal_ii = blk->cend();
     --terminal_ii;
-    if (terminal_ii->opcode() == SpvOpReturn || 
+    if (terminal_ii->opcode() == SpvOpReturn ||
         terminal_ii->opcode() == SpvOpReturnValue) {
       if (outerLoopMergeId != 0) {
         return_in_loop = true;
         break;
       }
-    }
-    else if (terminal_ii != blk->cbegin()) {
+    } else if (terminal_ii != blk->cbegin()) {
       auto merge_ii = terminal_ii;
       --merge_ii;
       // Entering outermost loop
       if (merge_ii->opcode() == SpvOpLoopMerge && outerLoopMergeId == 0)
-        outerLoopMergeId = merge_ii->GetSingleWordOperand(
-            kSpvLoopMergeMergeBlockId);
+        outerLoopMergeId =
+            merge_ii->GetSingleWordOperand(kSpvLoopMergeMergeBlockId);
     }
   }
   return !return_in_loop;
@@ -633,14 +623,12 @@ void InlinePass::AnalyzeReturns(ir::Function* func) {
   }
   multi_return_funcs_.insert(func->result_id());
   // If multiple returns, see if any are in a loop
-  if (HasNoReturnInLoop(func))
-    no_return_in_loop_.insert(func->result_id());
+  if (HasNoReturnInLoop(func)) no_return_in_loop_.insert(func->result_id());
 }
 
 bool InlinePass::IsInlinableFunction(ir::Function* func) {
   // We can only inline a function if it has blocks.
-  if (func->cbegin() == func->cend())
-    return false;
+  if (func->cbegin() == func->cend()) return false;
   // Do not inline functions with returns in loops. Currently early return
   // functions are inlined by wrapping them in a one trip loop and implementing
   // the returns as a branch to the loop's merge block. However, this can only
@@ -671,8 +659,7 @@ void InlinePass::InitializeInline(ir::IRContext* c) {
       id2block_[blk.id()] = &blk;
     }
     // Compute inlinability
-    if (IsInlinableFunction(&fn))
-      inlinable_.insert(fn.result_id());
+    if (IsInlinableFunction(&fn)) inlinable_.insert(fn.result_id());
   }
 };
 
diff --git a/source/opt/inline_pass.h b/source/opt/inline_pass.h
index 1eae3f07..61d0b7ff 100644
--- a/source/opt/inline_pass.h
+++ b/source/opt/inline_pass.h
@@ -18,10 +18,10 @@
 #define LIBSPIRV_OPT_INLINE_PASS_H_
 
 #include <algorithm>
+#include <list>
 #include <memory>
 #include <unordered_map>
 #include <vector>
-#include <list>
 
 #include "def_use_manager.h"
 #include "module.h"
@@ -32,12 +32,11 @@ namespace opt {
 
 // See optimizer.hpp for documentation.
 class InlinePass : public Pass {
-
   using cbb_ptr = const ir::BasicBlock*;
 
  public:
-   using GetBlocksFunction =
-     std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
+  using GetBlocksFunction =
+      std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
 
   InlinePass();
   virtual ~InlinePass() = default;
@@ -54,8 +53,8 @@ class InlinePass : public Pass {
   void AddBranch(uint32_t labelId, std::unique_ptr<ir::BasicBlock>* block_ptr);
 
   // Add conditional branch to end of block |block_ptr|.
-  void AddBranchCond(uint32_t cond_id, uint32_t true_id,
-    uint32_t false_id, std::unique_ptr<ir::BasicBlock>* block_ptr);
+  void AddBranchCond(uint32_t cond_id, uint32_t true_id, uint32_t false_id,
+                     std::unique_ptr<ir::BasicBlock>* block_ptr);
 
   // Add unconditional branch to labelId to end of block block_ptr.
   void AddLoopMerge(uint32_t merge_id, uint32_t continue_id,
@@ -77,8 +76,7 @@ class InlinePass : public Pass {
   uint32_t GetFalseId();
 
   // Map callee params to caller args
-  void MapParams(ir::Function* calleeFn,
-                 ir::BasicBlock::iterator call_inst_itr,
+  void MapParams(ir::Function* calleeFn, ir::BasicBlock::iterator call_inst_itr,
                  std::unordered_map<uint32_t, uint32_t>* callee2caller);
 
   // Clone and map callee locals
@@ -133,11 +131,11 @@ class InlinePass : public Pass {
   // A block's structured successors are the blocks it branches to
   // together with its declared merge block if it has one.
   // When order matters, the merge block always appears first.
-  // This assures correct depth first search in the presence of early 
+  // This assures correct depth first search in the presence of early
   // returns and kills. If the successor vector contain duplicates
   // if the merge block, they are safely ignored by DFS.
   void ComputeStructuredSuccessors(ir::Function* func);
-  
+
   // Return function to return ordered structure successors for a given block
   // Assumes ComputeStructuredSuccessors() has been called.
   GetBlocksFunction StructuredSuccessorsFunction();
diff --git a/source/opt/insert_extract_elim.cpp b/source/opt/insert_extract_elim.cpp
index c44ec48d..d3c64854 100644
--- a/source/opt/insert_extract_elim.cpp
+++ b/source/opt/insert_extract_elim.cpp
@@ -16,8 +16,8 @@
 
 #include "insert_extract_elim.h"
 
-#include "iterator.h"
 #include "ir_context.h"
+#include "iterator.h"
 
 namespace spvtools {
 namespace opt {
@@ -28,12 +28,11 @@ const uint32_t kExtractCompositeIdInIdx = 0;
 const uint32_t kInsertObjectIdInIdx = 0;
 const uint32_t kInsertCompositeIdInIdx = 1;
 
-} // anonymous namespace
+}  // anonymous namespace
 
 bool InsertExtractElimPass::ExtInsMatch(const ir::Instruction* extInst,
-    const ir::Instruction* insInst) const {
-  if (extInst->NumInOperands() != insInst->NumInOperands() - 1)
-    return false;
+                                        const ir::Instruction* insInst) const {
+  if (extInst->NumInOperands() != insInst->NumInOperands() - 1) return false;
   uint32_t numIdx = extInst->NumInOperands() - 1;
   for (uint32_t i = 0; i < numIdx; ++i)
     if (extInst->GetSingleWordInOperand(i + 1) !=
@@ -42,10 +41,9 @@ bool InsertExtractElimPass::ExtInsMatch(const ir::Instruction* extInst,
   return true;
 }
 
-bool InsertExtractElimPass::ExtInsConflict(const ir::Instruction* extInst,
-    const ir::Instruction* insInst) const {
-  if (extInst->NumInOperands() == insInst->NumInOperands() - 1)
-    return false;
+bool InsertExtractElimPass::ExtInsConflict(
+    const ir::Instruction* extInst, const ir::Instruction* insInst) const {
+  if (extInst->NumInOperands() == insInst->NumInOperands() - 1) return false;
   uint32_t extNumIdx = extInst->NumInOperands() - 1;
   uint32_t insNumIdx = insInst->NumInOperands() - 2;
   uint32_t numIdx = std::min(extNumIdx, insNumIdx);
@@ -71,8 +69,7 @@ bool InsertExtractElimPass::EliminateInsertExtract(ir::Function* func) {
           ir::Instruction* cinst = get_def_use_mgr()->GetDef(cid);
           uint32_t replId = 0;
           while (cinst->opcode() == SpvOpCompositeInsert) {
-            if (ExtInsConflict(&*ii, cinst))
-              break;
+            if (ExtInsConflict(&*ii, cinst)) break;
             if (ExtInsMatch(&*ii, cinst)) {
               replId = cinst->GetSingleWordInOperand(kInsertObjectIdInIdx);
               break;
@@ -96,14 +93,12 @@ bool InsertExtractElimPass::EliminateInsertExtract(ir::Function* func) {
                 for (; i <= compIdx; i++) {
                   uint32_t compId = cinst->GetSingleWordInOperand(i);
                   ir::Instruction* compInst = get_def_use_mgr()->GetDef(compId);
-                  if (compInst->type_id() != (*ii).type_id())
-                    break;
+                  if (compInst->type_id() != (*ii).type_id()) break;
                 }
                 if (i > compIdx)
                   replId = cinst->GetSingleWordInOperand(compIdx);
               }
-            }
-            else {
+            } else {
               replId = cinst->GetSingleWordInOperand(compIdx);
             }
           }
@@ -132,8 +127,8 @@ void InsertExtractElimPass::Initialize(ir::IRContext* c) {
 bool InsertExtractElimPass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -142,8 +137,7 @@ bool InsertExtractElimPass::AllExtensionsSupported() const {
 
 Pass::Status InsertExtractElimPass::ProcessImpl() {
   // Do not process if any disallowed extensions are enabled
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Process all entry point functions.
   ProcessFunction pfn = [this](ir::Function* fp) {
     return EliminateInsertExtract(fp);
@@ -162,31 +156,30 @@ Pass::Status InsertExtractElimPass::Process(ir::IRContext* c) {
 void InsertExtractElimPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    "SPV_KHR_variable_pointers",
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax",
+      "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot",
+      "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float",
+      "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote",
+      "SPV_KHR_16bit_storage",
+      "SPV_KHR_device_group",
+      "SPV_KHR_multiview",
+      "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2",
+      "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough",
+      "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      "SPV_KHR_variable_pointers",
+      "SPV_AMD_gpu_shader_int16",
+      "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/insert_extract_elim.h b/source/opt/insert_extract_elim.h
index fc475800..d5dba00f 100644
--- a/source/opt/insert_extract_elim.h
+++ b/source/opt/insert_extract_elim.h
@@ -17,7 +17,6 @@
 #ifndef LIBSPIRV_OPT_INSERT_EXTRACT_ELIM_PASS_H_
 #define LIBSPIRV_OPT_INSERT_EXTRACT_ELIM_PASS_H_
 
-
 #include <algorithm>
 #include <map>
 #include <unordered_map>
@@ -26,9 +25,9 @@
 
 #include "basic_block.h"
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
@@ -42,16 +41,16 @@ class InsertExtractElimPass : public Pass {
 
  private:
   // Return true if indices of extract |extInst| and insert |insInst| match
-  bool ExtInsMatch(
-    const ir::Instruction* extInst, const ir::Instruction* insInst) const;
+  bool ExtInsMatch(const ir::Instruction* extInst,
+                   const ir::Instruction* insInst) const;
 
   // Return true if indices of extract |extInst| and insert |insInst| conflict,
   // specifically, if the insert changes bits specified by the extract, but
   // changes either more bits or less bits than the extract specifies,
   // meaning the exact value being inserted cannot be used to replace
   // the extract.
-  bool ExtInsConflict(
-    const ir::Instruction* extInst, const ir::Instruction* insInst) const;
+  bool ExtInsConflict(const ir::Instruction* extInst,
+                      const ir::Instruction* insInst) const;
 
   // Return true if |typeId| is a vector type
   bool IsVectorType(uint32_t typeId);
@@ -79,4 +78,3 @@ class InsertExtractElimPass : public Pass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_INSERT_EXTRACT_ELIM_PASS_H_
-
diff --git a/source/opt/instruction.h b/source/opt/instruction.h
index 95ac0d5b..cc4474e2 100644
--- a/source/opt/instruction.h
+++ b/source/opt/instruction.h
@@ -219,8 +219,8 @@ class Instruction : public utils::IntrusiveNodeBase<Instruction> {
 
   // Runs the given function |f| on all "in" operands
   inline void ForEachInOperand(const std::function<void(uint32_t*)>& f);
-  inline void ForEachInOperand(const std::function<void(const uint32_t*)>& f)
-      const;
+  inline void ForEachInOperand(
+      const std::function<void(const uint32_t*)>& f) const;
 
   // Returns true if any operands can be labels
   inline bool HasLabels() const;
@@ -308,9 +308,9 @@ inline void Instruction::ForEachInst(
 inline void Instruction::ForEachId(const std::function<void(uint32_t*)>& f) {
   for (auto& opnd : operands_)
     if (spvIsIdType(opnd.type)) f(&opnd.words[0]);
-  if (type_id_ != 0u)
-    type_id_ = GetSingleWordOperand(0u);
-  if (result_id_ != 0u) result_id_ = GetSingleWordOperand(type_id_ == 0u ? 0u : 1u);
+  if (type_id_ != 0u) type_id_ = GetSingleWordOperand(0u);
+  if (result_id_ != 0u)
+    result_id_ = GetSingleWordOperand(type_id_ == 0u ? 0u : 1u);
 }
 
 inline void Instruction::ForEachId(
@@ -347,7 +347,7 @@ inline void Instruction::ForEachInId(
 }
 
 inline void Instruction::ForEachInOperand(
-      const std::function<void(uint32_t*)>& f) {
+    const std::function<void(uint32_t*)>& f) {
   for (auto& opnd : operands_) {
     switch (opnd.type) {
       case SPV_OPERAND_TYPE_RESULT_ID:
diff --git a/source/opt/instruction_list.cpp b/source/opt/instruction_list.cpp
index 904a0b32..d8ddb84e 100644
--- a/source/opt/instruction_list.cpp
+++ b/source/opt/instruction_list.cpp
@@ -17,7 +17,6 @@
 namespace spvtools {
 namespace ir {
 
-
 InstructionList::iterator InstructionList::iterator::InsertBefore(
     std::vector<std::unique_ptr<Instruction>>&& list) {
   Instruction* first_node = list.front().get();
diff --git a/source/opt/ir_context.cpp b/source/opt/ir_context.cpp
index 85d3298e..122aff03 100644
--- a/source/opt/ir_context.cpp
+++ b/source/opt/ir_context.cpp
@@ -24,7 +24,8 @@ void IRContext::BuildInvalidAnalyses(IRContext::Analysis set) {
   }
 }
 
-void IRContext::InvalidateAnalysesExceptFor(IRContext::Analysis preserved_analyses) {
+void IRContext::InvalidateAnalysesExceptFor(
+    IRContext::Analysis preserved_analyses) {
   uint32_t analyses_to_invalidate = valid_analyses_ & (~preserved_analyses);
   if (analyses_to_invalidate & kAnalysisDefUse) {
     def_use_mgr_.reset(nullptr);
@@ -75,7 +76,7 @@ bool IRContext::ReplaceAllUsesWith(uint32_t before, uint32_t after) {
       } else if (use.inst->type_id() == 0) {
         SPIRV_ASSERT(consumer_, false,
                      "Result type id considered as use while the instruction "
-                         "doesn't have a result type id.");
+                     "doesn't have a result type id.");
         (void)consumer_;  // Makes the compiler happy for release build.
       } else {
         SPIRV_ASSERT(consumer_, false,
diff --git a/source/opt/iterator.h b/source/opt/iterator.h
index e62bb74c..d2247f49 100644
--- a/source/opt/iterator.h
+++ b/source/opt/iterator.h
@@ -123,21 +123,23 @@ class IteratorRange {
 
 // Returns a (begin, end) iterator pair for the given iterators.
 // The iterators must belong to the same container.
-template<typename IteratorType>
-inline IteratorRange<IteratorType> make_range(IteratorType& begin, IteratorType& end) {
+template <typename IteratorType>
+inline IteratorRange<IteratorType> make_range(IteratorType& begin,
+                                              IteratorType& end) {
   return {begin, end};
 }
 
 // Returns a (begin, end) iterator pair for the given iterators.
 // The iterators must belong to the same container.
-template<typename IteratorType>
-inline IteratorRange<IteratorType> make_range(IteratorType&& begin, IteratorType&& end) {
+template <typename IteratorType>
+inline IteratorRange<IteratorType> make_range(IteratorType&& begin,
+                                              IteratorType&& end) {
   return {begin, end};
 }
 
 // Returns a (begin, end) iterator pair for the given container.
-template<typename ValueType,
-    class IteratorType = UptrVectorIterator<ValueType>>
+template <typename ValueType,
+          class IteratorType = UptrVectorIterator<ValueType>>
 inline IteratorRange<IteratorType> make_range(
     std::vector<std::unique_ptr<ValueType>>& container) {
   return {IteratorType(&container, container.begin()),
diff --git a/source/opt/local_access_chain_convert_pass.cpp b/source/opt/local_access_chain_convert_pass.cpp
index 1ea52251..41c92885 100644
--- a/source/opt/local_access_chain_convert_pass.cpp
+++ b/source/opt/local_access_chain_convert_pass.cpp
@@ -28,7 +28,7 @@ const uint32_t kAccessChainPtrIdInIdx = 0;
 const uint32_t kConstantValueInIdx = 0;
 const uint32_t kTypeIntWidthInIdx = 0;
 
-} // anonymous namespace
+}  // anonymous namespace
 
 void LocalAccessChainConvertPass::DeleteIfUseless(ir::Instruction* inst) {
   const uint32_t resId = inst->result_id();
@@ -40,21 +40,17 @@ void LocalAccessChainConvertPass::DeleteIfUseless(ir::Instruction* inst) {
 }
 
 void LocalAccessChainConvertPass::BuildAndAppendInst(
-    SpvOp opcode,
-    uint32_t typeId,
-    uint32_t resultId,
+    SpvOp opcode, uint32_t typeId, uint32_t resultId,
     const std::vector<ir::Operand>& in_opnds,
     std::vector<std::unique_ptr<ir::Instruction>>* newInsts) {
-  std::unique_ptr<ir::Instruction> newInst(new ir::Instruction(
-      opcode, typeId, resultId, in_opnds));
+  std::unique_ptr<ir::Instruction> newInst(
+      new ir::Instruction(opcode, typeId, resultId, in_opnds));
   get_def_use_mgr()->AnalyzeInstDefUse(&*newInst);
   newInsts->emplace_back(std::move(newInst));
 }
 
 uint32_t LocalAccessChainConvertPass::BuildAndAppendVarLoad(
-    const ir::Instruction* ptrInst,
-    uint32_t* varId,
-    uint32_t* varPteTypeId,
+    const ir::Instruction* ptrInst, uint32_t* varId, uint32_t* varPteTypeId,
     std::vector<std::unique_ptr<ir::Instruction>>* newInsts) {
   const uint32_t ldResultId = TakeNextId();
   *varId = ptrInst->GetSingleWordInOperand(kAccessChainPtrIdInIdx);
@@ -62,20 +58,20 @@ uint32_t LocalAccessChainConvertPass::BuildAndAppendVarLoad(
   assert(varInst->opcode() == SpvOpVariable);
   *varPteTypeId = GetPointeeTypeId(varInst);
   BuildAndAppendInst(SpvOpLoad, *varPteTypeId, ldResultId,
-      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {*varId}}}, newInsts);
+                     {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {*varId}}},
+                     newInsts);
   return ldResultId;
 }
 
 void LocalAccessChainConvertPass::AppendConstantOperands(
-    const ir::Instruction* ptrInst,
-    std::vector<ir::Operand>* in_opnds) {
+    const ir::Instruction* ptrInst, std::vector<ir::Operand>* in_opnds) {
   uint32_t iidIdx = 0;
-  ptrInst->ForEachInId([&iidIdx, &in_opnds, this](const uint32_t *iid) {
+  ptrInst->ForEachInId([&iidIdx, &in_opnds, this](const uint32_t* iid) {
     if (iidIdx > 0) {
       const ir::Instruction* cInst = get_def_use_mgr()->GetDef(*iid);
       uint32_t val = cInst->GetSingleWordInOperand(kConstantValueInIdx);
       in_opnds->push_back(
-        {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {val}});
+          {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {val}});
     }
     ++iidIdx;
   });
@@ -84,12 +80,11 @@ void LocalAccessChainConvertPass::AppendConstantOperands(
 uint32_t LocalAccessChainConvertPass::GenAccessChainLoadReplacement(
     const ir::Instruction* ptrInst,
     std::vector<std::unique_ptr<ir::Instruction>>* newInsts) {
-
   // Build and append load of variable in ptrInst
   uint32_t varId;
   uint32_t varPteTypeId;
-  const uint32_t ldResultId = BuildAndAppendVarLoad(ptrInst, &varId,
-                                                    &varPteTypeId, newInsts);
+  const uint32_t ldResultId =
+      BuildAndAppendVarLoad(ptrInst, &varId, &varPteTypeId, newInsts);
 
   // Build and append Extract
   const uint32_t extResultId = TakeNextId();
@@ -103,30 +98,28 @@ uint32_t LocalAccessChainConvertPass::GenAccessChainLoadReplacement(
 }
 
 void LocalAccessChainConvertPass::GenAccessChainStoreReplacement(
-    const ir::Instruction* ptrInst,
-    uint32_t valId,
+    const ir::Instruction* ptrInst, uint32_t valId,
     std::vector<std::unique_ptr<ir::Instruction>>* newInsts) {
-
   // Build and append load of variable in ptrInst
   uint32_t varId;
   uint32_t varPteTypeId;
-  const uint32_t ldResultId = BuildAndAppendVarLoad(ptrInst, &varId,
-                                                    &varPteTypeId, newInsts);
+  const uint32_t ldResultId =
+      BuildAndAppendVarLoad(ptrInst, &varId, &varPteTypeId, newInsts);
 
   // Build and append Insert
   const uint32_t insResultId = TakeNextId();
-  std::vector<ir::Operand> ins_in_opnds = 
-      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {valId}}, 
-       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ldResultId}}};
+  std::vector<ir::Operand> ins_in_opnds = {
+      {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {valId}},
+      {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ldResultId}}};
   AppendConstantOperands(ptrInst, &ins_in_opnds);
-  BuildAndAppendInst(
-      SpvOpCompositeInsert, varPteTypeId, insResultId, ins_in_opnds, newInsts);
+  BuildAndAppendInst(SpvOpCompositeInsert, varPteTypeId, insResultId,
+                     ins_in_opnds, newInsts);
 
   // Build and append Store
-  BuildAndAppendInst(SpvOpStore, 0, 0, 
-      {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {varId}}, 
-       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {insResultId}}},
-      newInsts);
+  BuildAndAppendInst(SpvOpStore, 0, 0,
+                     {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {varId}},
+                      {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {insResultId}}},
+                     newInsts);
 }
 
 bool LocalAccessChainConvertPass::IsConstantIndexAccessChain(
@@ -144,8 +137,7 @@ bool LocalAccessChainConvertPass::IsConstantIndexAccessChain(
 }
 
 bool LocalAccessChainConvertPass::HasOnlySupportedRefs(uint32_t ptrId) {
-  if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end())
-    return true;
+  if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true;
   analysis::UseList* uses = get_def_use_mgr()->GetUses(ptrId);
   assert(uses != nullptr);
   for (auto u : *uses) {
@@ -164,36 +156,36 @@ void LocalAccessChainConvertPass::FindTargetVars(ir::Function* func) {
   for (auto bi = func->begin(); bi != func->end(); ++bi) {
     for (auto ii = bi->begin(); ii != bi->end(); ++ii) {
       switch (ii->opcode()) {
-      case SpvOpStore:
-      case SpvOpLoad: {
-        uint32_t varId;
-        ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
-        if (!IsTargetVar(varId))
-          break;
-        const SpvOp op = ptrInst->opcode();
-        // Rule out variables with non-supported refs eg function calls
-        if (!HasOnlySupportedRefs(varId)) {
-          seen_non_target_vars_.insert(varId);
-          seen_target_vars_.erase(varId);
+        case SpvOpStore:
+        case SpvOpLoad: {
+          uint32_t varId;
+          ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
+          if (!IsTargetVar(varId)) break;
+          const SpvOp op = ptrInst->opcode();
+          // Rule out variables with non-supported refs eg function calls
+          if (!HasOnlySupportedRefs(varId)) {
+            seen_non_target_vars_.insert(varId);
+            seen_target_vars_.erase(varId);
+            break;
+          }
+          // Rule out variables with nested access chains
+          // TODO(): Convert nested access chains
+          if (IsNonPtrAccessChain(op) &&
+              ptrInst->GetSingleWordInOperand(kAccessChainPtrIdInIdx) !=
+                  varId) {
+            seen_non_target_vars_.insert(varId);
+            seen_target_vars_.erase(varId);
+            break;
+          }
+          // Rule out variables accessed with non-constant indices
+          if (!IsConstantIndexAccessChain(ptrInst)) {
+            seen_non_target_vars_.insert(varId);
+            seen_target_vars_.erase(varId);
+            break;
+          }
+        } break;
+        default:
           break;
-        }
-        // Rule out variables with nested access chains
-        // TODO(): Convert nested access chains
-        if (IsNonPtrAccessChain(op) &&
-            ptrInst->GetSingleWordInOperand(kAccessChainPtrIdInIdx) != varId) {
-          seen_non_target_vars_.insert(varId);
-          seen_target_vars_.erase(varId);
-          break;
-        }
-        // Rule out variables accessed with non-constant indices
-        if (!IsConstantIndexAccessChain(ptrInst)) {
-          seen_non_target_vars_.insert(varId);
-          seen_target_vars_.erase(varId);
-          break;
-        }
-      } break;
-      default:
-        break;
       }
     }
   }
@@ -207,42 +199,37 @@ bool LocalAccessChainConvertPass::ConvertLocalAccessChains(ir::Function* func) {
   for (auto bi = func->begin(); bi != func->end(); ++bi) {
     for (auto ii = bi->begin(); ii != bi->end(); ++ii) {
       switch (ii->opcode()) {
-      case SpvOpLoad: {
-        uint32_t varId;
-        ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
-        if (!IsNonPtrAccessChain(ptrInst->opcode()))
-          break;
-        if (!IsTargetVar(varId))
-          break;
-        std::vector<std::unique_ptr<ir::Instruction>> newInsts;
-        uint32_t replId =
-            GenAccessChainLoadReplacement(ptrInst, &newInsts);
-        ReplaceAndDeleteLoad(&*ii, replId);
-        ++ii;
-        ii = ii.InsertBefore(std::move(newInsts));
-        ++ii;
-        modified = true;
-      } break;
-      case SpvOpStore: {
-        uint32_t varId;
-        ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
-        if (!IsNonPtrAccessChain(ptrInst->opcode()))
+        case SpvOpLoad: {
+          uint32_t varId;
+          ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
+          if (!IsNonPtrAccessChain(ptrInst->opcode())) break;
+          if (!IsTargetVar(varId)) break;
+          std::vector<std::unique_ptr<ir::Instruction>> newInsts;
+          uint32_t replId = GenAccessChainLoadReplacement(ptrInst, &newInsts);
+          ReplaceAndDeleteLoad(&*ii, replId);
+          ++ii;
+          ii = ii.InsertBefore(std::move(newInsts));
+          ++ii;
+          modified = true;
+        } break;
+        case SpvOpStore: {
+          uint32_t varId;
+          ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
+          if (!IsNonPtrAccessChain(ptrInst->opcode())) break;
+          if (!IsTargetVar(varId)) break;
+          std::vector<std::unique_ptr<ir::Instruction>> newInsts;
+          uint32_t valId = ii->GetSingleWordInOperand(kStoreValIdInIdx);
+          GenAccessChainStoreReplacement(ptrInst, valId, &newInsts);
+          context()->KillInst(&*ii);
+          DeleteIfUseless(ptrInst);
+          ++ii;
+          ii = ii.InsertBefore(std::move(newInsts));
+          ++ii;
+          ++ii;
+          modified = true;
+        } break;
+        default:
           break;
-        if (!IsTargetVar(varId))
-          break;
-        std::vector<std::unique_ptr<ir::Instruction>> newInsts;
-        uint32_t valId = ii->GetSingleWordInOperand(kStoreValIdInIdx);
-        GenAccessChainStoreReplacement(ptrInst, valId, &newInsts);
-        context()->KillInst(&*ii);
-        DeleteIfUseless(ptrInst);
-        ++ii;
-        ii = ii.InsertBefore(std::move(newInsts));
-        ++ii;
-        ++ii;
-        modified = true;
-      } break;
-      default:
-        break;
       }
     }
   }
@@ -266,8 +253,8 @@ void LocalAccessChainConvertPass::Initialize(ir::IRContext* c) {
 bool LocalAccessChainConvertPass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -285,11 +272,9 @@ Pass::Status LocalAccessChainConvertPass::ProcessImpl() {
   // support required in KillNamesAndDecorates().
   // TODO(greg-lunarg): Add support for OpGroupDecorate
   for (auto& ai : get_module()->annotations())
-    if (ai.opcode() == SpvOpGroupDecorate)
-      return Status::SuccessWithoutChange;
+    if (ai.opcode() == SpvOpGroupDecorate) return Status::SuccessWithoutChange;
   // Do not process if any disallowed extensions are enabled
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Process all entry point functions.
   ProcessFunction pfn = [this](ir::Function* fp) {
     return ConvertLocalAccessChains(fp);
@@ -308,32 +293,22 @@ Pass::Status LocalAccessChainConvertPass::Process(ir::IRContext* c) {
 void LocalAccessChainConvertPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    // SPV_KHR_variable_pointers
-    //   Currently do not support extended pointer expressions
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
+      "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      // SPV_KHR_variable_pointers
+      //   Currently do not support extended pointer expressions
+      "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/local_access_chain_convert_pass.h b/source/opt/local_access_chain_convert_pass.h
index 07c03a44..152e71c7 100644
--- a/source/opt/local_access_chain_convert_pass.h
+++ b/source/opt/local_access_chain_convert_pass.h
@@ -17,7 +17,6 @@
 #ifndef LIBSPIRV_OPT_LOCAL_ACCESS_CHAIN_CONVERT_PASS_H_
 #define LIBSPIRV_OPT_LOCAL_ACCESS_CHAIN_CONVERT_PASS_H_
 
-
 #include <algorithm>
 #include <map>
 #include <queue>
@@ -27,8 +26,8 @@
 
 #include "basic_block.h"
 #include "def_use_manager.h"
-#include "module.h"
 #include "mem_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
@@ -59,38 +58,40 @@ class LocalAccessChainConvertPass : public MemPass {
 
   // Build instruction from |opcode|, |typeId|, |resultId|, and |in_opnds|.
   // Append to |newInsts|.
-  void BuildAndAppendInst(SpvOp opcode, uint32_t typeId, uint32_t resultId,
-    const std::vector<ir::Operand>& in_opnds,
-    std::vector<std::unique_ptr<ir::Instruction>>* newInsts);
+  void BuildAndAppendInst(
+      SpvOp opcode, uint32_t typeId, uint32_t resultId,
+      const std::vector<ir::Operand>& in_opnds,
+      std::vector<std::unique_ptr<ir::Instruction>>* newInsts);
 
   // Build load of variable in |ptrInst| and append to |newInsts|.
   // Return var in |varId| and its pointee type in |varPteTypeId|.
-  uint32_t BuildAndAppendVarLoad(const ir::Instruction* ptrInst,
-    uint32_t* varId, uint32_t* varPteTypeId,
-    std::vector<std::unique_ptr<ir::Instruction>>* newInsts);
+  uint32_t BuildAndAppendVarLoad(
+      const ir::Instruction* ptrInst, uint32_t* varId, uint32_t* varPteTypeId,
+      std::vector<std::unique_ptr<ir::Instruction>>* newInsts);
 
   // Append literal integer operands to |in_opnds| corresponding to constant
   // integer operands from access chain |ptrInst|. Assumes all indices in
   // access chains are OpConstant.
-  void AppendConstantOperands( const ir::Instruction* ptrInst,
-    std::vector<ir::Operand>* in_opnds);
+  void AppendConstantOperands(const ir::Instruction* ptrInst,
+                              std::vector<ir::Operand>* in_opnds);
 
   // Create a load/insert/store equivalent to a store of
   // |valId| through (constant index) access chaing |ptrInst|.
   // Append to |newInsts|.
-  void GenAccessChainStoreReplacement(const ir::Instruction* ptrInst,
-      uint32_t valId,
+  void GenAccessChainStoreReplacement(
+      const ir::Instruction* ptrInst, uint32_t valId,
       std::vector<std::unique_ptr<ir::Instruction>>* newInsts);
 
   // For the (constant index) access chain |ptrInst|, create an
   // equivalent load and extract. Append to |newInsts|.
-  uint32_t GenAccessChainLoadReplacement(const ir::Instruction* ptrInst,
+  uint32_t GenAccessChainLoadReplacement(
+      const ir::Instruction* ptrInst,
       std::vector<std::unique_ptr<ir::Instruction>>* newInsts);
 
   // Return true if all indices of access chain |acp| are OpConstant integers
   bool IsConstantIndexAccessChain(const ir::Instruction* acp) const;
 
-  // Identify all function scope variables of target type which are 
+  // Identify all function scope variables of target type which are
   // accessed only with loads, stores and access chains with constant
   // indices. Convert all loads and stores of such variables into equivalent
   // loads, stores, extracts and inserts. This unifies access to these
@@ -122,4 +123,3 @@ class LocalAccessChainConvertPass : public MemPass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_LOCAL_ACCESS_CHAIN_CONVERT_PASS_H_
-
diff --git a/source/opt/local_single_block_elim_pass.cpp b/source/opt/local_single_block_elim_pass.cpp
index 04916d86..8fd40238 100644
--- a/source/opt/local_single_block_elim_pass.cpp
+++ b/source/opt/local_single_block_elim_pass.cpp
@@ -25,11 +25,10 @@ namespace {
 
 const uint32_t kStoreValIdInIdx = 1;
 
-} // anonymous namespace
+}  // anonymous namespace
 
 bool LocalSingleBlockLoadStoreElimPass::HasOnlySupportedRefs(uint32_t ptrId) {
-  if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end())
-    return true;
+  if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true;
   analysis::UseList* uses = get_def_use_mgr()->GetUses(ptrId);
   assert(uses != nullptr);
   for (auto u : *uses) {
@@ -54,83 +53,74 @@ bool LocalSingleBlockLoadStoreElimPass::LocalSingleBlockLoadStoreElim(
     pinned_vars_.clear();
     for (auto ii = bi->begin(); ii != bi->end(); ++ii) {
       switch (ii->opcode()) {
-      case SpvOpStore: {
-        // Verify store variable is target type
-        uint32_t varId;
-        ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
-        if (!IsTargetVar(varId))
-          continue;
-        if (!HasOnlySupportedRefs(varId))
-          continue;
-        // Register the store
-        if (ptrInst->opcode() == SpvOpVariable) {
-          // if not pinned, look for WAW
-          if (pinned_vars_.find(varId) == pinned_vars_.end()) {
+        case SpvOpStore: {
+          // Verify store variable is target type
+          uint32_t varId;
+          ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
+          if (!IsTargetVar(varId)) continue;
+          if (!HasOnlySupportedRefs(varId)) continue;
+          // Register the store
+          if (ptrInst->opcode() == SpvOpVariable) {
+            // if not pinned, look for WAW
+            if (pinned_vars_.find(varId) == pinned_vars_.end()) {
+              auto si = var2store_.find(varId);
+              if (si != var2store_.end()) {
+                context()->KillInst(si->second);
+              }
+            }
+            var2store_[varId] = &*ii;
+          } else {
+            assert(IsNonPtrAccessChain(ptrInst->opcode()));
+            var2store_.erase(varId);
+          }
+          pinned_vars_.erase(varId);
+          var2load_.erase(varId);
+        } break;
+        case SpvOpLoad: {
+          // Verify store variable is target type
+          uint32_t varId;
+          ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
+          if (!IsTargetVar(varId)) continue;
+          if (!HasOnlySupportedRefs(varId)) continue;
+          // Look for previous store or load
+          uint32_t replId = 0;
+          if (ptrInst->opcode() == SpvOpVariable) {
             auto si = var2store_.find(varId);
             if (si != var2store_.end()) {
-              context()->KillInst(si->second);
+              replId = si->second->GetSingleWordInOperand(kStoreValIdInIdx);
+            } else {
+              auto li = var2load_.find(varId);
+              if (li != var2load_.end()) {
+                replId = li->second->result_id();
+              }
             }
           }
-          var2store_[varId] = &*ii;
-        }
-        else {
-          assert(IsNonPtrAccessChain(ptrInst->opcode()));
-          var2store_.erase(varId);
-        }
-        pinned_vars_.erase(varId);
-        var2load_.erase(varId);
-      } break;
-      case SpvOpLoad: {
-        // Verify store variable is target type
-        uint32_t varId;
-        ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
-        if (!IsTargetVar(varId))
-          continue;
-        if (!HasOnlySupportedRefs(varId))
-          continue;
-        // Look for previous store or load
-        uint32_t replId = 0;
-        if (ptrInst->opcode() == SpvOpVariable) {
-          auto si = var2store_.find(varId);
-          if (si != var2store_.end()) {
-            replId = si->second->GetSingleWordInOperand(kStoreValIdInIdx);
+          if (replId != 0) {
+            // replace load's result id and delete load
+            ReplaceAndDeleteLoad(&*ii, replId);
+            modified = true;
+          } else {
+            if (ptrInst->opcode() == SpvOpVariable)
+              var2load_[varId] = &*ii;  // register load
+            pinned_vars_.insert(varId);
           }
-          else {
-            auto li = var2load_.find(varId);
-            if (li != var2load_.end()) {
-              replId = li->second->result_id();
-            }
-          }
-        }
-        if (replId != 0) {
-          // replace load's result id and delete load
-          ReplaceAndDeleteLoad(&*ii, replId);
-          modified = true;
-        }
-        else {
-          if (ptrInst->opcode() == SpvOpVariable)
-            var2load_[varId] = &*ii;  // register load
-          pinned_vars_.insert(varId);
-        }
-      } break;
-      case SpvOpFunctionCall: {
-        // Conservatively assume all locals are redefined for now.
-        // TODO(): Handle more optimally
-        var2store_.clear();
-        var2load_.clear();
-        pinned_vars_.clear();
-      } break;
-      default:
-        break;
+        } break;
+        case SpvOpFunctionCall: {
+          // Conservatively assume all locals are redefined for now.
+          // TODO(): Handle more optimally
+          var2store_.clear();
+          var2load_.clear();
+          pinned_vars_.clear();
+        } break;
+        default:
+          break;
       }
     }
     // Go back and delete useless stores in block
     // TODO(greg-lunarg): Consider moving DCE into separate pass
     for (auto ii = bi->begin(); ii != bi->end(); ++ii) {
-      if (ii->opcode() != SpvOpStore)
-        continue;
-      if (IsLiveStore(&*ii))
-        continue;
+      if (ii->opcode() != SpvOpStore) continue;
+      if (IsLiveStore(&*ii)) continue;
       DCEInst(&*ii);
     }
   }
@@ -154,8 +144,8 @@ void LocalSingleBlockLoadStoreElimPass::Initialize(ir::IRContext* c) {
 bool LocalSingleBlockLoadStoreElimPass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -170,12 +160,10 @@ Pass::Status LocalSingleBlockLoadStoreElimPass::ProcessImpl() {
   // support required in KillNamesAndDecorates().
   // TODO(greg-lunarg): Add support for OpGroupDecorate
   for (auto& ai : get_module()->annotations())
-    if (ai.opcode() == SpvOpGroupDecorate)
-      return Status::SuccessWithoutChange;
+    if (ai.opcode() == SpvOpGroupDecorate) return Status::SuccessWithoutChange;
   // If any extensions in the module are not explicitly supported,
-  // return unmodified. 
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  // return unmodified.
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Process all entry point functions
   ProcessFunction pfn = [this](ir::Function* fp) {
     return LocalSingleBlockLoadStoreElim(fp);
@@ -194,29 +182,20 @@ Pass::Status LocalSingleBlockLoadStoreElimPass::Process(ir::IRContext* c) {
 void LocalSingleBlockLoadStoreElimPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    // SPV_KHR_variable_pointers
-    //   Currently do not support extended pointer expressions
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
+      "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      // SPV_KHR_variable_pointers
+      //   Currently do not support extended pointer expressions
+      "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
diff --git a/source/opt/local_single_block_elim_pass.h b/source/opt/local_single_block_elim_pass.h
index f178304d..5ceb3784 100644
--- a/source/opt/local_single_block_elim_pass.h
+++ b/source/opt/local_single_block_elim_pass.h
@@ -17,18 +17,17 @@
 #ifndef LIBSPIRV_OPT_LOCAL_SINGLE_BLOCK_ELIM_PASS_H_
 #define LIBSPIRV_OPT_LOCAL_SINGLE_BLOCK_ELIM_PASS_H_
 
-
 #include <algorithm>
 #include <map>
 #include <queue>
-#include <utility>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 
 #include "basic_block.h"
 #include "def_use_manager.h"
-#include "module.h"
 #include "mem_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
@@ -98,4 +97,3 @@ class LocalSingleBlockLoadStoreElimPass : public MemPass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_LOCAL_SINGLE_BLOCK_ELIM_PASS_H_
-
diff --git a/source/opt/local_single_store_elim_pass.cpp b/source/opt/local_single_store_elim_pass.cpp
index 83f6f3a8..e3a00ba9 100644
--- a/source/opt/local_single_store_elim_pass.cpp
+++ b/source/opt/local_single_store_elim_pass.cpp
@@ -27,11 +27,10 @@ namespace {
 
 const uint32_t kStoreValIdInIdx = 1;
 
-} // anonymous namespace
+}  // anonymous namespace
 
 bool LocalSingleStoreElimPass::HasOnlySupportedRefs(uint32_t ptrId) {
-  if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end())
-    return true;
+  if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true;
   analysis::UseList* uses = get_def_use_mgr()->GetUses(ptrId);
   assert(uses != nullptr);
   for (auto u : *uses) {
@@ -55,41 +54,40 @@ void LocalSingleStoreElimPass::SingleStoreAnalyze(ir::Function* func) {
     uint32_t instIdx = 0;
     for (auto ii = bi->begin(); ii != bi->end(); ++ii, ++instIdx) {
       switch (ii->opcode()) {
-      case SpvOpStore: {
-        // Verify store variable is target type
-        uint32_t varId;
-        ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
-        if (non_ssa_vars_.find(varId) != non_ssa_vars_.end())
-          continue;
-        if (ptrInst->opcode() != SpvOpVariable) {
-          non_ssa_vars_.insert(varId);
-          ssa_var2store_.erase(varId);
-          continue;
-        }
-        // Verify target type and function storage class
-        if (!IsTargetVar(varId)) {
-          non_ssa_vars_.insert(varId);
-          continue;
-        }
-        if (!HasOnlySupportedRefs(varId)) {
-          non_ssa_vars_.insert(varId);
-          continue;
-        }
-        // Ignore variables with multiple stores
-        if (ssa_var2store_.find(varId) != ssa_var2store_.end()) {
-          non_ssa_vars_.insert(varId);
-          ssa_var2store_.erase(varId);
-          continue;
-        }
-        // Remember pointer to variable's store and it's
-        // ordinal position in block
-        ssa_var2store_[varId] = &*ii;
-        store2idx_[&*ii] = instIdx;
-        store2blk_[&*ii] = &*bi;
-      } break;
-      default:
-        break;
-      } // switch
+        case SpvOpStore: {
+          // Verify store variable is target type
+          uint32_t varId;
+          ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
+          if (non_ssa_vars_.find(varId) != non_ssa_vars_.end()) continue;
+          if (ptrInst->opcode() != SpvOpVariable) {
+            non_ssa_vars_.insert(varId);
+            ssa_var2store_.erase(varId);
+            continue;
+          }
+          // Verify target type and function storage class
+          if (!IsTargetVar(varId)) {
+            non_ssa_vars_.insert(varId);
+            continue;
+          }
+          if (!HasOnlySupportedRefs(varId)) {
+            non_ssa_vars_.insert(varId);
+            continue;
+          }
+          // Ignore variables with multiple stores
+          if (ssa_var2store_.find(varId) != ssa_var2store_.end()) {
+            non_ssa_vars_.insert(varId);
+            ssa_var2store_.erase(varId);
+            continue;
+          }
+          // Remember pointer to variable's store and it's
+          // ordinal position in block
+          ssa_var2store_[varId] = &*ii;
+          store2idx_[&*ii] = instIdx;
+          store2blk_[&*ii] = &*bi;
+        } break;
+        default:
+          break;
+      }  // switch
     }
   }
 }
@@ -98,8 +96,7 @@ LocalSingleStoreElimPass::GetBlocksFunction
 LocalSingleStoreElimPass::AugmentedCFGSuccessorsFunction() const {
   return [this](const ir::BasicBlock* block) {
     auto asmi = augmented_successors_map_.find(block);
-    if (asmi != augmented_successors_map_.end())
-      return &(*asmi).second;
+    if (asmi != augmented_successors_map_.end()) return &(*asmi).second;
     auto smi = successors_map_.find(block);
     return &(*smi).second;
   };
@@ -109,8 +106,7 @@ LocalSingleStoreElimPass::GetBlocksFunction
 LocalSingleStoreElimPass::AugmentedCFGPredecessorsFunction() const {
   return [this](const ir::BasicBlock* block) {
     auto apmi = augmented_predecessors_map_.find(block);
-    if (apmi != augmented_predecessors_map_.end())
-      return &(*apmi).second;
+    if (apmi != augmented_predecessors_map_.end()) return &(*apmi).second;
     auto pmi = predecessors_map_.find(block);
     return &(*pmi).second;
   };
@@ -134,43 +130,36 @@ void LocalSingleStoreElimPass::CalculateImmediateDominators(
   augmented_predecessors_map_.clear();
   successors_map_[cfg()->pseudo_exit_block()] = {};
   predecessors_map_[cfg()->pseudo_entry_block()] = {};
-  auto succ_func = [this](const ir::BasicBlock* b)
-    { return &successors_map_[b]; };
-  auto pred_func = [this](const ir::BasicBlock* b)
-    { return &predecessors_map_[b]; };
+  auto succ_func = [this](const ir::BasicBlock* b) {
+    return &successors_map_[b];
+  };
+  auto pred_func = [this](const ir::BasicBlock* b) {
+    return &predecessors_map_[b];
+  };
   CFA<ir::BasicBlock>::ComputeAugmentedCFG(
-    ordered_blocks,
-    cfg()->pseudo_entry_block(),
-    cfg()->pseudo_exit_block(),
-    &augmented_successors_map_,
-    &augmented_predecessors_map_,
-    succ_func,
-    pred_func);
+      ordered_blocks, cfg()->pseudo_entry_block(), cfg()->pseudo_exit_block(),
+      &augmented_successors_map_, &augmented_predecessors_map_, succ_func,
+      pred_func);
   // Compute Dominators
   vector<const ir::BasicBlock*> postorder;
   auto ignore_block = [](cbb_ptr) {};
   auto ignore_edge = [](cbb_ptr, cbb_ptr) {};
   spvtools::CFA<ir::BasicBlock>::DepthFirstTraversal(
-    ordered_blocks[0], AugmentedCFGSuccessorsFunction(),
-    ignore_block, [&](cbb_ptr b) { postorder.push_back(b); },
-    ignore_edge);
+      ordered_blocks[0], AugmentedCFGSuccessorsFunction(), ignore_block,
+      [&](cbb_ptr b) { postorder.push_back(b); }, ignore_edge);
   auto edges = spvtools::CFA<ir::BasicBlock>::CalculateDominators(
-    postorder, AugmentedCFGPredecessorsFunction());
+      postorder, AugmentedCFGPredecessorsFunction());
   idom_.clear();
-  for (auto edge : edges)
-    idom_[edge.first] = edge.second;
+  for (auto edge : edges) idom_[edge.first] = edge.second;
 }
 
-bool LocalSingleStoreElimPass::Dominates(
-    ir::BasicBlock* blk0, uint32_t idx0,
-    ir::BasicBlock* blk1, uint32_t idx1) {
-  if (blk0 == blk1)
-    return idx0 <= idx1;
+bool LocalSingleStoreElimPass::Dominates(ir::BasicBlock* blk0, uint32_t idx0,
+                                         ir::BasicBlock* blk1, uint32_t idx1) {
+  if (blk0 == blk1) return idx0 <= idx1;
   ir::BasicBlock* b = blk1;
   while (idom_[b] != b) {
     b = idom_[b];
-    if (b == blk0)
-      return true;
+    if (b == blk0) return true;
   }
   return false;
 }
@@ -181,20 +170,17 @@ bool LocalSingleStoreElimPass::SingleStoreProcess(ir::Function* func) {
   for (auto bi = func->begin(); bi != func->end(); ++bi) {
     uint32_t instIdx = 0;
     for (auto ii = bi->begin(); ii != bi->end(); ++ii, ++instIdx) {
-      if (ii->opcode() != SpvOpLoad)
-        continue;
+      if (ii->opcode() != SpvOpLoad) continue;
       uint32_t varId;
       ir::Instruction* ptrInst = GetPtr(&*ii, &varId);
       // Skip access chain loads
-      if (ptrInst->opcode() != SpvOpVariable)
-        continue;
+      if (ptrInst->opcode() != SpvOpVariable) continue;
       const auto vsi = ssa_var2store_.find(varId);
-      if (vsi == ssa_var2store_.end())
-        continue;
-      if (non_ssa_vars_.find(varId) != non_ssa_vars_.end())
-        continue;
+      if (vsi == ssa_var2store_.end()) continue;
+      if (non_ssa_vars_.find(varId) != non_ssa_vars_.end()) continue;
       // store must dominate load
-      if (!Dominates(store2blk_[vsi->second], store2idx_[vsi->second], &*bi, instIdx))
+      if (!Dominates(store2blk_[vsi->second], store2idx_[vsi->second], &*bi,
+                     instIdx))
         continue;
       // Use store value as replacement id
       uint32_t replId = vsi->second->GetSingleWordInOperand(kStoreValIdInIdx);
@@ -210,10 +196,8 @@ bool LocalSingleStoreElimPass::SingleStoreDCE() {
   bool modified = false;
   for (auto v : ssa_var2store_) {
     // check that it hasn't already been DCE'd
-    if (v.second->opcode() != SpvOpStore)
-      continue;
-    if (non_ssa_vars_.find(v.first) != non_ssa_vars_.end())
-      continue;
+    if (v.second->opcode() != SpvOpStore) continue;
+    if (non_ssa_vars_.find(v.first) != non_ssa_vars_.end()) continue;
     if (!IsLiveStore(v.second)) {
       DCEInst(v.second);
       modified = true;
@@ -225,8 +209,7 @@ bool LocalSingleStoreElimPass::SingleStoreDCE() {
 bool LocalSingleStoreElimPass::LocalSingleStoreElim(ir::Function* func) {
   bool modified = false;
   SingleStoreAnalyze(func);
-  if (ssa_var2store_.empty())
-    return false;
+  if (ssa_var2store_.empty()) return false;
   modified |= SingleStoreProcess(func);
   modified |= SingleStoreDCE();
   return modified;
@@ -258,8 +241,8 @@ void LocalSingleStoreElimPass::Initialize(ir::IRContext* irContext) {
 bool LocalSingleStoreElimPass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -274,11 +257,9 @@ Pass::Status LocalSingleStoreElimPass::ProcessImpl() {
   // support required in KillNamesAndDecorates().
   // TODO(greg-lunarg): Add support for OpGroupDecorate
   for (auto& ai : get_module()->annotations())
-    if (ai.opcode() == SpvOpGroupDecorate)
-      return Status::SuccessWithoutChange;
+    if (ai.opcode() == SpvOpGroupDecorate) return Status::SuccessWithoutChange;
   // Do not process if any disallowed extensions are enabled
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Process all entry point functions
   ProcessFunction pfn = [this](ir::Function* fp) {
     return LocalSingleStoreElim(fp);
@@ -297,29 +278,20 @@ Pass::Status LocalSingleStoreElimPass::Process(ir::IRContext* irContext) {
 void LocalSingleStoreElimPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    // SPV_KHR_variable_pointers
-    //   Currently do not support extended pointer expressions
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
+      "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      // SPV_KHR_variable_pointers
+      //   Currently do not support extended pointer expressions
+      "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
diff --git a/source/opt/local_single_store_elim_pass.h b/source/opt/local_single_store_elim_pass.h
index e3aff0d1..1d0f1ff9 100644
--- a/source/opt/local_single_store_elim_pass.h
+++ b/source/opt/local_single_store_elim_pass.h
@@ -17,7 +17,6 @@
 #ifndef LIBSPIRV_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_
 #define LIBSPIRV_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_
 
-
 #include <algorithm>
 #include <map>
 #include <queue>
@@ -27,8 +26,8 @@
 
 #include "basic_block.h"
 #include "def_use_manager.h"
-#include "module.h"
 #include "mem_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
@@ -58,7 +57,7 @@ class LocalSingleStoreElimPass : public MemPass {
   void SingleStoreAnalyze(ir::Function* func);
 
   using GetBlocksFunction =
-    std::function<const std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
+      std::function<const std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
 
   /// Returns the block successors function for the augmented CFG.
   GetBlocksFunction AugmentedCFGSuccessorsFunction() const;
@@ -70,11 +69,11 @@ class LocalSingleStoreElimPass : public MemPass {
   // in idom_. Entries for augmented CFG (pseudo blocks) are not created.
   // TODO(dnovillo): Move to new CFG class.
   void CalculateImmediateDominators(ir::Function* func);
-  
+
   // Return true if instruction in |blk0| at ordinal position |idx0|
   // dominates instruction in |blk1| at position |idx1|.
-  bool Dominates(ir::BasicBlock* blk0, uint32_t idx0,
-    ir::BasicBlock* blk1, uint32_t idx1);
+  bool Dominates(ir::BasicBlock* blk0, uint32_t idx0, ir::BasicBlock* blk1,
+                 uint32_t idx1);
 
   // For each load of an SSA variable in |func|, replace all uses of
   // the load with the value stored if the store dominates the load.
@@ -123,19 +122,19 @@ class LocalSingleStoreElimPass : public MemPass {
 
   // CFG Predecessors
   std::unordered_map<const ir::BasicBlock*, std::vector<ir::BasicBlock*>>
-    predecessors_map_;
+      predecessors_map_;
 
   // CFG Successors
   std::unordered_map<const ir::BasicBlock*, std::vector<ir::BasicBlock*>>
-    successors_map_;
+      successors_map_;
 
   // CFG Augmented Predecessors
   std::unordered_map<const ir::BasicBlock*, std::vector<ir::BasicBlock*>>
-    augmented_predecessors_map_;
+      augmented_predecessors_map_;
 
   // CFG Augmented Successors
   std::unordered_map<const ir::BasicBlock*, std::vector<ir::BasicBlock*>>
-    augmented_successors_map_;
+      augmented_successors_map_;
 
   // Immediate Dominator Map
   // If block has no idom it points to itself.
@@ -149,4 +148,3 @@ class LocalSingleStoreElimPass : public MemPass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_
-
diff --git a/source/opt/local_ssa_elim_pass.cpp b/source/opt/local_ssa_elim_pass.cpp
index 1ec7db58..f0aaee7d 100644
--- a/source/opt/local_ssa_elim_pass.cpp
+++ b/source/opt/local_ssa_elim_pass.cpp
@@ -16,27 +16,24 @@
 
 #include "local_ssa_elim_pass.h"
 
-#include "iterator.h"
 #include "cfa.h"
+#include "iterator.h"
 
 namespace spvtools {
 namespace opt {
 
 bool LocalMultiStoreElimPass::EliminateMultiStoreLocal(ir::Function* func) {
   // Add Phi instructions to the function.
-  if (InsertPhiInstructions(func) == Status::SuccessWithoutChange)
-    return false;
+  if (InsertPhiInstructions(func) == Status::SuccessWithoutChange) return false;
 
   // Remove all target variable stores.
   bool modified = false;
   for (auto bi = func->begin(); bi != func->end(); ++bi) {
     for (auto ii = bi->begin(); ii != bi->end(); ++ii) {
-      if (ii->opcode() != SpvOpStore)
-        continue;
+      if (ii->opcode() != SpvOpStore) continue;
       uint32_t varId;
-      (void) GetPtr(&*ii, &varId);
-      if (!IsTargetVar(varId))
-        continue;
+      (void)GetPtr(&*ii, &varId);
+      if (!IsTargetVar(varId)) continue;
       assert(!HasLoads(varId));
       DCEInst(&*ii);
       modified = true;
@@ -56,8 +53,8 @@ void LocalMultiStoreElimPass::Initialize(ir::IRContext* c) {
 bool LocalMultiStoreElimPass::AllExtensionsSupported() const {
   // If any extension not in whitelist, return false
   for (auto& ei : get_module()->extensions()) {
-    const char* extName = reinterpret_cast<const char*>(
-        &ei.GetInOperand(0).words[0]);
+    const char* extName =
+        reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
     if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
       return false;
   }
@@ -76,12 +73,10 @@ Pass::Status LocalMultiStoreElimPass::ProcessImpl() {
   // Do not process if module contains OpGroupDecorate. Additional
   // support required in KillNamesAndDecorates().
   // TODO(greg-lunarg): Add support for OpGroupDecorate
-  for (auto& ai : get_module()->annotations()) 
-    if (ai.opcode() == SpvOpGroupDecorate)
-      return Status::SuccessWithoutChange;
+  for (auto& ai : get_module()->annotations())
+    if (ai.opcode() == SpvOpGroupDecorate) return Status::SuccessWithoutChange;
   // Do not process if any disallowed extensions are enabled
-  if (!AllExtensionsSupported())
-    return Status::SuccessWithoutChange;
+  if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
   // Process functions
   ProcessFunction pfn = [this](ir::Function* fp) {
     return EliminateMultiStoreLocal(fp);
@@ -100,32 +95,22 @@ Pass::Status LocalMultiStoreElimPass::Process(ir::IRContext* c) {
 void LocalMultiStoreElimPass::InitExtensions() {
   extensions_whitelist_.clear();
   extensions_whitelist_.insert({
-    "SPV_AMD_shader_explicit_vertex_parameter",
-    "SPV_AMD_shader_trinary_minmax",
-    "SPV_AMD_gcn_shader",
-    "SPV_KHR_shader_ballot",
-    "SPV_AMD_shader_ballot",
-    "SPV_AMD_gpu_shader_half_float",
-    "SPV_KHR_shader_draw_parameters",
-    "SPV_KHR_subgroup_vote",
-    "SPV_KHR_16bit_storage",
-    "SPV_KHR_device_group",
-    "SPV_KHR_multiview",
-    "SPV_NVX_multiview_per_view_attributes",
-    "SPV_NV_viewport_array2",
-    "SPV_NV_stereo_view_rendering",
-    "SPV_NV_sample_mask_override_coverage",
-    "SPV_NV_geometry_shader_passthrough",
-    "SPV_AMD_texture_gather_bias_lod",
-    "SPV_KHR_storage_buffer_storage_class",
-    // SPV_KHR_variable_pointers
-    //   Currently do not support extended pointer expressions
-    "SPV_AMD_gpu_shader_int16",
-    "SPV_KHR_post_depth_coverage",
-    "SPV_KHR_shader_atomic_counter_ops",
+      "SPV_AMD_shader_explicit_vertex_parameter",
+      "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
+      "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
+      "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
+      "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
+      "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
+      "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+      "SPV_NV_sample_mask_override_coverage",
+      "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+      "SPV_KHR_storage_buffer_storage_class",
+      // SPV_KHR_variable_pointers
+      //   Currently do not support extended pointer expressions
+      "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+      "SPV_KHR_shader_atomic_counter_ops",
   });
 }
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/local_ssa_elim_pass.h b/source/opt/local_ssa_elim_pass.h
index 65177bbf..ae293be0 100644
--- a/source/opt/local_ssa_elim_pass.h
+++ b/source/opt/local_ssa_elim_pass.h
@@ -17,18 +17,17 @@
 #ifndef LIBSPIRV_OPT_LOCAL_SSA_ELIM_PASS_H_
 #define LIBSPIRV_OPT_LOCAL_SSA_ELIM_PASS_H_
 
-
 #include <algorithm>
 #include <map>
 #include <queue>
-#include <utility>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 
 #include "basic_block.h"
 #include "def_use_manager.h"
-#include "module.h"
 #include "mem_pass.h"
+#include "module.h"
 
 namespace spvtools {
 namespace opt {
@@ -38,8 +37,8 @@ class LocalMultiStoreElimPass : public MemPass {
   using cbb_ptr = const ir::BasicBlock*;
 
  public:
-   using GetBlocksFunction =
-     std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
+  using GetBlocksFunction =
+      std::function<std::vector<ir::BasicBlock*>*(const ir::BasicBlock*)>;
 
   LocalMultiStoreElimPass();
   const char* name() const override { return "eliminate-local-multi-store"; }
@@ -70,4 +69,3 @@ class LocalMultiStoreElimPass : public MemPass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_LOCAL_SSA_ELIM_PASS_H_
-
diff --git a/source/opt/mem_pass.cpp b/source/opt/mem_pass.cpp
index c4bfd127..3affc484 100644
--- a/source/opt/mem_pass.cpp
+++ b/source/opt/mem_pass.cpp
@@ -626,7 +626,8 @@ Pass::Status MemPass::InsertPhiInstructions(ir::Function* func) {
           }
           // If variable is not defined, use undef
           if (replId == 0) {
-            replId = Type2Undef(GetPointeeTypeId(get_def_use_mgr()->GetDef(varId)));
+            replId =
+                Type2Undef(GetPointeeTypeId(get_def_use_mgr()->GetDef(varId)));
           }
           // Replace load's id with the last stored value id for variable
           // and delete load. Kill any names or decorates using id before
@@ -720,7 +721,7 @@ void MemPass::RemovePhiOperands(
     assert(i % 2 == 0 && i < phi->NumOperands() - 1 &&
            "malformed Phi arguments");
 
-    ir::BasicBlock *in_block = cfg()->block(phi->GetSingleWordOperand(i + 1));
+    ir::BasicBlock* in_block = cfg()->block(phi->GetSingleWordOperand(i + 1));
     if (reachable_blocks.find(in_block) == reachable_blocks.end()) {
       // If the incoming block is unreachable, remove both operands as this
       // means that the |phi| has lost an incoming edge.
@@ -730,7 +731,7 @@ void MemPass::RemovePhiOperands(
 
     // In all other cases, the operand must be kept but may need to be changed.
     uint32_t arg_id = phi->GetSingleWordOperand(i);
-    ir::BasicBlock *def_block = def_block_[arg_id];
+    ir::BasicBlock* def_block = def_block_[arg_id];
     if (def_block &&
         reachable_blocks.find(def_block_[arg_id]) == reachable_blocks.end()) {
       // If the current |phi| argument was defined in an unreachable block, it
@@ -824,10 +825,8 @@ bool MemPass::RemoveUnreachableBlocks(ir::Function* func) {
     // If the block is reachable and has Phi instructions, remove all
     // operands from its Phi instructions that reference unreachable blocks.
     // If the block has no Phi instructions, this is a no-op.
-    block.ForEachPhiInst(
-        [&block, &reachable_blocks, this](ir::Instruction* phi) {
-          RemovePhiOperands(phi, reachable_blocks);
-        });
+    block.ForEachPhiInst([&block, &reachable_blocks, this](
+        ir::Instruction* phi) { RemovePhiOperands(phi, reachable_blocks); });
   }
 
   // Erase unreachable blocks.
@@ -869,4 +868,3 @@ void MemPass::InitializeCFGCleanup(ir::IRContext* c) {
 
 }  // namespace opt
 }  // namespace spvtools
-
diff --git a/source/opt/mem_pass.h b/source/opt/mem_pass.h
index a9fd36fa..29beeccd 100644
--- a/source/opt/mem_pass.h
+++ b/source/opt/mem_pass.h
@@ -242,4 +242,3 @@ class MemPass : public Pass {
 }  // namespace spvtools
 
 #endif  // LIBSPIRV_OPT_OPT_PASS_H_
-
diff --git a/source/opt/module.h b/source/opt/module.h
index 1719832d..e4c03e27 100644
--- a/source/opt/module.h
+++ b/source/opt/module.h
@@ -323,7 +323,7 @@ inline IteratorRange<Module::inst_iterator> Module::ext_inst_imports() {
 }
 
 inline IteratorRange<Module::const_inst_iterator> Module::ext_inst_imports()
-const {
+    const {
   return make_range(ext_inst_imports_.begin(), ext_inst_imports_.end());
 }
 
@@ -380,7 +380,7 @@ inline IteratorRange<Module::inst_iterator> Module::execution_modes() {
 }
 
 inline IteratorRange<Module::const_inst_iterator> Module::execution_modes()
-const {
+    const {
   return make_range(execution_modes_.begin(), execution_modes_.end());
 }
 
diff --git a/source/opt/null_pass.h b/source/opt/null_pass.h
index 4685f66c..54ea06e3 100644
--- a/source/opt/null_pass.h
+++ b/source/opt/null_pass.h
@@ -25,7 +25,9 @@ namespace opt {
 class NullPass : public Pass {
  public:
   const char* name() const override { return "null"; }
-  Status Process(ir::IRContext*) override { return Status::SuccessWithoutChange; }
+  Status Process(ir::IRContext*) override {
+    return Status::SuccessWithoutChange;
+  }
 };
 
 }  // namespace opt
diff --git a/source/opt/pass.h b/source/opt/pass.h
index 9b231d6c..e11d6e43 100644
--- a/source/opt/pass.h
+++ b/source/opt/pass.h
@@ -87,7 +87,7 @@ class Pass {
 
   // Returns a pointer to the CFG for current module. TODO(dnovillo): This
   // should belong in IRContext.
-  ir::CFG *cfg() const { return cfg_.get(); }
+  ir::CFG* cfg() const { return cfg_.get(); }
 
   // Add to |todo| all ids of functions called in |func|.
   void AddCalls(ir::Function* func, std::queue<uint32_t>* todo);
@@ -111,8 +111,8 @@ class Pass {
       const std::unordered_map<uint32_t, ir::Function*>& id2function,
       std::queue<uint32_t>* roots);
 
-
-  // Run the pass on the given |module|. Returns Status::Failure if errors occur when
+  // Run the pass on the given |module|. Returns Status::Failure if errors occur
+  // when
   // processing. Returns the corresponding Status::Success if processing is
   // successful to indicate whether changes are made to the module.  If there
   // were any changes it will also invalidate the analyses in the IRContext
diff --git a/source/opt/pass_manager.h b/source/opt/pass_manager.h
index 1193f5dd..7b1ef9df 100644
--- a/source/opt/pass_manager.h
+++ b/source/opt/pass_manager.h
@@ -22,8 +22,8 @@
 #include "module.h"
 #include "pass.h"
 
-#include "spirv-tools/libspirv.hpp"
 #include "ir_context.h"
+#include "spirv-tools/libspirv.hpp"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/passes.h b/source/opt/passes.h
index 657f4945..ef01b487 100644
--- a/source/opt/passes.h
+++ b/source/opt/passes.h
@@ -17,6 +17,7 @@
 
 // A single header to include all passes.
 
+#include "aggressive_dead_code_elim_pass.h"
 #include "block_merge_pass.h"
 #include "cfg_cleanup_pass.h"
 #include "common_uniform_elim_pass.h"
@@ -24,22 +25,21 @@
 #include "dead_branch_elim_pass.h"
 #include "dead_variable_elimination.h"
 #include "eliminate_dead_constant_pass.h"
+#include "eliminate_dead_functions_pass.h"
 #include "flatten_decoration_pass.h"
 #include "fold_spec_constant_op_and_composite_pass.h"
+#include "freeze_spec_constant_value_pass.h"
 #include "inline_exhaustive_pass.h"
 #include "inline_opaque_pass.h"
 #include "insert_extract_elim.h"
+#include "local_access_chain_convert_pass.h"
 #include "local_single_block_elim_pass.h"
 #include "local_single_store_elim_pass.h"
 #include "local_ssa_elim_pass.h"
-#include "freeze_spec_constant_value_pass.h"
-#include "local_access_chain_convert_pass.h"
-#include "aggressive_dead_code_elim_pass.h"
 #include "null_pass.h"
 #include "set_spec_constant_default_value_pass.h"
 #include "strength_reduction_pass.h"
 #include "strip_debug_info_pass.h"
 #include "unify_const_pass.h"
-#include "eliminate_dead_functions_pass.h"
 
 #endif  // LIBSPIRV_OPT_PASSES_H_
diff --git a/source/opt/remove_duplicates_pass.cpp b/source/opt/remove_duplicates_pass.cpp
index 3ee78f4d..6bb62120 100644
--- a/source/opt/remove_duplicates_pass.cpp
+++ b/source/opt/remove_duplicates_pass.cpp
@@ -23,8 +23,8 @@
 #include <vector>
 
 #include "decoration_manager.h"
-#include "opcode.h"
 #include "ir_context.h"
+#include "opcode.h"
 
 namespace spvtools {
 namespace opt {
@@ -46,11 +46,13 @@ Pass::Status RemoveDuplicatesPass::Process(ir::IRContext* irContext) {
   return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
 }
 
-bool RemoveDuplicatesPass::RemoveDuplicateCapabilities(ir::IRContext* irContext) const {
+bool RemoveDuplicatesPass::RemoveDuplicateCapabilities(
+    ir::IRContext* irContext) const {
   bool modified = false;
 
   std::unordered_set<uint32_t> capabilities;
-  for (auto i = irContext->capability_begin(); i != irContext->capability_end();) {
+  for (auto i = irContext->capability_begin();
+       i != irContext->capability_end();) {
     auto res = capabilities.insert(i->GetSingleWordOperand(0u));
 
     if (res.second) {
@@ -66,8 +68,8 @@ bool RemoveDuplicatesPass::RemoveDuplicateCapabilities(ir::IRContext* irContext)
   return modified;
 }
 
-bool
-RemoveDuplicatesPass::RemoveDuplicatesExtInstImports(ir::IRContext* irContext) const {
+bool RemoveDuplicatesPass::RemoveDuplicatesExtInstImports(
+    ir::IRContext* irContext) const {
   bool modified = false;
 
   std::unordered_map<std::string, SpvId> extInstImports;
@@ -90,8 +92,8 @@ RemoveDuplicatesPass::RemoveDuplicatesExtInstImports(ir::IRContext* irContext) c
   return modified;
 }
 
-bool RemoveDuplicatesPass::RemoveDuplicateTypes(ir::IRContext* irContext,
-                                                DecorationManager& decManager) const {
+bool RemoveDuplicatesPass::RemoveDuplicateTypes(
+    ir::IRContext* irContext, DecorationManager& decManager) const {
   bool modified = false;
 
   std::vector<Instruction> visitedTypes;
@@ -142,7 +144,8 @@ bool RemoveDuplicatesPass::RemoveDuplicateDecorations(
   std::vector<const Instruction*> visitedDecorations;
 
   opt::analysis::DecorationManager decorationManager(irContext->module());
-  for (auto i = irContext->annotation_begin(); i != irContext->annotation_end();) {
+  for (auto i = irContext->annotation_begin();
+       i != irContext->annotation_end();) {
     // Is the current decoration equal to one of the decorations we have aready
     // visited?
     bool alreadyVisited = false;
diff --git a/source/opt/remove_duplicates_pass.h b/source/opt/remove_duplicates_pass.h
index 82e5f1db..d61079e9 100644
--- a/source/opt/remove_duplicates_pass.h
+++ b/source/opt/remove_duplicates_pass.h
@@ -19,9 +19,9 @@
 
 #include "decoration_manager.h"
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
@@ -44,7 +44,7 @@ class RemoveDuplicatesPass : public Pass {
   bool RemoveDuplicateCapabilities(ir::IRContext* irContext) const;
   bool RemoveDuplicatesExtInstImports(ir::IRContext* irContext) const;
   bool RemoveDuplicateTypes(ir::IRContext* irContext,
-                              analysis::DecorationManager& decManager) const;
+                            analysis::DecorationManager& decManager) const;
   bool RemoveDuplicateDecorations(ir::IRContext* irContext) const;
 };
 
diff --git a/source/opt/set_spec_constant_default_value_pass.cpp b/source/opt/set_spec_constant_default_value_pass.cpp
index d78a4138..9f2786e7 100644
--- a/source/opt/set_spec_constant_default_value_pass.cpp
+++ b/source/opt/set_spec_constant_default_value_pass.cpp
@@ -21,12 +21,12 @@
 #include <vector>
 
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "make_unique.h"
 #include "spirv-tools/libspirv.h"
 #include "type_manager.h"
 #include "types.h"
 #include "util/parse_number.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
@@ -188,7 +188,8 @@ ir::Instruction* GetSpecIdTargetFromDecorationGroup(
 }
 };
 
-Pass::Status SetSpecConstantDefaultValuePass::Process(ir::IRContext* irContext) {
+Pass::Status SetSpecConstantDefaultValuePass::Process(
+    ir::IRContext* irContext) {
   // The operand index of decoration target in an OpDecorate instruction.
   const uint32_t kTargetIdOperandIndex = 0;
   // The operand index of the decoration literal in an OpDecorate instruction.
@@ -254,8 +255,8 @@ Pass::Status SetSpecConstantDefaultValuePass::Process(ir::IRContext* irContext)
       // Gets the string of the default value and parses it to bit pattern
       // with the type of the spec constant.
       const std::string& default_value_str = iter->second;
-      bit_pattern = ParseDefaultValueStr(default_value_str.c_str(),
-                                  type_mgr.GetType(spec_inst->type_id()));
+      bit_pattern = ParseDefaultValueStr(
+          default_value_str.c_str(), type_mgr.GetType(spec_inst->type_id()));
 
     } else {
       // Search for the new bit-pattern-form default value for this spec id.
diff --git a/source/opt/set_spec_constant_default_value_pass.h b/source/opt/set_spec_constant_default_value_pass.h
index dc4efca3..95667bb8 100644
--- a/source/opt/set_spec_constant_default_value_pass.h
+++ b/source/opt/set_spec_constant_default_value_pass.h
@@ -19,9 +19,9 @@
 #include <string>
 #include <unordered_map>
 
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
@@ -38,17 +38,22 @@ class SetSpecConstantDefaultValuePass : public Pass {
   // in the form of string.
   explicit SetSpecConstantDefaultValuePass(
       const SpecIdToValueStrMap& default_values)
-      : spec_id_to_value_str_(default_values), spec_id_to_value_bit_pattern_() {}
+      : spec_id_to_value_str_(default_values),
+        spec_id_to_value_bit_pattern_() {}
   explicit SetSpecConstantDefaultValuePass(SpecIdToValueStrMap&& default_values)
-      : spec_id_to_value_str_(std::move(default_values)), spec_id_to_value_bit_pattern_() {}
+      : spec_id_to_value_str_(std::move(default_values)),
+        spec_id_to_value_bit_pattern_() {}
 
   // Constructs a pass instance with a map from spec ids to default values in
   // the form of bit pattern.
   explicit SetSpecConstantDefaultValuePass(
       const SpecIdToValueBitPatternMap& default_values)
-      : spec_id_to_value_str_(), spec_id_to_value_bit_pattern_(default_values) {}
-  explicit SetSpecConstantDefaultValuePass(SpecIdToValueBitPatternMap&& default_values)
-      : spec_id_to_value_str_(), spec_id_to_value_bit_pattern_(std::move(default_values)) {}
+      : spec_id_to_value_str_(),
+        spec_id_to_value_bit_pattern_(default_values) {}
+  explicit SetSpecConstantDefaultValuePass(
+      SpecIdToValueBitPatternMap&& default_values)
+      : spec_id_to_value_str_(),
+        spec_id_to_value_bit_pattern_(std::move(default_values)) {}
 
   const char* name() const override { return "set-spec-const-default-value"; }
   Status Process(ir::IRContext*) override;
@@ -96,7 +101,8 @@ class SetSpecConstantDefaultValuePass : public Pass {
 
   // The mapping from spec ids to their string-form default values to be set.
   const SpecIdToValueStrMap spec_id_to_value_str_;
-  // The mapping from spec ids to their bitpattern-form default values to be set.
+  // The mapping from spec ids to their bitpattern-form default values to be
+  // set.
   const SpecIdToValueBitPatternMap spec_id_to_value_bit_pattern_;
 };
 
diff --git a/source/opt/strength_reduction_pass.cpp b/source/opt/strength_reduction_pass.cpp
index 689034ac..5c08f5e3 100644
--- a/source/opt/strength_reduction_pass.cpp
+++ b/source/opt/strength_reduction_pass.cpp
@@ -21,9 +21,9 @@
 #include <unordered_set>
 
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "log.h"
 #include "reflect.h"
-#include "ir_context.h"
 
 namespace {
 // Count the number of trailing zeros in the binary representation of
diff --git a/source/opt/strength_reduction_pass.h b/source/opt/strength_reduction_pass.h
index 8981660a..425bb321 100644
--- a/source/opt/strength_reduction_pass.h
+++ b/source/opt/strength_reduction_pass.h
@@ -16,9 +16,9 @@
 #define LIBSPIRV_OPT_STRENGTH_REDUCTION_PASS_H_
 
 #include "def_use_manager.h"
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
@@ -34,8 +34,10 @@ class StrengthReductionPass : public Pass {
   // Returns true if something changed.
   bool ReplaceMultiplyByPowerOf2(ir::BasicBlock::iterator*);
 
-  // Scan the types and constants in the module looking for the the integer types that we are
-  // interested in.  The shift operation needs a small unsigned integer.  We need to find
+  // Scan the types and constants in the module looking for the the integer
+  // types that we are
+  // interested in.  The shift operation needs a small unsigned integer.  We
+  // need to find
   // them or create them.  We do not want duplicates.
   void FindIntTypesAndConstants();
 
diff --git a/source/opt/strip_debug_info_pass.cpp b/source/opt/strip_debug_info_pass.cpp
index 6cbba42d..ae35b109 100644
--- a/source/opt/strip_debug_info_pass.cpp
+++ b/source/opt/strip_debug_info_pass.cpp
@@ -19,7 +19,8 @@ namespace spvtools {
 namespace opt {
 
 Pass::Status StripDebugInfoPass::Process(ir::IRContext* irContext) {
-  bool modified = !irContext->debugs1().empty() || !irContext->debugs2().empty() ||
+  bool modified = !irContext->debugs1().empty() ||
+                  !irContext->debugs2().empty() ||
                   !irContext->debugs3().empty();
   irContext->debug_clear();
 
diff --git a/source/opt/strip_debug_info_pass.h b/source/opt/strip_debug_info_pass.h
index 3e88c944..52cbd680 100644
--- a/source/opt/strip_debug_info_pass.h
+++ b/source/opt/strip_debug_info_pass.h
@@ -15,9 +15,9 @@
 #ifndef LIBSPIRV_OPT_STRIP_DEBUG_INFO_PASS_H_
 #define LIBSPIRV_OPT_STRIP_DEBUG_INFO_PASS_H_
 
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/types.cpp b/source/opt/types.cpp
index 1d8cad24..39bc9074 100644
--- a/source/opt/types.cpp
+++ b/source/opt/types.cpp
@@ -42,10 +42,10 @@ bool CompareTwoVectors(const U32VecVec a, const U32VecVec b) {
     b_ptrs.push_back(&b[i]);
   }
 
-  const auto cmp =
-      [](const std::vector<uint32_t>* m, const std::vector<uint32_t>* n) {
-        return m->front() < n->front();
-      };
+  const auto cmp = [](const std::vector<uint32_t>* m,
+                      const std::vector<uint32_t>* n) {
+    return m->front() < n->front();
+  };
 
   std::sort(a_ptrs.begin(), a_ptrs.end(), cmp);
   std::sort(b_ptrs.begin(), b_ptrs.end(), cmp);
diff --git a/source/opt/unify_const_pass.cpp b/source/opt/unify_const_pass.cpp
index 56ed894a..088e1022 100644
--- a/source/opt/unify_const_pass.cpp
+++ b/source/opt/unify_const_pass.cpp
@@ -18,8 +18,8 @@
 #include <utility>
 
 #include "def_use_manager.h"
-#include "make_unique.h"
 #include "ir_context.h"
+#include "make_unique.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/opt/unify_const_pass.h b/source/opt/unify_const_pass.h
index 913ed49f..64838176 100644
--- a/source/opt/unify_const_pass.h
+++ b/source/opt/unify_const_pass.h
@@ -15,9 +15,9 @@
 #ifndef LIBSPIRV_OPT_UNIFY_CONSTANT_PASS_H_
 #define LIBSPIRV_OPT_UNIFY_CONSTANT_PASS_H_
 
+#include "ir_context.h"
 #include "module.h"
 #include "pass.h"
-#include "ir_context.h"
 
 namespace spvtools {
 namespace opt {
diff --git a/source/print.cpp b/source/print.cpp
index fc07b945..5336df63 100644
--- a/source/print.cpp
+++ b/source/print.cpp
@@ -14,7 +14,8 @@
 
 #include "print.h"
 
-#if defined(SPIRV_ANDROID) || defined(SPIRV_LINUX) || defined(SPIRV_MAC) || defined(SPIRV_FREEBSD)
+#if defined(SPIRV_ANDROID) || defined(SPIRV_LINUX) || defined(SPIRV_MAC) || \
+    defined(SPIRV_FREEBSD)
 namespace libspirv {
 
 clr::reset::operator const char*() { return "\x1b[0m"; }
@@ -35,8 +36,7 @@ clr::blue::operator const char*() { return "\x1b[34m"; }
 
 namespace libspirv {
 
-static void SetConsoleForegroundColorPrimary(HANDLE hConsole, WORD color)
-{
+static void SetConsoleForegroundColorPrimary(HANDLE hConsole, WORD color) {
   // Get screen buffer information from console handle
   CONSOLE_SCREEN_BUFFER_INFO bufInfo;
   GetConsoleScreenBufferInfo(hConsole, &bufInfo);
@@ -48,8 +48,7 @@ static void SetConsoleForegroundColorPrimary(HANDLE hConsole, WORD color)
   SetConsoleTextAttribute(hConsole, color);
 }
 
-static void SetConsoleForegroundColor(WORD color)
-{
+static void SetConsoleForegroundColor(WORD color) {
   SetConsoleForegroundColorPrimary(GetStdHandle(STD_OUTPUT_HANDLE), color);
   SetConsoleForegroundColorPrimary(GetStdHandle(STD_ERROR_HANDLE), color);
 }
diff --git a/source/software_version.cpp b/source/software_version.cpp
index 04cf3dfb..f19f67e2 100644
--- a/source/software_version.cpp
+++ b/source/software_version.cpp
@@ -22,10 +22,6 @@ const char* kBuildVersions[] = {
 
 }  // anonymous namespace
 
-const char* spvSoftwareVersionString() {
-  return kBuildVersions[0];
-}
+const char* spvSoftwareVersionString() { return kBuildVersions[0]; }
 
-const char* spvSoftwareVersionDetailsString() {
-  return kBuildVersions[1];
-}
+const char* spvSoftwareVersionDetailsString() { return kBuildVersions[1]; }
diff --git a/source/spirv_stats.cpp b/source/spirv_stats.cpp
index 34cab6d5..ff4b3c67 100644
--- a/source/spirv_stats.cpp
+++ b/source/spirv_stats.cpp
@@ -25,16 +25,16 @@
 #include "diagnostic.h"
 #include "enum_string_mapping.h"
 #include "extensions.h"
-#include "instruction.h"
 #include "id_descriptor.h"
+#include "instruction.h"
 #include "opcode.h"
 #include "operand.h"
 #include "spirv-tools/libspirv.h"
 #include "spirv_endian.h"
 #include "spirv_validator_options.h"
-#include "validate.h"
 #include "val/instruction.h"
 #include "val/validation_state.h"
+#include "validate.h"
 
 using libspirv::IdDescriptorCollection;
 using libspirv::Instruction;
@@ -54,10 +54,10 @@ class StatsAggregator {
   }
 
   // Collects header statistics and sets correct id_bound.
-  spv_result_t ProcessHeader(
-      spv_endianness_t /* endian */, uint32_t /* magic */,
-      uint32_t version, uint32_t generator, uint32_t id_bound,
-      uint32_t /* schema */) {
+  spv_result_t ProcessHeader(spv_endianness_t /* endian */,
+                             uint32_t /* magic */, uint32_t version,
+                             uint32_t generator, uint32_t id_bound,
+                             uint32_t /* schema */) {
     vstate_->setIdBound(id_bound);
     ++stats_->version_hist[version];
     ++stats_->generator_hist[generator];
@@ -68,9 +68,9 @@ class StatsAggregator {
   // then procession the instruction to collect stats.
   spv_result_t ProcessInstruction(const spv_parsed_instruction_t* inst) {
     const spv_result_t validation_result =
-        spvtools::ValidateInstructionAndUpdateValidationState(vstate_.get(), inst);
-    if (validation_result != SPV_SUCCESS)
-      return validation_result;
+        spvtools::ValidateInstructionAndUpdateValidationState(vstate_.get(),
+                                                              inst);
+    if (validation_result != SPV_SUCCESS) return validation_result;
 
     ProcessOpcode();
     ProcessCapability();
@@ -106,8 +106,9 @@ class StatsAggregator {
             id_descriptors_.GetDescriptor(inst.word(operand.offset));
         if (descriptor) {
           ++stats_->id_descriptor_hist[descriptor];
-          ++stats_->operand_slot_id_descriptor_hist[
-              std::pair<uint32_t, uint32_t>(inst.opcode(), index)][descriptor];
+          ++stats_
+                ->operand_slot_id_descriptor_hist[std::pair<uint32_t, uint32_t>(
+                    inst.opcode(), index)][descriptor];
         }
       }
       ++index;
@@ -168,8 +169,8 @@ class StatsAggregator {
     uint32_t index = 0;
     for (const auto& operand : inst.operands()) {
       if (operand.num_words == 1 && !spvIsIdType(operand.type)) {
-          ++stats_->operand_slot_non_id_words_hist[std::pair<uint32_t, uint32_t>(
-              inst.opcode(), index)][inst.word(operand.offset)];
+        ++stats_->operand_slot_non_id_words_hist[std::pair<uint32_t, uint32_t>(
+            inst.opcode(), index)][inst.word(operand.offset)];
       }
       ++index;
     }
@@ -205,13 +206,14 @@ class StatsAggregator {
 
     if (inst_it != vstate_->ordered_instructions().rend()) {
       const SpvOp prev_opcode = inst_it->opcode();
-      ++stats_->opcode_and_num_operands_markov_hist[prev_opcode][
-          opcode_and_num_operands];
+      ++stats_->opcode_and_num_operands_markov_hist[prev_opcode]
+                                                   [opcode_and_num_operands];
     }
 
     auto step_it = stats_->opcode_markov_hist.begin();
     for (; inst_it != vstate_->ordered_instructions().rend() &&
-         step_it != stats_->opcode_markov_hist.end(); ++inst_it, ++step_it) {
+           step_it != stats_->opcode_markov_hist.end();
+         ++inst_it, ++step_it) {
       auto& hist = (*step_it)[inst_it->opcode()];
       ++hist[opcode];
     }
@@ -260,9 +262,7 @@ class StatsAggregator {
     }
   }
 
-  SpirvStats* stats() {
-    return stats_;
-  }
+  SpirvStats* stats() { return stats_; }
 
  private:
   // Returns the current instruction (the one last processed by the validator).
@@ -276,18 +276,17 @@ class StatsAggregator {
   IdDescriptorCollection id_descriptors_;
 };
 
-spv_result_t ProcessHeader(
-    void* user_data, spv_endianness_t endian, uint32_t magic,
-    uint32_t version, uint32_t generator, uint32_t id_bound,
-    uint32_t schema) {
+spv_result_t ProcessHeader(void* user_data, spv_endianness_t endian,
+                           uint32_t magic, uint32_t version, uint32_t generator,
+                           uint32_t id_bound, uint32_t schema) {
   StatsAggregator* stats_aggregator =
       reinterpret_cast<StatsAggregator*>(user_data);
-  return stats_aggregator->ProcessHeader(
-      endian, magic, version, generator, id_bound, schema);
+  return stats_aggregator->ProcessHeader(endian, magic, version, generator,
+                                         id_bound, schema);
 }
 
-spv_result_t ProcessInstruction(
-    void* user_data, const spv_parsed_instruction_t* inst) {
+spv_result_t ProcessInstruction(void* user_data,
+                                const spv_parsed_instruction_t* inst) {
   StatsAggregator* stats_aggregator =
       reinterpret_cast<StatsAggregator*>(user_data);
   return stats_aggregator->ProcessInstruction(inst);
@@ -297,9 +296,9 @@ spv_result_t ProcessInstruction(
 
 namespace libspirv {
 
-spv_result_t AggregateStats(
-    const spv_context_t& context, const uint32_t* words, const size_t num_words,
-    spv_diagnostic* pDiagnostic, SpirvStats* stats) {
+spv_result_t AggregateStats(const spv_context_t& context, const uint32_t* words,
+                            const size_t num_words, spv_diagnostic* pDiagnostic,
+                            SpirvStats* stats) {
   spv_const_binary_t binary = {words, num_words};
 
   spv_endianness_t endian;
@@ -307,14 +306,14 @@ spv_result_t AggregateStats(
   if (spvBinaryEndianness(&binary, &endian)) {
     return libspirv::DiagnosticStream(position, context.consumer,
                                       SPV_ERROR_INVALID_BINARY)
-        << "Invalid SPIR-V magic number.";
+           << "Invalid SPIR-V magic number.";
   }
 
   spv_header_t header;
   if (spvBinaryHeaderGet(&binary, endian, &header)) {
     return libspirv::DiagnosticStream(position, context.consumer,
                                       SPV_ERROR_INVALID_BINARY)
-        << "Invalid SPIR-V header.";
+           << "Invalid SPIR-V header.";
   }
 
   StatsAggregator stats_aggregator(stats, &context);
diff --git a/source/spirv_stats.h b/source/spirv_stats.h
index 541dd036..cc6c2391 100644
--- a/source/spirv_stats.h
+++ b/source/spirv_stats.h
@@ -69,15 +69,15 @@ struct SpirvStats {
   std::unordered_map<double, uint32_t> f64_constant_hist;
 
   // Enum histogram, operand type -> operand value -> count.
-  std::unordered_map<uint32_t,
-      std::unordered_map<uint32_t, uint32_t>> enum_hist;
+  std::unordered_map<uint32_t, std::unordered_map<uint32_t, uint32_t>>
+      enum_hist;
 
   // Histogram of all non-id single words.
   // pair<opcode, operand index> -> value -> count.
   // This is a generalization of enum_hist, also includes literal integers and
   // masks.
-  std::map<std::pair<uint32_t, uint32_t>,
-      std::map<uint32_t, uint32_t>> operand_slot_non_id_words_hist;
+  std::map<std::pair<uint32_t, uint32_t>, std::map<uint32_t, uint32_t>>
+      operand_slot_non_id_words_hist;
 
   // Historgam of descriptors generated by IdDescriptorCollection.
   // Descriptor -> count.
@@ -88,10 +88,11 @@ struct SpirvStats {
 
   // Historgam of descriptors generated by IdDescriptorCollection for every
   // operand slot. pair<opcode, operand index> -> descriptor -> count.
-  std::map<std::pair<uint32_t, uint32_t>,
-      std::map<uint32_t, uint32_t>> operand_slot_id_descriptor_hist;
+  std::map<std::pair<uint32_t, uint32_t>, std::map<uint32_t, uint32_t>>
+      operand_slot_id_descriptor_hist;
 
-  // Histogram of literal strings, sharded by opcodes, opcode -> string -> count.
+  // Histogram of literal strings, sharded by opcodes, opcode -> string ->
+  // count.
   // This is suboptimal if an opcode has multiple literal string operands,
   // as it wouldn't differentiate between operands.
   std::unordered_map<uint32_t, std::unordered_map<std::string, uint32_t>>
@@ -114,14 +115,15 @@ struct SpirvStats {
   // The size of the outer std::vector also serves as an input parameter,
   // determining how many steps will be collected.
   // I.e. do opcode_markov_hist.resize(1) to collect data for one step only.
-  std::vector<std::unordered_map<uint32_t,
-      std::unordered_map<uint32_t, uint32_t>>> opcode_markov_hist;
+  std::vector<
+      std::unordered_map<uint32_t, std::unordered_map<uint32_t, uint32_t>>>
+      opcode_markov_hist;
 };
 
 // Aggregates existing |stats| with new stats extracted from |binary|.
-spv_result_t AggregateStats(
-    const spv_context_t& context, const uint32_t* words, const size_t num_words,
-    spv_diagnostic* pDiagnostic, SpirvStats* stats);
+spv_result_t AggregateStats(const spv_context_t& context, const uint32_t* words,
+                            const size_t num_words, spv_diagnostic* pDiagnostic,
+                            SpirvStats* stats);
 
 }  // namespace libspirv
 
diff --git a/source/spirv_validator_options.h b/source/spirv_validator_options.h
index b3cc17fb..4a67812a 100644
--- a/source/spirv_validator_options.h
+++ b/source/spirv_validator_options.h
@@ -37,12 +37,10 @@ struct validator_universal_limits_t {
 // Manages command line options passed to the SPIR-V Validator. New struct
 // members may be added for any new option.
 struct spv_validator_options_t {
-  spv_validator_options_t()
-      : universal_limits_(), relax_struct_store(false) {}
+  spv_validator_options_t() : universal_limits_(), relax_struct_store(false) {}
 
   validator_universal_limits_t universal_limits_;
   bool relax_struct_store;
 };
 
 #endif  // LIBSPIRV_SPIRV_VALIDATOR_OPTIONS_H_
-
diff --git a/source/text.cpp b/source/text.cpp
index 8c48814b..78a3e587 100644
--- a/source/text.cpp
+++ b/source/text.cpp
@@ -241,8 +241,8 @@ spv_result_t spvTextEncodeOperand(const libspirv::AssemblyGrammar& grammar,
       // 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 << "'.";
+        return context->diagnostic()
+               << "Invalid extended instruction name '" << textValue << "'.";
       }
       spvInstructionAddWord(pInst, extInst->ext_inst);
 
@@ -522,8 +522,8 @@ spv_result_t spvTextEncodeOpcode(const libspirv::AssemblyGrammar& grammar,
     error = context->getWord(&opcodeName, &nextPosition);
     if (error) return context->diagnostic(error) << "Internal Error";
     if (!context->startsWithOp()) {
-      return context->diagnostic() << "Invalid Opcode prefix '" << opcodeName
-                                   << "'.";
+      return context->diagnostic()
+             << "Invalid Opcode prefix '" << opcodeName << "'.";
     }
   }
 
@@ -533,8 +533,8 @@ spv_result_t spvTextEncodeOpcode(const libspirv::AssemblyGrammar& grammar,
   spv_opcode_desc opcodeEntry;
   error = grammar.lookupOpcode(pInstName, &opcodeEntry);
   if (error) {
-    return context->diagnostic(error) << "Invalid Opcode name '" << opcodeName
-                                      << "'";
+    return context->diagnostic(error)
+           << "Invalid Opcode name '" << opcodeName << "'";
   }
   if (opcodeEntry->hasResult && result_id.empty()) {
     return context->diagnostic()
@@ -556,7 +556,8 @@ spv_result_t spvTextEncodeOpcode(const libspirv::AssemblyGrammar& grammar,
   spv_operand_pattern_t expectedOperands;
   expectedOperands.reserve(opcodeEntry->numTypes);
   for (auto i = 0; i < opcodeEntry->numTypes; i++)
-      expectedOperands.push_back(opcodeEntry->operandTypes[opcodeEntry->numTypes - i - 1]);
+    expectedOperands.push_back(
+        opcodeEntry->operandTypes[opcodeEntry->numTypes - i - 1]);
 
   while (!expectedOperands.empty()) {
     const spv_operand_type_t type = expectedOperands.back();
@@ -694,10 +695,11 @@ spv_result_t GetNumericIds(const libspirv::AssemblyGrammar& grammar,
 // Translates a given assembly language module into binary form.
 // If a diagnostic is generated, it is not yet marked as being
 // for a text-based input.
-spv_result_t spvTextToBinaryInternal(
-    const libspirv::AssemblyGrammar& grammar,
-    const spvtools::MessageConsumer& consumer, const spv_text text,
-    const uint32_t options, spv_binary* pBinary) {
+spv_result_t spvTextToBinaryInternal(const libspirv::AssemblyGrammar& grammar,
+                                     const spvtools::MessageConsumer& consumer,
+                                     const spv_text text,
+                                     const uint32_t options,
+                                     spv_binary* pBinary) {
   // The ids in this set will have the same values both in source and binary.
   // All other ids will be generated by filling in the gaps.
   std::set<uint32_t> ids_to_preserve;
@@ -770,15 +772,17 @@ spv_result_t spvTextToBinary(const spv_const_context context,
                              const char* input_text,
                              const size_t input_text_size, spv_binary* pBinary,
                              spv_diagnostic* pDiagnostic) {
-  return spvTextToBinaryWithOptions(
-      context, input_text, input_text_size, SPV_BINARY_TO_TEXT_OPTION_NONE,
-      pBinary, pDiagnostic);
+  return spvTextToBinaryWithOptions(context, input_text, input_text_size,
+                                    SPV_BINARY_TO_TEXT_OPTION_NONE, pBinary,
+                                    pDiagnostic);
 }
 
-spv_result_t spvTextToBinaryWithOptions(
-    const spv_const_context context, const char* input_text,
-    const size_t input_text_size, const uint32_t options, spv_binary* pBinary,
-    spv_diagnostic* pDiagnostic) {
+spv_result_t spvTextToBinaryWithOptions(const spv_const_context context,
+                                        const char* input_text,
+                                        const size_t input_text_size,
+                                        const uint32_t options,
+                                        spv_binary* pBinary,
+                                        spv_diagnostic* pDiagnostic) {
   spv_context_t hijack_context = *context;
   if (pDiagnostic) {
     *pDiagnostic = nullptr;
diff --git a/source/text_handler.cpp b/source/text_handler.cpp
index 1806926e..1a1b48d0 100644
--- a/source/text_handler.cpp
+++ b/source/text_handler.cpp
@@ -389,8 +389,7 @@ std::set<uint32_t> AssemblyContext::GetNumericIds() const {
   std::set<uint32_t> ids;
   for (const auto& kv : named_ids_) {
     uint32_t id;
-    if (spvutils::ParseNumber(kv.first.c_str(), &id))
-      ids.insert(id);
+    if (spvutils::ParseNumber(kv.first.c_str(), &id)) ids.insert(id);
   }
   return ids;
 }
diff --git a/source/text_handler.h b/source/text_handler.h
index 1e17948d..40bfe6c0 100644
--- a/source/text_handler.h
+++ b/source/text_handler.h
@@ -119,8 +119,12 @@ class AssemblyContext {
  public:
   AssemblyContext(spv_text text, const spvtools::MessageConsumer& consumer,
                   std::set<uint32_t>&& ids_to_preserve = std::set<uint32_t>())
-      : current_position_({}), consumer_(consumer), text_(text), bound_(1),
-        next_id_(1), ids_to_preserve_(std::move(ids_to_preserve))  {}
+      : current_position_({}),
+        consumer_(consumer),
+        text_(text),
+        bound_(1),
+        next_id_(1),
+        ids_to_preserve_(std::move(ids_to_preserve)) {}
 
   // Assigns a new integer value to the given text ID, or returns the previously
   // assigned integer value if the ID has been seen before.
diff --git a/source/util/bit_stream.cpp b/source/util/bit_stream.cpp
index d66f13dc..77e2bc17 100644
--- a/source/util/bit_stream.cpp
+++ b/source/util/bit_stream.cpp
@@ -121,15 +121,13 @@ bool ReadVariableWidthInternal(BitReaderInterface* reader, uint64_t* val,
 
   while (payload_read + chunk_length < max_payload) {
     uint64_t bits = 0;
-    if (reader->ReadBits(&bits, chunk_length) != chunk_length)
-      return false;
+    if (reader->ReadBits(&bits, chunk_length) != chunk_length) return false;
 
     *val |= bits << payload_read;
     payload_read += chunk_length;
 
     uint64_t more_to_come = 0;
-    if (reader->ReadBits(&more_to_come, 1) != 1)
-      return false;
+    if (reader->ReadBits(&more_to_come, 1) != 1) return false;
 
     if (!more_to_come) {
       return true;
@@ -139,8 +137,7 @@ bool ReadVariableWidthInternal(BitReaderInterface* reader, uint64_t* val,
   // Need to read the last chunk which may be truncated. No signal bit follows.
   uint64_t bits = 0;
   const size_t left_to_read = max_payload - payload_read;
-  if (reader->ReadBits(&bits, left_to_read) != left_to_read)
-    return false;
+  if (reader->ReadBits(&bits, left_to_read) != left_to_read) return false;
 
   *val |= bits << payload_read;
   return true;
@@ -255,26 +252,22 @@ void BitWriterInterface::WriteVariableWidthU8(uint8_t val,
   WriteVariableWidthUnsigned(this, val, chunk_length);
 }
 
-void BitWriterInterface::WriteVariableWidthS64(int64_t val,
-                                               size_t chunk_length,
+void BitWriterInterface::WriteVariableWidthS64(int64_t val, size_t chunk_length,
                                                size_t zigzag_exponent) {
   WriteVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
 
-void BitWriterInterface::WriteVariableWidthS32(int32_t val,
-                                               size_t chunk_length,
+void BitWriterInterface::WriteVariableWidthS32(int32_t val, size_t chunk_length,
                                                size_t zigzag_exponent) {
   WriteVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
 
-void BitWriterInterface::WriteVariableWidthS16(int16_t val,
-                                               size_t chunk_length,
+void BitWriterInterface::WriteVariableWidthS16(int16_t val, size_t chunk_length,
                                                size_t zigzag_exponent) {
   WriteVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
 
-void BitWriterInterface::WriteVariableWidthS8(int8_t val,
-                                              size_t chunk_length,
+void BitWriterInterface::WriteVariableWidthS8(int8_t val, size_t chunk_length,
                                               size_t zigzag_exponent) {
   WriteVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
@@ -352,26 +345,22 @@ bool BitReaderInterface::ReadVariableWidthU8(uint8_t* val,
   return ReadVariableWidthUnsigned(this, val, chunk_length);
 }
 
-bool BitReaderInterface::ReadVariableWidthS64(int64_t* val,
-                                              size_t chunk_length,
+bool BitReaderInterface::ReadVariableWidthS64(int64_t* val, size_t chunk_length,
                                               size_t zigzag_exponent) {
   return ReadVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
 
-bool BitReaderInterface::ReadVariableWidthS32(int32_t* val,
-                                              size_t chunk_length,
+bool BitReaderInterface::ReadVariableWidthS32(int32_t* val, size_t chunk_length,
                                               size_t zigzag_exponent) {
   return ReadVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
 
-bool BitReaderInterface::ReadVariableWidthS16(int16_t* val,
-                                              size_t chunk_length,
+bool BitReaderInterface::ReadVariableWidthS16(int16_t* val, size_t chunk_length,
                                               size_t zigzag_exponent) {
   return ReadVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
 
-bool BitReaderInterface::ReadVariableWidthS8(int8_t* val,
-                                             size_t chunk_length,
+bool BitReaderInterface::ReadVariableWidthS8(int8_t* val, size_t chunk_length,
                                              size_t zigzag_exponent) {
   return ReadVariableWidthSigned(this, val, chunk_length, zigzag_exponent);
 }
@@ -396,8 +385,7 @@ size_t BitReaderWord64::ReadBits(uint64_t* bits, size_t num_bits) {
   assert(is_little_endian && "Big-endian architecture support not implemented");
   if (!is_little_endian) return 0;
 
-  if (ReachedEnd())
-    return 0;
+  if (ReachedEnd()) return 0;
 
   // Index of the current word.
   const size_t index = pos_ / 64;
@@ -431,17 +419,13 @@ size_t BitReaderWord64::ReadBits(uint64_t* bits, size_t num_bits) {
   return num_bits;
 }
 
-bool BitReaderWord64::ReachedEnd() const {
-  return pos_ >= buffer_.size() * 64;
-}
+bool BitReaderWord64::ReachedEnd() const { return pos_ >= buffer_.size() * 64; }
 
 bool BitReaderWord64::OnlyZeroesLeft() const {
-  if (ReachedEnd())
-    return true;
+  if (ReachedEnd()) return true;
 
   const size_t index = pos_ / 64;
-  if (index < buffer_.size() - 1)
-    return false;
+  if (index < buffer_.size() - 1) return false;
 
   assert(index == buffer_.size() - 1);
 
diff --git a/source/util/bit_stream.h b/source/util/bit_stream.h
index f98b74bf..247ae354 100644
--- a/source/util/bit_stream.h
+++ b/source/util/bit_stream.h
@@ -21,8 +21,8 @@
 #include <bitset>
 #include <cstdint>
 #include <functional>
-#include <string>
 #include <sstream>
+#include <string>
 #include <vector>
 
 namespace spvutils {
@@ -60,9 +60,7 @@ inline T GetLowerBits(T in, size_t num_bits) {
 //  2 -> 4
 // Motivation: -1 is 0xFF...FF what doesn't work very well with
 // WriteVariableWidth which prefers to have as many 0 bits as possible.
-inline uint64_t EncodeZigZag(int64_t val) {
-  return (val << 1) ^ (val >> 63);
-}
+inline uint64_t EncodeZigZag(int64_t val) { return (val << 1) ^ (val >> 63); }
 
 // Decodes signed integer encoded with EncodeZigZag.
 inline int64_t DecodeZigZag(uint64_t val) {
@@ -92,7 +90,8 @@ inline int64_t DecodeZigZag(uint64_t val) {
 inline uint64_t EncodeZigZag(int64_t val, size_t block_exponent) {
   assert(block_exponent < 64);
   const uint64_t uval = static_cast<uint64_t>(val >= 0 ? val : -val - 1);
-  const uint64_t block_num = ((uval >> block_exponent) << 1) + (val >= 0 ? 0 : 1);
+  const uint64_t block_num =
+      ((uval >> block_exponent) << 1) + (val >= 0 ? 0 : 1);
   const uint64_t pos = GetLowerBits(uval, block_exponent);
   return (block_num << block_exponent) + pos;
 }
@@ -139,13 +138,13 @@ std::vector<T> StreamToBuffer(std::string str) {
   std::vector<T> buffer;
   buffer.reserve(NumBitsToNumWords<sizeof(T)>(str.length()));
   for (int index = str_length - word_size; index >= 0; index -= word_size) {
-    buffer.push_back(static_cast<T>(std::bitset<sizeof(T) * 8>(
-        str, index, word_size).to_ullong()));
+    buffer.push_back(static_cast<T>(
+        std::bitset<sizeof(T) * 8>(str, index, word_size).to_ullong()));
   }
   const size_t suffix_length = str.length() % word_size;
   if (suffix_length != 0) {
-    buffer.push_back(static_cast<T>(std::bitset<sizeof(T) * 8>(
-        str, 0, suffix_length).to_ullong()));
+    buffer.push_back(static_cast<T>(
+        std::bitset<sizeof(T) * 8>(str, 0, suffix_length).to_ullong()));
   }
   return buffer;
 }
@@ -154,8 +153,7 @@ std::vector<T> StreamToBuffer(std::string str) {
 template <size_t N>
 inline std::string PadToWord(std::string&& str) {
   const size_t tail_length = str.size() % N;
-  if (tail_length != 0)
-    str += std::string(N - tail_length, '0');
+  if (tail_length != 0) str += std::string(N - tail_length, '0');
   return str;
 }
 
@@ -174,7 +172,8 @@ inline std::bitset<N> StreamToBitset(std::string str) {
 
 // Converts first |num_bits| of std::bitset to a left-to-right stream of bits.
 template <size_t N>
-inline std::string BitsetToStream(const std::bitset<N>& bits, size_t num_bits = N) {
+inline std::string BitsetToStream(const std::bitset<N>& bits,
+                                  size_t num_bits = N) {
   std::string str = bits.to_string().substr(N - num_bits);
   std::reverse(str.begin(), str.end());
   return str;
@@ -237,14 +236,14 @@ class BitWriterInterface {
   void WriteVariableWidthU32(uint32_t val, size_t chunk_length);
   void WriteVariableWidthU16(uint16_t val, size_t chunk_length);
   void WriteVariableWidthU8(uint8_t val, size_t chunk_length);
-  void WriteVariableWidthS64(
-      int64_t val, size_t chunk_length, size_t zigzag_exponent);
-  void WriteVariableWidthS32(
-      int32_t val, size_t chunk_length, size_t zigzag_exponent);
-  void WriteVariableWidthS16(
-      int16_t val, size_t chunk_length, size_t zigzag_exponent);
-  void WriteVariableWidthS8(
-      int8_t val, size_t chunk_length, size_t zigzag_exponent);
+  void WriteVariableWidthS64(int64_t val, size_t chunk_length,
+                             size_t zigzag_exponent);
+  void WriteVariableWidthS32(int32_t val, size_t chunk_length,
+                             size_t zigzag_exponent);
+  void WriteVariableWidthS16(int16_t val, size_t chunk_length,
+                             size_t zigzag_exponent);
+  void WriteVariableWidthS8(int8_t val, size_t chunk_length,
+                            size_t zigzag_exponent);
 
   // Writes |val| using fixed bit width. Bit width is determined by |max_val|:
   // max_val 0 -> bit width 1
@@ -262,14 +261,10 @@ class BitWriterInterface {
   virtual size_t GetNumBits() const = 0;
 
   // Provides direct access to the buffer data if implemented.
-  virtual const uint8_t* GetData() const {
-    return nullptr;
-  }
+  virtual const uint8_t* GetData() const { return nullptr; }
 
   // Returns buffer size in bytes.
-  size_t GetDataSizeBytes() const {
-    return NumBitsToNumWords<8>(GetNumBits());
-  }
+  size_t GetDataSizeBytes() const { return NumBitsToNumWords<8>(GetNumBits()); }
 
   // Generates and returns byte array containing written bits.
   virtual std::vector<uint8_t> GetDataCopy() const = 0;
@@ -286,9 +281,7 @@ class BitWriterWord64 : public BitWriterInterface {
 
   void WriteBits(uint64_t bits, size_t num_bits) override;
 
-  size_t GetNumBits() const override {
-    return end_;
-  }
+  size_t GetNumBits() const override { return end_; }
 
   const uint8_t* GetData() const override {
     return reinterpret_cast<const uint8_t*>(buffer_.data());
@@ -300,9 +293,7 @@ class BitWriterWord64 : public BitWriterInterface {
 
   // Returns written stream as std::string, padded with zeroes so that the
   // length is a multiple of 64.
-  std::string GetStreamPadded64() const {
-    return BufferToStream(buffer_);
-  }
+  std::string GetStreamPadded64() const { return BufferToStream(buffer_); }
 
   // Sets callback to emit bit sequences after every write.
   void SetCallback(std::function<void(const std::string&)> callback) {
@@ -312,8 +303,7 @@ class BitWriterWord64 : public BitWriterInterface {
  protected:
   // Sends string generated from arguments to callback_ if defined.
   void EmitSequence(uint64_t bits, size_t num_bits) const {
-    if (callback_)
-      callback_(BitsToStream(bits, num_bits));
+    if (callback_) callback_(BitsToStream(bits, num_bits));
   }
 
  private:
@@ -363,8 +353,7 @@ class BitReaderInterface {
     static_assert(sizeof(T) <= 64, "Type size too large");
     uint64_t bits = 0;
     const size_t num_read = ReadBits(&bits, sizeof(T) * 8);
-    if (num_read != sizeof(T) * 8)
-      return false;
+    if (num_read != sizeof(T) * 8) return false;
     memcpy(val, &bits, sizeof(T));
     return true;
   }
@@ -384,9 +373,7 @@ class BitReaderInterface {
   // the buffer stream ends with padding zeroes, and would accept this as a
   // 'soft' EOF. Implementations of this class do not necessarily need to
   // implement this, default behavior can simply delegate to ReachedEnd().
-  virtual bool OnlyZeroesLeft() const {
-    return ReachedEnd();
-  }
+  virtual bool OnlyZeroesLeft() const { return ReachedEnd(); }
 
   // Reads value encoded with WriteVariableWidthXXX (see BitWriterInterface).
   // Reader and writer must use the same |chunk_length| and variable type.
@@ -395,14 +382,14 @@ class BitReaderInterface {
   bool ReadVariableWidthU32(uint32_t* val, size_t chunk_length);
   bool ReadVariableWidthU16(uint16_t* val, size_t chunk_length);
   bool ReadVariableWidthU8(uint8_t* val, size_t chunk_length);
-  bool ReadVariableWidthS64(
-      int64_t* val, size_t chunk_length, size_t zigzag_exponent);
-  bool ReadVariableWidthS32(
-      int32_t* val, size_t chunk_length, size_t zigzag_exponent);
-  bool ReadVariableWidthS16(
-      int16_t* val, size_t chunk_length, size_t zigzag_exponent);
-  bool ReadVariableWidthS8(
-      int8_t* val, size_t chunk_length, size_t zigzag_exponent);
+  bool ReadVariableWidthS64(int64_t* val, size_t chunk_length,
+                            size_t zigzag_exponent);
+  bool ReadVariableWidthS32(int32_t* val, size_t chunk_length,
+                            size_t zigzag_exponent);
+  bool ReadVariableWidthS16(int16_t* val, size_t chunk_length,
+                            size_t zigzag_exponent);
+  bool ReadVariableWidthS8(int8_t* val, size_t chunk_length,
+                           size_t zigzag_exponent);
 
   // Reads value written by WriteFixedWidth (|max_val| needs to be the same).
   // Returns true on success, false if the bit stream ends prematurely.
@@ -428,9 +415,7 @@ class BitReaderWord64 : public BitReaderInterface {
 
   size_t ReadBits(uint64_t* bits, size_t num_bits) override;
 
-  size_t GetNumReadBits() const override {
-    return pos_;
-  }
+  size_t GetNumReadBits() const override { return pos_; }
 
   bool ReachedEnd() const override;
   bool OnlyZeroesLeft() const override;
@@ -445,8 +430,7 @@ class BitReaderWord64 : public BitReaderInterface {
  protected:
   // Sends string generated from arguments to callback_ if defined.
   void EmitSequence(uint64_t bits, size_t num_bits) const {
-    if (callback_)
-      callback_(BitsToStream(bits, num_bits));
+    if (callback_) callback_(BitsToStream(bits, num_bits));
   }
 
  private:
diff --git a/source/util/huffman_codec.h b/source/util/huffman_codec.h
index 2ccc3c98..c2f7b1a9 100644
--- a/source/util/huffman_codec.h
+++ b/source/util/huffman_codec.h
@@ -20,11 +20,11 @@
 #include <algorithm>
 #include <cassert>
 #include <functional>
-#include <queue>
 #include <iomanip>
 #include <map>
 #include <memory>
 #include <ostream>
+#include <queue>
 #include <sstream>
 #include <stack>
 #include <tuple>
@@ -74,10 +74,10 @@ class HuffmanCodec {
     std::vector<uint32_t> queue_vector;
     queue_vector.reserve(hist.size());
     std::priority_queue<uint32_t, std::vector<uint32_t>,
-        std::function<bool(uint32_t, uint32_t)>>
-            queue(std::bind(&HuffmanCodec::LeftIsBigger, this,
-                            std::placeholders::_1, std::placeholders::_2),
-                  std::move(queue_vector));
+                        std::function<bool(uint32_t, uint32_t)>>
+        queue(std::bind(&HuffmanCodec::LeftIsBigger, this,
+                        std::placeholders::_1, std::placeholders::_2),
+              std::move(queue_vector));
 
     // Put all leaves in the queue.
     for (const auto& pair : hist) {
@@ -153,11 +153,9 @@ class HuffmanCodec {
 
     for (const Node& node : nodes_) {
       code << indent2 << "{";
-      if (value_is_text)
-        code << "\"";
+      if (value_is_text) code << "\"";
       code << node.value;
-      if (value_is_text)
-        code << "\"";
+      if (value_is_text) code << "\"";
       code << ", " << node.left << ", " << node.right << "},\n";
     }
 
@@ -172,9 +170,7 @@ class HuffmanCodec {
   // Where w stands for the weight of the node.
   // Right tree branches appear above left branches. Taking the right path
   // adds 1 to the code, taking the left adds 0.
-  void PrintTree(std::ostream& out) const {
-    PrintTreeInternal(out, root_, 0);
-  }
+  void PrintTree(std::ostream& out) const { PrintTreeInternal(out, root_, 0); }
 
   // Traverses the tree and prints the Huffman table: value, code
   // and optionally node weight for every leaf.
@@ -188,23 +184,20 @@ class HuffmanCodec {
       queue.pop();
       if (!RightOf(node) && !LeftOf(node)) {
         out << ValueOf(node);
-        if (print_weights)
-            out << " " << WeightOf(node);
+        if (print_weights) out << " " << WeightOf(node);
         out << " " << code << std::endl;
       } else {
-        if (LeftOf(node))
-          queue.emplace(LeftOf(node), code + "0");
+        if (LeftOf(node)) queue.emplace(LeftOf(node), code + "0");
 
-        if (RightOf(node))
-          queue.emplace(RightOf(node), code + "1");
+        if (RightOf(node)) queue.emplace(RightOf(node), code + "1");
       }
     }
   }
 
   // Returns the Huffman table. The table was built at at construction time,
   // this function just returns a const reference.
-  const std::unordered_map<Val, std::pair<uint64_t, size_t>>&
-      GetEncodingTable() const {
+  const std::unordered_map<Val, std::pair<uint64_t, size_t>>& GetEncodingTable()
+      const {
     return encoding_table_;
   }
 
@@ -212,8 +205,7 @@ class HuffmanCodec {
   // |bits|. Returns false of |val| is not in the Huffman table.
   bool Encode(const Val& val, uint64_t* bits, size_t* num_bits) const {
     auto it = encoding_table_.find(val);
-    if (it == encoding_table_.end())
-      return false;
+    if (it == encoding_table_.end()) return false;
     *bits = it->second.first;
     *num_bits = it->second.second;
     return true;
@@ -225,8 +217,8 @@ class HuffmanCodec {
   // |read_bit| has type bool func(bool* bit). When called, the next bit is
   // stored in |bit|. |read_bit| returns false if the stream terminates
   // prematurely.
-  bool DecodeFromStream(
-      const std::function<bool(bool*)>& read_bit, Val* val) const {
+  bool DecodeFromStream(const std::function<bool(bool*)>& read_bit,
+                        Val* val) const {
     uint32_t node = root_;
     while (true) {
       assert(node);
@@ -237,8 +229,7 @@ class HuffmanCodec {
       }
 
       bool go_right;
-      if (!read_bit(&go_right))
-        return false;
+      if (!read_bit(&go_right)) return false;
 
       if (go_right)
         node = RightOf(node);
@@ -246,35 +237,25 @@ class HuffmanCodec {
         node = LeftOf(node);
     }
 
-    assert (0);
+    assert(0);
     return false;
   }
 
  private:
   // Returns value of the node referenced by |handle|.
-  Val ValueOf(uint32_t node) const {
-    return nodes_.at(node).value;
-  }
+  Val ValueOf(uint32_t node) const { return nodes_.at(node).value; }
 
   // Returns left child of |node|.
-  uint32_t LeftOf(uint32_t node) const {
-    return nodes_.at(node).left;
-  }
+  uint32_t LeftOf(uint32_t node) const { return nodes_.at(node).left; }
 
   // Returns right child of |node|.
-  uint32_t RightOf(uint32_t node) const {
-    return nodes_.at(node).right;
-  }
+  uint32_t RightOf(uint32_t node) const { return nodes_.at(node).right; }
 
   // Returns weight of |node|.
-  uint32_t WeightOf(uint32_t node) const {
-    return nodes_.at(node).weight;
-  }
+  uint32_t WeightOf(uint32_t node) const { return nodes_.at(node).weight; }
 
   // Returns id of |node|.
-  uint32_t IdOf(uint32_t node) const {
-    return nodes_.at(node).id;
-  }
+  uint32_t IdOf(uint32_t node) const { return nodes_.at(node).id; }
 
   // Returns mutable reference to value of |node|.
   Val& MutableValueOf(uint32_t node) {
@@ -295,20 +276,16 @@ class HuffmanCodec {
   }
 
   // Returns mutable reference to weight of |node|.
-  uint32_t& MutableWeightOf(uint32_t node) {
-    return nodes_.at(node).weight;
-  }
+  uint32_t& MutableWeightOf(uint32_t node) { return nodes_.at(node).weight; }
 
   // Returns mutable reference to id of |node|.
-  uint32_t& MutableIdOf(uint32_t node) {
-    return nodes_.at(node).id;
-  }
+  uint32_t& MutableIdOf(uint32_t node) { return nodes_.at(node).id; }
 
   // Returns true if |left| has bigger weight than |right|. Node ids are
   // used as tie-breaker.
   bool LeftIsBigger(uint32_t left, uint32_t right) const {
     if (WeightOf(left) == WeightOf(right)) {
-      assert (IdOf(left) != IdOf(right));
+      assert(IdOf(left) != IdOf(right));
       return IdOf(left) > IdOf(right);
     }
     return WeightOf(left) > WeightOf(right);
@@ -316,8 +293,7 @@ class HuffmanCodec {
 
   // Prints subtree (helper function used by PrintTree).
   void PrintTreeInternal(std::ostream& out, uint32_t node, size_t depth) const {
-    if (!node)
-      return;
+    if (!node) return;
 
     const size_t kTextFieldWidth = 7;
 
@@ -348,7 +324,7 @@ class HuffmanCodec {
   void CreateEncodingTable() {
     struct Context {
       Context(uint32_t in_node, uint64_t in_bits, size_t in_depth)
-          :  node(in_node), bits(in_bits), depth(in_depth) {}
+          : node(in_node), bits(in_bits), depth(in_depth) {}
       uint32_t node;
       // Huffman tree depth cannot exceed 64 as histogramm counts are expected
       // to be positive and limited by numeric_limits<uint32_t>::max().
@@ -373,8 +349,7 @@ class HuffmanCodec {
         assert(insertion_result.second);
         (void)insertion_result;
       } else {
-        if (LeftOf(node))
-          queue.emplace(LeftOf(node), bits, depth + 1);
+        if (LeftOf(node)) queue.emplace(LeftOf(node), bits, depth + 1);
 
         if (RightOf(node))
           queue.emplace(RightOf(node), bits | (1ULL << depth), depth + 1);
diff --git a/source/util/ilist.h b/source/util/ilist.h
index 6be01fd3..ebd5def4 100644
--- a/source/util/ilist.h
+++ b/source/util/ilist.h
@@ -272,7 +272,7 @@ bool IntrusiveList<NodeType>::empty() const {
   return sentinel_.NextNode() == nullptr;
 }
 
-template<class NodeType>
+template <class NodeType>
 void IntrusiveList<NodeType>::clear() {
   while (!empty()) {
     front().RemoveFromList();
diff --git a/source/util/ilist_node.h b/source/util/ilist_node.h
index 342fb1dc..76ea302d 100644
--- a/source/util/ilist_node.h
+++ b/source/util/ilist_node.h
@@ -110,7 +110,7 @@ template <class NodeType>
 inline IntrusiveNodeBase<NodeType>::IntrusiveNodeBase()
     : next_node_(nullptr), previous_node_(nullptr), is_sentinel_(false) {}
 
-template<class NodeType>
+template <class NodeType>
 inline IntrusiveNodeBase<NodeType>::IntrusiveNodeBase(
     const IntrusiveNodeBase&) {
   next_node_ = nullptr;
@@ -118,7 +118,7 @@ inline IntrusiveNodeBase<NodeType>::IntrusiveNodeBase(
   is_sentinel_ = false;
 }
 
-template<class NodeType>
+template <class NodeType>
 inline IntrusiveNodeBase<NodeType>& IntrusiveNodeBase<NodeType>::operator=(
     const IntrusiveNodeBase&) {
   assert(!is_sentinel_);
@@ -128,7 +128,7 @@ inline IntrusiveNodeBase<NodeType>& IntrusiveNodeBase<NodeType>::operator=(
   return *this;
 }
 
-template<class NodeType>
+template <class NodeType>
 inline IntrusiveNodeBase<NodeType>::IntrusiveNodeBase(IntrusiveNodeBase&& that)
     : next_node_(nullptr),
       previous_node_(nullptr),
@@ -140,19 +140,19 @@ inline IntrusiveNodeBase<NodeType>::IntrusiveNodeBase(IntrusiveNodeBase&& that)
   that.ReplaceWith(this);
 }
 
-template<class NodeType>
+template <class NodeType>
 IntrusiveNodeBase<NodeType>::~IntrusiveNodeBase() {
   assert(is_sentinel_ || !IsInAList());
 }
 
-template<class NodeType>
+template <class NodeType>
 IntrusiveNodeBase<NodeType>& IntrusiveNodeBase<NodeType>::operator=(
     IntrusiveNodeBase&& that) {
   that.ReplaceWith(this);
   return *this;
 }
 
-template<class NodeType>
+template <class NodeType>
 inline bool IntrusiveNodeBase<NodeType>::IsInAList() const {
   return next_node_ != nullptr;
 }
@@ -199,7 +199,7 @@ template <class NodeType>
 inline void IntrusiveNodeBase<NodeType>::RemoveFromList() {
   assert(!this->is_sentinel_ && "Sentinel nodes cannot be moved around.");
   assert(this->IsInAList() &&
-      "Cannot remove a node from a list if it is not in a list.");
+         "Cannot remove a node from a list if it is not in a list.");
 
   this->next_node_->previous_node_ = this->previous_node_;
   this->previous_node_->next_node_ = this->next_node_;
@@ -207,16 +207,16 @@ inline void IntrusiveNodeBase<NodeType>::RemoveFromList() {
   this->previous_node_ = nullptr;
 }
 
-template<class NodeType>
+template <class NodeType>
 void IntrusiveNodeBase<NodeType>::ReplaceWith(NodeType* target) {
   if (this->is_sentinel_) {
     assert(target->IsEmptyList() &&
-        "If target is not an empty list, the nodes in that list would not "
-            "be linked to a sentinel.");
+           "If target is not an empty list, the nodes in that list would not "
+           "be linked to a sentinel.");
   } else {
     assert(IsInAList() && "The node being replaced must be in a list.");
     assert(!target->is_sentinel_ &&
-        "Cannot turn a sentinel node into one that is not.");
+           "Cannot turn a sentinel node into one that is not.");
   }
 
   if (!this->IsEmptyList()) {
@@ -245,13 +245,13 @@ void IntrusiveNodeBase<NodeType>::ReplaceWith(NodeType* target) {
   }
 }
 
-template<class NodeType>
+template <class NodeType>
 bool IntrusiveNodeBase<NodeType>::IsEmptyList() {
   if (next_node_ == this) {
     assert(is_sentinel_ &&
-               "None sentinel nodes should never point to themselves.");
+           "None sentinel nodes should never point to themselves.");
     assert(previous_node_ == this &&
-        "Inconsistency with the previous and next nodes.");
+           "Inconsistency with the previous and next nodes.");
     return true;
   }
   return false;
diff --git a/source/util/move_to_front.h b/source/util/move_to_front.h
index 3c5ce6a3..0cfd7c18 100644
--- a/source/util/move_to_front.h
+++ b/source/util/move_to_front.h
@@ -94,16 +94,16 @@ class MoveToFront {
   bool HasValue(const Val& value) const;
 
   // Returns the number of elements in the move-to-front sequence.
-  uint32_t GetSize() const {
-    return SizeOf(root_);
-  }
+  uint32_t GetSize() const { return SizeOf(root_); }
 
  protected:
   // Internal tree data structure uses handles instead of pointers. Leaves and
   // root parent reference a singleton under handle 0. Although dereferencing
   // a null pointer is not possible, inappropriate access to handle 0 would
-  // cause an assertion. Handles are not garbage collected if value was deprecated
-  // with DeprecateValue(). But handles are recycled when a node is repositioned.
+  // cause an assertion. Handles are not garbage collected if value was
+  // deprecated
+  // with DeprecateValue(). But handles are recycled when a node is
+  // repositioned.
 
   // Internal tree data structure node.
   struct Node {
@@ -125,7 +125,8 @@ class MoveToFront {
   };
 
   // Creates node and sets correct values. Non-NIL nodes should be created only
-  // through this function. If the node with this value has been created previously
+  // through this function. If the node with this value has been created
+  // previously
   // and since orphaned, reuses the old node instead of creating a new one.
   uint32_t CreateNode(uint32_t timestamp, const Val& value) {
     uint32_t handle = static_cast<uint32_t>(nodes_.size());
@@ -137,7 +138,8 @@ class MoveToFront {
       node.timestamp = timestamp;
       node.value = value;
       node.size = 1;
-      // Non-NIL nodes start with height 1 because their NIL children are leaves.
+      // Non-NIL nodes start with height 1 because their NIL children are
+      // leaves.
       node.height = 1;
     } else {
       // Reuse old node.
@@ -157,24 +159,16 @@ class MoveToFront {
   // ParentOf(LeftestDescendentOf(RightOf(node)))
 
   // Returns value of the node referenced by |handle|.
-  Val ValueOf(uint32_t node) const {
-    return nodes_.at(node).value;
-  }
+  Val ValueOf(uint32_t node) const { return nodes_.at(node).value; }
 
   // Returns left child of |node|.
-  uint32_t LeftOf(uint32_t node) const {
-    return nodes_.at(node).left;
-  }
+  uint32_t LeftOf(uint32_t node) const { return nodes_.at(node).left; }
 
   // Returns right child of |node|.
-  uint32_t RightOf(uint32_t node) const {
-    return nodes_.at(node).right;
-  }
+  uint32_t RightOf(uint32_t node) const { return nodes_.at(node).right; }
 
   // Returns parent of |node|.
-  uint32_t ParentOf(uint32_t node) const {
-    return nodes_.at(node).parent;
-  }
+  uint32_t ParentOf(uint32_t node) const { return nodes_.at(node).parent; }
 
   // Returns timestamp of |node|.
   uint32_t TimestampOf(uint32_t node) const {
@@ -183,14 +177,10 @@ class MoveToFront {
   }
 
   // Returns size of |node|.
-  uint32_t SizeOf(uint32_t node) const {
-    return nodes_.at(node).size;
-  }
+  uint32_t SizeOf(uint32_t node) const { return nodes_.at(node).size; }
 
   // Returns height of |node|.
-  uint32_t HeightOf(uint32_t node) const {
-    return nodes_.at(node).height;
-  }
+  uint32_t HeightOf(uint32_t node) const { return nodes_.at(node).height; }
 
   // Returns mutable reference to value of |node|.
   Val& MutableValueOf(uint32_t node) {
@@ -347,8 +337,7 @@ class MultiMoveToFront {
   // Removes |value| from all sequences which have it.
   void RemoveFromAll(const Val& value) {
     auto it = val_to_mtfs_.find(value);
-    if (it == val_to_mtfs_.end())
-      return;
+    if (it == val_to_mtfs_.end()) return;
 
     auto& mtfs_containing_value = it->second;
     for (uint64_t mtf : mtfs_containing_value) {
@@ -371,15 +360,12 @@ class MultiMoveToFront {
   }
 
   // Returns size of |mtf| sequence.
-  uint32_t GetSize(uint64_t mtf) {
-    return GetMtf(mtf).GetSize();
-  }
+  uint32_t GetSize(uint64_t mtf) { return GetMtf(mtf).GetSize(); }
 
   // Promotes |value| in all sequences which have it.
   void Promote(const Val& value) {
     const auto it = val_to_mtfs_.find(value);
-    if (it == val_to_mtfs_.end())
-      return;
+    if (it == val_to_mtfs_.end()) return;
 
     const auto& mtfs_containing_value = it->second;
     for (uint64_t mtf : mtfs_containing_value) {
@@ -426,8 +412,7 @@ class MultiMoveToFront {
 template <typename Val>
 bool MoveToFront<Val>::Insert(const Val& value) {
   auto it = value_to_node_.find(value);
-  if (it != value_to_node_.end() && IsInTree(it->second))
-    return false;
+  if (it != value_to_node_.end() && IsInTree(it->second)) return false;
 
   const uint32_t old_size = GetSize();
   (void)old_size;
@@ -445,14 +430,11 @@ bool MoveToFront<Val>::Insert(const Val& value) {
 template <typename Val>
 bool MoveToFront<Val>::Remove(const Val& value) {
   auto it = value_to_node_.find(value);
-  if (it == value_to_node_.end())
-    return false;
+  if (it == value_to_node_.end()) return false;
 
-  if (!IsInTree(it->second))
-    return false;
+  if (!IsInTree(it->second)) return false;
 
-  if (last_accessed_value_ == value)
-    last_accessed_value_valid_ = false;
+  if (last_accessed_value_ == value) last_accessed_value_valid_ = false;
 
   const uint32_t orphan = RemoveNode(it->second);
   (void)orphan;
@@ -494,8 +476,7 @@ bool MoveToFront<Val>::RankFromValue(const Val& value, uint32_t* rank) {
   uint32_t node = target;
   *rank = 1 + SizeOf(LeftOf(node));
   while (node) {
-    if (IsRightChild(node))
-      *rank += 1 + SizeOf(LeftOf(ParentOf(node)));
+    if (IsRightChild(node)) *rank += 1 + SizeOf(LeftOf(ParentOf(node)));
     node = ParentOf(node);
   }
 
@@ -532,8 +513,7 @@ bool MoveToFront<Val>::Promote(const Val& value) {
   }
 
   const uint32_t old_size = GetSize();
-  if (old_size == 1)
-    return ValueOf(root_) == value;
+  if (old_size == 1) return ValueOf(root_) == value;
 
   const auto it = value_to_node_.find(value);
   if (it == value_to_node_.end()) {
@@ -663,8 +643,7 @@ void MoveToFront<Val>::InsertNode(uint32_t node) {
         // Added node to the right subtree.
         if (parent_balance > 1) {
           // Parent is right heavy, rotate left.
-          if (BalanceOf(node) < 0)
-            RotateRight(node);
+          if (BalanceOf(node) < 0) RotateRight(node);
           parent = RotateLeft(parent);
         } else if (parent_balance == 0 || parent_balance == -1) {
           // Parent is balanced or left heavy, no need to balance further.
@@ -674,8 +653,7 @@ void MoveToFront<Val>::InsertNode(uint32_t node) {
         // Added node to the left subtree.
         if (parent_balance < -1) {
           // Parent is left heavy, rotate right.
-          if (BalanceOf(node) > 0)
-            RotateLeft(node);
+          if (BalanceOf(node) > 0) RotateLeft(node);
           parent = RotateRight(parent);
         } else if (parent_balance == 0 || parent_balance == 1) {
           // Parent is balanced or right heavy, no need to balance further.
@@ -695,9 +673,11 @@ template <typename Val>
 uint32_t MoveToFront<Val>::RemoveNode(uint32_t node) {
   if (LeftOf(node) && RightOf(node)) {
     // If |node| has two children, then use another node as scapegoat and swap
-    // their contents. We pick the scapegoat on the side of the tree which has more nodes.
-    const uint32_t scapegoat = SizeOf(LeftOf(node)) >= SizeOf(RightOf(node)) ?
-        RightestDescendantOf(LeftOf(node)) : LeftestDescendantOf(RightOf(node));
+    // their contents. We pick the scapegoat on the side of the tree which has
+    // more nodes.
+    const uint32_t scapegoat = SizeOf(LeftOf(node)) >= SizeOf(RightOf(node))
+                                   ? RightestDescendantOf(LeftOf(node))
+                                   : LeftestDescendantOf(RightOf(node));
     assert(scapegoat);
     std::swap(MutableValueOf(node), MutableValueOf(scapegoat));
     std::swap(MutableTimestampOf(node), MutableTimestampOf(scapegoat));
@@ -713,8 +693,7 @@ uint32_t MoveToFront<Val>::RemoveNode(uint32_t node) {
   uint32_t child = RightOf(node) ? RightOf(node) : LeftOf(node);
 
   // Orphan |node| and reconnect parent and child.
-  if (child)
-    MutableParentOf(child) = parent;
+  if (child) MutableParentOf(child) = parent;
 
   if (parent) {
     if (LeftOf(parent) == node)
@@ -729,8 +708,7 @@ uint32_t MoveToFront<Val>::RemoveNode(uint32_t node) {
   UpdateNode(node);
   const uint32_t orphan = node;
 
-  if (root_ == node)
-    root_ = child;
+  if (root_ == node) root_ = child;
 
   // Removal is finished. Start the balancing process.
   bool needs_rebalancing = true;
@@ -751,8 +729,7 @@ uint32_t MoveToFront<Val>::RemoveNode(uint32_t node) {
           if (parent_balance < -1) {
             // Parent is left heavy, rotate right.
             const uint32_t sibling = LeftOf(parent);
-            if (BalanceOf(sibling) > 0)
-              RotateLeft(sibling);
+            if (BalanceOf(sibling) > 0) RotateLeft(sibling);
             parent = RotateRight(parent);
           }
         } else {
@@ -760,8 +737,7 @@ uint32_t MoveToFront<Val>::RemoveNode(uint32_t node) {
           if (parent_balance > 1) {
             // Parent is right heavy, rotate left.
             const uint32_t sibling = RightOf(parent);
-            if (BalanceOf(sibling) < 0)
-              RotateRight(sibling);
+            if (BalanceOf(sibling) < 0) RotateRight(sibling);
             parent = RotateLeft(parent);
           }
         }
@@ -784,8 +760,7 @@ uint32_t MoveToFront<Val>::RotateLeft(const uint32_t node) {
 
   // LeftOf(pivot) gets attached to node in place of pivot.
   MutableRightOf(node) = LeftOf(pivot);
-  if (RightOf(node))
-    MutableParentOf(RightOf(node)) = node;
+  if (RightOf(node)) MutableParentOf(RightOf(node)) = node;
 
   // Pivot gets attached to ParentOf(node) in place of node.
   MutableParentOf(pivot) = ParentOf(node);
@@ -815,8 +790,7 @@ uint32_t MoveToFront<Val>::RotateRight(const uint32_t node) {
 
   // RightOf(pivot) gets attached to node in place of pivot.
   MutableLeftOf(node) = RightOf(pivot);
-  if (LeftOf(node))
-    MutableParentOf(LeftOf(node)) = node;
+  if (LeftOf(node)) MutableParentOf(LeftOf(node)) = node;
 
   // Pivot gets attached to ParentOf(node) in place of node.
   MutableParentOf(pivot) = ParentOf(node);
diff --git a/source/util/parse_number.cpp b/source/util/parse_number.cpp
index c71b3115..5ec905d1 100644
--- a/source/util/parse_number.cpp
+++ b/source/util/parse_number.cpp
@@ -68,8 +68,8 @@ EncodeNumberStatus ParseAndEncodeIntegerNumber(
   const uint32_t bit_width = AssumedBitWidth(type);
 
   if (bit_width > 64) {
-    ErrorMsgStream(error_msg) << "Unsupported " << bit_width
-                              << "-bit integer literals";
+    ErrorMsgStream(error_msg)
+        << "Unsupported " << bit_width << "-bit integer literals";
     return EncodeNumberStatus::kUnsupported;
   }
 
@@ -182,8 +182,8 @@ EncodeNumberStatus ParseAndEncodeFloatingPointNumber(
     default:
       break;
   }
-  ErrorMsgStream(error_msg) << "Unsupported " << bit_width
-                            << "-bit float literals";
+  ErrorMsgStream(error_msg)
+      << "Unsupported " << bit_width << "-bit float literals";
   return EncodeNumberStatus::kUnsupported;
 }
 
diff --git a/source/util/parse_number.h b/source/util/parse_number.h
index 5b7922b8..2a9bd6d4 100644
--- a/source/util/parse_number.h
+++ b/source/util/parse_number.h
@@ -171,7 +171,7 @@ bool ParseNumber(const char* text, T* value_pointer) {
   static_assert(sizeof(T) > 1,
                 "Single-byte types are not supported in this parse method");
 
-  if (!text)  return false;
+  if (!text) return false;
   std::istringstream text_stream(text);
   // Allow both decimal and hex input for integers.
   // It also allows octal input, but we don't care about that case.
diff --git a/source/val/basic_block.cpp b/source/val/basic_block.cpp
index 0bfc4f12..a0b10fa7 100644
--- a/source/val/basic_block.cpp
+++ b/source/val/basic_block.cpp
@@ -118,7 +118,7 @@ const BasicBlock::DominatorIterator BasicBlock::pdom_begin() const {
 
 BasicBlock::DominatorIterator BasicBlock::pdom_begin() {
   return DominatorIterator(
-    this, [](const BasicBlock* b) { return b->immediate_post_dominator(); });
+      this, [](const BasicBlock* b) { return b->immediate_post_dominator(); });
 }
 
 const BasicBlock::DominatorIterator BasicBlock::pdom_end() const {
diff --git a/source/val/basic_block.h b/source/val/basic_block.h
index 81f0f666..70b2eec3 100644
--- a/source/val/basic_block.h
+++ b/source/val/basic_block.h
@@ -108,7 +108,8 @@ class BasicBlock {
   void RegisterBranchInstruction(SpvOp branch_instruction);
 
   /// Adds @p next BasicBlocks as successors of this BasicBlock
-  void RegisterSuccessors(const std::vector<BasicBlock*>& next = std::vector<BasicBlock*>());
+  void RegisterSuccessors(
+      const std::vector<BasicBlock*>& next = std::vector<BasicBlock*>());
 
   /// Returns true if the id of the BasicBlock matches
   bool operator==(const BasicBlock& other) const { return other.id_ == id_; }
diff --git a/source/val/construct.cpp b/source/val/construct.cpp
index 4270063f..e3ad7f06 100644
--- a/source/val/construct.cpp
+++ b/source/val/construct.cpp
@@ -19,9 +19,8 @@
 
 namespace libspirv {
 
-Construct::Construct(ConstructType construct_type,
-                     BasicBlock* entry, BasicBlock* exit,
-                     std::vector<Construct*> constructs)
+Construct::Construct(ConstructType construct_type, BasicBlock* entry,
+                     BasicBlock* exit, std::vector<Construct*> constructs)
     : type_(construct_type),
       corresponding_constructs_(constructs),
       entry_block_(entry),
@@ -38,11 +37,16 @@ std::vector<Construct*>& Construct::corresponding_constructs() {
 
 bool ValidateConstructSize(ConstructType type, size_t size) {
   switch (type) {
-    case ConstructType::kSelection: return size == 0;
-    case ConstructType::kContinue:  return size == 1;
-    case ConstructType::kLoop:      return size == 1;
-    case ConstructType::kCase:      return size >= 1;
-    default: assert(1 == 0 && "Type not defined");
+    case ConstructType::kSelection:
+      return size == 0;
+    case ConstructType::kContinue:
+      return size == 1;
+    case ConstructType::kLoop:
+      return size == 1;
+    case ConstructType::kCase:
+      return size >= 1;
+    default:
+      assert(1 == 0 && "Type not defined");
   }
   return false;
 }
diff --git a/source/val/decoration.h b/source/val/decoration.h
index a6d7ff95..d77b0684 100644
--- a/source/val/decoration.h
+++ b/source/val/decoration.h
@@ -84,4 +84,3 @@ class Decoration {
 }  // namespace libspirv
 
 #endif  /// LIBSPIRV_VAL_DECORATION_H_
-
diff --git a/source/val/function.cpp b/source/val/function.cpp
index 42f7ec15..91352b2e 100644
--- a/source/val/function.cpp
+++ b/source/val/function.cpp
@@ -17,14 +17,14 @@
 #include <cassert>
 
 #include <algorithm>
-#include <unordered_set>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 
+#include "cfa.h"
 #include "val/basic_block.h"
 #include "val/construct.h"
 #include "validate.h"
-#include "cfa.h"
 
 using std::ignore;
 using std::list;
@@ -275,13 +275,9 @@ void Function::ComputeAugmentedCFG() {
   auto succ_func = [](const BasicBlock* b) { return b->successors(); };
   auto pred_func = [](const BasicBlock* b) { return b->predecessors(); };
   spvtools::CFA<BasicBlock>::ComputeAugmentedCFG(
-    ordered_blocks_,
-    &pseudo_entry_block_,
-    &pseudo_exit_block_,
-    &augmented_successors_map_,
-    &augmented_predecessors_map_,
-    succ_func,
-    pred_func);
+      ordered_blocks_, &pseudo_entry_block_, &pseudo_exit_block_,
+      &augmented_successors_map_, &augmented_predecessors_map_, succ_func,
+      pred_func);
 };
 
 Construct& Function::AddConstruct(const Construct& new_construct) {
diff --git a/source/val/function.h b/source/val/function.h
index 8baeb33f..f7856b3b 100644
--- a/source/val/function.h
+++ b/source/val/function.h
@@ -183,7 +183,8 @@ class Function {
   GetBlocksFunction AugmentedCFGSuccessorsFunction() const;
   /// Like AugmentedCFGSuccessorsFunction, but also includes a forward edge from
   /// a loop header block to its continue target, if they are different blocks.
-  GetBlocksFunction AugmentedCFGSuccessorsFunctionIncludingHeaderToContinueEdge() const;
+  GetBlocksFunction
+  AugmentedCFGSuccessorsFunctionIncludingHeaderToContinueEdge() const;
   /// Returns the block predecessors function for the augmented CFG.
   GetBlocksFunction AugmentedCFGPredecessorsFunction() const;
 
diff --git a/source/val/instruction.h b/source/val/instruction.h
index 31b463a6..5ae89e2c 100644
--- a/source/val/instruction.h
+++ b/source/val/instruction.h
@@ -72,9 +72,7 @@ class Instruction {
   }
 
   /// Provides direct access to the stored C instruction object.
-  const spv_parsed_instruction_t& c_inst() const {
-    return inst_;
-  }
+  const spv_parsed_instruction_t& c_inst() const { return inst_; }
 
   // Casts the words belonging to the operand under |index| to |T| and returns.
   template <typename T>
diff --git a/source/val/validation_state.h b/source/val/validation_state.h
index db39dae5..b60e48df 100644
--- a/source/val/validation_state.h
+++ b/source/val/validation_state.h
@@ -358,15 +358,14 @@ class ValidationState_t {
 
   // Provides detailed information on matrix type.
   // Returns false iff |id| is not matrix type.
-  bool GetMatrixTypeInfo(
-      uint32_t id, uint32_t* num_rows, uint32_t* num_cols,
-      uint32_t* column_type, uint32_t* component_type) const;
+  bool GetMatrixTypeInfo(uint32_t id, uint32_t* num_rows, uint32_t* num_cols,
+                         uint32_t* column_type, uint32_t* component_type) const;
 
   // Collects struct member types into |member_types|.
   // Returns false iff not struct type or has no members.
   // Deletes prior contents of |member_types|.
-  bool GetStructMemberTypes(
-      uint32_t struct_type_id, std::vector<uint32_t>* member_types) const;
+  bool GetStructMemberTypes(uint32_t struct_type_id,
+                            std::vector<uint32_t>* member_types) const;
 
   // Returns true iff |id| is a type corresponding to the name of the function.
   // Only works for types not for objects.
@@ -393,8 +392,8 @@ class ValidationState_t {
                             size_t operand_index) const;
 
   // Provides information on pointer type. Returns false iff not pointer type.
-  bool GetPointerTypeInfo(
-      uint32_t id, uint32_t* data_type, uint32_t* storage_class) const;
+  bool GetPointerTypeInfo(uint32_t id, uint32_t* data_type,
+                          uint32_t* storage_class) const;
 
  private:
   ValidationState_t(const ValidationState_t&);
diff --git a/source/validate.cpp b/source/validate.cpp
index 536f798a..ca73bd09 100644
--- a/source/validate.cpp
+++ b/source/validate.cpp
@@ -139,11 +139,10 @@ void RegisterExtension(ValidationState_t& _,
 // once an instruction which is not SpvOpCapability and SpvOpExtension is
 // encountered. According to the SPIR-V spec extensions are declared after
 // capabilities and before everything else.
-spv_result_t ProcessExtensions(
-    void* user_data, const spv_parsed_instruction_t* inst) {
+spv_result_t ProcessExtensions(void* user_data,
+                               const spv_parsed_instruction_t* inst) {
   const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
-  if (opcode == SpvOpCapability)
-    return SPV_SUCCESS;
+  if (opcode == SpvOpCapability) return SPV_SUCCESS;
 
   if (opcode == SpvOpExtension) {
     ValidationState_t& _ = *(reinterpret_cast<ValidationState_t*>(user_data));
@@ -242,7 +241,7 @@ spv_result_t ValidateBinaryUsingContextAndValidationState(
     const spv_context_t& context, const uint32_t* words, const size_t num_words,
     spv_diagnostic* pDiagnostic, ValidationState_t* vstate) {
   auto binary = std::unique_ptr<spv_const_binary_t>(
-    new spv_const_binary_t{words, num_words});
+      new spv_const_binary_t{words, num_words});
 
   spv_endianness_t endian;
   spv_position_t position = {};
@@ -267,8 +266,8 @@ spv_result_t ValidateBinaryUsingContextAndValidationState(
 
   // NOTE: Parse the module and perform inline validation checks. These
   // checks do not require the the knowledge of the whole module.
-  if (auto error = spvBinaryParse(&context, vstate, words, num_words,
-                                  setHeader, ProcessInstruction, pDiagnostic))
+  if (auto error = spvBinaryParse(&context, vstate, words, num_words, setHeader,
+                                  ProcessInstruction, pDiagnostic))
     return error;
 
   if (vstate->in_function_body())
@@ -296,7 +295,7 @@ spv_result_t ValidateBinaryUsingContextAndValidationState(
   if (auto error = PerformCfgChecks(*vstate)) return error;
   if (auto error = UpdateIdUse(*vstate)) return error;
   if (auto error = CheckIdDefinitionDominateUse(*vstate)) return error;
-  if (auto error = ValidateDecorations(*vstate))  return error;
+  if (auto error = ValidateDecorations(*vstate)) return error;
 
   // Entry point validation. Based on 2.16.1 (Universal Validation Rules) of the
   // SPIRV spec:
@@ -338,8 +337,7 @@ spv_result_t ValidateBinaryUsingContextAndValidationState(
 
   position.index = SPV_INDEX_INSTRUCTION;
   return spvValidateIDs(instructions.data(), instructions.size(),
-                        context.opcode_table,
-                        context.operand_table,
+                        context.opcode_table, context.operand_table,
                         context.ext_inst_table, *vstate, &position);
 }
 
diff --git a/source/validate.h b/source/validate.h
index 2e088d94..3c3bcb2f 100644
--- a/source/validate.h
+++ b/source/validate.h
@@ -113,7 +113,7 @@ spv_result_t TypeUniquePass(ValidationState_t& _,
 
 /// Validates correctness of arithmetic instructions.
 spv_result_t ArithmeticsPass(ValidationState_t& _,
-                            const spv_parsed_instruction_t* inst);
+                             const spv_parsed_instruction_t* inst);
 
 /// Validates correctness of conversion instructions.
 spv_result_t ConversionPass(ValidationState_t& _,
diff --git a/source/validate_arithmetics.cpp b/source/validate_arithmetics.cpp
index a2d3fbce..42399fcc 100644
--- a/source/validate_arithmetics.cpp
+++ b/source/validate_arithmetics.cpp
@@ -38,16 +38,15 @@ inline uint32_t GetOperandWord(const spv_parsed_instruction_t* inst,
 // Returns the type id of instruction operand at |operand_index|.
 // The operand is expected to be an id.
 inline uint32_t GetOperandTypeId(ValidationState_t& _,
-                               const spv_parsed_instruction_t* inst,
-                               size_t operand_index) {
+                                 const spv_parsed_instruction_t* inst,
+                                 size_t operand_index) {
   return _.GetTypeId(GetOperandWord(inst, operand_index));
 }
-
 }
 
 // Validates correctness of arithmetic instructions.
 spv_result_t ArithmeticsPass(ValidationState_t& _,
-                            const spv_parsed_instruction_t* inst) {
+                             const spv_parsed_instruction_t* inst) {
   const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
   const uint32_t result_type = inst->type_id;
 
@@ -62,15 +61,16 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
       if (!_.IsFloatScalarType(result_type) &&
           !_.IsFloatVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected floating scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected floating scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       for (size_t operand_index = 2; operand_index < inst->num_operands;
            ++operand_index) {
         if (GetOperandTypeId(_, inst, operand_index) != result_type)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected arithmetic operands to be of Result Type: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected arithmetic operands to be of Result Type: "
+                 << spvOpcodeString(opcode) << " operand index "
+                 << operand_index;
       }
       break;
     }
@@ -80,15 +80,16 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
       if (!_.IsUnsignedIntScalarType(result_type) &&
           !_.IsUnsignedIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected unsigned int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected unsigned int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       for (size_t operand_index = 2; operand_index < inst->num_operands;
            ++operand_index) {
         if (GetOperandTypeId(_, inst, operand_index) != result_type)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected arithmetic operands to be of Result Type: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected arithmetic operands to be of Result Type: "
+                 << spvOpcodeString(opcode) << " operand index "
+                 << operand_index;
       }
       break;
     }
@@ -100,36 +101,35 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
     case SpvOpSMod:
     case SpvOpSRem:
     case SpvOpSNegate: {
-      if (!_.IsIntScalarType(result_type) &&
-          !_.IsIntVectorType(result_type))
+      if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t dimension = _.GetDimension(result_type);
       const uint32_t bit_width = _.GetBitWidth(result_type);
 
       for (size_t operand_index = 2; operand_index < inst->num_operands;
            ++operand_index) {
-
         const uint32_t type_id = GetOperandTypeId(_, inst, operand_index);
         if (!type_id ||
             (!_.IsIntScalarType(type_id) && !_.IsIntVectorType(type_id)))
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected int scalar or vector type as operand: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected int scalar or vector type as operand: "
+                 << spvOpcodeString(opcode) << " operand index "
+                 << operand_index;
 
         if (_.GetDimension(type_id) != dimension)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected arithmetic operands to have the same dimension "
-              << "as Result Type: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected arithmetic operands to have the same dimension "
+                 << "as Result Type: " << spvOpcodeString(opcode)
+                 << " operand index " << operand_index;
 
         if (_.GetBitWidth(type_id) != bit_width)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected arithmetic operands to have the same bit width "
-              << "as Result Type: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected arithmetic operands to have the same bit width "
+                 << "as Result Type: " << spvOpcodeString(opcode)
+                 << " operand index " << operand_index;
       }
       break;
     }
@@ -137,8 +137,8 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
     case SpvOpDot: {
       if (!_.IsFloatScalarType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float scalar type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float scalar type as Result Type: "
+               << spvOpcodeString(opcode);
 
       uint32_t first_vector_num_components = 0;
 
@@ -148,23 +148,24 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
 
         if (!type_id || !_.IsFloatVectorType(type_id))
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected float vector as operand: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
-
+                 << "Expected float vector as operand: "
+                 << spvOpcodeString(opcode) << " operand index "
+                 << operand_index;
 
         const uint32_t component_type = _.GetComponentType(type_id);
         if (component_type != result_type)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected component type to be equal to Result Type: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected component type to be equal to Result Type: "
+                 << spvOpcodeString(opcode) << " operand index "
+                 << operand_index;
 
         const uint32_t num_components = _.GetDimension(type_id);
         if (operand_index == 2) {
           first_vector_num_components = num_components;
         } else if (num_components != first_vector_num_components) {
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected operands to have the same number of componenets: "
-              << spvOpcodeString(opcode);
+                 << "Expected operands to have the same number of componenets: "
+                 << spvOpcodeString(opcode);
         }
       }
       break;
@@ -173,23 +174,22 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
     case SpvOpVectorTimesScalar: {
       if (!_.IsFloatVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t vector_type_id = GetOperandTypeId(_, inst, 2);
       if (result_type != vector_type_id)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected vector operand type to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected vector operand type to be equal to Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t component_type = _.GetComponentType(vector_type_id);
 
       const uint32_t scalar_type_id = GetOperandTypeId(_, inst, 3);
       if (component_type != scalar_type_id)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected scalar operand type to be equal to the component "
-            << "type of the vector operand: "
-            << spvOpcodeString(opcode);
+               << "Expected scalar operand type to be equal to the component "
+               << "type of the vector operand: " << spvOpcodeString(opcode);
 
       break;
     }
@@ -197,23 +197,22 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
     case SpvOpMatrixTimesScalar: {
       if (!_.IsFloatMatrixType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t matrix_type_id = GetOperandTypeId(_, inst, 2);
       if (result_type != matrix_type_id)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected matrix operand type to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected matrix operand type to be equal to Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t component_type = _.GetComponentType(matrix_type_id);
 
       const uint32_t scalar_type_id = GetOperandTypeId(_, inst, 3);
       if (component_type != scalar_type_id)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected scalar operand type to be equal to the component "
-            << "type of the matrix operand: "
-            << spvOpcodeString(opcode);
+               << "Expected scalar operand type to be equal to the component "
+               << "type of the matrix operand: " << spvOpcodeString(opcode);
 
       break;
     }
@@ -224,20 +223,20 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
 
       if (!_.IsFloatVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t res_component_type = _.GetComponentType(result_type);
 
       if (!vector_type_id || !_.IsFloatVectorType(vector_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float vector type as left operand: "
-            << spvOpcodeString(opcode);
+               << "Expected float vector type as left operand: "
+               << spvOpcodeString(opcode);
 
       if (res_component_type != _.GetComponentType(vector_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected component types of Result Type and vector to be "
-            << "equal: " << spvOpcodeString(opcode);
+               << "Expected component types of Result Type and vector to be "
+               << "equal: " << spvOpcodeString(opcode);
 
       uint32_t matrix_num_rows = 0;
       uint32_t matrix_num_cols = 0;
@@ -247,23 +246,23 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
                                &matrix_num_cols, &matrix_col_type,
                                &matrix_component_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as right operand: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as right operand: "
+               << spvOpcodeString(opcode);
 
       if (res_component_type != matrix_component_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected component types of Result Type and matrix to be "
-            << "equal: " << spvOpcodeString(opcode);
+               << "Expected component types of Result Type and matrix to be "
+               << "equal: " << spvOpcodeString(opcode);
 
       if (matrix_num_cols != _.GetDimension(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected number of columns of the matrix to be equal to "
-            << "Result Type vector size: " << spvOpcodeString(opcode);
+               << "Expected number of columns of the matrix to be equal to "
+               << "Result Type vector size: " << spvOpcodeString(opcode);
 
       if (matrix_num_rows != _.GetDimension(vector_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected number of rows of the matrix to be equal to the "
-            << "vector operand size: " << spvOpcodeString(opcode);
+               << "Expected number of rows of the matrix to be equal to the "
+               << "vector operand size: " << spvOpcodeString(opcode);
 
       break;
     }
@@ -274,8 +273,8 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
 
       if (!_.IsFloatVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       uint32_t matrix_num_rows = 0;
       uint32_t matrix_num_cols = 0;
@@ -285,28 +284,29 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
                                &matrix_num_cols, &matrix_col_type,
                                &matrix_component_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as left operand: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as left operand: "
+               << spvOpcodeString(opcode);
 
       if (result_type != matrix_col_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected column type of the matrix to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected column type of the matrix to be equal to Result "
+                  "Type: "
+               << spvOpcodeString(opcode);
 
       if (!vector_type_id || !_.IsFloatVectorType(vector_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float vector type as right operand: "
-            << spvOpcodeString(opcode);
+               << "Expected float vector type as right operand: "
+               << spvOpcodeString(opcode);
 
       if (matrix_component_type != _.GetComponentType(vector_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected component types of the operands to be equal: "
-            << spvOpcodeString(opcode);
+               << "Expected component types of the operands to be equal: "
+               << spvOpcodeString(opcode);
 
       if (matrix_num_cols != _.GetDimension(vector_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected number of columns of the matrix to be equal to the "
-            << "vector size: " << spvOpcodeString(opcode);
+               << "Expected number of columns of the matrix to be equal to the "
+               << "vector size: " << spvOpcodeString(opcode);
 
       break;
     }
@@ -322,8 +322,8 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
       if (!_.GetMatrixTypeInfo(result_type, &res_num_rows, &res_num_cols,
                                &res_col_type, &res_component_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as Result Type: "
+               << spvOpcodeString(opcode);
 
       uint32_t left_num_rows = 0;
       uint32_t left_num_cols = 0;
@@ -332,8 +332,8 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
       if (!_.GetMatrixTypeInfo(left_type_id, &left_num_rows, &left_num_cols,
                                &left_col_type, &left_component_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as left operand: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as left operand: "
+               << spvOpcodeString(opcode);
 
       uint32_t right_num_rows = 0;
       uint32_t right_num_cols = 0;
@@ -342,33 +342,36 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
       if (!_.GetMatrixTypeInfo(right_type_id, &right_num_rows, &right_num_cols,
                                &right_col_type, &right_component_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as right operand: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as right operand: "
+               << spvOpcodeString(opcode);
 
       if (!_.IsFloatScalarType(res_component_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as Result Type: "
+               << spvOpcodeString(opcode);
 
       if (res_col_type != left_col_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected column types of Result Type and left matrix to be "
-            << "equal: " << spvOpcodeString(opcode);
+               << "Expected column types of Result Type and left matrix to be "
+               << "equal: " << spvOpcodeString(opcode);
 
       if (res_component_type != right_component_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected component types of Result Type and right matrix to be "
-            << "equal: " << spvOpcodeString(opcode);
+               << "Expected component types of Result Type and right matrix to "
+                  "be "
+               << "equal: " << spvOpcodeString(opcode);
 
       if (res_num_cols != right_num_cols)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected number of columns of Result Type and right matrix to "
-            << "be equal: " << spvOpcodeString(opcode);
+               << "Expected number of columns of Result Type and right matrix "
+                  "to "
+               << "be equal: " << spvOpcodeString(opcode);
 
       if (left_num_cols != right_num_rows)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected number of columns of left matrix and number of rows "
-            << "of right matrix to be equal: " << spvOpcodeString(opcode);
+               << "Expected number of columns of left matrix and number of "
+                  "rows "
+               << "of right matrix to be equal: " << spvOpcodeString(opcode);
 
       assert(left_num_rows == res_num_rows);
       break;
@@ -385,29 +388,29 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
       if (!_.GetMatrixTypeInfo(result_type, &res_num_rows, &res_num_cols,
                                &res_col_type, &res_component_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float matrix type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float matrix type as Result Type: "
+               << spvOpcodeString(opcode);
 
       if (left_type_id != res_col_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected column type of Result Type to be equal to the type "
-            << "of the left operand: "
-            << spvOpcodeString(opcode);
+               << "Expected column type of Result Type to be equal to the type "
+               << "of the left operand: " << spvOpcodeString(opcode);
 
       if (!right_type_id || !_.IsFloatVectorType(right_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float vector type as right operand: "
-            << spvOpcodeString(opcode);
+               << "Expected float vector type as right operand: "
+               << spvOpcodeString(opcode);
 
       if (res_component_type != _.GetComponentType(right_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected component types of the operands to be equal: "
-            << spvOpcodeString(opcode);
+               << "Expected component types of the operands to be equal: "
+               << spvOpcodeString(opcode);
 
       if (res_num_cols != _.GetDimension(right_type_id))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected number of columns of the matrix to be equal to the "
-            << "vector size of the right operand: " << spvOpcodeString(opcode);
+               << "Expected number of columns of the matrix to be equal to the "
+               << "vector size of the right operand: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -419,40 +422,41 @@ spv_result_t ArithmeticsPass(ValidationState_t& _,
       std::vector<uint32_t> result_types;
       if (!_.GetStructMemberTypes(result_type, &result_types))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected a struct as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected a struct as Result Type: "
+               << spvOpcodeString(opcode);
 
       if (result_types.size() != 2)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type struct to have two members: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type struct to have two members: "
+               << spvOpcodeString(opcode);
 
       if (opcode == SpvOpSMulExtended) {
         if (!_.IsIntScalarType(result_types[0]) &&
             !_.IsIntVectorType(result_types[0]))
-        return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type struct member types to be integer scalar "
-            << "or vector: " << spvOpcodeString(opcode);
+          return _.diag(SPV_ERROR_INVALID_DATA)
+                 << "Expected Result Type struct member types to be integer "
+                    "scalar "
+                 << "or vector: " << spvOpcodeString(opcode);
       } else {
         if (!_.IsUnsignedIntScalarType(result_types[0]) &&
             !_.IsUnsignedIntVectorType(result_types[0]))
-        return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type struct member types to be unsigned "
-            << "integer scalar or vector: " << spvOpcodeString(opcode);
+          return _.diag(SPV_ERROR_INVALID_DATA)
+                 << "Expected Result Type struct member types to be unsigned "
+                 << "integer scalar or vector: " << spvOpcodeString(opcode);
       }
 
       if (result_types[0] != result_types[1])
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type struct member types to be identical: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type struct member types to be identical: "
+               << spvOpcodeString(opcode);
 
       const uint32_t left_type_id = GetOperandTypeId(_, inst, 2);
       const uint32_t right_type_id = GetOperandTypeId(_, inst, 3);
 
       if (left_type_id != result_types[0] || right_type_id != result_types[0])
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected both operands to be of Result Type member type: "
-            << spvOpcodeString(opcode);
+               << "Expected both operands to be of Result Type member type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
diff --git a/source/validate_bitwise.cpp b/source/validate_bitwise.cpp
index c175ea64..e7171386 100644
--- a/source/validate_bitwise.cpp
+++ b/source/validate_bitwise.cpp
@@ -38,11 +38,10 @@ inline uint32_t GetOperandWord(const spv_parsed_instruction_t* inst,
 // Returns the type id of instruction operand at |operand_index|.
 // The operand is expected to be an id.
 inline uint32_t GetOperandTypeId(ValidationState_t& _,
-                               const spv_parsed_instruction_t* inst,
-                               size_t operand_index) {
+                                 const spv_parsed_instruction_t* inst,
+                                 size_t operand_index) {
   return _.GetTypeId(GetOperandWord(inst, operand_index));
 }
-
 }
 
 // Validates correctness of bitwise instructions.
@@ -55,11 +54,10 @@ spv_result_t BitwisePass(ValidationState_t& _,
     case SpvOpShiftRightLogical:
     case SpvOpShiftRightArithmetic:
     case SpvOpShiftLeftLogical: {
-      if (!_.IsIntScalarType(result_type) &&
-          !_.IsIntVectorType(result_type))
+      if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t result_dimension = _.GetDimension(result_type);
       const uint32_t base_type = GetOperandTypeId(_, inst, 2);
@@ -68,32 +66,29 @@ spv_result_t BitwisePass(ValidationState_t& _,
       if (!base_type ||
           (!_.IsIntScalarType(base_type) && !_.IsIntVectorType(base_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Base to be int scalar or vector: "
-            << spvOpcodeString(opcode);
+               << "Expected Base to be int scalar or vector: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(base_type) != result_dimension)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Base to have the same dimension "
-            << "as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected Base to have the same dimension "
+               << "as Result Type: " << spvOpcodeString(opcode);
 
       if (_.GetBitWidth(base_type) != _.GetBitWidth(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Base to have the same bit width "
-            << "as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected Base to have the same bit width "
+               << "as Result Type: " << spvOpcodeString(opcode);
 
       if (!shift_type ||
           (!_.IsIntScalarType(shift_type) && !_.IsIntVectorType(shift_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Shift to be int scalar or vector: "
-            << spvOpcodeString(opcode);
+               << "Expected Shift to be int scalar or vector: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(shift_type) != result_dimension)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Shift to have the same dimension "
-            << "as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected Shift to have the same dimension "
+               << "as Result Type: " << spvOpcodeString(opcode);
       break;
     }
 
@@ -101,46 +96,44 @@ spv_result_t BitwisePass(ValidationState_t& _,
     case SpvOpBitwiseXor:
     case SpvOpBitwiseAnd:
     case SpvOpNot: {
-      if (!_.IsIntScalarType(result_type) &&
-          !_.IsIntVectorType(result_type))
+      if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t result_dimension = _.GetDimension(result_type);
       const uint32_t result_bit_width = _.GetBitWidth(result_type);
 
       for (size_t operand_index = 2; operand_index < inst->num_operands;
            ++operand_index) {
-
         const uint32_t type_id = GetOperandTypeId(_, inst, operand_index);
         if (!type_id ||
             (!_.IsIntScalarType(type_id) && !_.IsIntVectorType(type_id)))
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected int scalar or vector as operand: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected int scalar or vector as operand: "
+                 << spvOpcodeString(opcode) << " operand index "
+                 << operand_index;
 
         if (_.GetDimension(type_id) != result_dimension)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected operands to have the same dimension "
-              << "as Result Type: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected operands to have the same dimension "
+                 << "as Result Type: " << spvOpcodeString(opcode)
+                 << " operand index " << operand_index;
 
         if (_.GetBitWidth(type_id) != result_bit_width)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected operands to have the same bit width "
-              << "as Result Type: "
-              << spvOpcodeString(opcode) << " operand index " << operand_index;
+                 << "Expected operands to have the same bit width "
+                 << "as Result Type: " << spvOpcodeString(opcode)
+                 << " operand index " << operand_index;
       }
       break;
     }
 
     case SpvOpBitFieldInsert: {
-      if (!_.IsIntScalarType(result_type) &&
-          !_.IsIntVectorType(result_type))
+      if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t base_type = GetOperandTypeId(_, inst, 2);
       const uint32_t insert_type = GetOperandTypeId(_, inst, 3);
@@ -149,33 +142,32 @@ spv_result_t BitwisePass(ValidationState_t& _,
 
       if (base_type != result_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Base Type to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected Base Type to be equal to Result Type: "
+               << spvOpcodeString(opcode);
 
       if (insert_type != result_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Insert Type to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected Insert Type to be equal to Result Type: "
+               << spvOpcodeString(opcode);
 
       if (!offset_type || !_.IsIntScalarType(offset_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Offset Type to be int scalar: "
-            << spvOpcodeString(opcode);
+               << "Expected Offset Type to be int scalar: "
+               << spvOpcodeString(opcode);
 
       if (!count_type || !_.IsIntScalarType(count_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Count Type to be int scalar: "
-            << spvOpcodeString(opcode);
+               << "Expected Count Type to be int scalar: "
+               << spvOpcodeString(opcode);
       break;
     }
 
     case SpvOpBitFieldSExtract:
     case SpvOpBitFieldUExtract: {
-      if (!_.IsIntScalarType(result_type) &&
-          !_.IsIntVectorType(result_type))
+      if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t base_type = GetOperandTypeId(_, inst, 2);
       const uint32_t offset_type = GetOperandTypeId(_, inst, 3);
@@ -183,43 +175,41 @@ spv_result_t BitwisePass(ValidationState_t& _,
 
       if (base_type != result_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Base Type to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected Base Type to be equal to Result Type: "
+               << spvOpcodeString(opcode);
 
       if (!offset_type || !_.IsIntScalarType(offset_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Offset Type to be int scalar: "
-            << spvOpcodeString(opcode);
+               << "Expected Offset Type to be int scalar: "
+               << spvOpcodeString(opcode);
 
       if (!count_type || !_.IsIntScalarType(count_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Count Type to be int scalar: "
-            << spvOpcodeString(opcode);
+               << "Expected Count Type to be int scalar: "
+               << spvOpcodeString(opcode);
       break;
     }
 
     case SpvOpBitReverse: {
-      if (!_.IsIntScalarType(result_type) &&
-          !_.IsIntVectorType(result_type))
+      if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t base_type = GetOperandTypeId(_, inst, 2);
 
       if (base_type != result_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Base Type to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected Base Type to be equal to Result Type: "
+               << spvOpcodeString(opcode);
       break;
     }
 
     case SpvOpBitCount: {
-      if (!_.IsIntScalarType(result_type) &&
-          !_.IsIntVectorType(result_type))
+      if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t base_type = GetOperandTypeId(_, inst, 2);
       if (!base_type ||
@@ -233,8 +223,9 @@ spv_result_t BitwisePass(ValidationState_t& _,
 
       if (base_dimension != result_dimension)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Base dimension to be equal to Result Type dimension: "
-            << spvOpcodeString(opcode);
+               << "Expected Base dimension to be equal to Result Type "
+                  "dimension: "
+               << spvOpcodeString(opcode);
       break;
     }
 
diff --git a/source/validate_cfg.cpp b/source/validate_cfg.cpp
index f237a0fd..45a6c956 100644
--- a/source/validate_cfg.cpp
+++ b/source/validate_cfg.cpp
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "validate.h"
 #include "cfa.h"
+#include "validate.h"
 
 #include <algorithm>
 #include <cassert>
@@ -298,8 +298,9 @@ spv_result_t PerformCfgChecks(ValidationState_t& _) {
           function.pseudo_exit_block(),
           function.AugmentedCFGPredecessorsFunction(), ignore_block,
           [&](cbb_ptr b) { postdom_postorder.push_back(b); }, ignore_edge);
-      auto postdom_edges = spvtools::CFA<libspirv::BasicBlock>::CalculateDominators(
-          postdom_postorder, function.AugmentedCFGSuccessorsFunction());
+      auto postdom_edges =
+          spvtools::CFA<libspirv::BasicBlock>::CalculateDominators(
+              postdom_postorder, function.AugmentedCFGSuccessorsFunction());
       for (auto edge : postdom_edges) {
         edge.first->SetImmediatePostDominator(edge.second);
       }
@@ -407,8 +408,8 @@ spv_result_t CfgPass(ValidationState_t& _,
       assert(return_type_inst);
       if (return_type_inst->opcode() != SpvOpTypeVoid)
         return _.diag(SPV_ERROR_INVALID_CFG)
-            << "OpReturn can only be called from a function with void "
-            << "return type.";
+               << "OpReturn can only be called from a function with void "
+               << "return type.";
     }
     // Fallthrough.
     case SpvOpKill:
diff --git a/source/validate_conversion.cpp b/source/validate_conversion.cpp
index 222796e7..a885d1b5 100644
--- a/source/validate_conversion.cpp
+++ b/source/validate_conversion.cpp
@@ -34,20 +34,20 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.IsUnsignedIntScalarType(result_type) &&
           !_.IsUnsignedIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected unsigned int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected unsigned int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       if (!input_type || (!_.IsFloatScalarType(input_type) &&
                           !_.IsFloatVectorType(input_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be float scalar or vector: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be float scalar or vector: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have the same dimension as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have the same dimension as Result Type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -55,20 +55,20 @@ spv_result_t ConversionPass(ValidationState_t& _,
     case SpvOpConvertFToS: {
       if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       if (!input_type || (!_.IsFloatScalarType(input_type) &&
                           !_.IsFloatVectorType(input_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be float scalar or vector: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be float scalar or vector: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have the same dimension as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have the same dimension as Result Type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -78,20 +78,20 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.IsFloatScalarType(result_type) &&
           !_.IsFloatVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
-      if (!input_type || (!_.IsIntScalarType(input_type) &&
-                          !_.IsIntVectorType(input_type)))
+      if (!input_type ||
+          (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be int scalar or vector: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be int scalar or vector: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have the same dimension as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have the same dimension as Result Type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -128,25 +128,26 @@ spv_result_t ConversionPass(ValidationState_t& _,
     case SpvOpSConvert: {
       if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
-      if (!input_type || (!_.IsIntScalarType(input_type) &&
-                          !_.IsIntVectorType(input_type)))
+      if (!input_type ||
+          (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be int scalar or vector: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be int scalar or vector: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have the same dimension as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have the same dimension as Result Type: "
+               << spvOpcodeString(opcode);
 
       if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have different bit width from Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have different bit width from Result "
+                  "Type: "
+               << spvOpcodeString(opcode);
       break;
     }
 
@@ -154,54 +155,55 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.IsFloatScalarType(result_type) &&
           !_.IsFloatVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected float scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected float scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       if (!input_type || (!_.IsFloatScalarType(input_type) &&
                           !_.IsFloatVectorType(input_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be float scalar or vector: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be float scalar or vector: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have the same dimension as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have the same dimension as Result Type: "
+               << spvOpcodeString(opcode);
 
       if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have different bit width from Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have different bit width from Result "
+                  "Type: "
+               << spvOpcodeString(opcode);
       break;
     }
 
     case SpvOpQuantizeToF16: {
       if ((!_.IsFloatScalarType(result_type) &&
-          !_.IsFloatVectorType(result_type)) ||
+           !_.IsFloatVectorType(result_type)) ||
           _.GetBitWidth(result_type) != 32)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected 32-bit float scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected 32-bit float scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       if (input_type != result_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input type to be equal to Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input type to be equal to Result Type: "
+               << spvOpcodeString(opcode);
       break;
     }
 
     case SpvOpConvertPtrToU: {
       if (!_.IsUnsignedIntScalarType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected unsigned int scalar type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected unsigned int scalar type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       if (!_.IsPointerType(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be a pointer: " << spvOpcodeString(opcode);
+               << "Expected input to be a pointer: " << spvOpcodeString(opcode);
       break;
     }
 
@@ -209,33 +211,33 @@ spv_result_t ConversionPass(ValidationState_t& _,
     case SpvOpSatConvertUToS: {
       if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
-      if (!input_type || (!_.IsIntScalarType(input_type) &&
-                          !_.IsIntVectorType(input_type)))
+      if (!input_type ||
+          (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar or vector as input: "
-            << spvOpcodeString(opcode);
+               << "Expected int scalar or vector as input: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have the same dimension as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have the same dimension as Result Type: "
+               << spvOpcodeString(opcode);
       break;
     }
 
     case SpvOpConvertUToPtr: {
       if (!_.IsPointerType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to be a pointer: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type to be a pointer: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       if (!_.IsIntScalarType(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected int scalar as input: " << spvOpcodeString(opcode);
+               << "Expected int scalar as input: " << spvOpcodeString(opcode);
       break;
     }
 
@@ -245,13 +247,13 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.GetPointerTypeInfo(result_type, &result_data_type,
                                 &result_storage_class))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to be a pointer: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type to be a pointer: "
+               << spvOpcodeString(opcode);
 
       if (result_storage_class != SpvStorageClassGeneric)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to have storage class Generic: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type to have storage class Generic: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       uint32_t input_storage_class = 0;
@@ -259,21 +261,19 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.GetPointerTypeInfo(input_type, &input_data_type,
                                 &input_storage_class))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be a pointer: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be a pointer: " << spvOpcodeString(opcode);
 
       if (input_storage_class != SpvStorageClassWorkgroup &&
           input_storage_class != SpvStorageClassCrossWorkgroup &&
           input_storage_class != SpvStorageClassFunction)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have storage class Workgroup, "
-            << "CrossWorkgroup or Function: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have storage class Workgroup, "
+               << "CrossWorkgroup or Function: " << spvOpcodeString(opcode);
 
       if (result_data_type != input_data_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input and Result Type to point to the same type: "
-            << spvOpcodeString(opcode);
+               << "Expected input and Result Type to point to the same type: "
+               << spvOpcodeString(opcode);
       break;
     }
 
@@ -283,16 +283,15 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.GetPointerTypeInfo(result_type, &result_data_type,
                                 &result_storage_class))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to be a pointer: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type to be a pointer: "
+               << spvOpcodeString(opcode);
 
       if (result_storage_class != SpvStorageClassWorkgroup &&
           result_storage_class != SpvStorageClassCrossWorkgroup &&
           result_storage_class != SpvStorageClassFunction)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to have storage class Workgroup, "
-            << "CrossWorkgroup or Function: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type to have storage class Workgroup, "
+               << "CrossWorkgroup or Function: " << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       uint32_t input_storage_class = 0;
@@ -300,18 +299,17 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.GetPointerTypeInfo(input_type, &input_data_type,
                                 &input_storage_class))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be a pointer: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be a pointer: " << spvOpcodeString(opcode);
 
       if (input_storage_class != SpvStorageClassGeneric)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have storage class Generic: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have storage class Generic: "
+               << spvOpcodeString(opcode);
 
       if (result_data_type != input_data_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input and Result Type to point to the same type: "
-            << spvOpcodeString(opcode);
+               << "Expected input and Result Type to point to the same type: "
+               << spvOpcodeString(opcode);
       break;
     }
 
@@ -321,14 +319,14 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.GetPointerTypeInfo(result_type, &result_data_type,
                                 &result_storage_class))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to be a pointer: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type to be a pointer: "
+               << spvOpcodeString(opcode);
 
       const uint32_t target_storage_class = inst->words[4];
       if (result_storage_class != target_storage_class)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to be of target storage class: "
-            << spvOpcodeString(opcode);
+               << "Expected Result Type to be of target storage class: "
+               << spvOpcodeString(opcode);
 
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       uint32_t input_storage_class = 0;
@@ -336,26 +334,24 @@ spv_result_t ConversionPass(ValidationState_t& _,
       if (!_.GetPointerTypeInfo(input_type, &input_data_type,
                                 &input_storage_class))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be a pointer: "
-            << spvOpcodeString(opcode);
+               << "Expected input to be a pointer: " << spvOpcodeString(opcode);
 
       if (input_storage_class != SpvStorageClassGeneric)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have storage class Generic: "
-            << spvOpcodeString(opcode);
+               << "Expected input to have storage class Generic: "
+               << spvOpcodeString(opcode);
 
       if (result_data_type != input_data_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input and Result Type to point to the same type: "
-            << spvOpcodeString(opcode);
+               << "Expected input and Result Type to point to the same type: "
+               << spvOpcodeString(opcode);
 
       if (target_storage_class != SpvStorageClassWorkgroup &&
           target_storage_class != SpvStorageClassCrossWorkgroup &&
           target_storage_class != SpvStorageClassFunction)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected target storage class to be Workgroup, "
-            << "CrossWorkgroup or Function: "
-            << spvOpcodeString(opcode);
+               << "Expected target storage class to be Workgroup, "
+               << "CrossWorkgroup or Function: " << spvOpcodeString(opcode);
       break;
     }
 
@@ -363,7 +359,7 @@ spv_result_t ConversionPass(ValidationState_t& _,
       const uint32_t input_type = _.GetOperandTypeId(inst, 2);
       if (!input_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to have a type: " << spvOpcodeString(opcode);
+               << "Expected input to have a type: " << spvOpcodeString(opcode);
 
       const bool result_is_pointer = _.IsPointerType(result_type);
       const bool result_is_int_scalar = _.IsIntScalarType(result_type);
@@ -375,26 +371,25 @@ spv_result_t ConversionPass(ValidationState_t& _,
           !_.IsFloatScalarType(result_type) &&
           !_.IsFloatVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected Result Type to be a pointer or int or float vector "
-            << "or scalar type: " << spvOpcodeString(opcode);
+               << "Expected Result Type to be a pointer or int or float vector "
+               << "or scalar type: " << spvOpcodeString(opcode);
 
       if (!input_is_pointer && !input_is_int_scalar &&
-          !_.IsIntVectorType(input_type) &&
-          !_.IsFloatScalarType(input_type) &&
+          !_.IsIntVectorType(input_type) && !_.IsFloatScalarType(input_type) &&
           !_.IsFloatVectorType(input_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be a pointer or int or float vector "
-            << "or scalar: " << spvOpcodeString(opcode);
+               << "Expected input to be a pointer or int or float vector "
+               << "or scalar: " << spvOpcodeString(opcode);
 
       if (result_is_pointer && !input_is_pointer && !input_is_int_scalar)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected input to be a pointer or int scalar if Result Type "
-            << "is pointer: " << spvOpcodeString(opcode);
+               << "Expected input to be a pointer or int scalar if Result Type "
+               << "is pointer: " << spvOpcodeString(opcode);
 
       if (input_is_pointer && !result_is_pointer && !result_is_int_scalar)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Pointer can only be converted to another pointer or int "
-            << "scalar: " << spvOpcodeString(opcode);
+               << "Pointer can only be converted to another pointer or int "
+               << "scalar: " << spvOpcodeString(opcode);
 
       if (!result_is_pointer && !input_is_pointer) {
         const uint32_t result_size =
@@ -403,8 +398,8 @@ spv_result_t ConversionPass(ValidationState_t& _,
             _.GetBitWidth(input_type) * _.GetDimension(input_type);
         if (result_size != input_size)
           return _.diag(SPV_ERROR_INVALID_DATA)
-              << "Expected input to have the same total bit width as "
-              << "Result Type: " << spvOpcodeString(opcode);
+                 << "Expected input to have the same total bit width as "
+                 << "Result Type: " << spvOpcodeString(opcode);
       }
       break;
     }
diff --git a/source/validate_datarules.cpp b/source/validate_datarules.cpp
index 5a11e686..7d51ecab 100644
--- a/source/validate_datarules.cpp
+++ b/source/validate_datarules.cpp
@@ -122,8 +122,8 @@ spv_result_t ValidateIntSize(ValidationState_t& _,
     return _.diag(SPV_ERROR_INVALID_DATA)
            << "Using a 64-bit integer type requires the Int64 capability.";
   }
-  return _.diag(SPV_ERROR_INVALID_DATA) << "Invalid number of bits ("
-                                        << num_bits << ") used for OpTypeInt.";
+  return _.diag(SPV_ERROR_INVALID_DATA)
+         << "Invalid number of bits (" << num_bits << ") used for OpTypeInt.";
 }
 
 // Validates that the matrix is parameterized with floating-point types.
diff --git a/source/validate_decorations.cpp b/source/validate_decorations.cpp
index e2b7dfba..6fd3eeb6 100644
--- a/source/validate_decorations.cpp
+++ b/source/validate_decorations.cpp
@@ -165,4 +165,3 @@ spv_result_t ValidateDecorations(ValidationState_t& vstate) {
 }
 
 }  // namespace libspirv
-
diff --git a/source/validate_id.cpp b/source/validate_id.cpp
index 87d47282..6ee2f11d 100644
--- a/source/validate_id.cpp
+++ b/source/validate_id.cpp
@@ -202,22 +202,21 @@ bool idUsage::isValid<SpvOpMemberDecorate>(const spv_instruction_t* inst,
 
 template <>
 bool idUsage::isValid<SpvOpDecorationGroup>(const spv_instruction_t* inst,
-                                     const spv_opcode_desc) {
+                                            const spv_opcode_desc) {
   auto decorationGroupIndex = 1;
   auto decorationGroup = module_.FindDef(inst->words[decorationGroupIndex]);
 
   for (auto pair : decorationGroup->uses()) {
     auto use = pair.first;
-    if (use->opcode() != SpvOpDecorate &&
-        use->opcode() != SpvOpGroupDecorate &&
+    if (use->opcode() != SpvOpDecorate && use->opcode() != SpvOpGroupDecorate &&
         use->opcode() != SpvOpGroupMemberDecorate &&
-        use->opcode() != SpvOpName ) {
+        use->opcode() != SpvOpName) {
       DIAG(decorationGroupIndex) << "Result id of OpDecorationGroup can only "
                                  << "be targeted by OpName, OpGroupDecorate, "
                                  << "OpDecorate, and OpGroupMemberDecorate";
       return false;
     }
-  }                                        
+  }
   return true;
 }
 
@@ -228,8 +227,8 @@ bool idUsage::isValid<SpvOpGroupDecorate>(const spv_instruction_t* inst,
   auto decorationGroup = module_.FindDef(inst->words[decorationGroupIndex]);
   if (!decorationGroup || SpvOpDecorationGroup != decorationGroup->opcode()) {
     DIAG(decorationGroupIndex)
-    << "OpGroupDecorate Decoration group <id> '"
-    << inst->words[decorationGroupIndex] << "' is not a decoration group.";
+        << "OpGroupDecorate Decoration group <id> '"
+        << inst->words[decorationGroupIndex] << "' is not a decoration group.";
     return false;
   }
   return true;
@@ -296,8 +295,8 @@ bool idUsage::isValid<SpvOpEntryPoint>(const spv_instruction_t* inst,
     auto entryPointType = module_.FindDef(entryPoint->words()[4]);
     if (!entryPointType || 3 != entryPointType->words().size()) {
       DIAG(entryPointIndex)
-      << "OpEntryPoint Entry Point <id> '" << inst->words[entryPointIndex]
-      << "'s function parameter count is not zero.";
+          << "OpEntryPoint Entry Point <id> '" << inst->words[entryPointIndex]
+          << "'s function parameter count is not zero.";
       return false;
     }
   }
@@ -457,8 +456,8 @@ bool idUsage::isValid<SpvOpTypeStruct>(const spv_instruction_t* inst,
     auto memberType = module_.FindDef(memberTypeId);
     if (!memberType || !spvOpcodeGeneratesType(memberType->opcode())) {
       DIAG(memberTypeIndex)
-      << "OpTypeStruct Member Type <id> '" << inst->words[memberTypeIndex]
-      << "' is not a type.";
+          << "OpTypeStruct Member Type <id> '" << inst->words[memberTypeIndex]
+          << "' is not a type.";
       return false;
     }
     if (SpvOpTypeStruct == memberType->opcode() &&
@@ -638,10 +637,10 @@ bool idUsage::isValid<SpvOpConstantComposite>(const spv_instruction_t* inst,
         if (!constituentResultType ||
             componentType->opcode() != constituentResultType->opcode()) {
           DIAG(constituentIndex)
-          << "OpConstantComposite Constituent <id> '"
-          << inst->words[constituentIndex]
-          << "'s type does not match Result Type <id> '" << resultType->id()
-          << "'s vector element type.";
+              << "OpConstantComposite Constituent <id> '"
+              << inst->words[constituentIndex]
+              << "'s type does not match Result Type <id> '" << resultType->id()
+              << "'s vector element type.";
           return false;
         }
       }
@@ -666,8 +665,9 @@ bool idUsage::isValid<SpvOpConstantComposite>(const spv_instruction_t* inst,
       for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
            constituentIndex++) {
         auto constituent = module_.FindDef(inst->words[constituentIndex]);
-        if (!constituent || !(SpvOpConstantComposite == constituent->opcode() ||
-            SpvOpUndef == constituent->opcode())) {
+        if (!constituent ||
+            !(SpvOpConstantComposite == constituent->opcode() ||
+              SpvOpUndef == constituent->opcode())) {
           // The message says "... or undef" because the spec does not say
           // undef is a constant.
           DIAG(constituentIndex) << "OpConstantComposite Constituent <id> '"
@@ -679,10 +679,10 @@ bool idUsage::isValid<SpvOpConstantComposite>(const spv_instruction_t* inst,
         assert(vector);
         if (columnType->opcode() != vector->opcode()) {
           DIAG(constituentIndex)
-          << "OpConstantComposite Constituent <id> '"
-          << inst->words[constituentIndex]
-          << "' type does not match Result Type <id> '" << resultType->id()
-          << "'s matrix column type.";
+              << "OpConstantComposite Constituent <id> '"
+              << inst->words[constituentIndex]
+              << "' type does not match Result Type <id> '" << resultType->id()
+              << "'s matrix column type.";
           return false;
         }
         auto vectorComponentType = module_.FindDef(vector->words()[2]);
@@ -731,10 +731,10 @@ bool idUsage::isValid<SpvOpConstantComposite>(const spv_instruction_t* inst,
         assert(constituentType);
         if (elementType->id() != constituentType->id()) {
           DIAG(constituentIndex)
-          << "OpConstantComposite Constituent <id> '"
-          << inst->words[constituentIndex]
-          << "'s type does not match Result Type <id> '" << resultType->id()
-          << "'s array element type.";
+              << "OpConstantComposite Constituent <id> '"
+              << inst->words[constituentIndex]
+              << "'s type does not match Result Type <id> '" << resultType->id()
+              << "'s array element type.";
           return false;
         }
       }
@@ -892,13 +892,12 @@ bool idUsage::isValid<SpvOpSampledImage>(const spv_instruction_t* inst,
       auto consumer_opcode = consumer_instr->opcode();
       if (consumer_instr->block() != sampledImageInstr->block()) {
         DIAG(resultTypeIndex)
-        << "All OpSampledImage instructions must be in the same block in "
+            << "All OpSampledImage instructions must be in the same block in "
                "which their Result <id> are consumed. OpSampledImage Result "
                "Type <id> '"
-        << resultID
-        << "' has a consumer in a different basic "
-            "block. The consumer instruction <id> is '"
-        << consumer_id << "'.";
+            << resultID << "' has a consumer in a different basic "
+                           "block. The consumer instruction <id> is '"
+            << consumer_id << "'.";
         return false;
       }
       // TODO: The following check is incomplete. We should also check that the
@@ -966,10 +965,10 @@ bool idUsage::isValid<SpvOpSpecConstantComposite>(const spv_instruction_t* inst,
         if (!constituentResultType ||
             componentType->opcode() != constituentResultType->opcode()) {
           DIAG(constituentIndex)
-          << "OpSpecConstantComposite Constituent <id> '"
-          << inst->words[constituentIndex]
-          << "'s type does not match Result Type <id> '" << resultType->id()
-          << "'s vector element type.";
+              << "OpSpecConstantComposite Constituent <id> '"
+              << inst->words[constituentIndex]
+              << "'s type does not match Result Type <id> '" << resultType->id()
+              << "'s vector element type.";
           return false;
         }
       }
@@ -995,9 +994,10 @@ bool idUsage::isValid<SpvOpSpecConstantComposite>(const spv_instruction_t* inst,
            constituentIndex++) {
         auto constituent = module_.FindDef(inst->words[constituentIndex]);
         auto constituentOpCode = constituent->opcode();
-        if (!constituent || !(SpvOpSpecConstantComposite == constituentOpCode ||
-            SpvOpConstantComposite == constituentOpCode ||
-            SpvOpUndef == constituentOpCode)) {
+        if (!constituent ||
+            !(SpvOpSpecConstantComposite == constituentOpCode ||
+              SpvOpConstantComposite == constituentOpCode ||
+              SpvOpUndef == constituentOpCode)) {
           // The message says "... or undef" because the spec does not say
           // undef is a constant.
           DIAG(constituentIndex) << "OpSpecConstantComposite Constituent <id> '"
@@ -1009,10 +1009,10 @@ bool idUsage::isValid<SpvOpSpecConstantComposite>(const spv_instruction_t* inst,
         assert(vector);
         if (columnType->opcode() != vector->opcode()) {
           DIAG(constituentIndex)
-          << "OpSpecConstantComposite Constituent <id> '"
-          << inst->words[constituentIndex]
-          << "' type does not match Result Type <id> '" << resultType->id()
-          << "'s matrix column type.";
+              << "OpSpecConstantComposite Constituent <id> '"
+              << inst->words[constituentIndex]
+              << "' type does not match Result Type <id> '" << resultType->id()
+              << "'s matrix column type.";
           return false;
         }
         auto vectorComponentType = module_.FindDef(vector->words()[2]);
@@ -1062,10 +1062,10 @@ bool idUsage::isValid<SpvOpSpecConstantComposite>(const spv_instruction_t* inst,
         assert(constituentType);
         if (elementType->id() != constituentType->id()) {
           DIAG(constituentIndex)
-          << "OpSpecConstantComposite Constituent <id> '"
-          << inst->words[constituentIndex]
-          << "'s type does not match Result Type <id> '" << resultType->id()
-          << "'s array element type.";
+              << "OpSpecConstantComposite Constituent <id> '"
+              << inst->words[constituentIndex]
+              << "'s type does not match Result Type <id> '" << resultType->id()
+              << "'s array element type.";
           return false;
         }
       }
@@ -1139,8 +1139,8 @@ bool idUsage::isValid<SpvOpVariable>(const spv_instruction_t* inst,
         initialiser && spvOpcodeIsConstant(initialiser->opcode());
     if (!initialiser || !(is_constant || is_module_scope_var)) {
       DIAG(initialiserIndex)
-      << "OpVariable Initializer <id> '" << inst->words[initialiserIndex]
-      << "' is not a constant or module-scope variable.";
+          << "OpVariable Initializer <id> '" << inst->words[initialiserIndex]
+          << "' is not a constant or module-scope variable.";
       return false;
     }
   }
@@ -1227,15 +1227,20 @@ bool idUsage::isValid<SpvOpStore>(const spv_instruction_t* inst,
   {
     uint32_t dataType;
     uint32_t storageClass;
-    if (!module_.GetPointerTypeInfo(pointerType->id(), &dataType, &storageClass)) {
-      DIAG(pointerIndex) << "OpStore Pointer <id> '"<< inst->words[pointerIndex] << "' is not pointer type";
+    if (!module_.GetPointerTypeInfo(pointerType->id(), &dataType,
+                                    &storageClass)) {
+      DIAG(pointerIndex) << "OpStore Pointer <id> '"
+                         << inst->words[pointerIndex]
+                         << "' is not pointer type";
       return false;
     }
 
     if (storageClass == SpvStorageClassUniformConstant ||
         storageClass == SpvStorageClassInput ||
         storageClass == SpvStorageClassPushConstant) {
-      DIAG(pointerIndex) << "OpStore Pointer <id> '" << inst->words[pointerIndex] << "' storage class is read-only";
+      DIAG(pointerIndex) << "OpStore Pointer <id> '"
+                         << inst->words[pointerIndex]
+                         << "' storage class is read-only";
       return false;
     }
   }
@@ -1256,9 +1261,9 @@ bool idUsage::isValid<SpvOpStore>(const spv_instruction_t* inst,
   }
 
   if (type->id() != objectType->id()) {
-    if (!module_.options()->relax_struct_store
-        || type->opcode() != SpvOpTypeStruct
-        || objectType->opcode() != SpvOpTypeStruct) {
+    if (!module_.options()->relax_struct_store ||
+        type->opcode() != SpvOpTypeStruct ||
+        objectType->opcode() != SpvOpTypeStruct) {
       DIAG(pointerIndex) << "OpStore Pointer <id> '"
                          << inst->words[pointerIndex]
                          << "'s type does not match Object <id> '"
@@ -1490,9 +1495,8 @@ bool idUsage::isValid<SpvOpAccessChain>(const spv_instruction_t* inst,
       }
       default: {
         // Give an error. reached non-composite type while indexes still remain.
-        DIAG(i) << instr_name
-                << " reached non-composite type while indexes "
-                    "still remain to be traversed.";
+        DIAG(i) << instr_name << " reached non-composite type while indexes "
+                                 "still remain to be traversed.";
         return false;
       }
     }
@@ -1568,8 +1572,8 @@ bool idUsage::isValid<SpvOpFunction>(const spv_instruction_t* inst,
   auto functionType = module_.FindDef(inst->words[functionTypeIndex]);
   if (!functionType || SpvOpTypeFunction != functionType->opcode()) {
     DIAG(functionTypeIndex)
-    << "OpFunction Function Type <id> '" << inst->words[functionTypeIndex]
-    << "' is not a function type.";
+        << "OpFunction Function Type <id> '" << inst->words[functionTypeIndex]
+        << "' is not a function type.";
     return false;
   }
   auto returnType = module_.FindDef(functionType->words()[2]);
@@ -1825,9 +1829,8 @@ bool walkCompositeTypeHierarchy(
       }
       default: {
         // Give an error. reached non-composite type while indexes still remain.
-        *error << instr_name()
-               << " reached non-composite type while indexes "
-                   "still remain to be traversed.";
+        *error << instr_name() << " reached non-composite type while indexes "
+                                  "still remain to be traversed.";
         return false;
       }
     }
@@ -1952,13 +1955,12 @@ bool idUsage::isValid<SpvOpCompositeInsert>(const spv_instruction_t* inst,
   auto objectTypeInstr = module_.FindDef(objectInstr->type_id());
   if (indexedTypeInstr->id() != objectTypeInstr->id()) {
     DIAG(objectIdIndex)
-    << "The Object type (Op"
-    << spvOpcodeString(static_cast<SpvOp>(objectTypeInstr->opcode()))
-    << ") in " << instr_name()
-    << " does not match the type that results "
-        "from indexing into the Composite (Op"
-    << spvOpcodeString(static_cast<SpvOp>(indexedTypeInstr->opcode()))
-    << ").";
+        << "The Object type (Op"
+        << spvOpcodeString(static_cast<SpvOp>(objectTypeInstr->opcode()))
+        << ") in " << instr_name() << " does not match the type that results "
+                                      "from indexing into the Composite (Op"
+        << spvOpcodeString(static_cast<SpvOp>(indexedTypeInstr->opcode()))
+        << ").";
     return false;
   }
 
@@ -2056,16 +2058,16 @@ bool idUsage::isValid<OpBranch>(const spv_instruction_t *inst,
 #endif
 
 template <>
-bool idUsage::isValid<SpvOpBranchConditional>(
-    const spv_instruction_t *inst, const spv_opcode_desc) {
+bool idUsage::isValid<SpvOpBranchConditional>(const spv_instruction_t* inst,
+                                              const spv_opcode_desc) {
   const size_t numOperands = inst->words.size() - 1;
   const size_t condOperandIndex = 1;
   const size_t targetTrueIndex = 2;
   const size_t targetFalseIndex = 3;
 
-  // num_operands is either 3 or 5 --- if 5, the last two need to be literal integers
-  if (numOperands != 3 &&
-      numOperands != 5) {
+  // num_operands is either 3 or 5 --- if 5, the last two need to be literal
+  // integers
+  if (numOperands != 3 && numOperands != 5) {
     DIAG(0) << "OpBranchConditional requires either 3 or 5 parameters";
     return false;
   }
@@ -2075,22 +2077,26 @@ bool idUsage::isValid<SpvOpBranchConditional>(
   // grab the condition operand and check that it is a bool
   const auto condOp = module_.FindDef(inst->words[condOperandIndex]);
   if (!condOp || !module_.IsBoolScalarType(condOp->type_id())) {
-    DIAG(0) << "Condition operand for OpBranchConditional must be of boolean type";
+    DIAG(0)
+        << "Condition operand for OpBranchConditional must be of boolean type";
     ret = false;
   }
 
   // target operands must be OpLabel
-  // note that we don't need to check that the target labels are in the same function,
+  // note that we don't need to check that the target labels are in the same
+  // function,
   // PerformCfgChecks already checks for that
   const auto targetOpTrue = module_.FindDef(inst->words[targetTrueIndex]);
   if (!targetOpTrue || SpvOpLabel != targetOpTrue->opcode()) {
-    DIAG(0) << "The 'True Label' operand for OpBranchConditional must be the ID of an OpLabel instruction";
+    DIAG(0) << "The 'True Label' operand for OpBranchConditional must be the "
+               "ID of an OpLabel instruction";
     ret = false;
   }
 
   const auto targetOpFalse = module_.FindDef(inst->words[targetFalseIndex]);
   if (!targetOpFalse || SpvOpLabel != targetOpFalse->opcode()) {
-    DIAG(0) << "The 'False Label' operand for OpBranchConditional must be the ID of an OpLabel instruction";
+    DIAG(0) << "The 'False Label' operand for OpBranchConditional must be the "
+               "ID of an OpLabel instruction";
     ret = false;
   }
 
@@ -2723,9 +2729,9 @@ bool idUsage::HaveLayoutCompatibleMembers(const libspirv::Instruction* type1,
 bool idUsage::HaveSameLayoutDecorations(const libspirv::Instruction* type1,
                                         const libspirv::Instruction* type2) {
   assert(type1->opcode() == SpvOpTypeStruct &&
-      "type1 must be and OpTypeStruct instruction.");
+         "type1 must be and OpTypeStruct instruction.");
   assert(type2->opcode() == SpvOpTypeStruct &&
-      "type2 must be and OpTypeStruct instruction.");
+         "type2 must be and OpTypeStruct instruction.");
   const std::vector<Decoration>& type1_decorations =
       module_.id_decorations(type1->id());
   const std::vector<Decoration>& type2_decorations =
@@ -2915,8 +2921,8 @@ spv_result_t IdPass(ValidationState_t& _,
           ret = _.ForwardDeclareId(operand_word);
         } else {
           ret = _.diag(SPV_ERROR_INVALID_ID)
-              << "ID " << _.getIdName(operand_word)
-              << " has not been defined";
+                << "ID " << _.getIdName(operand_word)
+                << " has not been defined";
         }
         break;
       default:
diff --git a/source/validate_logicals.cpp b/source/validate_logicals.cpp
index 1a3fb148..766fd26a 100644
--- a/source/validate_logicals.cpp
+++ b/source/validate_logicals.cpp
@@ -38,11 +38,10 @@ inline uint32_t GetOperandWord(const spv_parsed_instruction_t* inst,
 // Returns the type id of instruction operand at |operand_index|.
 // The operand is expected to be an id.
 inline uint32_t GetOperandTypeId(ValidationState_t& _,
-                               const spv_parsed_instruction_t* inst,
-                               size_t operand_index) {
+                                 const spv_parsed_instruction_t* inst,
+                                 size_t operand_index) {
   return _.GetTypeId(GetOperandWord(inst, operand_index));
 }
-
 }
 
 // Validates correctness of logical instructions.
@@ -56,14 +55,14 @@ spv_result_t LogicalsPass(ValidationState_t& _,
     case SpvOpAll: {
       if (!_.IsBoolScalarType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected bool scalar type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected bool scalar type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t vector_type = GetOperandTypeId(_, inst, 2);
       if (!vector_type || !_.IsBoolVectorType(vector_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected operand to be vector bool: "
-            << spvOpcodeString(opcode);
+               << "Expected operand to be vector bool: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -73,28 +72,27 @@ spv_result_t LogicalsPass(ValidationState_t& _,
     case SpvOpIsFinite:
     case SpvOpIsNormal:
     case SpvOpSignBitSet: {
-      if (!_.IsBoolScalarType(result_type) &&
-          !_.IsBoolVectorType(result_type))
+      if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected bool scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected bool scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t operand_type = GetOperandTypeId(_, inst, 2);
       if (!operand_type || (!_.IsFloatScalarType(operand_type) &&
-                           !_.IsFloatVectorType(operand_type)))
+                            !_.IsFloatVectorType(operand_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected operand to be scalar or vector float: "
-            << spvOpcodeString(opcode);
+               << "Expected operand to be scalar or vector float: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(operand_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected vector sizes of Result Type and the operand to be equal: "
-            << spvOpcodeString(opcode);
+               << "Expected vector sizes of Result Type and the operand to be "
+                  "equal: "
+               << spvOpcodeString(opcode);
 
       break;
     }
 
-
     case SpvOpFOrdEqual:
     case SpvOpFUnordEqual:
     case SpvOpFOrdNotEqual:
@@ -110,28 +108,28 @@ spv_result_t LogicalsPass(ValidationState_t& _,
     case SpvOpLessOrGreater:
     case SpvOpOrdered:
     case SpvOpUnordered: {
-      if (!_.IsBoolScalarType(result_type) &&
-          !_.IsBoolVectorType(result_type))
+      if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected bool scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected bool scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t left_operand_type = GetOperandTypeId(_, inst, 2);
       if (!left_operand_type || (!_.IsFloatScalarType(left_operand_type) &&
                                  !_.IsFloatVectorType(left_operand_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected operands to be scalar or vector float: "
-            << spvOpcodeString(opcode);
+               << "Expected operands to be scalar or vector float: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(left_operand_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected vector sizes of Result Type and the operands to be equal: "
-            << spvOpcodeString(opcode);
+               << "Expected vector sizes of Result Type and the operands to be "
+                  "equal: "
+               << spvOpcodeString(opcode);
 
       if (left_operand_type != GetOperandTypeId(_, inst, 3))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected left and right operands to have the same type: "
-            << spvOpcodeString(opcode);
+               << "Expected left and right operands to have the same type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -140,32 +138,30 @@ spv_result_t LogicalsPass(ValidationState_t& _,
     case SpvOpLogicalNotEqual:
     case SpvOpLogicalOr:
     case SpvOpLogicalAnd: {
-      if (!_.IsBoolScalarType(result_type) &&
-          !_.IsBoolVectorType(result_type))
+      if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected bool scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected bool scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       if (result_type != GetOperandTypeId(_, inst, 2) ||
           result_type != GetOperandTypeId(_, inst, 3))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected both operands to be of Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected both operands to be of Result Type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
 
     case SpvOpLogicalNot: {
-      if (!_.IsBoolScalarType(result_type) &&
-          !_.IsBoolVectorType(result_type))
+      if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected bool scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected bool scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       if (result_type != GetOperandTypeId(_, inst, 2))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected operand to be of Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected operand to be of Result Type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -182,8 +178,8 @@ spv_result_t LogicalsPass(ValidationState_t& _,
             if (!_.features().variable_pointers &&
                 !_.features().variable_pointers_storage_buffer)
               return _.diag(SPV_ERROR_INVALID_DATA)
-                  << "Using pointers with OpSelect requires capability "
-                  << "VariablePointers or VariablePointersStorageBuffer";
+                     << "Using pointers with OpSelect requires capability "
+                     << "VariablePointers or VariablePointersStorageBuffer";
             break;
           }
 
@@ -200,8 +196,8 @@ spv_result_t LogicalsPass(ValidationState_t& _,
 
           default: {
             return _.diag(SPV_ERROR_INVALID_DATA)
-                << "Expected scalar or vector type as Result Type: "
-                << spvOpcodeString(opcode);
+                   << "Expected scalar or vector type as Result Type: "
+                   << spvOpcodeString(opcode);
           }
         }
       }
@@ -213,18 +209,18 @@ spv_result_t LogicalsPass(ValidationState_t& _,
       if (!condition_type || (!_.IsBoolScalarType(condition_type) &&
                               !_.IsBoolVectorType(condition_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected bool scalar or vector type as condition: "
-            << spvOpcodeString(opcode);
+               << "Expected bool scalar or vector type as condition: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(condition_type) != dimension)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected vector sizes of Result Type and the condition to be"
-            << " equal: " << spvOpcodeString(opcode);
+               << "Expected vector sizes of Result Type and the condition to be"
+               << " equal: " << spvOpcodeString(opcode);
 
       if (result_type != left_type || result_type != right_type)
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected both objects to be of Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected both objects to be of Result Type: "
+               << spvOpcodeString(opcode);
 
       break;
     }
@@ -239,41 +235,41 @@ spv_result_t LogicalsPass(ValidationState_t& _,
     case SpvOpSGreaterThanEqual:
     case SpvOpSLessThan:
     case SpvOpSLessThanEqual: {
-      if (!_.IsBoolScalarType(result_type) &&
-          !_.IsBoolVectorType(result_type))
+      if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected bool scalar or vector type as Result Type: "
-            << spvOpcodeString(opcode);
+               << "Expected bool scalar or vector type as Result Type: "
+               << spvOpcodeString(opcode);
 
       const uint32_t left_type = GetOperandTypeId(_, inst, 2);
       const uint32_t right_type = GetOperandTypeId(_, inst, 3);
 
-      if (!left_type || (!_.IsIntScalarType(left_type) &&
-                         !_.IsIntVectorType(left_type)))
+      if (!left_type ||
+          (!_.IsIntScalarType(left_type) && !_.IsIntVectorType(left_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected operands to be scalar or vector int: "
-            << spvOpcodeString(opcode);
+               << "Expected operands to be scalar or vector int: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(left_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected vector sizes of Result Type and the operands to be"
-            << " equal: " << spvOpcodeString(opcode);
+               << "Expected vector sizes of Result Type and the operands to be"
+               << " equal: " << spvOpcodeString(opcode);
 
-      if (!right_type || (!_.IsIntScalarType(right_type) &&
-                         !_.IsIntVectorType(right_type)))
+      if (!right_type ||
+          (!_.IsIntScalarType(right_type) && !_.IsIntVectorType(right_type)))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected operands to be scalar or vector int: "
-            << spvOpcodeString(opcode);
+               << "Expected operands to be scalar or vector int: "
+               << spvOpcodeString(opcode);
 
       if (_.GetDimension(result_type) != _.GetDimension(right_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected vector sizes of Result Type and the operands to be"
-            << " equal: " << spvOpcodeString(opcode);
+               << "Expected vector sizes of Result Type and the operands to be"
+               << " equal: " << spvOpcodeString(opcode);
 
       if (_.GetBitWidth(left_type) != _.GetBitWidth(right_type))
         return _.diag(SPV_ERROR_INVALID_DATA)
-            << "Expected both operands to have the same component bit width: "
-            << spvOpcodeString(opcode);
+               << "Expected both operands to have the same component bit "
+                  "width: "
+               << spvOpcodeString(opcode);
 
       break;
     }
diff --git a/source/validate_type_unique.cpp b/source/validate_type_unique.cpp
index 7b54200c..b7f77ed6 100644
--- a/source/validate_type_unique.cpp
+++ b/source/validate_type_unique.cpp
@@ -50,9 +50,9 @@ spv_result_t TypeUniquePass(ValidationState_t& _,
 
     if (!_.RegisterUniqueTypeDeclaration(*inst)) {
       return _.diag(SPV_ERROR_INVALID_DATA)
-          << "Duplicate non-aggregate type declarations are not allowed."
-          << " Opcode: " << spvOpcodeString(SpvOp(inst->opcode))
-          << " id: " << inst->result_id;
+             << "Duplicate non-aggregate type declarations are not allowed."
+             << " Opcode: " << spvOpcodeString(SpvOp(inst->opcode))
+             << " id: " << inst->result_id;
     }
   }