@@ -79,6 +79,19 @@ support. Changes to the specification itself are tracked in the root
 
 ### Fixed
 
+- A struct read from storage into a local, as in
+  `let p = players[who];` or `let s = stored;`, is now a copy in memory,
+  as the examples' README describes: reading `p.score` reads the copy,
+  and a write to `p.score` changes the copy, not storage. A field that is
+  a struct is copied too; a struct with an array, mapping, `string` or
+  dynamic `bytes` field is an error. Before, at every optimization level,
+  the local held the struct's first storage word as if it were a memory
+  address, and a write to one of its fields failed code generation
+  ([#PR]).
+- A value whose only later uses are as the address, slot or value of a
+  read or write, or as the base of an offset, now gets a home in memory
+  when code generation cannot keep it on the stack. Before, such a value
+  could fail code generation with "Cannot load value" ([#PR]).
 - A call to a function with no return type now compiles as a statement,
   as in `bump();`, at every optimization level. The function's `return`
   context has no `data`. Before, IR generation failed with "Cannot convert
 
@@ -360,6 +360,25 @@ function getUsedValues(inst: Ir.Instruction): Set<string> {
     case "assert":
       addValue(inst.condition);
       break;
+    case "read":
+      addValue(inst.slot);
+      addValue(inst.offset);
+      addValue(inst.length);
+      break;
+    case "write":
+      addValue(inst.slot);
+      addValue(inst.offset);
+      addValue(inst.length);
+      addValue(inst.value);
+      break;
+    case "compute_offset":
+      addValue(inst.base);
+      if (Ir.Instruction.ComputeOffset.isArray(inst)) {
+        addValue(inst.index);
+      } else if (Ir.Instruction.ComputeOffset.isByte(inst)) {
+        addValue(inst.offset);
+      }
+      break;
     // Call instruction removed - calls are now block terminators
   }
 
 
@@ -1289,6 +1289,105 @@ code {
     }
   });
 
+  describe("struct locals copied from storage", () => {
+    const program = (body: string) => `name StructCopy;
+
+define {
+  struct Inner {
+    a: uint8;
+    b: uint256;
+  };
+  struct Player {
+    score: uint64;
+    combo: int32;
+    active: bool;
+    total: uint256;
+    inner: Inner;
+  };
+}
+
+storage {
+  [0] players: mapping<address, Player>;
+  [1] out: uint256;
+  [2] one: Player;
+}
+
+create {
+  players[0x0000000000000000000000000000000000000000].score = 10;
+  players[0x0000000000000000000000000000000000000000].combo = (0 as int32) - 3;
+  players[0x0000000000000000000000000000000000000000].active = true;
+  players[0x0000000000000000000000000000000000000000].total = 99;
+  players[0x0000000000000000000000000000000000000000].inner.a = 7;
+  players[0x0000000000000000000000000000000000000000].inner.b = 8;
+  one.score = 20;
+  one.total = 21;
+}
+
+code {
+  let who = 0x0000000000000000000000000000000000000000;
+  ${body}
+}`;
+
+    const cases: Record<string, [string, bigint]> = {
+      "a field in the first slot": [
+        `let p = players[who];
+  out = p.score;`,
+        10n,
+      ],
+      "a signed field": [
+        `let p = players[who];
+  if (p.combo == (0 as int32) - 3) { out = 1; }`,
+        1n,
+      ],
+      "a bool field": [
+        `let p = players[who];
+  if (p.active) { out = 1; }`,
+        1n,
+      ],
+      "a field in the second slot": [
+        `let p = players[who];
+  out = p.total;`,
+        99n,
+      ],
+      "a nested struct's fields": [
+        `let p = players[who];
+  out = (p.inner.a as uint256) * 1000 + p.inner.b;`,
+        7008n,
+      ],
+      "a storage struct variable": [
+        `let p = one;
+  out = p.score + p.total;`,
+        41n,
+      ],
+      "a write to the copy, which storage does not see": [
+        `let p = players[who];
+  p.score = 50;
+  out = p.score * 1000 + players[who].score;`,
+        50010n,
+      ],
+      "a write to storage, which the copy does not see": [
+        `let p = players[who];
+  players[who].score = 50;
+  out = p.score * 1000 + players[who].score;`,
+        10050n,
+      ],
+    };
+
+    for (const [name, [body, expected]] of Object.entries(cases)) {
+      for (const level of [0, 1, 2, 3] as const) {
+        it(`should copy ${name} (level ${level})`, async () => {
+          const result = await executeProgram(program(body), {
+            calldata: "",
+            optimizationLevel: level,
+          });
+
+          expect(result.callSuccess).toBe(true);
+          expect(await result.getStorage(1n)).toBe(expected);
+        });
+      }
+    }
+  });
+
   describe("modulo", () => {
     const program = (expr: string) => `name Modulo;
 
 
@@ -5,7 +5,10 @@ import { Severity } from "#result";
 import { Error as IrgenError, ErrorMessages } from "#irgen/errors";
 import { fromBugType } from "#irgen/type";
 
+import { Type } from "#types";
+
 import { Process } from "../process.js";
+import { emitStorageStructCopy } from "../storage.js";
 
 /**
  * Build an identifier expression
@@ -30,6 +33,15 @@ export function* buildIdentifier(
       ? fromBugType(storageType)
       : Ir.Type.Scalar.uint256;
 
+    // A struct is a copy in memory, not the slot's word
+    if (storageType && Type.isStruct(storageType)) {
+      return yield* emitStorageStructCopy(
+        Ir.Value.constant(BigInt(storageSlot.slot), Ir.Type.Scalar.uint256),
+        storageType,
+        expr,
+      );
+    }
+
     // Build storage load using new unified read instruction
     const tempId = yield* Process.Variables.newTemp();
     yield* Process.Instructions.emit({
 
@@ -173,15 +173,16 @@ function* assignToTarget(node: Ast.Expression, value: Ir.Value): Process<void> {
           const offsetTemp = yield* Process.Variables.newTemp();
           // Calculate field offset - assuming 32 bytes per field for now
           const fieldOffset = fieldIndex * 32;
-          yield* Process.Instructions.emit({
-            kind: "compute_offset",
-            location: "memory",
-            base: object,
-            field: fieldName,
-            fieldOffset,
-            dest: offsetTemp,
-            operationDebug: yield* Process.Debug.forAstNode(accessNode),
-          } as Ir.Instruction.ComputeOffset);
+          yield* Process.Instructions.emit(
+            Ir.Instruction.ComputeOffset.field(
+              "memory",
+              object,
+              fieldName,
+              fieldOffset,
+              offsetTemp,
+              yield* Process.Debug.forAstNode(accessNode),
+            ),
+          );
 
           // Then write to that offset
           yield* Process.Instructions.emit({
 
@@ -271,6 +271,11 @@ export function* emitStorageChainLoad(
     }
   }
 
+  // A struct is a copy in memory, not the slot's word
+  if (currentOrigin && Type.isStruct(currentOrigin)) {
+    return yield* emitStorageStructCopy(currentSlot, currentOrigin, node);
+  }
+
   // Check if the last access was a struct field to get packed field info
   let byteOffset = 0;
   let fieldSize = 32; // Default to full slot
@@ -305,6 +310,117 @@ export function* emitStorageChainLoad(
   return Ir.Value.temp(loadTempId, valueType);
 }
 
+/**
+ * Copy a struct from storage, starting at `slot`, into new memory, and
+ * return its address. A struct in memory has one word per field, in
+ * order; a struct field is the address of its own copy.
+ */
+export function* emitStorageStructCopy(
+  slot: Ir.Value,
+  struct: Type.Struct,
+  node: Ast.Node | undefined,
+): Process<Ir.Value> {
+  const debug = node ? yield* Process.Debug.forAstNode(node) : {};
+  const uint256 = Ir.Type.Scalar.uint256;
+  const constant = (value: bigint) => Ir.Value.constant(value, uint256);
+
+  const address = yield* Process.Variables.newTemp();
+  yield* Process.Instructions.emit({
+    kind: "allocate",
+    location: "memory",
+    size: constant(BigInt(struct.fields.size * 32)),
+    dest: address,
+    operationDebug: debug,
+  } as Ir.Instruction);
+
+  let index = 0;
+  for (const [name, fieldType] of struct.fields) {
+    const layout = struct.layout.get(name);
+    if (!layout) {
+      throw new Error(`Field ${name} not found in struct ${struct.name}`);
+    }
+
+    // The field's slot
+    let fieldSlot = slot;
+    if (layout.byteOffset >= 32) {
+      const temp = yield* Process.Variables.newTemp();
+      yield* Process.Instructions.emit({
+        kind: "compute_slot",
+        slotKind: "field",
+        base: slot,
+        fieldOffset: layout.byteOffset,
+        dest: temp,
+        operationDebug: debug,
+      } as Ir.Instruction.ComputeSlot);
+      fieldSlot = Ir.Value.temp(temp, uint256);
+    }
+
+    let value: Ir.Value;
+    if (Type.isStruct(fieldType)) {
+      value = yield* emitStorageStructCopy(fieldSlot, fieldType, node);
+    } else if (
+      Type.isElementary(fieldType) &&
+      !(Type.Elementary.isBytes(fieldType) && fieldType.size === undefined) &&
+      !Type.Elementary.isString(fieldType)
+    ) {
+      const irType = fromBugType(fieldType);
+      const temp = yield* Process.Variables.newTemp();
+      yield* Process.Instructions.emit({
+        kind: "read",
+        location: "storage",
+        slot: fieldSlot,
+        offset: constant(BigInt(layout.byteOffset % 32)),
+        length: constant(BigInt(getFieldSize(irType))),
+        type: irType,
+        dest: temp,
+        operationDebug: debug,
+      } as Ir.Instruction.Read);
+      value = Ir.Value.temp(temp, irType);
+    } else {
+      yield* Process.Errors.report(
+        new IrgenError(
+          `Cannot copy struct ${struct.name} from storage: its field ` +
+            `${name} is a ${Type.format(fieldType)}, and only value ` +
+            `and struct fields can be copied to memory`,
+          node?.loc ?? undefined,
+          Severity.Error,
+        ),
+      );
+      value = constant(0n);
+    }
+
+    // The field's word in memory
+    let offset = Ir.Value.temp(address, uint256);
+    if (index > 0) {
+      const temp = yield* Process.Variables.newTemp();
+      yield* Process.Instructions.emit(
+        Ir.Instruction.ComputeOffset.field(
+          "memory",
+          offset,
+          name,
+          index * 32,
+          temp,
+          debug,
+        ),
+      );
+      offset = Ir.Value.temp(temp, uint256);
+    }
+
+    yield* Process.Instructions.emit({
+      kind: "write",
+      location: "memory",
+      offset,
+      length: constant(32n),
+      value,
+      operationDebug: debug,
+    } as Ir.Instruction.Write);
+
+    index++;
+  }
+
+  return Ir.Value.temp(address, Ir.Type.Ref.memory());
+}
+
 /**
  * Emit a storage write for an access chain
  */
 
@@ -107,4 +107,35 @@ describe("generateModule error handling", () => {
     );
     expect(defaultingWarnings).toHaveLength(0);
   });
+  it("should reject a struct copy from storage with an array field", async () => {
+    const source = `
+      name Test;
+      define {
+        struct Bag {
+          count: uint256;
+          items: array<uint256>;
+        };
+      }
+      storage {
+        [0] bag: Bag;
+        [1] out: uint256;
+      }
+      code {
+        let b = bag;
+        out = b.count;
+      }
+    `;
+
+    const result = await compileTest(source);
+
+    expect(result.success).toBe(false);
+    const messages = Result.findMessages(result, {
+      severity: Severity.Error,
+    }).map((d) => d.message);
+    expect(messages).toContainEqual(
+      expect.stringContaining(
+        "Cannot copy struct Bag from storage: its field items",
+      ),
+    );
+  });
 });