diff --git a/pkg/analyzer/CHANGELOG.md b/pkg/analyzer/CHANGELOG.md
index 924f983..13a6e34 100644
--- a/pkg/analyzer/CHANGELOG.md
+++ b/pkg/analyzer/CHANGELOG.md
@@ -1,5 +1,7 @@
 ## 0.40.5-dev
 * Deprecated `GenericTypeAliasElement`. Use `FunctionTypeAliasElement`.
+* Read imports, exports, and parts on demand in `AnalysisDriver`.
+  Specifically, `parseFileSync` will not read any referenced files.
 
 ## 0.40.4
 * Deprecated `IndexExpression.auxiliaryElements` and
diff --git a/pkg/analyzer/lib/src/dart/analysis/file_state.dart b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
index 2524193..00d6c6f 100644
--- a/pkg/analyzer/lib/src/dart/analysis/file_state.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
@@ -192,23 +192,54 @@
 
   /// Return the set of all directly referenced files - imported, exported or
   /// parted.
-  Set<FileState> get directReferencedFiles => _directReferencedFiles;
+  Set<FileState> get directReferencedFiles {
+    return _directReferencedFiles ??= <FileState>{
+      ...importedFiles,
+      ...exportedFiles,
+      ...partedFiles,
+    };
+  }
 
   /// Return the set of all directly referenced libraries - imported or
   /// exported.
-  Set<FileState> get directReferencedLibraries => _directReferencedLibraries;
+  Set<FileState> get directReferencedLibraries {
+    return _directReferencedLibraries ??= <FileState>{
+      ...importedFiles,
+      ...exportedFiles,
+    };
+  }
 
   /// Return `true` if the file exists.
   bool get exists => _exists;
 
   /// The list of files this file exports.
-  List<FileState> get exportedFiles => _exportedFiles;
+  List<FileState> get exportedFiles {
+    if (_exportedFiles == null) {
+      _exportedFiles = <FileState>[];
+      for (var directive in _unlinked2.exports) {
+        var uri = _selectRelativeUri(directive);
+        var file = _fileForRelativeUri(uri);
+        _exportedFiles.add(file);
+      }
+    }
+    return _exportedFiles;
+  }
 
   @override
   int get hashCode => uri.hashCode;
 
   /// The list of files this file imports.
-  List<FileState> get importedFiles => _importedFiles;
+  List<FileState> get importedFiles {
+    if (_importedFiles == null) {
+      _importedFiles = <FileState>[];
+      for (var directive in _unlinked2.imports) {
+        var uri = _selectRelativeUri(directive);
+        var file = _fileForRelativeUri(uri);
+        _importedFiles.add(file);
+      }
+    }
+    return _importedFiles;
+  }
 
   LibraryCycle get internal_libraryCycle => _libraryCycle;
 
