diff --git a/src/Pipeline/SpirvShaderDebugger.cpp b/src/Pipeline/SpirvShaderDebugger.cpp
index 06f75c9..ea2adc8 100644
--- a/src/Pipeline/SpirvShaderDebugger.cpp
+++ b/src/Pipeline/SpirvShaderDebugger.cpp
@@ -33,6 +33,7 @@
 #	include "spirv-tools/libspirv.h"
 
 #	include <algorithm>
+#	include <queue>
 
 namespace {
 
@@ -52,6 +53,14 @@
 template<typename T>
 using ArgTyT = typename ArgTy<T>::type;
 
+template<typename T>
+T take(std::queue<T> &queue)
+{
+	auto v = queue.front();
+	queue.pop();
+	return v;
+}
+
 }  // anonymous namespace
 
 namespace spvtools {
@@ -256,12 +265,26 @@
 		       kind == Kind::TemplateType;
 	}
 
+	std::pair<const Type *, uint32_t> index(std::queue<uint32_t> &&indices) const
+	{
+		if(indices.size() == 0)
+		{
+			return { this, 0 };
+		}
+		return indexMember(std::move(indices));
+	}
+
 	// sizeInBytes() returns the number of bytes of the given debug type.
 	virtual uint32_t sizeInBytes() const = 0;
 
 	// value() returns a shared pointer to a vk::dbg::Value that views the data
 	// at ptr of this type.
 	virtual std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const = 0;
+
+protected:
+	// indexMember() returns the nested inner element debug type and byte offset
+	// from the base of this type, using the list of indices.
+	virtual std::pair<const Type *, uint32_t> indexMember(std::queue<uint32_t> &&) const = 0;
 };
 
 struct CompilationUnit : ObjectImpl<CompilationUnit, Scope, Object::Kind::CompilationUnit>
@@ -286,6 +309,12 @@
 
 	uint32_t sizeInBytes() const override { return size / 8; }
 
+	std::pair<const Type *, uint32_t> indexMember(std::queue<uint32_t> &&) const override
+	{
+		DABORT("indexMember() called on BasicType %s", name.c_str());
+		return {};
+	}
+
 	std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
 	{
 		switch(encoding)
@@ -397,6 +426,24 @@
 		return numBytes;
 	}
 
+	std::pair<const Type *, uint32_t> indexMember(std::queue<uint32_t> &&indices) const override
+	{
+		std::vector<uint32_t> arrIndices(dimensions.size());
+		for(size_t i = 0; i < dimensions.size(); i++)
+		{
+			arrIndices[i] = take(indices);
+		}
+
+		auto out = base->index(std::move(indices));
+		auto stride = base->sizeInBytes();
+		for(int i = static_cast<int>(dimensions.size()) - 1; i >= 0; i--)
+		{
+			out.second += arrIndices[i] * stride;
+			stride *= dimensions[i];
+		}
+		return out;
+	}
+
 	std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
 	{
 		auto vc = std::make_shared<vk::dbg::VariableContainer>();
@@ -431,6 +478,14 @@
 		return base->sizeInBytes() * components;
 	}
 
+	std::pair<const Type *, uint32_t> indexMember(std::queue<uint32_t> &&indices) const override
+	{
+		auto idx = take(indices);
+		auto out = base->index(std::move(indices));
+		out.second += base->sizeInBytes() * idx;
+		return out;
+	}
+
 	std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
 	{
 		const auto elSize = base->sizeInBytes();
@@ -456,6 +511,11 @@
 	std::vector<Type *> paramTys;
 
 	uint32_t sizeInBytes() const override { return 0; }
+	std::pair<const Type *, uint32_t> indexMember(std::queue<uint32_t> &&indices) const override
+	{
+		DABORT("indexMember() called on FunctionType");
+		return {};
+	}
 	std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override { return nullptr; }
 };
 
@@ -487,6 +547,15 @@
 
 	uint32_t sizeInBytes() const override { return size / 8; }
 
