diff --git a/dex2oat/linker/oat_writer.cc b/dex2oat/linker/oat_writer.cc
index 01c24fc..23c486d 100644
--- a/dex2oat/linker/oat_writer.cc
+++ b/dex2oat/linker/oat_writer.cc
@@ -3401,6 +3401,11 @@
 }
 
 bool OatWriter::LayoutAndWriteDexFile(OutputStream* out, OatDexFile* oat_dex_file) {
+  // Open dex files and write them into `out`.
+  // Note that we only verify dex files which do not belong to the boot class path.
+  // This is because those have been processed by `hiddenapi` and would not pass
+  // some of the checks. No guarantees are lost, however, as `hiddenapi` verifies
+  // the dex files prior to processing.
   TimingLogger::ScopedTiming split("Dex Layout", timings_);
   std::string error_msg;
   std::string location(oat_dex_file->GetLocation());
@@ -3421,7 +3426,7 @@
     dex_file = dex_file_loader.Open(location,
                                     zip_entry->GetCrc32(),
                                     std::move(mem_map),
-                                    /* verify */ true,
+                                    /* verify */ !GetCompilerOptions().IsBootImage(),
                                     /* verify_checksum */ true,
                                     &error_msg);
   } else if (oat_dex_file->source_.IsRawFile()) {
@@ -3433,7 +3438,7 @@
     }
     TimingLogger::ScopedTiming extract("Open", timings_);
     dex_file = dex_file_loader.OpenDex(dup_fd, location,
-                                       /* verify */ true,
+                                       /* verify */ !GetCompilerOptions().IsBootImage(),
                                        /* verify_checksum */ true,
                                        /* mmap_shared */ false,
                                        &error_msg);
diff --git a/dexdump/dexdump.cc b/dexdump/dexdump.cc
index 2b59342..6b2a1b9 100644
--- a/dexdump/dexdump.cc
+++ b/dexdump/dexdump.cc
@@ -1208,7 +1208,7 @@
  */
 static void dumpMethod(const ClassAccessor::Method& method, int i) {
   // Bail for anything private if export only requested.
-  const uint32_t flags = method.GetAccessFlags();
+  const uint32_t flags = method.GetRawAccessFlags();
   if (gOptions.exportsOnly && (flags & (kAccPublic | kAccProtected)) == 0) {
     return;
   }
@@ -1319,7 +1319,7 @@
  */
 static void dumpField(const ClassAccessor::Field& field, int i, const u1** data = nullptr) {
   // Bail for anything private if export only requested.
-  const uint32_t flags = field.GetAccessFlags();
+  const uint32_t flags = field.GetRawAccessFlags();
   if (gOptions.exportsOnly && (flags & (kAccPublic | kAccProtected)) == 0) {
     return;
   }
diff --git a/dexlayout/compact_dex_writer.cc b/dexlayout/compact_dex_writer.cc
index a7dad07..a04cfb6 100644
--- a/dexlayout/compact_dex_writer.cc
+++ b/dexlayout/compact_dex_writer.cc
@@ -441,7 +441,6 @@
   WriteTypeLists(data_stream);
   WriteClassDatas(data_stream);
   WriteStringDatas(data_stream);
-  WriteHiddenapiClassData(data_stream);
 
   // Write delayed id sections that depend on data sections.
   {
diff --git a/dexlayout/dex_ir.h b/dexlayout/dex_ir.h
index 20ebc17..598f7df 100644
--- a/dexlayout/dex_ir.h
+++ b/dexlayout/dex_ir.h
@@ -21,11 +21,11 @@
 
 #include <stdint.h>
 
+#include <map>
 #include <vector>
 
 #include "base/iteration_range.h"
 #include "base/leb128.h"
-#include "base/safe_map.h"
 #include "base/stl_util.h"
 #include "dex/dex_file-inl.h"
 #include "dex/dex_file_types.h"
@@ -50,7 +50,6 @@
 class FieldId;
 class FieldItem;
 class Header;
-class HiddenapiClassData;
 class MapList;
 class MapItem;
 class MethodHandleItem;
@@ -102,7 +101,6 @@
   virtual void Dispatch(AnnotationSetItem* annotation_set_item) = 0;
   virtual void Dispatch(AnnotationSetRefList* annotation_set_ref_list) = 0;
   virtual void Dispatch(AnnotationsDirectoryItem* annotations_directory_item) = 0;
-  virtual void Dispatch(HiddenapiClassData* hiddenapi_class_data) = 0;
   virtual void Dispatch(MapList* map_list) = 0;
   virtual void Dispatch(MapItem* map_item) = 0;
 
@@ -218,7 +216,6 @@
   uint32_t GetOffset() const { return offset_; }
   void SetOffset(uint32_t new_offset) { offset_ = new_offset; }
   virtual uint32_t Size() const = 0;
-  bool Empty() const { return Size() == 0u; }
 
  private:
   // Start out unassigned.
@@ -479,12 +476,6 @@
   const CollectionVector<AnnotationsDirectoryItem>& AnnotationsDirectoryItems() const {
     return annotations_directory_items_;
   }
-  IndexedCollectionVector<HiddenapiClassData>& HiddenapiClassDatas() {
-    return hiddenapi_class_datas_;
-  }
-  const IndexedCollectionVector<HiddenapiClassData>& HiddenapiClassDatas() const {
-    return hiddenapi_class_datas_;
-  }
   CollectionVector<DebugInfoItem>& DebugInfoItems() { return debug_info_items_; }
   const CollectionVector<DebugInfoItem>& DebugInfoItems() const { return debug_info_items_; }
   CollectionVector<CodeItem>& CodeItems() { return code_items_; }
@@ -562,7 +553,6 @@
   IndexedCollectionVector<AnnotationSetItem> annotation_set_items_;
   IndexedCollectionVector<AnnotationSetRefList> annotation_set_ref_lists_;
   IndexedCollectionVector<AnnotationsDirectoryItem> annotations_directory_items_;
-  IndexedCollectionVector<HiddenapiClassData> hiddenapi_class_datas_;
   // The order of the vectors controls the layout of the output file by index order, to change the
   // layout just sort the vector. Note that you may only change the order of the non indexed vectors
   // below. Indexed vectors are accessed by indices in other places, changing the sorting order will
@@ -1274,49 +1264,6 @@
   DISALLOW_COPY_AND_ASSIGN(MethodHandleItem);
 };
 
-using HiddenapiFlagsMap = SafeMap<const Item*, uint32_t>;
-
-class HiddenapiClassData : public IndexedItem {
- public:
-  HiddenapiClassData(const ClassDef* class_def, std::unique_ptr<HiddenapiFlagsMap> flags)
-      : class_def_(class_def), flags_(std::move(flags)) { }
-  ~HiddenapiClassData() override { }
-
-  const ClassDef* GetClassDef() const { return class_def_; }
-
-  uint32_t GetFlags(const Item* field_or_method_item) const {
-    return (flags_ == nullptr) ? 0u : flags_->Get(field_or_method_item);
-  }
-
-  static uint32_t GetFlags(Header* header, ClassDef* class_def, const Item* field_or_method_item) {
-    DCHECK(header != nullptr);
-    DCHECK(class_def != nullptr);
-    return (header->HiddenapiClassDatas().Empty())
-        ? 0u
-        : header->HiddenapiClassDatas()[class_def->GetIndex()]->GetFlags(field_or_method_item);
-  }
-
-  uint32_t ItemSize() const {
-    uint32_t size = 0u;
-    bool has_non_zero_entries = false;
-    if (flags_ != nullptr) {
-      for (const auto& entry : *flags_) {
-        size += UnsignedLeb128Size(entry.second);
-        has_non_zero_entries |= (entry.second != 0u);
-      }
-    }
-    return has_non_zero_entries ? size : 0u;
-  }
-
-  void Accept(AbstractDispatcher* dispatch) { dispatch->Dispatch(this); }
-
- private:
-  const ClassDef* class_def_;
-  std::unique_ptr<HiddenapiFlagsMap> flags_;
-
-  DISALLOW_COPY_AND_ASSIGN(HiddenapiClassData);
-};
-
 // TODO(sehr): implement MapList.
 class MapList : public Item {
  public:
diff --git a/dexlayout/dex_ir_builder.cc b/dexlayout/dex_ir_builder.cc
index c38e563..947d3d5 100644
--- a/dexlayout/dex_ir_builder.cc
+++ b/dexlayout/dex_ir_builder.cc
@@ -170,7 +170,6 @@
   void AddAnnotationsFromMapListSection(const DexFile& dex_file,
                                         uint32_t start_offset,
                                         uint32_t count);
-  void AddHiddenapiClassDataFromMapListSection(const DexFile& dex_file, uint32_t offset);
 
   void CheckAndSetRemainingOffsets(const DexFile& dex_file, const Options& options);
 
@@ -409,10 +408,6 @@
       case DexFile::kDexTypeAnnotationsDirectoryItem:
         header_->AnnotationsDirectoryItems().SetOffset(item->offset_);
         break;
-      case DexFile::kDexTypeHiddenapiClassData:
-        header_->HiddenapiClassDatas().SetOffset(item->offset_);
-        AddHiddenapiClassDataFromMapListSection(dex_file, item->offset_);
-        break;
       default:
         LOG(ERROR) << "Unknown map list item type.";
     }
@@ -629,44 +624,6 @@
   }
 }
 
-void BuilderMaps::AddHiddenapiClassDataFromMapListSection(const DexFile& dex_file,
-                                                          uint32_t offset) {
-  const DexFile::HiddenapiClassData* hiddenapi_class_data =
-      dex_file.GetHiddenapiClassDataAtOffset(offset);
-  DCHECK(hiddenapi_class_data == dex_file.GetHiddenapiClassData());
-
-  for (size_t i = 0; i < dex_file.NumClassDefs(); ++i) {
-    ClassDef* class_def = header_->ClassDefs()[i];
-    ClassData* class_data = class_def->GetClassData();
-    const uint8_t* ptr = hiddenapi_class_data->GetFlagsPointer(i);
-
-    std::unique_ptr<HiddenapiFlagsMap> flags = nullptr;
-    if (ptr != nullptr) {
-      DCHECK(class_data != nullptr);
-      flags = std::make_unique<HiddenapiFlagsMap>();
-      for (const dex_ir::FieldItem& field : *class_data->StaticFields()) {
-        flags->emplace(&field, DecodeUnsignedLeb128(&ptr));
-      }
-      for (const dex_ir::FieldItem& field : *class_data->InstanceFields()) {
-        flags->emplace(&field, DecodeUnsignedLeb128(&ptr));
-      }
-      for (const dex_ir::MethodItem& method : *class_data->DirectMethods()) {
-        flags->emplace(&method, DecodeUnsignedLeb128(&ptr));
-      }
-      for (const dex_ir::MethodItem& method : *class_data->VirtualMethods()) {
-        flags->emplace(&method, DecodeUnsignedLeb128(&ptr));
-      }
-    }
-
-    CreateAndAddIndexedItem(header_->HiddenapiClassDatas(),
-                            header_->HiddenapiClassDatas().GetOffset() +
-                                hiddenapi_class_data->flags_offset_[i],
-                            i,
-                            class_def,
-                            std::move(flags));
-  }
-}
-
 AnnotationItem* BuilderMaps::CreateAnnotationItem(const DexFile& dex_file,
                                                   const DexFile::AnnotationItem* annotation) {
   const uint8_t* const start_data = reinterpret_cast<const uint8_t*>(annotation);
@@ -951,13 +908,13 @@
     FieldItemVector* static_fields = new FieldItemVector();
     for (const ClassAccessor::Field& field : accessor.GetStaticFields()) {
       FieldId* field_item = header_->FieldIds()[field.GetIndex()];
-      uint32_t access_flags = field.GetAccessFlags();
+      uint32_t access_flags = field.GetRawAccessFlags();
       static_fields->emplace_back(access_flags, field_item);
     }
     FieldItemVector* instance_fields = new FieldItemVector();
     for (const ClassAccessor::Field& field : accessor.GetInstanceFields()) {
       FieldId* field_item = header_->FieldIds()[field.GetIndex()];
-      uint32_t access_flags = field.GetAccessFlags();
+      uint32_t access_flags = field.GetRawAccessFlags();
       instance_fields->emplace_back(access_flags, field_item);
     }
     // Direct methods.
@@ -1223,7 +1180,7 @@
 MethodItem BuilderMaps::GenerateMethodItem(const DexFile& dex_file,
                                            const ClassAccessor::Method& method) {
   MethodId* method_id = header_->MethodIds()[method.GetIndex()];
-  uint32_t access_flags = method.GetAccessFlags();
+  uint32_t access_flags = method.GetRawAccessFlags();
   const DexFile::CodeItem* disk_code_item = method.GetCodeItem();
   // Temporary hack to prevent incorrectly deduping code items if they have the same offset since
   // they may have different debug info streams.
diff --git a/dexlayout/dex_writer.cc b/dexlayout/dex_writer.cc
index 929ed40..365171b 100644
--- a/dexlayout/dex_writer.cc
+++ b/dexlayout/dex_writer.cc
@@ -462,58 +462,6 @@
   }
 }
 