@@ -237,6 +268,7 @@
   /// of. Return `null` if a library is not known, for example because we have
   /// not processed a library file yet.
   FileState get library {
+    _fsState.readPartsForLibraries();
     List<FileState> libraries = _fsState._partToLibraries[this];
     if (libraries == null || libraries.isEmpty) {
       return null;
@@ -264,13 +296,27 @@
 
   /// The list of files files that this library consists of, i.e. this library
   /// file itself and its [partedFiles].
-  List<FileState> get libraryFiles => _libraryFiles;
+  List<FileState> get libraryFiles {
+    return _libraryFiles ??= [this, ...partedFiles];
+  }
 
   /// Return information about line in the file.
   LineInfo get lineInfo => _lineInfo;
 
   /// The list of files this library file references as parts.
-  List<FileState> get partedFiles => _partedFiles;
+  List<FileState> get partedFiles {
+    if (_partedFiles == null) {
+      _partedFiles = <FileState>[];
+      for (var uri in _unlinked2.parts) {
+        var file = _fileForRelativeUri(uri);
+        _partedFiles.add(file);
+        _fsState._partToLibraries
+            .putIfAbsent(file, () => <FileState>[])
+            .add(this);
+      }
+    }
+    return _partedFiles;
+  }
 
   /// The external names referenced by the file.
   Set<String> get referencedNames {
@@ -287,7 +333,7 @@
 
     void appendReferenced(FileState file) {
       if (transitiveFiles.add(file)) {
-        file._directReferencedFiles?.forEach(appendReferenced);
+        file.directReferencedFiles.forEach(appendReferenced);
       }
     }
 
@@ -436,39 +482,16 @@
       }
     }
 
-    // Build the graph.
-    _importedFiles = <FileState>[];
-    _exportedFiles = <FileState>[];
-    _partedFiles = <FileState>[];
-    for (var directive in _unlinked2.imports) {
-      var uri = _selectRelativeUri(directive);
-      var file = _fileForRelativeUri(uri);
-      _importedFiles.add(file);
-    }
-    for (var directive in _unlinked2.exports) {
-      var uri = _selectRelativeUri(directive);
-      var file = _fileForRelativeUri(uri);
-      _exportedFiles.add(file);
-    }
-    for (var uri in _unlinked2.parts) {
-      var file = _fileForRelativeUri(uri);
-      _partedFiles.add(file);
-      _fsState._partToLibraries
-          .putIfAbsent(file, () => <FileState>[])
-          .add(this);
-    }
-    _libraryFiles = [this, ..._partedFiles];
+    // Read imports/exports on demand.
+    _importedFiles = null;
+    _exportedFiles = null;
+    _directReferencedFiles = null;
+    _directReferencedLibraries = null;
 
-    // Compute referenced files.
-    _directReferencedFiles = <FileState>{
-      ..._importedFiles,
-      ..._exportedFiles,
-      ..._partedFiles,
-    };
-    _directReferencedLibraries = <FileState>{
-      ..._importedFiles,
-      ..._exportedFiles,
-    };
+    // Read parts on demand.
+    _fsState._librariesWithoutPartsRead.add(this);
+    _partedFiles = null;
+    _libraryFiles = null;
 
     // Update mapping from subtyped names to files.
     for (var name in _driverUnlinkedUnit.subtypedNames) {
@@ -748,6 +771,11 @@
   /// Mapping from a path to the corresponding canonical [FileState].
   final Map<String, FileState> _pathToCanonicalFile = {};
 
+  /// We don't read parts until requested, but if we need to know the
+  /// library for a file, we need to read parts of every file to know
+  /// which libraries reference this part.
+  final List<FileState> _librariesWithoutPartsRead = [];
+
   /// Mapping from a part to the libraries it is a part of.
   final Map<FileState, List<FileState>> _partToLibraries = {};
 
@@ -950,6 +978,19 @@
     _fileContentCache.remove(path);
   }
 
+  void readPartsForLibraries() {
+    // Make a copy, because reading new files will update it.
+    var libraryToProcess = _librariesWithoutPartsRead.toList();
+
+    // We will process these files, so clear it now.
+    // It will be filled with new files during the loop below.
+    _librariesWithoutPartsRead.clear();
+
+    for (var library in libraryToProcess) {
+      library.partedFiles;
+    }
+  }
+
   /// Remove the file with the given [path].
   void removeFile(String path) {
     markFileForReading(path);
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
index 7d59c48..16cf839 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
@@ -2349,6 +2349,49 @@
     }
   }
 