+	std::pair<const Type *, uint32_t> indexMember(std::queue<uint32_t> &&indices) const override
+	{
+		auto idx = take(indices);
+		auto member = members[idx];
+		auto out = member->type->index(std::move(indices));
+		out.second += member->offset / 8;
+		return out;
+	}
+
 	std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
 	{
 		auto vc = std::make_shared<vk::dbg::VariableContainer>();
@@ -520,6 +589,10 @@
 	std::vector<TemplateParameter *> parameters;
 
 	uint32_t sizeInBytes() const override { return target->sizeInBytes(); }
+	std::pair<const Type *, uint32_t> indexMember(std::queue<uint32_t> &&indices) const override
+	{
+		return target->index(std::move(indices));
+	}
 	std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
 	{
 		return target->value(ptr, interleaved);
@@ -605,7 +678,7 @@
 struct Value : ObjectImpl<Value, Object, Object::Kind::Value>
 {
 	LocalVariable *local = nullptr;
-	sw::SpirvShader::Object::ID variable;
+	sw::SpirvShader::Object::ID value;
 	Expression *expression = nullptr;
 	std::vector<uint32_t> indexes;
 };
@@ -658,6 +731,7 @@
 // sw::SpirvShader::Impl::Debugger
 //
 // Private struct holding debugger information for the SpirvShader.
+// There is an instance of this class per shader program.
 ////////////////////////////////////////////////////////////////////////////////
 struct SpirvShader::Impl::Debugger
 {
@@ -676,6 +750,13 @@
 	void setLocation(EmitState *state, const std::shared_ptr<vk::dbg::File> &, int line, int column);
 	void setLocation(EmitState *state, const std::string &path, int line, int column);
 
+	// foreachLane() calls f for each debugger group representing the SIMD
+	// lanes of execution.
+	// FUNC is a function with the signature:
+	//   (int lane, const Group &group, auto &key)
+	template<typename Key, typename Func>
+	void foreachLane(const Key &key, const debug::Scope *scope, EmitState *state, Func &&f) const;
+
 	// exposeVariable exposes the variable with the given ID to the debugger
 	// using the specified key.
 	template<typename Key>
@@ -705,6 +786,17 @@
 	std::unordered_map<const void *, int> spirvLineMappings;  // instruction pointer to line
 	std::unordered_map<const void *, Object::ID> results;     // instruction pointer to result ID
 
+	// Shadow memory is used to construct a contiguous memory block for local
+	// variables that may be formed from multiple SSA values.
+	struct Shadow
+	{
+		// Offset in the shadow memory allocation for the given local variable.
+		std::unordered_map<debug::LocalVariable *, uint32_t> offsets;
+
+		// Total size of the shadow memory in bytes.
+		uint32_t size;
+	} shadow;
+
 private:
 	// add() registers the debug object with the given id.
 	template<typename ID>
@@ -754,6 +846,7 @@
 // sw::SpirvShader::Impl::Debugger::State
 //
 // State holds the runtime data structures for the shader debug session.
+// There is an instance of this class per shader invocation.
 ////////////////////////////////////////////////////////////////////////////////
 class SpirvShader::Impl::Debugger::State
 {
@@ -800,6 +893,7 @@
 
 	const Debugger *debugger;
 	const std::shared_ptr<vk::dbg::Thread> thread;
+	std::unique_ptr<uint8_t[]> const shadow;
 	std::unordered_map<const debug::Scope *, Scopes> scopes;
 	Scopes globals;                          // Scope for globals.
 	debug::SourceScope *srcScope = nullptr;  // Current source scope.
@@ -821,6 +915,7 @@
 SpirvShader::Impl::Debugger::State::State(const Debugger *debugger, const char *stackBase, vk::dbg::Context::Lock &lock)
     : debugger(debugger)
     , thread(lock.currentThread())
+    , shadow(new uint8_t[debugger->shadow.size])
     , initialThreadDepth(thread->depth())
 {
 	enter(lock, stackBase);
@@ -1371,11 +1466,92 @@
 		case OpenCLDebugInfo100DebugValue:
 			defineOrEmit(insn, pass, [&](debug::Value *value) {
 				value->local = get(debug::LocalVariable::ID(insn.word(5)));
-				value->variable = Object::ID(insn.word(6));
+				value->value = Object::ID(insn.word(6));
 				value->expression = get(debug::Expression::ID(insn.word(7)));
 				for(uint32_t i = 8; i < insn.wordCount(); i++)
 				{
-					value->indexes.push_back(insn.word(i));
+					auto idx = shader->GetConstScalarInt(insn.word(i));
+					value->indexes.push_back(idx);
+				}
+
+				// DebugValue partially updates a DebugLocalVariable with an SSA
+				// value. This is typically used to update a DebugLocalVariable
+				// of a composite type, which holds structure member offsets
+				// from a base address.
+				// To handle these, we allocate shadow memory to hold a copy of
+				// the entire variable in contiguous memory and have the
+				// DebugLocalVariable point to this memory. Whenever we
+				// encounter a DebugValue, we copy the necessary fields to the
+				// shadow memory.
+
+				// type of the full DebugLocalVariable.
+				auto type = value->local->type;
+
+				// base address of the variable.
+				// Start by pointing base to the root of the shadow memory.
+				// This will be offset to the variable, then the member within
+				// the variable below.
+				SIMD::Pointer base(*Pointer<Pointer<Byte>>(state->routine->dbgState + OFFSET(State, shadow)), shadow.size);
+
+				// All variables are considered local, and therefore
+				// interleaved.
+				base = InterleaveByLane(base);
+
+				// Have we already allocated shadow memory for this variable?
+				auto it = shadow.offsets.find(value->local);
+				if(it == shadow.offsets.end())
+				{
+					// No shadow memory has been allocated for this local
+					// variable yet.
+
+					// Allocate the memory for the variable.
+					auto offset = shadow.size;
+					shadow.offsets.emplace(value->local, offset);
+					auto size = type->sizeInBytes() * SIMD::Width;
+					base += offset;
+					shadow.size += size;
+
+					// Expose the variable.
+					auto name = value->local->name.c_str();
+					auto scope = value->local->parent;
+					auto offsets = base.offsets();
+					foreachLane(name, scope, state, [&](int lane, const Group &group, auto &key) {
+						auto ptr = base.base + Extract(offsets, lane);
+						group.putPtr<const char *>(name, ptr, true, value->local->type);
+					});
+				}
+				else
+				{
+					// Shadow memory already allocated for this variable.
+					// Offset base to point to it.
+					base += it->second;
+				}
+
+				// Find the byte offset on the indexed member of the variable.
+				std::queue<uint32_t> indices;
+				for(auto idx : value->indexes)
+				{
+					indices.emplace(idx);
+				}
+				auto offset = type->index(std::move(indices)).second;
+
+				// Update base to point to the particular member.
+				base += offset;
+
+				// Now copy the updated value into shadow memory representation
+				// of the variable.
+				// TODO(b/148401179): This assumes tight packing of all
+				// components, which may not match with the debug structure
+				// layout.
+				auto &valObject = shader->getObject(value->value);
+				auto &valType = shader->getType(valObject);
+				for(auto i = 0u; i < valType.componentCount; i++)
+				{
+					auto val = Operand(shader, state, value->value).Int(i);
+					auto dst = base + i * sizeof(uint32_t) * SIMD::Width;
+					// Use RobustBufferAccess as the size as described by the
+					// debug type may be smaller than the true SSA size.
+					dst.Store(val, sw::OutOfBoundsBehavior::RobustBufferAccess, state->activeLaneMask());
 				}
 			});
 			break;
@@ -1505,6 +1681,22 @@
 	return ptr;
 }
 
+template<typename Key, typename Func>
+void SpirvShader::Impl::Debugger::foreachLane(
+    const Key &key,
+    const debug::Scope *scope,
+    EmitState *state,
+    Func &&f) const
+{
+	auto dbgState = state->routine->dbgState;
+	auto hover = Group::hovers(dbgState, scope).group<Key>(key);
+	for(int lane = 0; lane < SIMD::Width; lane++)
+	{
+		f(lane, Group::localsLane(dbgState, scope, lane), key);
+		f(lane, hover, laneNames[lane]);
+	}
+}
+
 template<typename Key>
 void SpirvShader::Impl::Debugger::exposeVariable(
     const SpirvShader *shader,
@@ -1514,13 +1706,9 @@
     Object::ID id,
     EmitState *state) const
 {
-	auto dbgState = state->routine->dbgState;
-	auto hover = Group::hovers(dbgState, scope).group<Key>(key);
-	for(int lane = 0; lane < SIMD::Width; lane++)
-	{
-		exposeVariable(shader, Group::localsLane(dbgState, scope, lane), lane, key, type, id, state);
-		exposeVariable(shader, hover, lane, laneNames[lane], type, id, state);
-	}
+	foreachLane(key, scope, state, [&](int lane, const Group &group, auto &key) {
+		exposeVariable(shader, group, lane, laneNames[lane], type, id, state);
+	});
 }
 
 template<typename Key>