-void DexWriter::WriteHiddenapiClassData(Stream* stream) {
-  if (header_->HiddenapiClassDatas().Empty()) {
-    return;
-  }
-  DCHECK_EQ(header_->HiddenapiClassDatas().Size(), header_->ClassDefs().Size());
-
-  const uint32_t start = stream->Tell();
-
-  // Compute offsets for each class def and write the header.
-  // data_header[0]: total size of the section
-  // data_header[i + 1]: offset of class def[i] from the beginning of the section,
-  //                     or zero if no data
-  std::vector<uint32_t> data_header(header_->ClassDefs().Size() + 1, 0);
-  data_header[0] = sizeof(uint32_t) * (header_->ClassDefs().Size() + 1);
-  for (uint32_t i = 0; i < header_->ClassDefs().Size(); ++i) {
-    uint32_t item_size = header_->HiddenapiClassDatas()[i]->ItemSize();
-    data_header[i + 1] = item_size == 0u ? 0 : data_header[0];
-    data_header[0] += item_size;
-  }
-  stream->Write(data_header.data(), sizeof(uint32_t) * data_header.size());
-
-  // Write class data streams.
-  for (uint32_t i = 0; i < header_->ClassDefs().Size(); ++i) {
-    dex_ir::ClassDef* class_def = header_->ClassDefs()[i];
-    const auto& item = header_->HiddenapiClassDatas()[i];
-    DCHECK(item->GetClassDef() == class_def);
-
-    if (data_header[i + 1] != 0u) {
-      dex_ir::ClassData* class_data = class_def->GetClassData();
-      DCHECK(class_data != nullptr);
-      DCHECK_EQ(data_header[i + 1], stream->Tell() - start);
-      for (const dex_ir::FieldItem& field : *class_data->StaticFields()) {
-        stream->WriteUleb128(item->GetFlags(&field));
-      }
-      for (const dex_ir::FieldItem& field : *class_data->InstanceFields()) {
-        stream->WriteUleb128(item->GetFlags(&field));
-      }
-      for (const dex_ir::MethodItem& method : *class_data->DirectMethods()) {
-        stream->WriteUleb128(item->GetFlags(&method));
-      }
-      for (const dex_ir::MethodItem& method : *class_data->VirtualMethods()) {
-        stream->WriteUleb128(item->GetFlags(&method));
-      }
-    }
-  }
-  DCHECK_EQ(stream->Tell() - start, data_header[0]);
-
-  if (compute_offsets_ && start != stream->Tell()) {
-    header_->HiddenapiClassDatas().SetOffset(start);
-  }
-}
-
 void DexWriter::WriteDebugInfoItem(Stream* stream, dex_ir::DebugInfoItem* debug_info) {
   stream->AlignTo(SectionAlignment(DexFile::kDexTypeDebugInfoItem));
   ProcessOffset(stream, debug_info);
@@ -782,9 +730,6 @@
   queue.AddIfNotEmpty(MapItem(DexFile::kDexTypeAnnotationsDirectoryItem,
                               header_->AnnotationsDirectoryItems().Size(),
                               header_->AnnotationsDirectoryItems().GetOffset()));
-  queue.AddIfNotEmpty(MapItem(DexFile::kDexTypeHiddenapiClassData,
-                              header_->HiddenapiClassDatas().Empty() ? 0u : 1u,
-                              header_->HiddenapiClassDatas().GetOffset()));
   WriteMapItems(stream, &queue);
 }
 
@@ -884,7 +829,6 @@
   WriteTypeLists(stream);
   WriteClassDatas(stream);
   WriteStringDatas(stream);
-  WriteHiddenapiClassData(stream);
 
   // Write delayed id sections that depend on data sections.
   {
diff --git a/dexlayout/dex_writer.h b/dexlayout/dex_writer.h
index 98041d3..dd2ebad 100644
--- a/dexlayout/dex_writer.h
+++ b/dexlayout/dex_writer.h
@@ -257,7 +257,6 @@
   void WriteStringDatas(Stream* stream);
   void WriteClassDatas(Stream* stream);
   void WriteMethodHandles(Stream* stream);
-  void WriteHiddenapiClassData(Stream* stream);
   void WriteMapItems(Stream* stream, MapItemQueue* queue);
   void GenerateAndWriteMapItems(Stream* stream);
 
diff --git a/dexlayout/dexlayout.cc b/dexlayout/dexlayout.cc
index 09f0b20..8905aa3 100644
--- a/dexlayout/dexlayout.cc
+++ b/dexlayout/dexlayout.cc
@@ -222,17 +222,6 @@
   return str;
 }
 