+  test_parseFileSync_doesNotReadImportedFiles() async {
+    var a = convertPath('/test/lib/a.dart');
+    var b = convertPath('/test/lib/b.dart');
+
+    newFile(a, content: '');
+    newFile(b, content: r'''
+import 'a.dart';
+''');
+
+    expect(driver.fsState.knownFilePaths, isEmpty);
+
+    // Don't read `a.dart` when parse.
+    driver.parseFileSync(b);
+    expect(driver.fsState.knownFilePaths, unorderedEquals([b]));
+
+    // Still don't read `a.dart` when parse the second time.
+    driver.parseFileSync(b);
+    expect(driver.fsState.knownFilePaths, unorderedEquals([b]));
+  }
+
+  test_parseFileSync_doesNotReadPartedFiles() async {
+    var a = convertPath('/test/lib/a.dart');
+    var b = convertPath('/test/lib/b.dart');
+
+    newFile(a, content: r'''
+part of my;
+''');
+    newFile(b, content: r'''
+library my;
+part 'a.dart';
+''');
+
+    expect(driver.fsState.knownFilePaths, isEmpty);
+
+    // Don't read `a.dart` when parse.
+    driver.parseFileSync(b);
+    expect(driver.fsState.knownFilePaths, unorderedEquals([b]));
+
+    // Still don't read `a.dart` when parse the second time.
+    driver.parseFileSync(b);
+    expect(driver.fsState.knownFilePaths, unorderedEquals([b]));
+  }
+
   test_parseFileSync_languageVersion() async {
     var path = convertPath('/test/lib/test.dart');
 
diff --git a/pkg/analyzer_cli/lib/src/driver.dart b/pkg/analyzer_cli/lib/src/driver.dart
index 3e86667..1115b86 100644
--- a/pkg/analyzer_cli/lib/src/driver.dart
+++ b/pkg/analyzer_cli/lib/src/driver.dart
@@ -8,6 +8,7 @@
 import 'package:analyzer/dart/analysis/context_locator.dart' as api;
 import 'package:analyzer/dart/sdk/build_sdk_summary.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/src/context/builder.dart';
@@ -27,6 +28,8 @@
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/lint/linter.dart';
+import 'package:analyzer/src/lint/pub.dart';
 import 'package:analyzer/src/manifest/manifest_validator.dart';
 import 'package:analyzer/src/pubspec/pubspec_validator.dart';
 import 'package:analyzer/src/source/package_map_resolver.dart';
@@ -284,6 +287,7 @@
             }
           }
         } else if (shortName == AnalysisEngine.PUBSPEC_YAML_FILE) {
+          var errors = <AnalysisError>[];
           try {
             var file = resourceProvider.getFile(path);
             var content = file.readAsStringSync();
@@ -291,17 +295,46 @@
             if (node is YamlMap) {
               var validator =
                   PubspecValidator(resourceProvider, file.createSource());
-              var lineInfo = LineInfo.fromContent(content);
-              var errors = validator.validate(node.nodes);
-              formatter.formatErrors([
-                ErrorsResultImpl(analysisDriver.currentSession, path, null,
-                    lineInfo, false, errors)
-              ]);
+              errors.addAll(validator.validate(node.nodes));
+            }
+
+            if (analysisDriver != null && analysisDriver.analysisOptions.lint) {
+              var visitors = <LintRule, PubspecVisitor>{};
+              for (var linter in analysisDriver.analysisOptions.lintRules) {
+                if (linter is LintRule) {
+                  var visitor = linter.getPubspecVisitor();
+                  if (visitor != null) {
+                    visitors[linter] = visitor;
+                  }
+                }
+              }
+              if (visitors.isNotEmpty) {
+                var sourceUri = resourceProvider.pathContext.toUri(path);
+                var pubspecAst = Pubspec.parse(content,
+                    sourceUrl: sourceUri, resourceProvider: resourceProvider);
+                var listener = RecordingErrorListener();
+                var reporter = ErrorReporter(listener,
+                    resourceProvider.getFile(path).createSource(sourceUri),
+                    isNonNullableByDefault: false);
+                for (var entry in visitors.entries) {
+                  entry.key.reporter = reporter;
+                  pubspecAst.accept(entry.value);
+                }
+                errors.addAll(listener.errors);
+              }
+            }
+
+            if (errors.isNotEmpty) {
               for (var error in errors) {
                 var severity = determineProcessedSeverity(
                     error, options, analysisDriver.analysisOptions);
                 allResult = allResult.max(severity);
               }
+              var lineInfo = LineInfo.fromContent(content);
+              formatter.formatErrors([
+                ErrorsResultImpl(analysisDriver.currentSession, path, null,
+                    lineInfo, false, errors)
+              ]);
             }
           } catch (exception) {
             // If the file cannot be analyzed, ignore it.
diff --git a/pkg/analyzer_cli/test/data/linter_project/analysis_options.yaml b/pkg/analyzer_cli/test/data/linter_project/analysis_options.yaml
index 6af57a5..50bbbb0 100644
--- a/pkg/analyzer_cli/test/data/linter_project/analysis_options.yaml
+++ b/pkg/analyzer_cli/test/data/linter_project/analysis_options.yaml
@@ -1,3 +1,4 @@
 linter:
   rules:
     - camel_case_types
+    - sort_pub_dependencies
diff --git a/pkg/analyzer_cli/test/data/linter_project/pubspec.yaml b/pkg/analyzer_cli/test/data/linter_project/pubspec.yaml
new file mode 100644
index 0000000..132fb58
--- /dev/null
+++ b/pkg/analyzer_cli/test/data/linter_project/pubspec.yaml
@@ -0,0 +1,5 @@
+name: linter_project
+
+dependencies:
+  test: any
+  async: any
diff --git a/pkg/analyzer_cli/test/driver_test.dart b/pkg/analyzer_cli/test/driver_test.dart
index ffd85a2..45d42ab 100644
--- a/pkg/analyzer_cli/test/driver_test.dart
+++ b/pkg/analyzer_cli/test/driver_test.dart
@@ -863,9 +863,10 @@
     /// Lints should be enabled.
     expect(analysisOptions.lint, isTrue);
 
-    /// The analysis options file only specifies 'camel_case_types'.
+    /// The analysis options file specifies 'camel_case_types' and 'sort_pub_dependencies'.
     var lintNames = analysisOptions.lintRules.map((r) => r.name);
-    expect(lintNames, orderedEquals(['camel_case_types']));
+    expect(lintNames,
+        orderedEquals(['camel_case_types', 'sort_pub_dependencies']));
   }
 
   Future<void> test_noLints_lintsDisabled() async {
@@ -883,6 +884,12 @@
     expect(analysisOptions.lintRules, isEmpty);
   }
 
+  Future<void> test_pubspec_lintsInOptions_generatedLints() async {
+    await drive('data/linter_project/pubspec.yaml',
+        options: 'data/linter_project/$optionsFileName');
+    expect(bulletToDash(outSink), contains('lint - Sort pub dependencies'));
+  }
+
   YamlMap _parseOptions(String src) =>
       AnalysisOptionsProvider().getOptionsFromString(src);
 
diff --git a/runtime/vm/compiler/asm_intrinsifier_arm64.cc b/runtime/vm/compiler/asm_intrinsifier_arm64.cc
index 7552c3c..bf0eb6a 100644
--- a/runtime/vm/compiler/asm_intrinsifier_arm64.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_arm64.cc
@@ -1554,8 +1554,10 @@
 
   __ Bind(&use_declaration_type);
   __ LoadClassById(R2, R1);
-  __ ldr(R3, FieldAddress(R2, target::Class::num_type_arguments_offset()),
-         kHalfword);
+  __ ldr(
+      R3,
+      FieldAddress(R2, target::Class::num_type_arguments_offset(), kHalfword),
+      kHalfword);
   __ CompareImmediate(R3, 0);
   __ b(normal_ir_body, NE);
 
@@ -1594,7 +1596,8 @@
   // Otherwise fall through into the runtime to handle comparison.
   __ LoadClassById(scratch, cid1);
   __ ldr(scratch,
-         FieldAddress(scratch, target::Class::num_type_arguments_offset()),
+         FieldAddress(scratch, target::Class::num_type_arguments_offset(),
+                      kHalfword),
          kHalfword);
   __ cbnz(normal_ir_body, scratch);
   __ b(equal);
@@ -1693,9 +1696,9 @@
 
   // Check nullability.
   __ Bind(&equiv_cids);
-  __ ldr(R1, FieldAddress(R1, target::Type::nullability_offset()),
+  __ ldr(R1, FieldAddress(R1, target::Type::nullability_offset(), kByte),
          kUnsignedByte);
-  __ ldr(R2, FieldAddress(R2, target::Type::nullability_offset()),
+  __ ldr(R2, FieldAddress(R2, target::Type::nullability_offset(), kByte),
          kUnsignedByte);
   __ cmp(R1, Operand(R2));
   __ b(&check_legacy, NE);
@@ -1703,7 +1706,7 @@
 
   __ Bind(&equal);
   __ LoadObject(R0, CastHandle<Object>(TrueObject()));
-  __ Ret();
+  __ ret();
 
   // At this point the nullabilities are different, so they can only be
   // syntactically equivalent if they're both either kNonNullable or kLegacy.
@@ -1726,7 +1729,8 @@
 void AsmIntrinsifier::Object_getHash(Assembler* assembler,
                                      Label* normal_ir_body) {
   __ ldr(R0, Address(SP, 0 * target::kWordSize));
-  __ ldr(R0, FieldAddress(R0, target::String::hash_offset()), kUnsignedWord);
+  __ ldr(R0, FieldAddress(R0, target::String::hash_offset(), kWord),
+         kUnsignedWord);
   __ SmiTag(R0);
   __ ret();
 }
@@ -1736,7 +1740,8 @@
   __ ldr(R0, Address(SP, 1 * target::kWordSize));  // Object.
   __ ldr(R1, Address(SP, 0 * target::kWordSize));  // Value.
   __ SmiUntag(R1);
-  __ str(R1, FieldAddress(R0, target::String::hash_offset()), kUnsignedWord);
+  __ str(R1, FieldAddress(R0, target::String::hash_offset(), kWord),
+         kUnsignedWord);
   __ ret();
 }
 
@@ -2096,7 +2101,7 @@
   __ AddImmediate(R6, 1);
   __ sub(R2, R2, Operand(1));
   __ cmp(R2, Operand(0));
-  __ str(R1, FieldAddress(R7, target::OneByteString::data_offset()),
+  __ str(R1, FieldAddress(R7, target::OneByteString::data_offset(), kByte),
          kUnsignedByte);
   __ AddImmediate(R7, 1);
   __ b(&loop, GT);
diff --git a/runtime/vm/compiler/assembler/assembler_arm64.cc b/runtime/vm/compiler/assembler/assembler_arm64.cc
index 4699f5d..9e3c425 100644
--- a/runtime/vm/compiler/assembler/assembler_arm64.cc
+++ b/runtime/vm/compiler/assembler/assembler_arm64.cc
@@ -987,8 +987,10 @@
   if (can_be_smi == kValueCanBeSmi) {
     BranchIfSmi(value, &done);
   }
-  ldr(TMP, FieldAddress(object, target::Object::tags_offset()), kUnsignedByte);
-  ldr(TMP2, FieldAddress(value, target::Object::tags_offset()), kUnsignedByte);
+  ldr(TMP, FieldAddress(object, target::Object::tags_offset(), kByte),
+      kUnsignedByte);
+  ldr(TMP2, FieldAddress(value, target::Object::tags_offset(), kByte),
+      kUnsignedByte);
   and_(TMP, TMP2,
        Operand(TMP, LSR, target::ObjectLayout::kBarrierOverlapShift));
   tst(TMP, Operand(BARRIER_MASK));
@@ -1049,8 +1051,10 @@
   if (can_be_smi == kValueCanBeSmi) {
     BranchIfSmi(value, &done);
   }
-  ldr(TMP, FieldAddress(object, target::Object::tags_offset()), kUnsignedByte);
-  ldr(TMP2, FieldAddress(value, target::Object::tags_offset()), kUnsignedByte);
+  ldr(TMP, FieldAddress(object, target::Object::tags_offset(), kByte),
+      kUnsignedByte);
+  ldr(TMP2, FieldAddress(value, target::Object::tags_offset(), kByte),
+      kUnsignedByte);
   and_(TMP, TMP2,
        Operand(TMP, LSR, target::ObjectLayout::kBarrierOverlapShift));
   tst(TMP, Operand(BARRIER_MASK));
@@ -1077,7 +1081,8 @@
   Label done;
   StoreIntoObjectFilter(object, value, &done, kValueCanBeSmi, kJumpToNoUpdate);
 
-  ldr(TMP, FieldAddress(object, target::Object::tags_offset()), kUnsignedByte);
+  ldr(TMP, FieldAddress(object, target::Object::tags_offset(), kByte),
+      kUnsignedByte);
   tsti(TMP, Immediate(1 << target::ObjectLayout::kOldAndNotRememberedBit));
   b(&done, ZERO);
 
diff --git a/runtime/vm/compiler/assembler/assembler_arm64.h b/runtime/vm/compiler/assembler/assembler_arm64.h
index c9bd624..b60f259 100644
--- a/runtime/vm/compiler/assembler/assembler_arm64.h
+++ b/runtime/vm/compiler/assembler/assembler_arm64.h
@@ -94,12 +94,14 @@
       : ValueObject(),
         encoding_(other.encoding_),
         type_(other.type_),
-        base_(other.base_) {}
+        base_(other.base_),
+        log2sz_(other.log2sz_) {}
 
   Address& operator=(const Address& other) {
     encoding_ = other.encoding_;
     type_ = other.type_;
     base_ = other.base_;
+    log2sz_ = other.log2sz_;
     return *this;
   }
 
@@ -136,11 +138,15 @@
           OperandSize sz = kDoubleWord) {
     ASSERT((rn != kNoRegister) && (rn != R31) && (rn != ZR));
     ASSERT(CanHoldOffset(offset, at, sz));
+    log2sz_ = -1;
     const int32_t scale = Log2OperandSizeBytes(sz);
     if ((at == Offset) && Utils::IsUint(12 + scale, offset) &&
         (offset == ((offset >> scale) << scale))) {
       encoding_ =
           B24 | ((offset >> scale) << kImm12Shift) | Arm64Encode::Rn(rn);
+      if (offset != 0) {
+        log2sz_ = scale;
+      }
     } else if ((at == Offset) && Utils::IsInt(9, offset)) {
       encoding_ = ((offset & 0x1ff) << kImm9Shift) | Arm64Encode::Rn(rn);
     } else if ((at == PreIndex) || (at == PostIndex)) {
@@ -172,6 +178,9 @@
           idx |
           ((static_cast<uint32_t>(offset >> scale) << kImm7Shift) & kImm7Mask) |
           Arm64Encode::Rn(rn);
+      if (offset != 0) {
+        log2sz_ = scale;
+      }
     }
     type_ = at;
     base_ = ConcreteRegister(rn);
@@ -214,6 +223,7 @@
     addr.encoding_ = (((pc_off >> 2) << kImm19Shift) & kImm19Mask);
     addr.base_ = kNoRegister;
     addr.type_ = PCOffset;
+    addr.log2sz_ = -1;
     return addr;
   }
 
@@ -249,6 +259,7 @@
                 (static_cast<int32_t>(ext) << kExtendTypeShift);
     type_ = Reg;
     base_ = ConcreteRegister(rn);
+    log2sz_ = -1;  // Any.
   }
 
   static OperandSize OperandSizeFor(intptr_t cid) {
@@ -307,6 +318,7 @@
   uint32_t encoding_;
   AddressType type_;
   Register base_;
+  int32_t log2sz_;  // Required log2 of operand size (-1 means any).
 
   friend class Assembler;
 };
@@ -517,7 +529,8 @@
   }
 
   void CompareTypeNullabilityWith(Register type, int8_t value) {
-    ldr(TMP, FieldAddress(type, compiler::target::Type::nullability_offset()),
+    ldr(TMP,
+        FieldAddress(type, compiler::target::Type::nullability_offset(), kByte),
         kUnsignedByte);
     cmp(TMP, Operand(value));
   }
@@ -2244,6 +2257,7 @@
     ASSERT((op != LDR && op != STR && op != LDRS) || a.can_writeback_to(rt));
 
     const int32_t size = Log2OperandSizeBytes(sz);
+    ASSERT(a.log2sz_ == -1 || a.log2sz_ == size);
     const int32_t encoding =
         op | ((size & 0x3) << kSzShift) | Arm64Encode::Rt(rt) | a.encoding();
     Emit(encoding);
@@ -2254,6 +2268,7 @@
                           Address a,
                           OperandSize sz) {
     ASSERT((sz == kDoubleWord) || (sz == kWord) || (sz == kUnsignedWord));
+    ASSERT(a.log2sz_ == -1 || a.log2sz_ == Log2OperandSizeBytes(sz));
     ASSERT((rt != CSP) && (rt != R31));
     const int32_t size = (sz == kDoubleWord) ? B30 : 0;
     const int32_t encoding = op | size | Arm64Encode::Rt(rt) | a.encoding();
@@ -2270,6 +2285,7 @@
     ASSERT(op != LDP || rt != rt2);
 
     ASSERT((sz == kDoubleWord) || (sz == kWord) || (sz == kUnsignedWord));
+    ASSERT(a.log2sz_ == -1 || a.log2sz_ == Log2OperandSizeBytes(sz));
     ASSERT((rt != CSP) && (rt != R31));
     ASSERT((rt2 != CSP) && (rt2 != R31));
     int32_t opc = 0;
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index cfd814a..7ab2f6d 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -1407,7 +1407,7 @@
   const Register str = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   __ LoadFieldFromOffset(result, str, String::length_offset());
-  __ ldr(TMP, compiler::FieldAddress(str, OneByteString::data_offset()),
+  __ ldr(TMP, compiler::FieldAddress(str, OneByteString::data_offset(), kByte),
          kUnsignedByte);
   __ CompareImmediate(result, Smi::RawValue(1));
   __ LoadImmediate(result, -1);
@@ -4123,7 +4123,8 @@
   compiler::Label done;
   __ SmiUntag(result, value);
   __ BranchIfSmi(value, &done);
-  __ ldr(result, compiler::FieldAddress(value, Mint::value_offset()), kWord);
+  __ ldr(result, compiler::FieldAddress(value, Mint::value_offset(), kWord),
+         kWord);
   __ LoadFieldFromOffset(result, value, Mint::value_offset());
   __ Bind(&done);
 }
diff --git a/runtime/vm/compiler/stub_code_compiler_arm64.cc b/runtime/vm/compiler/stub_code_compiler_arm64.cc
index 84c1a04..488da1a 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm64.cc
@@ -1812,7 +1812,7 @@
     Label slow_case;
 
     // Load num. variable (int32) in the existing context.
-    __ ldr(R1, FieldAddress(R5, target::Context::num_variables_offset()),
+    __ ldr(R1, FieldAddress(R5, target::Context::num_variables_offset(), kWord),
            kWord);
 
     GenerateAllocateContextSpaceStub(assembler, &slow_case);
@@ -3461,10 +3461,10 @@
   __ BranchIf(NOT_EQUAL, &is_complex_case);
 
   // Check whether this [Type] is instantiated/uninstantiated.
-  __ ldr(
-      kTmp,
-      FieldAddress(TypeTestABI::kDstTypeReg, target::Type::type_state_offset()),
-      kByte);
+  __ ldr(kTmp,
+         FieldAddress(TypeTestABI::kDstTypeReg,
+                      target::Type::type_state_offset(), kByte),
+         kByte);
   __ cmp(kTmp,
          Operand(target::AbstractTypeLayout::kTypeStateFinalizedInstantiated));
   __ BranchIf(NOT_EQUAL, &is_complex_case);
@@ -3923,9 +3923,13 @@
 void StubCodeCompiler::GenerateSingleTargetCallStub(Assembler* assembler) {
   Label miss;
   __ LoadClassIdMayBeSmi(R1, R0);
-  __ ldr(R2, FieldAddress(R5, target::SingleTargetCache::lower_limit_offset()),
+  __ ldr(R2,
+         FieldAddress(R5, target::SingleTargetCache::lower_limit_offset(),
+                      kHalfword),
          kUnsignedHalfword);
-  __ ldr(R3, FieldAddress(R5, target::SingleTargetCache::upper_limit_offset()),
+  __ ldr(R3,
+         FieldAddress(R5, target::SingleTargetCache::upper_limit_offset(),
+                      kHalfword),
          kUnsignedHalfword);
 
   __ cmp(R1, Operand(R2));
diff --git a/tools/VERSION b/tools/VERSION
index 31c1251..0168c17 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 11
 PATCH 0
-PRERELEASE 235
+PRERELEASE 236
 PRERELEASE_PATCH 0
\ No newline at end of file