-static const char* GetHiddenapiFlagStr(uint32_t hiddenapi_flags) {
-  static const char* const kValue[] = {
-    "WHITELIST",             /* 0x0 */
-    "LIGHT_GREYLIST",        /* 0x1 */
-    "DARK_GREYLIST",         /* 0x2 */
-    "BLACKLIST",             /* 0x3 */
-  };
-  DCHECK_LT(hiddenapi_flags, arraysize(kValue));
-  return kValue[hiddenapi_flags];
-}
-
 static std::string GetSignatureForProtoId(const dex_ir::ProtoId* proto) {
   if (proto == nullptr) {
     return "<no signature>";
@@ -1158,11 +1147,7 @@
 /*
  * Dumps a method.
  */
-void DexLayout::DumpMethod(uint32_t idx,
-                           uint32_t flags,
-                           uint32_t hiddenapi_flags,
-                           const dex_ir::CodeItem* code,
-                           int i) {
+void DexLayout::DumpMethod(uint32_t idx, uint32_t flags, const dex_ir::CodeItem* code, int i) {
   // Bail for anything private if export only requested.
   if (options_.exports_only_ && (flags & (kAccPublic | kAccProtected)) == 0) {
     return;
@@ -1173,16 +1158,12 @@
   char* type_descriptor = strdup(GetSignatureForProtoId(method_id->Proto()).c_str());
   const char* back_descriptor = method_id->Class()->GetStringId()->Data();
   char* access_str = CreateAccessFlagStr(flags, kAccessForMethod);
-  const char* hiddenapi_str = GetHiddenapiFlagStr(hiddenapi_flags);
 
   if (options_.output_format_ == kOutputPlain) {
     fprintf(out_file_, "    #%d              : (in %s)\n", i, back_descriptor);
     fprintf(out_file_, "      name          : '%s'\n", name);
     fprintf(out_file_, "      type          : '%s'\n", type_descriptor);
     fprintf(out_file_, "      access        : 0x%04x (%s)\n", flags, access_str);
-    if (hiddenapi_flags != 0u) {
-      fprintf(out_file_, "      hiddenapi     : 0x%04x (%s)\n", hiddenapi_flags, hiddenapi_str);
-    }
     if (code == nullptr) {
       fprintf(out_file_, "      code          : (none)\n");
     } else {
@@ -1276,11 +1257,7 @@
 /*
  * Dumps a static (class) field.
  */
-void DexLayout::DumpSField(uint32_t idx,
-                           uint32_t flags,
-                           uint32_t hiddenapi_flags,
-                           int i,
-                           dex_ir::EncodedValue* init) {
+void DexLayout::DumpSField(uint32_t idx, uint32_t flags, int i, dex_ir::EncodedValue* init) {
   // Bail for anything private if export only requested.
   if (options_.exports_only_ && (flags & (kAccPublic | kAccProtected)) == 0) {
     return;
@@ -1291,16 +1268,12 @@
   const char* type_descriptor = field_id->Type()->GetStringId()->Data();
   const char* back_descriptor = field_id->Class()->GetStringId()->Data();
   char* access_str = CreateAccessFlagStr(flags, kAccessForField);
-  const char* hiddenapi_str = GetHiddenapiFlagStr(hiddenapi_flags);
 
   if (options_.output_format_ == kOutputPlain) {
     fprintf(out_file_, "    #%d              : (in %s)\n", i, back_descriptor);
     fprintf(out_file_, "      name          : '%s'\n", name);
     fprintf(out_file_, "      type          : '%s'\n", type_descriptor);
     fprintf(out_file_, "      access        : 0x%04x (%s)\n", flags, access_str);
-    if (hiddenapi_flags != 0u) {
-      fprintf(out_file_, "      hiddenapi     : 0x%04x (%s)\n", hiddenapi_flags, hiddenapi_str);
-    }
     if (init != nullptr) {
       fputs("      value         : ", out_file_);
       DumpEncodedValue(init);
@@ -1331,11 +1304,8 @@
 /*
  * Dumps an instance field.
  */
-void DexLayout::DumpIField(uint32_t idx,
-                           uint32_t flags,
-                           uint32_t hiddenapi_flags,
-                           int i) {
-  DumpSField(idx, flags, hiddenapi_flags, i, nullptr);
+void DexLayout::DumpIField(uint32_t idx, uint32_t flags, int i) {
+  DumpSField(idx, flags, i, nullptr);
 }
 
 /*
@@ -1461,7 +1431,6 @@
       for (uint32_t i = 0; i < static_fields->size(); i++) {
         DumpSField((*static_fields)[i].GetFieldId()->GetIndex(),
                    (*static_fields)[i].GetAccessFlags(),
-                   dex_ir::HiddenapiClassData::GetFlags(header_, class_def, &(*static_fields)[i]),
                    i,
                    i < encoded_values_size ? (*encoded_values)[i].get() : nullptr);
       }  // for
@@ -1478,7 +1447,6 @@
       for (uint32_t i = 0; i < instance_fields->size(); i++) {
         DumpIField((*instance_fields)[i].GetFieldId()->GetIndex(),
                    (*instance_fields)[i].GetAccessFlags(),
-                   dex_ir::HiddenapiClassData::GetFlags(header_, class_def, &(*instance_fields)[i]),
                    i);
       }  // for
     }
@@ -1494,9 +1462,8 @@
       for (uint32_t i = 0; i < direct_methods->size(); i++) {
         DumpMethod((*direct_methods)[i].GetMethodId()->GetIndex(),
                    (*direct_methods)[i].GetAccessFlags(),
-                   dex_ir::HiddenapiClassData::GetFlags(header_, class_def, &(*direct_methods)[i]),
                    (*direct_methods)[i].GetCodeItem(),
-                   i);
+                 i);
       }  // for
     }
   }
@@ -1511,7 +1478,6 @@
       for (uint32_t i = 0; i < virtual_methods->size(); i++) {
         DumpMethod((*virtual_methods)[i].GetMethodId()->GetIndex(),
                    (*virtual_methods)[i].GetAccessFlags(),
-                   dex_ir::HiddenapiClassData::GetFlags(header_, class_def, &(*virtual_methods)[i]),
                    (*virtual_methods)[i].GetCodeItem(),
                    i);
       }  // for
diff --git a/dexlayout/dexlayout.h b/dexlayout/dexlayout.h
index 6e006b7..2bca10d 100644
--- a/dexlayout/dexlayout.h
+++ b/dexlayout/dexlayout.h
@@ -148,7 +148,7 @@
   void DumpEncodedAnnotation(dex_ir::EncodedAnnotation* annotation);
   void DumpEncodedValue(const dex_ir::EncodedValue* data);
   void DumpFileHeader();
-  void DumpIField(uint32_t idx, uint32_t flags, uint32_t hiddenapi_flags, int i);
+  void DumpIField(uint32_t idx, uint32_t flags, int i);
   void DumpInstruction(const dex_ir::CodeItem* code,
                        uint32_t code_offset,
                        uint32_t insn_idx,
@@ -156,17 +156,9 @@
                        const Instruction* dec_insn);
   void DumpInterface(const dex_ir::TypeId* type_item, int i);
   void DumpLocalInfo(const dex_ir::CodeItem* code);
-  void DumpMethod(uint32_t idx,
-                  uint32_t flags,
-                  uint32_t hiddenapi_flags,
-                  const dex_ir::CodeItem* code,
-                  int i);
+  void DumpMethod(uint32_t idx, uint32_t flags, const dex_ir::CodeItem* code, int i);
   void DumpPositionInfo(const dex_ir::CodeItem* code);
-  void DumpSField(uint32_t idx,
-                  uint32_t flags,
-                  uint32_t hiddenapi_flags,
-                  int i,
-                  dex_ir::EncodedValue* init);
+  void DumpSField(uint32_t idx, uint32_t flags, int i, dex_ir::EncodedValue* init);
   void DumpDexFile();
 
   void LayoutClassDefsAndClassData(const DexFile* dex_file);
diff --git a/dexlist/dexlist.cc b/dexlist/dexlist.cc
index bdf3ca6..7d3ae71 100644
--- a/dexlist/dexlist.cc
+++ b/dexlist/dexlist.cc
@@ -146,7 +146,7 @@
     dumpMethod(pDexFile,
                fileName,
                method.GetIndex(),
-               method.GetAccessFlags(),
+               method.GetRawAccessFlags(),
                method.GetCodeItem(),
                method.GetCodeItemOffset());
   }
diff --git a/libdexfile/dex/class_accessor-inl.h b/libdexfile/dex/class_accessor-inl.h
index 40bca56..21db2cf 100644
--- a/libdexfile/dex/class_accessor-inl.h
+++ b/libdexfile/dex/class_accessor-inl.h
@@ -28,54 +28,34 @@
 inline ClassAccessor::ClassAccessor(const ClassIteratorData& data)
     : ClassAccessor(data.dex_file_, data.class_def_idx_) {}
 
-inline ClassAccessor::ClassAccessor(const DexFile& dex_file,
-                                    const DexFile::ClassDef& class_def,
-                                    bool parse_hiddenapi_class_data)
-    : ClassAccessor(dex_file,
-                    dex_file.GetClassData(class_def),
-                    dex_file.GetIndexForClassDef(class_def),
-                    parse_hiddenapi_class_data) {}
+inline ClassAccessor::ClassAccessor(const DexFile& dex_file, const DexFile::ClassDef& class_def)
+    : ClassAccessor(dex_file, dex_file.GetIndexForClassDef(class_def)) {}
 
 inline ClassAccessor::ClassAccessor(const DexFile& dex_file, uint32_t class_def_index)
-    : ClassAccessor(dex_file, dex_file.GetClassDef(class_def_index)) {}
+    : ClassAccessor(dex_file,
+                    dex_file.GetClassData(dex_file.GetClassDef(class_def_index)),
+                    class_def_index) {}
 
 inline ClassAccessor::ClassAccessor(const DexFile& dex_file,
                                     const uint8_t* class_data,
-                                    uint32_t class_def_index,
-                                    bool parse_hiddenapi_class_data)
+                                    uint32_t class_def_index)
     : dex_file_(dex_file),
       class_def_index_(class_def_index),
       ptr_pos_(class_data),
-      hiddenapi_ptr_pos_(nullptr),
       num_static_fields_(ptr_pos_ != nullptr ? DecodeUnsignedLeb128(&ptr_pos_) : 0u),
       num_instance_fields_(ptr_pos_ != nullptr ? DecodeUnsignedLeb128(&ptr_pos_) : 0u),
       num_direct_methods_(ptr_pos_ != nullptr ? DecodeUnsignedLeb128(&ptr_pos_) : 0u),
-      num_virtual_methods_(ptr_pos_ != nullptr ? DecodeUnsignedLeb128(&ptr_pos_) : 0u) {
-  if (parse_hiddenapi_class_data && class_def_index != DexFile::kDexNoIndex32) {
-    const DexFile::HiddenapiClassData* hiddenapi_class_data = dex_file.GetHiddenapiClassData();
-    if (hiddenapi_class_data != nullptr) {
-      hiddenapi_ptr_pos_ = hiddenapi_class_data->GetFlagsPointer(class_def_index);
-    }
-  }
-}
+      num_virtual_methods_(ptr_pos_ != nullptr ? DecodeUnsignedLeb128(&ptr_pos_) : 0u) {}
 
 inline void ClassAccessor::Method::Read() {
   index_ += DecodeUnsignedLeb128(&ptr_pos_);
   access_flags_ = DecodeUnsignedLeb128(&ptr_pos_);
   code_off_ = DecodeUnsignedLeb128(&ptr_pos_);
-  if (hiddenapi_ptr_pos_ != nullptr) {
-    hiddenapi_flags_ = DecodeUnsignedLeb128(&hiddenapi_ptr_pos_);
-    DCHECK(HiddenApiAccessFlags::AreValidFlags(hiddenapi_flags_));
-  }
 }
 
 inline void ClassAccessor::Field::Read() {
   index_ += DecodeUnsignedLeb128(&ptr_pos_);
   access_flags_ = DecodeUnsignedLeb128(&ptr_pos_);
-  if (hiddenapi_ptr_pos_ != nullptr) {
-    hiddenapi_flags_ = DecodeUnsignedLeb128(&hiddenapi_ptr_pos_);
-    DCHECK(HiddenApiAccessFlags::AreValidFlags(hiddenapi_flags_));
-  }
 }
 
 template <typename DataType, typename Visitor>
@@ -98,12 +78,12 @@
     const InstanceFieldVisitor& instance_field_visitor,
     const DirectMethodVisitor& direct_method_visitor,
     const VirtualMethodVisitor& virtual_method_visitor) const {
-  Field field(dex_file_, ptr_pos_, hiddenapi_ptr_pos_);
+  Field field(dex_file_, ptr_pos_);
   VisitMembers(num_static_fields_, static_field_visitor, &field);
   field.NextSection();
   VisitMembers(num_instance_fields_, instance_field_visitor, &field);
 
-  Method method(dex_file_, field.ptr_pos_, field.hiddenapi_ptr_pos_, /*is_static_or_direct*/ true);
+  Method method(dex_file_, field.ptr_pos_, /*is_static_or_direct*/ true);
   VisitMembers(num_direct_methods_, direct_method_visitor, &method);
   method.NextSection();
   VisitMembers(num_virtual_methods_, virtual_method_visitor, &method);
@@ -151,43 +131,19 @@
 
 inline IterationRange<ClassAccessor::DataIterator<ClassAccessor::Field>>
     ClassAccessor::GetFieldsInternal(size_t count) const {
-  return {
-      DataIterator<Field>(dex_file_,
-                          0u,
-                          num_static_fields_,
-                          count,
-                          ptr_pos_,
-                          hiddenapi_ptr_pos_),
-      DataIterator<Field>(dex_file_,
-                          count,
-                          num_static_fields_,
-                          count,
-                          // The following pointers are bogus but unused in the `end` iterator.
-                          ptr_pos_,
-                          hiddenapi_ptr_pos_) };
+  return { DataIterator<Field>(dex_file_, 0u, num_static_fields_, count, ptr_pos_),
+           DataIterator<Field>(dex_file_, count, num_static_fields_, count, ptr_pos_) };
 }
 
 // Return an iteration range for the first <count> methods.
 inline IterationRange<ClassAccessor::DataIterator<ClassAccessor::Method>>
     ClassAccessor::GetMethodsInternal(size_t count) const {
   // Skip over the fields.
-  Field field(dex_file_, ptr_pos_, hiddenapi_ptr_pos_);
+  Field field(dex_file_, ptr_pos_);
   VisitMembers(NumFields(), VoidFunctor(), &field);
   // Return the iterator pair.
-  return {
-      DataIterator<Method>(dex_file_,
-                           0u,
-                           num_direct_methods_,
-                           count,
-                           field.ptr_pos_,
-                           field.hiddenapi_ptr_pos_),
-      DataIterator<Method>(dex_file_,
-                           count,
-                           num_direct_methods_,
-                           count,
-                           // The following pointers are bogus but unused in the `end` iterator.
-                           field.ptr_pos_,
-                           field.hiddenapi_ptr_pos_) };
+  return { DataIterator<Method>(dex_file_, 0u, num_direct_methods_, count, field.ptr_pos_),
+           DataIterator<Method>(dex_file_, count, num_direct_methods_, count, field.ptr_pos_) };
 }
 
 inline IterationRange<ClassAccessor::DataIterator<ClassAccessor::Field>> ClassAccessor::GetFields()
@@ -225,6 +181,14 @@
   return { std::next(methods.begin(), NumDirectMethods()), methods.end() };
 }
 
+inline void ClassAccessor::Field::UnHideAccessFlags() const {
+  DexFile::UnHideAccessFlags(const_cast<uint8_t*>(ptr_pos_), GetAccessFlags(), /*is_method*/ false);
+}
+
+inline void ClassAccessor::Method::UnHideAccessFlags() const {
+  DexFile::UnHideAccessFlags(const_cast<uint8_t*>(ptr_pos_), GetAccessFlags(), /*is_method*/ true);
+}
+
 inline dex::TypeIndex ClassAccessor::GetClassIdx() const {
   return dex_file_.GetClassDef(class_def_index_).class_idx_;
 }
diff --git a/libdexfile/dex/class_accessor.h b/libdexfile/dex/class_accessor.h
index e9c1a82..d40577f 100644
--- a/libdexfile/dex/class_accessor.h
+++ b/libdexfile/dex/class_accessor.h
@@ -20,6 +20,7 @@
 #include "base/utils.h"
 #include "code_item_accessors.h"
 #include "dex_file.h"
+#include "hidden_api_access_flags.h"
 #include "invoke_type.h"
 #include "method_reference.h"
 #include "modifiers.h"
@@ -34,20 +35,22 @@
   class BaseItem {
    public:
     explicit BaseItem(const DexFile& dex_file,
-                      const uint8_t* ptr_pos,
-                      const uint8_t* hiddenapi_ptr_pos)
-        : dex_file_(dex_file), ptr_pos_(ptr_pos), hiddenapi_ptr_pos_(hiddenapi_ptr_pos) {}
+                      const uint8_t* ptr_pos) : dex_file_(dex_file), ptr_pos_(ptr_pos) {}
 
     uint32_t GetIndex() const {
       return index_;
     }
 
-    uint32_t GetAccessFlags() const {
+    uint32_t GetRawAccessFlags() const {
       return access_flags_;
     }
 
-    uint32_t GetHiddenapiFlags() const {
-      return hiddenapi_flags_;
+    uint32_t GetAccessFlags() const {
+      return HiddenApiAccessFlags::RemoveFromDex(access_flags_);
+    }
+
+    HiddenApiAccessFlags::ApiList DecodeHiddenAccessFlags() const {
+      return HiddenApiAccessFlags::DecodeFromDex(access_flags_);
     }
 
     bool IsFinal() const {
@@ -63,21 +66,19 @@
     }
 
     bool MemberIsNative() const {
-      return GetAccessFlags() & kAccNative;
+      return GetRawAccessFlags() & kAccNative;
     }
 
     bool MemberIsFinal() const {
-      return GetAccessFlags() & kAccFinal;
+      return GetRawAccessFlags() & kAccFinal;
     }
 
    protected:
     // Internal data pointer for reading.
     const DexFile& dex_file_;
     const uint8_t* ptr_pos_ = nullptr;
-    const uint8_t* hiddenapi_ptr_pos_ = nullptr;
     uint32_t index_ = 0u;
     uint32_t access_flags_ = 0u;
-    uint32_t hiddenapi_flags_ = 0u;
   };
 
   // A decoded version of the method of a class_data_item.
@@ -106,13 +107,14 @@
       return is_static_or_direct_;
     }
 
+    // Unhide the hidden API access flags at the iterator position. TODO: Deprecate.
+    void UnHideAccessFlags() const;
+
    private:
-    Method(const DexFile& dex_file,
-           const uint8_t* ptr_pos,
-           const uint8_t* hiddenapi_ptr_pos = nullptr,
-           bool is_static_or_direct = true)
-        : BaseItem(dex_file, ptr_pos, hiddenapi_ptr_pos),
-          is_static_or_direct_(is_static_or_direct) {}
+    explicit Method(const DexFile& dex_file,
+                    const uint8_t* ptr_pos,
+                    bool is_static_or_direct = true)
+        : BaseItem(dex_file, ptr_pos), is_static_or_direct_(is_static_or_direct) {}
 
     void Read();
 
@@ -148,15 +150,16 @@
   // A decoded version of the field of a class_data_item.
   class Field : public BaseItem {
    public:
-    Field(const DexFile& dex_file,
-          const uint8_t* ptr_pos,
-          const uint8_t* hiddenapi_ptr_pos = nullptr)
-        : BaseItem(dex_file, ptr_pos, hiddenapi_ptr_pos) {}
+    explicit Field(const DexFile& dex_file,
+                   const uint8_t* ptr_pos) : BaseItem(dex_file, ptr_pos) {}
 
     bool IsStatic() const {
      return is_static_;
     }
 
+    // Unhide the hidden API access flags at the iterator position. TODO: Deprecate.
+    void UnHideAccessFlags() const;
+
    private:
     void Read();
 
@@ -182,9 +185,8 @@
                  uint32_t position,
                  uint32_t partition_pos,
                  uint32_t iterator_end,
-                 const uint8_t* ptr_pos,
-                 const uint8_t* hiddenapi_ptr_pos)
-        : data_(dex_file, ptr_pos, hiddenapi_ptr_pos),
+                 const uint8_t* ptr_pos)
+        : data_(dex_file, ptr_pos),
           position_(position),
           partition_pos_(partition_pos),
           iterator_end_(iterator_end) {
@@ -266,16 +268,13 @@
   // Not explicit specifically for range-based loops.
   ALWAYS_INLINE ClassAccessor(const ClassIteratorData& data);
 
-  ALWAYS_INLINE ClassAccessor(const DexFile& dex_file,
-                              const DexFile::ClassDef& class_def,
-                              bool parse_hiddenapi_class_data = false);
+  ALWAYS_INLINE ClassAccessor(const DexFile& dex_file, const DexFile::ClassDef& class_def);
 
   ALWAYS_INLINE ClassAccessor(const DexFile& dex_file, uint32_t class_def_index);
 
   ClassAccessor(const DexFile& dex_file,
                 const uint8_t* class_data,
-                uint32_t class_def_index = DexFile::kDexNoIndex32,
-                bool parse_hiddenapi_class_data = false);
+                uint32_t class_def_index = DexFile::kDexNoIndex32);
 
   // Return the code item for a method.
   const DexFile::CodeItem* GetCodeItem(const Method& method) const;
@@ -354,10 +353,6 @@
     return ptr_pos_ != nullptr;
   }
 
-  bool HasHiddenapiClassData() const {
-    return hiddenapi_ptr_pos_ != nullptr;
-  }
-
   uint32_t GetClassDefIndex() const {
     return class_def_index_;
   }
@@ -382,7 +377,6 @@
   const DexFile& dex_file_;
   const uint32_t class_def_index_;
   const uint8_t* ptr_pos_ = nullptr;  // Pointer into stream of class_data_item.
-  const uint8_t* hiddenapi_ptr_pos_ = nullptr;  // Pointer into stream of hiddenapi_metadata.
   const uint32_t num_static_fields_ = 0u;
   const uint32_t num_instance_fields_ = 0u;
   const uint32_t num_direct_methods_ = 0u;
diff --git a/libdexfile/dex/dex_file.cc b/libdexfile/dex/dex_file.cc
index 7ccb9c0..48f38ca 100644
--- a/libdexfile/dex/dex_file.cc
+++ b/libdexfile/dex/dex_file.cc
@@ -46,6 +46,31 @@
 static_assert(sizeof(dex::TypeIndex) == sizeof(uint16_t), "TypeIndex size is wrong");
 static_assert(std::is_trivially_copyable<dex::TypeIndex>::value, "TypeIndex not trivial");
 
+void DexFile::UnHideAccessFlags(uint8_t* data_ptr,
+                                uint32_t new_access_flags,
+                                bool is_method) {
+  // Go back 1 uleb to start.
+  data_ptr = ReverseSearchUnsignedLeb128(data_ptr);
+  if (is_method) {
+    // Methods have another uleb field before the access flags
+    data_ptr = ReverseSearchUnsignedLeb128(data_ptr);
+  }
+  DCHECK_EQ(HiddenApiAccessFlags::RemoveFromDex(DecodeUnsignedLeb128WithoutMovingCursor(data_ptr)),
+            new_access_flags);
+  UpdateUnsignedLeb128(data_ptr, new_access_flags);
+}
+
+void DexFile::UnhideApis() const {
+  for (ClassAccessor accessor : GetClasses()) {
+    for (const ClassAccessor::Field& field : accessor.GetFields()) {
+      field.UnHideAccessFlags();
+    }
+    for (const ClassAccessor::Method& method : accessor.GetMethods()) {
+      method.UnHideAccessFlags();
+    }
+  }
+}
+
 uint32_t DexFile::CalculateChecksum() const {
   return CalculateChecksum(Begin(), Size());
 }
@@ -105,7 +130,6 @@
       num_method_handles_(0),
       call_site_ids_(nullptr),
       num_call_site_ids_(0),
-      hiddenapi_class_data_(nullptr),
       oat_dex_file_(oat_dex_file),
       container_(std::move(container)),
       is_compact_dex_(is_compact_dex),
@@ -181,11 +205,6 @@
     } else if (map_item.type_ == kDexTypeCallSiteIdItem) {
       call_site_ids_ = reinterpret_cast<const CallSiteIdItem*>(Begin() + map_item.offset_);
       num_call_site_ids_ = map_item.size_;
-    } else if (map_item.type_ == kDexTypeHiddenapiClassData) {
-      hiddenapi_class_data_ = GetHiddenapiClassDataAtOffset(map_item.offset_);
-    } else {
-      // Pointers to other sections are not necessary to retain in the DexFile struct.
-      // Other items have pointers directly into their data.
     }
   }
 }
diff --git a/libdexfile/dex/dex_file.h b/libdexfile/dex/dex_file.h
index 6a52f67..30d8b6d 100644
--- a/libdexfile/dex/dex_file.h
+++ b/libdexfile/dex/dex_file.h
@@ -92,7 +92,7 @@
     uint32_t endian_tag_ = 0;
     uint32_t link_size_ = 0;  // unused
     uint32_t link_off_ = 0;  // unused
-    uint32_t map_off_ = 0;  // map list offset from data_off_
+    uint32_t map_off_ = 0;  // unused
     uint32_t string_ids_size_ = 0;  // number of StringIds
     uint32_t string_ids_off_ = 0;  // file offset of StringIds array
     uint32_t type_ids_size_ = 0;  // number of TypeIds, we don't support more than 65535
@@ -134,7 +134,6 @@
     kDexTypeAnnotationItem           = 0x2004,
     kDexTypeEncodedArrayItem         = 0x2005,
     kDexTypeAnnotationsDirectoryItem = 0x2006,
-    kDexTypeHiddenapiClassData       = 0xF000,
   };
 
   struct MapItem {
@@ -148,8 +147,6 @@
     uint32_t size_;
     MapItem list_[1];
 
-    size_t Size() const { return sizeof(uint32_t) + (size_ * sizeof(MapItem)); }
-
    private:
     DISALLOW_COPY_AND_ASSIGN(MapList);
   };
@@ -422,27 +419,6 @@
     DISALLOW_COPY_AND_ASSIGN(AnnotationItem);
   };
 
-  struct HiddenapiClassData {
-    uint32_t size_;             // total size of the item
-    uint32_t flags_offset_[1];  // array of offsets from the beginning of this item,
-                                // indexed by class def index
-
-    // Returns a pointer to the beginning of a uleb128-stream of hiddenapi
-    // flags for a class def of given index. Values are in the same order
-    // as fields/methods in the class data. Returns null if the class does
-    // not have class data.
-    const uint8_t* GetFlagsPointer(uint32_t class_def_idx) const {
-      if (flags_offset_[class_def_idx] == 0) {
-        return nullptr;
-      } else {
-        return reinterpret_cast<const uint8_t*>(this) + flags_offset_[class_def_idx];
-      }
-    }
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(HiddenapiClassData);
-  };
-
   enum AnnotationResultStyle {  // private
     kAllObjects,
     kPrimitivesOrObjects,
@@ -861,14 +837,6 @@
     return DataPointer<AnnotationItem>(offset);
   }
 
-  ALWAYS_INLINE const HiddenapiClassData* GetHiddenapiClassDataAtOffset(uint32_t offset) const {
-    return DataPointer<HiddenapiClassData>(offset);
-  }
-
-  ALWAYS_INLINE const HiddenapiClassData* GetHiddenapiClassData() const {
-    return hiddenapi_class_data_;
-  }
-
   const AnnotationItem* GetAnnotationItem(const AnnotationSetItem* set_item, uint32_t index) const {
     DCHECK_LE(index, set_item->size_);
     return GetAnnotationItemAtOffset(set_item->entries_[index]);
@@ -1024,6 +992,12 @@
     return container_.get();
   }
 
+  // Changes the dex class data pointed to by data_ptr it to not have any hiddenapi flags.
+  static void UnHideAccessFlags(uint8_t* data_ptr, uint32_t new_access_flags, bool is_method);
+
+  // Iterate dex classes and remove hiddenapi flags in fields and methods.
+  void UnhideApis() const;
+
   IterationRange<ClassIterator> GetClasses() const;
 
   template <typename Visitor>
@@ -1106,10 +1080,6 @@
   // Number of elements in the call sites list.
   size_t num_call_site_ids_;
 
-  // Points to the base of the hiddenapi class data item_, or nullptr if the dex
-  // file does not have one.
-  const HiddenapiClassData* hiddenapi_class_data_;
-
   // If this dex file was loaded from an oat file, oat_dex_file_ contains a
   // pointer to the OatDexFile it was loaded from. Otherwise oat_dex_file_ is
   // null.
diff --git a/libdexfile/dex/dex_file_verifier.cc b/libdexfile/dex/dex_file_verifier.cc
index 43471c3..499a89b 100644
--- a/libdexfile/dex/dex_file_verifier.cc
+++ b/libdexfile/dex/dex_file_verifier.cc
@@ -67,7 +67,6 @@
     case DexFile::kDexTypeAnnotationItem:           return 1 << 17;
     case DexFile::kDexTypeEncodedArrayItem:         return 1 << 18;
     case DexFile::kDexTypeAnnotationsDirectoryItem: return 1 << 19;
-    case DexFile::kDexTypeHiddenapiClassData:       return 1 << 20;
   }
   return 0;
 }
@@ -95,7 +94,6 @@
     case DexFile::kDexTypeAnnotationItem:
     case DexFile::kDexTypeEncodedArrayItem:
     case DexFile::kDexTypeAnnotationsDirectoryItem:
-    case DexFile::kDexTypeHiddenapiClassData:
       return true;
   }
   return true;
@@ -1098,7 +1096,7 @@
       return false;
     }
     if (!CheckClassDataItemField(curr_index,
-                                 field->GetAccessFlags(),
+                                 field->GetRawAccessFlags(),
                                  (*class_def)->access_flags_,
                                  *class_type_index,
                                  kStatic)) {
@@ -1149,7 +1147,7 @@
       return false;
     }
     if (!CheckClassDataItemMethod(curr_index,
-                                  method->GetAccessFlags(),
+                                  method->GetRawAccessFlags(),
                                   (*class_def)->access_flags_,
                                   *class_type_index,
                                   method->GetCodeItemOffset(),
@@ -1557,107 +1555,6 @@
   return true;
 }
 
-bool DexFileVerifier::CheckIntraHiddenapiClassData() {
-  const DexFile::HiddenapiClassData* item =
-      reinterpret_cast<const DexFile::HiddenapiClassData*>(ptr_);
-
-  // Check expected header size.
-  uint32_t num_header_elems = dex_file_->NumClassDefs() + 1;
-  uint32_t elem_size = sizeof(uint32_t);
-  uint32_t header_size = num_header_elems * elem_size;
-  if (!CheckListSize(item, num_header_elems, elem_size, "hiddenapi class data section header")) {
-    return false;
-  }
-
-  // Check total size.
-  if (!CheckListSize(item, item->size_, 1u, "hiddenapi class data section")) {
-    return false;
-  }
-
-  // Check that total size can fit header.
-  if (item->size_ < header_size) {
-    ErrorStringPrintf(
-        "Hiddenapi class data too short to store header (%u < %u)", item->size_, header_size);
-    return false;
-  }
-
-  const uint8_t* data_end = ptr_ + item->size_;
-  ptr_ += header_size;
-
-  // Check offsets for each class def.
-  for (uint32_t i = 0; i < dex_file_->NumClassDefs(); ++i) {
-    const DexFile::ClassDef& class_def = dex_file_->GetClassDef(i);
-    const uint8_t* class_data = dex_file_->GetClassData(class_def);
-    uint32_t offset = item->flags_offset_[i];
-
-    if (offset == 0) {
-      continue;
-    }
-
-    // Check that class defs with no class data do not have any hiddenapi class data.
-    if (class_data == nullptr) {
-      ErrorStringPrintf(
-          "Hiddenapi class data offset not zero for class def %u with no class data", i);
-      return false;
-    }
-
-    // Check that the offset is within the section.
-    if (offset > item->size_) {
-      ErrorStringPrintf(
-          "Hiddenapi class data offset out of section bounds (%u > %u) for class def %u",
-          offset, item->size_, i);
-      return false;
-    }
-
-    // Check that the offset matches current pointer position. We do not allow
-    // offsets into already parsed data, or gaps between class def data.
-    uint32_t ptr_offset = ptr_ - reinterpret_cast<const uint8_t*>(item);
-    if (offset != ptr_offset) {
-      ErrorStringPrintf(
-          "Hiddenapi class data unexpected offset (%u != %u) for class def %u",
-          offset, ptr_offset, i);
-      return false;
-    }
-
-    // Parse a uleb128 value for each field and method of this class.
-    bool failure = false;
-    auto fn_member = [&](const ClassAccessor::BaseItem& member, const char* member_type) {
-      if (failure) {
-        return;
-      }
-      uint32_t decoded_flags;
-      if (!DecodeUnsignedLeb128Checked(&ptr_, data_end, &decoded_flags)) {
-        ErrorStringPrintf("Hiddenapi class data value out of bounds (%p > %p) for %s %i",
-                          ptr_, data_end, member_type, member.GetIndex());
-        failure = true;
-        return;
-      }
-      if (!HiddenApiAccessFlags::AreValidFlags(decoded_flags)) {
-        ErrorStringPrintf("Hiddenapi class data flags invalid (%u) for %s %i",
-                          decoded_flags, member_type, member.GetIndex());
-        failure = true;
-        return;
-      }
-    };
-    auto fn_field = [&](const ClassAccessor::Field& field) { fn_member(field, "field"); };
-    auto fn_method = [&](const ClassAccessor::Method& method) { fn_member(method, "method"); };
-    ClassAccessor accessor(*dex_file_, class_data);
-    accessor.VisitFieldsAndMethods(fn_field, fn_field, fn_method, fn_method);
-    if (failure) {
-      return false;
-    }
-  }
-
-  if (ptr_ != data_end) {
-    ErrorStringPrintf("Hiddenapi class data wrong reported size (%u != %u)",
-                       static_cast<uint32_t>(ptr_ - reinterpret_cast<const uint8_t*>(item)),
-                       item->size_);
-    return false;
-  }
-
-  return true;
-}
-
 bool DexFileVerifier::CheckIntraAnnotationsDirectoryItem() {
   const DexFile::AnnotationsDirectoryItem* item =
       reinterpret_cast<const DexFile::AnnotationsDirectoryItem*>(ptr_);
@@ -1872,12 +1769,6 @@
         }
         break;
       }
-      case DexFile::kDexTypeHiddenapiClassData: {
-        if (!CheckIntraHiddenapiClassData()) {
-          return false;
-        }
-        break;
-      }
       case DexFile::kDexTypeHeaderItem:
       case DexFile::kDexTypeMapList:
         break;
@@ -2082,7 +1973,6 @@
       CHECK_INTRA_DATA_SECTION_CASE(DexFile::kDexTypeAnnotationItem)
       CHECK_INTRA_DATA_SECTION_CASE(DexFile::kDexTypeEncodedArrayItem)
       CHECK_INTRA_DATA_SECTION_CASE(DexFile::kDexTypeAnnotationsDirectoryItem)
-      CHECK_INTRA_DATA_SECTION_CASE(DexFile::kDexTypeHiddenapiClassData)
 #undef CHECK_INTRA_DATA_SECTION_CASE
     }
 
@@ -2846,7 +2736,6 @@
       case DexFile::kDexTypeDebugInfoItem:
       case DexFile::kDexTypeAnnotationItem:
       case DexFile::kDexTypeEncodedArrayItem:
-      case DexFile::kDexTypeHiddenapiClassData:
         break;
       case DexFile::kDexTypeStringIdItem: {
         if (!CheckInterStringIdItem()) {
@@ -2979,8 +2868,7 @@
       case DexFile::kDexTypeAnnotationSetRefList:
       case DexFile::kDexTypeAnnotationSetItem:
       case DexFile::kDexTypeClassDataItem:
-      case DexFile::kDexTypeAnnotationsDirectoryItem:
-      case DexFile::kDexTypeHiddenapiClassData: {
+      case DexFile::kDexTypeAnnotationsDirectoryItem: {
         if (!CheckInterSectionIterate(section_offset, section_count, type)) {
           return false;
         }
diff --git a/libdexfile/dex/dex_file_verifier.h b/libdexfile/dex/dex_file_verifier.h
index a81df48..79ddea4 100644
--- a/libdexfile/dex/dex_file_verifier.h
+++ b/libdexfile/dex/dex_file_verifier.h
@@ -126,7 +126,6 @@
   bool CheckIntraDebugInfoItem();
   bool CheckIntraAnnotationItem();
   bool CheckIntraAnnotationsDirectoryItem();
-  bool CheckIntraHiddenapiClassData();
 
   template <DexFile::MapItemType kType>
   bool CheckIntraSectionIterate(size_t offset, uint32_t count);
diff --git a/libdexfile/dex/hidden_api_access_flags.h b/libdexfile/dex/hidden_api_access_flags.h
index 837056b..369615d 100644
--- a/libdexfile/dex/hidden_api_access_flags.h
+++ b/libdexfile/dex/hidden_api_access_flags.h
@@ -28,14 +28,31 @@
  * of information on whether the given class member should be hidden from apps
  * and under what circumstances.
  *
- * Two bits are encoded for each class member in the HiddenapiClassData item,
- * stored in a stream of uleb128-encoded values for each ClassDef item.
- * The two bits correspond to values in the ApiList enum below.
+ * The encoding is different inside DexFile, where we are concerned with size,
+ * and at runtime where we want to optimize for speed of access. The class
+ * provides helper functions to decode/encode both of them.
  *
- * At runtime, two bits are set aside in the uint32_t access flags in the
- * intrinsics ordinal space (thus intrinsics need to be special-cased). These are
- * two consecutive bits and they are directly used to store the integer value of
- * the ApiList enum values.
+ * Encoding in DexFile
+ * ===================
+ *
+ * First bit is encoded as inversion of visibility flags (public/private/protected).
+ * At most one can be set for any given class member. If two or three are set,
+ * this is interpreted as the first bit being set and actual visibility flags
+ * being the complement of the encoded flags.
+ *
+ * Second bit is either encoded as bit 5 for fields and non-native methods, where
+ * it carries no other meaning. If a method is native (bit 8 set), bit 9 is used.
+ *
+ * Bits were selected so that they never increase the length of unsigned LEB-128
+ * encoding of the access flags.
+ *
+ * Encoding at runtime
+ * ===================
+ *
+ * Two bits are set aside in the uint32_t access flags in the intrinsics ordinal
+ * space (thus intrinsics need to be special-cased). These are two consecutive
+ * bits and they are directly used to store the integer value of the ApiList
+ * enum values.
  *
  */
 class HiddenApiAccessFlags {
@@ -48,6 +65,27 @@
     kNoList,
   };
 
+  static ALWAYS_INLINE ApiList DecodeFromDex(uint32_t dex_access_flags) {
+    DexHiddenAccessFlags flags(dex_access_flags);
+    uint32_t int_value = (flags.IsFirstBitSet() ? 1 : 0) + (flags.IsSecondBitSet() ? 2 : 0);
+    return static_cast<ApiList>(int_value);
+  }
+
+  static ALWAYS_INLINE uint32_t RemoveFromDex(uint32_t dex_access_flags) {
+    DexHiddenAccessFlags flags(dex_access_flags);
+    flags.SetFirstBit(false);
+    flags.SetSecondBit(false);
+    return flags.GetEncoding();
+  }
+
+  static ALWAYS_INLINE uint32_t EncodeForDex(uint32_t dex_access_flags, ApiList value) {
+    DexHiddenAccessFlags flags(RemoveFromDex(dex_access_flags));
+    uint32_t int_value = static_cast<uint32_t>(value);
+    flags.SetFirstBit((int_value & 1) != 0);
+    flags.SetSecondBit((int_value & 2) != 0);
+    return flags.GetEncoding();
+  }
+
   static ALWAYS_INLINE ApiList DecodeFromRuntime(uint32_t runtime_access_flags) {
     // This is used in the fast path, only DCHECK here.
     DCHECK_EQ(runtime_access_flags & kAccIntrinsic, 0u);
@@ -65,14 +103,47 @@
     return runtime_access_flags | hidden_api_flags;
   }
 
-  static ALWAYS_INLINE bool AreValidFlags(uint32_t flags) {
-    return flags <= static_cast<uint32_t>(kBlacklist);
-  }
-
  private:
   static const int kAccFlagsShift = CTZ(kAccHiddenApiBits);
   static_assert(IsPowerOfTwo((kAccHiddenApiBits >> kAccFlagsShift) + 1),
                 "kAccHiddenApiBits are not continuous");
+
+  struct DexHiddenAccessFlags {
+    explicit DexHiddenAccessFlags(uint32_t access_flags) : access_flags_(access_flags) {}
+
+    ALWAYS_INLINE uint32_t GetSecondFlag() {
+      return ((access_flags_ & kAccNative) != 0) ? kAccDexHiddenBitNative : kAccDexHiddenBit;
+    }
+
+    ALWAYS_INLINE bool IsFirstBitSet() {
+      static_assert(IsPowerOfTwo(0u), "Following statement checks if *at most* one bit is set");
+      return !IsPowerOfTwo(access_flags_ & kAccVisibilityFlags);
+    }
+
+    ALWAYS_INLINE void SetFirstBit(bool value) {
+      if (IsFirstBitSet() != value) {
+        access_flags_ ^= kAccVisibilityFlags;
+      }
+    }
+
+    ALWAYS_INLINE bool IsSecondBitSet() {
+      return (access_flags_ & GetSecondFlag()) != 0;
+    }
+
+    ALWAYS_INLINE void SetSecondBit(bool value) {
+      if (value) {
+        access_flags_ |= GetSecondFlag();
+      } else {
+        access_flags_ &= ~GetSecondFlag();
+      }
+    }
+
+    ALWAYS_INLINE uint32_t GetEncoding() const {
+      return access_flags_;
+    }
+
+    uint32_t access_flags_;
+  };
 };
 
 inline std::ostream& operator<<(std::ostream& os, HiddenApiAccessFlags::ApiList value) {
diff --git a/libdexfile/dex/modifiers.h b/libdexfile/dex/modifiers.h
index 018b141..38f8455 100644
--- a/libdexfile/dex/modifiers.h
+++ b/libdexfile/dex/modifiers.h
@@ -42,6 +42,11 @@
 
 static constexpr uint32_t kAccJavaFlagsMask = 0xffff;  // bits set from Java sources (low 16)
 
+// The following flags are used to insert hidden API access flags into boot class path dex files.
+// They are decoded by ClassAccessor and removed from the access flags before used by the runtime.
+static constexpr uint32_t kAccDexHiddenBit =          0x00000020;  // field, method (not native)
+static constexpr uint32_t kAccDexHiddenBitNative =    0x00000200;  // method (native)
+
 static constexpr uint32_t kAccConstructor =           0x00010000;  // method (dex only) <(cl)init>
 static constexpr uint32_t kAccDeclaredSynchronized =  0x00020000;  // method (dex only)
 static constexpr uint32_t kAccClassIsProxy =          0x00040000;  // class  (dex only)
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index 358b7ba..86a36f2 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -628,6 +628,9 @@
         CHECK(oat_dex_file != nullptr);
         CHECK(vdex_dex_file != nullptr);
 
+        // Remove hiddenapis
+        vdex_dex_file->UnhideApis();
+
         // If a CompactDex file is detected within a Vdex container, DexLayout is used to convert
         // back to a StandardDex file. Since the converted DexFile will most likely not reproduce
         // the original input Dex file, the `update_checksum_` option is used to recompute the
@@ -1075,7 +1078,7 @@
                          dex_file,
                          method.GetIndex(),
                          method.GetCodeItem(),
-                         method.GetAccessFlags(),
+                         method.GetRawAccessFlags(),
                          &addr_found)) {
         success = false;
       }
diff --git a/openjdkjvmti/fixed_up_dex_file.cc b/openjdkjvmti/fixed_up_dex_file.cc
index eb93fc9..6745d91 100644
--- a/openjdkjvmti/fixed_up_dex_file.cc
+++ b/openjdkjvmti/fixed_up_dex_file.cc
@@ -71,6 +71,7 @@
                            original_dex_file,
                            /* decompile_return_instruction= */ true);
   }
+  new_dex_file.UnhideApis();
 }
 
 static void DCheckVerifyDexFile(const art::DexFile& dex) {
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index dab8d58..c18abab 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -3244,9 +3244,7 @@
                             const DexFile& dex_file,
                             const DexFile::ClassDef& dex_class_def,
                             Handle<mirror::Class> klass) {
-  ClassAccessor accessor(dex_file,
-                         dex_class_def,
-                         /* parse_hiddenapi_class_data= */ klass->IsBootStrapClassLoaded());
+  ClassAccessor accessor(dex_file, dex_class_def);
   if (!accessor.HasClassData()) {
     return;
   }
@@ -3362,8 +3360,8 @@
   // also set its runtime hidden API access flags.
   uint32_t access_flags = field.GetAccessFlags();
   if (klass->IsBootStrapClassLoaded()) {
-    access_flags = HiddenApiAccessFlags::EncodeForRuntime(
-        access_flags, static_cast<HiddenApiAccessFlags::ApiList>(field.GetHiddenapiFlags()));
+    access_flags =
+        HiddenApiAccessFlags::EncodeForRuntime(access_flags, field.DecodeHiddenAccessFlags());
   }
   dst->SetAccessFlags(access_flags);
 }
@@ -3384,9 +3382,10 @@
   // Get access flags from the DexFile. If this is a boot class path class,
   // also set its runtime hidden API access flags.
   uint32_t access_flags = method.GetAccessFlags();
+
   if (klass->IsBootStrapClassLoaded()) {
-    access_flags = HiddenApiAccessFlags::EncodeForRuntime(
-        access_flags, static_cast<HiddenApiAccessFlags::ApiList>(method.GetHiddenapiFlags()));
+    access_flags =
+        HiddenApiAccessFlags::EncodeForRuntime(access_flags, method.DecodeHiddenAccessFlags());
   }
 
   if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
diff --git a/test/etc/default-build b/test/etc/default-build
index 3e6699a..8542ad0 100755
--- a/test/etc/default-build
+++ b/test/etc/default-build
@@ -323,8 +323,7 @@
 function make_hiddenapi() {
   local args=( "encode" )
   while [[ $# -gt 0 ]]; do
-    args+=("--input-dex=$1")
-    args+=("--output-dex=$1")
+    args+=("--dex=$1")
     shift
   done
   if [ -f api-light-greylist.txt ]; then
diff --git a/tools/hiddenapi/hiddenapi.cc b/tools/hiddenapi/hiddenapi.cc
index 06bea1a..68211a1 100644
--- a/tools/hiddenapi/hiddenapi.cc
+++ b/tools/hiddenapi/hiddenapi.cc
@@ -22,8 +22,6 @@
 #include "android-base/stringprintf.h"
 #include "android-base/strings.h"
 
-#include "base/bit_utils.h"
-#include "base/stl_util.h"
 #include "base/mem_map.h"
 #include "base/os.h"
 #include "base/unix_file/fd_file.h"
@@ -68,9 +66,8 @@
   UsageError("Usage: hiddenapi [command_name] [options]...");
   UsageError("");
   UsageError("  Command \"encode\": encode API list membership in boot dex files");
-  UsageError("    --input-dex=<filename>: dex file which belongs to boot class path");
-  UsageError("    --output-dex=<filename>: file to write encoded dex into");
-  UsageError("        input and output dex files are paired in order of appearance");
+  UsageError("    --dex=<filename>: dex file which belongs to boot class path,");
+  UsageError("                      the file will be overwritten");
   UsageError("");
   UsageError("    --light-greylist=<filename>:");
   UsageError("    --dark-greylist=<filename>:");
@@ -150,6 +147,30 @@
 
   inline const DexClass& GetDeclaringClass() const { return klass_; }
 
+  // Sets hidden bits in access flags and writes them back into the DEX in memory.
+  // Note that this will not update the cached data of the class accessor
+  // until it iterates over this item again and therefore will fail a CHECK if
+  // it is called multiple times on the same DexMember.
+  void SetHidden(HiddenApiAccessFlags::ApiList value) const {
+    const uint32_t old_flags = item_.GetRawAccessFlags();
+    const uint32_t new_flags = HiddenApiAccessFlags::EncodeForDex(old_flags, value);
+    CHECK_EQ(UnsignedLeb128Size(new_flags), UnsignedLeb128Size(old_flags));
+
+    // Locate the LEB128-encoded access flags in class data.
+    // `ptr` initially points to the next ClassData item. We iterate backwards
+    // until we hit the terminating byte of the previous Leb128 value.
+    const uint8_t* ptr = item_.GetDataPointer();
+    if (IsMethod()) {
+      ptr = ReverseSearchUnsignedLeb128(ptr);
+      DCHECK_EQ(DecodeUnsignedLeb128WithoutMovingCursor(ptr), GetMethod().GetCodeItemOffset());
+    }
+    ptr = ReverseSearchUnsignedLeb128(ptr);
+    DCHECK_EQ(DecodeUnsignedLeb128WithoutMovingCursor(ptr), old_flags);
+
+    // Overwrite the access flags.
+    UpdateUnsignedLeb128(const_cast<uint8_t*>(ptr), new_flags);
+  }
+
   inline bool IsMethod() const { return is_method_; }
   inline bool IsVirtualMethod() const { return IsMethod() && !GetMethod().IsStaticOrDirect(); }
   inline bool IsConstructor() const { return IsMethod() && HasAccessFlags(kAccConstructor); }
@@ -241,10 +262,6 @@
     });
   }
 
-  std::vector<const DexFile*> GetDexFiles() const {
-    return MakeNonOwningPointerVector(dex_files_);
-  }
-
   void UpdateDexChecksums() {
     for (auto& dex_file : dex_files_) {
       // Obtain a writeable pointer to the dex header.
@@ -542,316 +559,6 @@
   std::map<std::string, HierarchyClass> classes_;
 };
 
-// Builder of dex section containing hiddenapi flags.
-class HiddenapiClassDataBuilder final {
- public:
-  explicit HiddenapiClassDataBuilder(const DexFile& dex_file)
-      : num_classdefs_(dex_file.NumClassDefs()),
-        next_class_def_idx_(0u),
-        class_def_has_non_zero_flags_(false),
-        dex_file_has_non_zero_flags_(false),
-        data_(sizeof(uint32_t) * (num_classdefs_ + 1), 0u) {
-    *GetSizeField() = GetCurrentDataSize();
-  }
-
-  // Notify the builder that new flags for the next class def
-  // will be written now. The builder records the current offset
-  // into the header.
-  void BeginClassDef(uint32_t idx) {
-    CHECK_EQ(next_class_def_idx_, idx);
-    CHECK_LT(idx, num_classdefs_);
-    GetOffsetArray()[idx] = GetCurrentDataSize();
-    class_def_has_non_zero_flags_ = false;
-  }
-
-  // Notify the builder that all flags for this class def have been
-  // written. The builder updates the total size of the data struct
-  // and may set offset for class def in header to zero if no data
-  // has been written.
-  void EndClassDef(uint32_t idx) {
-    CHECK_EQ(next_class_def_idx_, idx);
-    CHECK_LT(idx, num_classdefs_);
-
-    ++next_class_def_idx_;
-
-    if (!class_def_has_non_zero_flags_) {
-      // No need to store flags for this class. Remove the written flags
-      // and set offset in header to zero.
-      data_.resize(GetOffsetArray()[idx]);
-      GetOffsetArray()[idx] = 0u;
-    }
-
-    dex_file_has_non_zero_flags_ |= class_def_has_non_zero_flags_;
-
-    if (idx == num_classdefs_ - 1) {
-      if (dex_file_has_non_zero_flags_) {
-        // This was the last class def and we have generated non-zero hiddenapi
-        // flags. Update total size in the header.
-        *GetSizeField() = GetCurrentDataSize();
-      } else {
-        // This was the last class def and we have not generated any non-zero
-        // hiddenapi flags. Clear all the data.
-        data_.clear();
-      }
-    }
-  }
-
-  // Append flags at the end of the data struct. This should be called
-  // between BeginClassDef and EndClassDef in the order of appearance of
-  // fields/methods in the class data stream.
-  void WriteFlags(uint32_t flags) {
-    EncodeUnsignedLeb128(&data_, flags);
-    class_def_has_non_zero_flags_ |= (flags != 0u);
-  }
-
-  // Return backing data, assuming that all flags have been written.
-  const std::vector<uint8_t>& GetData() const {
-    CHECK_EQ(next_class_def_idx_, num_classdefs_) << "Incomplete data";
-    return data_;
-  }
-
- private:
-  // Returns pointer to the size field in the header of this dex section.
-  uint32_t* GetSizeField() {
-    // Assume malloc() aligns allocated memory to at least uint32_t.
-    CHECK(IsAligned<sizeof(uint32_t)>(data_.data()));
-    return reinterpret_cast<uint32_t*>(data_.data());
-  }
-
-  // Returns pointer to array of offsets (indexed by class def indices) in the
-  // header of this dex section.
-  uint32_t* GetOffsetArray() { return &GetSizeField()[1]; }
-  uint32_t GetCurrentDataSize() const { return data_.size(); }
-
-  // Number of class defs in this dex file.
-  const uint32_t num_classdefs_;
-
-  // Next expected class def index.
-  uint32_t next_class_def_idx_;
-
-  // Whether non-zero flags have been encountered for this class def.
-  bool class_def_has_non_zero_flags_;
-
-  // Whether any non-zero flags have been encountered for this dex file.
-  bool dex_file_has_non_zero_flags_;
-
-  // Vector containing the data of the built data structure.
-  std::vector<uint8_t> data_;
-};
-
-// Edits a dex file, inserting a new HiddenapiClassData section.
-class DexFileEditor final {
- public:
-  DexFileEditor(const DexFile& old_dex, const std::vector<uint8_t>& hiddenapi_class_data)
-      : old_dex_(old_dex),
-        hiddenapi_class_data_(hiddenapi_class_data),
-        loaded_dex_header_(nullptr),
-        loaded_dex_maplist_(nullptr) {}
-
-  // Copies dex file into a backing data vector, appends the given HiddenapiClassData
-  // and updates the MapList.
-  void Encode() {
-    // We do not support non-standard dex encodings, e.g. compact dex.
-    CHECK(old_dex_.IsStandardDexFile());
-
-    // If there are no data to append, copy the old dex file and return.
-    if (hiddenapi_class_data_.empty()) {
-      AllocateMemory(old_dex_.Size());
-      Append(old_dex_.Begin(), old_dex_.Size(), /* update_header= */ false);
-      return;
-    }
-
-    // Find the old MapList, find its size.
-    const DexFile::MapList* old_map = old_dex_.GetMapList();
-    CHECK_LT(old_map->size_, std::numeric_limits<uint32_t>::max());
-
-    // Compute the size of the new dex file. We append the HiddenapiClassData,
-    // one MapItem and possibly some padding to align the new MapList.
-    CHECK(IsAligned<kMapListAlignment>(old_dex_.Size()))
-        << "End of input dex file is not 4-byte aligned, possibly because its MapList is not "
-        << "at the end of the file.";
-    size_t size_delta =
-        RoundUp(hiddenapi_class_data_.size(), kMapListAlignment) + sizeof(DexFile::MapItem);
-    size_t new_size = old_dex_.Size() + size_delta;
-    AllocateMemory(new_size);
-
-    // Copy the old dex file into the backing data vector. Load the copied
-    // dex file to obtain pointers to its header and MapList.
-    Append(old_dex_.Begin(), old_dex_.Size(), /* update_header= */ false);
-    ReloadDex(/* verify= */ false);
-
-    // Truncate the new dex file before the old MapList. This assumes that
-    // the MapList is the last entry in the dex file. This is currently true
-    // for our tooling.
-    // TODO: Implement the general case by zero-ing the old MapList (turning
-    // it into padding.
-    RemoveOldMapList();
-
-    // Append HiddenapiClassData.
-    size_t payload_offset = AppendHiddenapiClassData();
-
-    // Wrute new MapList with an entry for HiddenapiClassData.
-    CreateMapListWithNewItem(payload_offset);
-
-    // Check that the pre-computed size matches the actual size.
-    CHECK_EQ(offset_, new_size);
-
-    // Reload to all data structures.
-    ReloadDex(/* verify= */ false);
-
-    // Update the dex checksum.
-    UpdateChecksum();
-
-    // Run DexFileVerifier on the new dex file as a CHECK.
-    ReloadDex(/* verify= */ true);
-  }
-
-  // Writes the edited dex file into a file.
-  void WriteTo(const std::string& path) {
-    CHECK(!data_.empty());
-    std::ofstream ofs(path.c_str(), std::ofstream::out | std::ofstream::binary);
-    ofs.write(reinterpret_cast<const char*>(data_.data()), data_.size());
-    ofs.flush();
-    CHECK(ofs.good());
-    ofs.close();
-  }
-
- private:
-  static constexpr size_t kMapListAlignment = 4u;
-  static constexpr size_t kHiddenapiClassDataAlignment = 4u;
-
-  void ReloadDex(bool verify) {
-    std::string error_msg;
-    DexFileLoader loader;
-    loaded_dex_ = loader.Open(
-        data_.data(),
-        data_.size(),
-        "test_location",
-        old_dex_.GetLocationChecksum(),
-        /* oat_dex_file= */ nullptr,
-        /* verify= */ verify,
-        /* verify_checksum= */ verify,
-        &error_msg);
-    if (loaded_dex_.get() == nullptr) {
-      LOG(FATAL) << "Failed to load edited dex file: " << error_msg;
-      UNREACHABLE();
-    }
-
-    // Load the location of header and map list before we start editing the file.
-    loaded_dex_header_ = const_cast<DexFile::Header*>(&loaded_dex_->GetHeader());
-    loaded_dex_maplist_ = const_cast<DexFile::MapList*>(loaded_dex_->GetMapList());
-  }
-
-  DexFile::Header& GetHeader() const {
-    CHECK(loaded_dex_header_ != nullptr);
-    return *loaded_dex_header_;
-  }
-
-  DexFile::MapList& GetMapList() const {
-    CHECK(loaded_dex_maplist_ != nullptr);
-    return *loaded_dex_maplist_;
-  }
-
-  void AllocateMemory(size_t total_size) {
-    data_.clear();
-    data_.resize(total_size);
-    CHECK(IsAligned<kMapListAlignment>(data_.data()));
-    CHECK(IsAligned<kHiddenapiClassDataAlignment>(data_.data()));
-    offset_ = 0;
-  }
-
-  uint8_t* GetCurrentDataPtr() {
-    return data_.data() + offset_;
-  }
-
-  void UpdateDataSize(off_t delta, bool update_header) {
-    offset_ += delta;
-    if (update_header) {
-      DexFile::Header& header = GetHeader();
-      header.file_size_ += delta;
-      header.data_size_ += delta;
-    }
-  }
-
-  template<typename T>
-  T* Append(const T* src, size_t len, bool update_header = true) {
-    CHECK_LE(offset_ + len, data_.size());
-    uint8_t* dst = GetCurrentDataPtr();
-    memcpy(dst, src, len);
-    UpdateDataSize(len, update_header);
-    return reinterpret_cast<T*>(dst);
-  }
-
-  void InsertPadding(size_t alignment) {
-    size_t len = RoundUp(offset_, alignment) - offset_;
-    std::vector<uint8_t> padding(len, 0);
-    Append(padding.data(), padding.size());
-  }
-
-  void RemoveOldMapList() {
-    size_t map_size = GetMapList().Size();
-    uint8_t* map_start = reinterpret_cast<uint8_t*>(&GetMapList());
-    CHECK_EQ(map_start + map_size, GetCurrentDataPtr()) << "MapList not at the end of dex file";
-    UpdateDataSize(-static_cast<off_t>(map_size), /* update_header= */ true);
-    CHECK_EQ(map_start, GetCurrentDataPtr());
-    loaded_dex_maplist_ = nullptr;  // do not use this map list any more
-  }
-
-  void CreateMapListWithNewItem(size_t payload_offset) {
-    InsertPadding(/* alignment= */ kMapListAlignment);
-
-    size_t new_map_offset = offset_;
-    DexFile::MapList* map = Append(old_dex_.GetMapList(), old_dex_.GetMapList()->Size());
-
-    // Check last map entry is a pointer to itself.
-    DexFile::MapItem& old_item = map->list_[map->size_ - 1];
-    CHECK(old_item.type_ == DexFile::kDexTypeMapList);
-    CHECK_EQ(old_item.size_, 1u);
-    CHECK_EQ(old_item.offset_, GetHeader().map_off_);
-
-    // Create a new MapItem entry with new MapList details.
-    DexFile::MapItem new_item;
-    new_item.type_ = old_item.type_;
-    new_item.size_ = old_item.size_;
-    new_item.offset_ = new_map_offset;
-
-    // Update pointer in the header.
-    GetHeader().map_off_ = new_map_offset;
-
-    // Append a new MapItem and return its pointer.
-    map->size_++;
-    Append(&new_item, sizeof(DexFile::MapItem));
-
-    // Change penultimate entry to point to metadata.
-    old_item.type_ = DexFile::kDexTypeHiddenapiClassData;
-    old_item.size_ = 1u;  // there is only one section
-    old_item.offset_ = payload_offset;
-  }
-
-  size_t AppendHiddenapiClassData() {
-    size_t payload_offset = offset_;
-    CHECK_EQ(kMapListAlignment, kHiddenapiClassDataAlignment);
-    CHECK(IsAligned<kHiddenapiClassDataAlignment>(payload_offset))
-        << "Should not need to align the section, previous data was already aligned";
-    Append(hiddenapi_class_data_.data(), hiddenapi_class_data_.size());
-    return payload_offset;
-  }
-
-  void UpdateChecksum() {
-    GetHeader().checksum_ = loaded_dex_->CalculateChecksum();
-  }
-
-  const DexFile& old_dex_;
-  const std::vector<uint8_t>& hiddenapi_class_data_;
-
-  std::vector<uint8_t> data_;
-  size_t offset_;
-
-  std::unique_ptr<const DexFile> loaded_dex_;
-  DexFile::Header* loaded_dex_header_;
-  DexFile::MapList* loaded_dex_maplist_;
-};
-
 class HiddenApi final {
  public:
   HiddenApi() {}
@@ -883,10 +590,8 @@
       if (command == "encode") {
         for (int i = 1; i < argc; ++i) {
           const StringPiece option(argv[i]);
-          if (option.starts_with("--input-dex=")) {
-            boot_dex_paths_.push_back(option.substr(strlen("--input-dex=")).ToString());
-          } else if (option.starts_with("--output-dex=")) {
-            output_dex_paths_.push_back(option.substr(strlen("--output-dex=")).ToString());
+          if (option.starts_with("--dex=")) {
+            boot_dex_paths_.push_back(option.substr(strlen("--dex=")).ToString());
           } else if (option.starts_with("--light-greylist=")) {
             light_greylist_path_ = option.substr(strlen("--light-greylist=")).ToString();
           } else if (option.starts_with("--dark-greylist=")) {
@@ -925,9 +630,7 @@
 
   void EncodeAccessFlags() {
     if (boot_dex_paths_.empty()) {
-      Usage("No input DEX files specified");
-    } else if (output_dex_paths_.size() != boot_dex_paths_.size()) {
-      Usage("Number of input DEX files does not match number of output DEX files");
+      Usage("No boot DEX files specified");
     }
 
     // Load dex signatures.
@@ -936,41 +639,16 @@
     OpenApiFile(dark_greylist_path_, api_list, HiddenApiAccessFlags::kDarkGreylist);
     OpenApiFile(blacklist_path_, api_list, HiddenApiAccessFlags::kBlacklist);
 
-    // Iterate over input dex files and insert HiddenapiClassData sections.
-    for (size_t i = 0; i < boot_dex_paths_.size(); ++i) {
-      const std::string& input_path = boot_dex_paths_[i];
-      const std::string& output_path = output_dex_paths_[i];
+    // Open all dex files.
+    ClassPath boot_classpath(boot_dex_paths_, /* open_writable= */ true);
 
-      ClassPath boot_classpath({ input_path }, /* open_writable= */ false);
-      std::vector<const DexFile*> input_dex_files = boot_classpath.GetDexFiles();
-      CHECK_EQ(input_dex_files.size(), 1u);
-      const DexFile& input_dex = *input_dex_files[0];
+    // Set access flags of all members.
+    boot_classpath.ForEachDexMember([&api_list](const DexMember& boot_member) {
+      auto it = api_list.find(boot_member.GetApiEntry());
+      boot_member.SetHidden(it == api_list.end() ? HiddenApiAccessFlags::kWhitelist : it->second);
+    });
 
-      HiddenapiClassDataBuilder builder(input_dex);
-      boot_classpath.ForEachDexClass([&api_list, &builder](const DexClass& boot_class) {
-        builder.BeginClassDef(boot_class.GetClassDefIndex());
-        if (boot_class.GetData() != nullptr) {
-          auto fn_shared = [&](const DexMember& boot_member) {
-            // TODO: Load whitelist and CHECK that entry was found.
-            auto it = api_list.find(boot_member.GetApiEntry());
-            builder.WriteFlags(
-                (it == api_list.end()) ? HiddenApiAccessFlags::kWhitelist : it->second);
-          };
-          auto fn_field = [&](const ClassAccessor::Field& boot_field) {
-            fn_shared(DexMember(boot_class, boot_field));
-          };
-          auto fn_method = [&](const ClassAccessor::Method& boot_method) {
-            fn_shared(DexMember(boot_class, boot_method));
-          };
-          boot_class.VisitFieldsAndMethods(fn_field, fn_field, fn_method, fn_method);
-        }
-        builder.EndClassDef(boot_class.GetClassDefIndex());
-      });
-
-      DexFileEditor dex_editor(input_dex, builder.GetData());
-      dex_editor.Encode();
-      dex_editor.WriteTo(output_path);
-    }
+    boot_classpath.UpdateDexChecksums();
   }
 
   void OpenApiFile(const std::string& path,
@@ -1070,9 +748,6 @@
   // Paths to DEX files which should be processed.
   std::vector<std::string> boot_dex_paths_;
 
-  // Output paths where modified DEX files should be written.
-  std::vector<std::string> output_dex_paths_;
-
   // Set of public API stub classpaths. Each classpath is formed by a list
   // of DEX/APK files in the order they appear on the classpath.
   std::vector<std::vector<std::string>> stub_classpaths_;
@@ -1090,8 +765,6 @@
 }  // namespace art
 
 int main(int argc, char** argv) {
-  art::original_argc = argc;
-  art::original_argv = argv;
   android::base::InitLogging(argv);
   art::MemMap::Init();
   art::HiddenApi().Run(argc, argv);
diff --git a/tools/hiddenapi/hiddenapi_test.cc b/tools/hiddenapi/hiddenapi_test.cc
index cdf797e..799546e 100644
--- a/tools/hiddenapi/hiddenapi_test.cc
+++ b/tools/hiddenapi/hiddenapi_test.cc
@@ -47,7 +47,6 @@
                                               const std::vector<std::string>& extra_args,
                                               ScratchFile* out_dex) {
     std::string error;
-    ScratchFile in_dex;
     std::unique_ptr<ZipArchive> jar(
         ZipArchive::Open(GetTestDexFileName("HiddenApi").c_str(), &error));
     if (jar == nullptr) {
@@ -59,7 +58,7 @@
       LOG(FATAL) << "Could not find classes.dex in test file " << GetTestDexFileName("HiddenApi")
                  << ": " << error;
       UNREACHABLE();
-    } else if (!jar_classes_dex->ExtractToFile(*in_dex.GetFile(), &error)) {
+    } else if (!jar_classes_dex->ExtractToFile(*out_dex->GetFile(), &error)) {
       LOG(FATAL) << "Could not extract classes.dex from test file "
                  << GetTestDexFileName("HiddenApi") << ": " << error;
       UNREACHABLE();
@@ -69,8 +68,7 @@
     argv_str.push_back(GetHiddenApiCmd());
     argv_str.insert(argv_str.end(), extra_args.begin(), extra_args.end());
     argv_str.push_back("encode");
-    argv_str.push_back("--input-dex=" + in_dex.GetFilename());
-    argv_str.push_back("--output-dex=" + out_dex->GetFilename());
+    argv_str.push_back("--dex=" + out_dex->GetFilename());
     argv_str.push_back("--light-greylist=" + light_greylist.GetFilename());
     argv_str.push_back("--dark-greylist=" + dark_greylist.GetFilename());
     argv_str.push_back("--blacklist=" + blacklist.GetFilename());
@@ -94,7 +92,7 @@
     }
 
     std::unique_ptr<const DexFile> dex_file(dex_loader.OpenDex(
-        fd.Release(), /* location= */ file.GetFilename(), /* verify= */ true,
+        fd.Release(), /* location= */ file.GetFilename(), /* verify= */ false,
         /* verify_checksum= */ true, /* mmap_shared= */ false, &error_msg));
     if (dex_file.get() == nullptr) {
       LOG(FATAL) << "Open failed for '" << file.GetFilename() << "' " << error_msg;
@@ -128,20 +126,16 @@
                                                     uint32_t expected_visibility,
                                                     const DexFile::ClassDef& class_def,
                                                     const DexFile& dex_file) {
-    ClassAccessor accessor(dex_file, class_def, /* parse hiddenapi flags */ true);
+    ClassAccessor accessor(dex_file, class_def);
     CHECK(accessor.HasClassData()) << "Class " << accessor.GetDescriptor() << " has no data";
 
-    if (!accessor.HasHiddenapiClassData()) {
-      return HiddenApiAccessFlags::kWhitelist;
-    }
-
     for (const ClassAccessor::Field& field : accessor.GetFields()) {
       const DexFile::FieldId& fid = dex_file.GetFieldId(field.GetIndex());
       if (strcmp(name, dex_file.GetFieldName(fid)) == 0) {
         const uint32_t actual_visibility = field.GetAccessFlags() & kAccVisibilityFlags;
         CHECK_EQ(actual_visibility, expected_visibility)
             << "Field " << name << " in class " << accessor.GetDescriptor();
-        return static_cast<HiddenApiAccessFlags::ApiList>(field.GetHiddenapiFlags());
+        return field.DecodeHiddenAccessFlags();
       }
     }
 
@@ -155,13 +149,9 @@
                                                      bool expected_native,
                                                      const DexFile::ClassDef& class_def,
                                                      const DexFile& dex_file) {
-    ClassAccessor accessor(dex_file, class_def, /* parse hiddenapi flags */ true);
+    ClassAccessor accessor(dex_file, class_def);
     CHECK(accessor.HasClassData()) << "Class " << accessor.GetDescriptor() << " has no data";
 
-    if (!accessor.HasHiddenapiClassData()) {
-      return HiddenApiAccessFlags::kWhitelist;
-    }
-
     for (const ClassAccessor::Method& method : accessor.GetMethods()) {
       const DexFile::MethodId& mid = dex_file.GetMethodId(method.GetIndex());
       if (strcmp(name, dex_file.GetMethodName(mid)) == 0) {
@@ -170,7 +160,7 @@
         const uint32_t actual_visibility = method.GetAccessFlags() & kAccVisibilityFlags;
         CHECK_EQ(actual_visibility, expected_visibility)
             << "Method " << name << " in class " << accessor.GetDescriptor();
-        return static_cast<HiddenApiAccessFlags::ApiList>(method.GetHiddenapiFlags());
+        return method.DecodeHiddenAccessFlags();
       }
     }