diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..749ccda
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
diff --git a/abi/Android.mk b/abi/Android.mk
index 5a34733..98d81af 100644
--- a/abi/Android.mk
+++ b/abi/Android.mk
@@ -19,6 +19,5 @@
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := VtsVndkAbi
-VTS_CONFIG_SRC_DIR := testcases/vndk/abi
 include test/vts/tools/build/Android.host_config.mk
 
diff --git a/abi/VtsVndkAbiTest.py b/abi/VtsVndkAbiTest.py
index 34f8ff5..89d12e2 100644
--- a/abi/VtsVndkAbiTest.py
+++ b/abi/VtsVndkAbiTest.py
@@ -15,6 +15,7 @@
 # limitations under the License.
 #
 
+import json
 import logging
 import os
 import shutil
@@ -22,34 +23,14 @@
 
 from vts.runners.host import asserts
 from vts.runners.host import base_test
-from vts.runners.host import const
 from vts.runners.host import keys
 from vts.runners.host import test_runner
+from vts.runners.host import utils
 from vts.testcases.vndk.golden import vndk_data
-from vts.utils.python.controllers import android_device
+from vts.utils.python.file import target_file_utils
 from vts.utils.python.library import elf_parser
-from vts.utils.python.library import vtable_parser
-
-
-def _IterateFiles(root_dir):
-    """A generator yielding relative and full paths in a directory.
-
-    Args:
-        root_dir: The directory to search.
-
-    Yields:
-        A tuple of (relative_path, full_path) for each regular file.
-        relative_path is the relative path to root_dir. full_path is the path
-        starting with root_dir.
-    """
-    for dir_path, dir_names, file_names in os.walk(root_dir):
-        if dir_path == root_dir:
-            rel_dir = ""
-        else:
-            rel_dir = os.path.relpath(dir_path, root_dir)
-        for file_name in file_names:
-            yield (os.path.join(rel_dir, file_name),
-                   os.path.join(dir_path, file_name))
+from vts.utils.python.library.vtable import vtable_dumper
+from vts.utils.python.vndk import vndk_utils
 
 
 class VtsVndkAbiTest(base_test.BaseTestClass):
@@ -61,12 +42,6 @@
         _vndk_version: String, the VNDK version supported by the device.
         data_file_path: The path to VTS data directory.
     """
-    _ODM_LIB_DIR_32 = "/odm/lib"
-    _ODM_LIB_DIR_64 = "/odm/lib64"
-    _VENDOR_LIB_DIR_32 = "/vendor/lib"
-    _VENDOR_LIB_DIR_64 = "/vendor/lib64"
-    _SYSTEM_LIB_DIR_32 = "/system/lib"
-    _SYSTEM_LIB_DIR_64 = "/system/lib64"
 
     def setUpClass(self):
         """Initializes data file path, device, and temporary directory."""
@@ -88,84 +63,170 @@
             target_dir: The directory to copy from device.
             host_dir: The directory to copy to host.
         """
-        test_cmd = "test -d " + target_dir
-        logging.info("adb shell %s", test_cmd)
-        result = self._dut.adb.shell(test_cmd, no_except=True)
-        if result[const.EXIT_CODE]:
+        if not target_file_utils.IsDirectory(target_dir, self._dut.shell):
             logging.info("%s doesn't exist. Create %s.", target_dir, host_dir)
-            os.mkdir(host_dir, 0750)
+            os.makedirs(host_dir)
             return
+        parent_dir = os.path.dirname(host_dir)
+        if parent_dir and not os.path.isdir(parent_dir):
+            os.makedirs(parent_dir)
         logging.info("adb pull %s %s", target_dir, host_dir)
         self._dut.adb.pull(target_dir, host_dir)
 
-    def _DiffSymbols(self, dump_path, lib_path):
+    def _ToHostPath(self, target_path):
+        """Maps target path to host path in self._temp_dir."""
+        return os.path.join(self._temp_dir, *target_path.strip("/").split("/"))
+
+    @staticmethod
+    def _LoadGlobalSymbolsFromDump(dump_obj):
+        """Loads global symbols from a dump object.
+
+        Args:
+            dump_obj: A dict, the dump in JSON format.
+
+        Returns:
+            A set of strings, the symbol names.
+        """
+        symbols = set()
+        for key in ("elf_functions", "elf_objects"):
+            symbols.update(
+                symbol.get("name", "") for symbol in dump_obj.get(key, []) if
+                symbol.get("binding", "global") == "global")
+        return symbols
+
+    def _DiffElfSymbols(self, dump_obj, parser):
         """Checks if a library includes all symbols in a dump.
 
         Args:
-            dump_path: The path to the dump file containing list of symbols.
-            lib_path: The path to the library.
+            dump_obj: A dict, the dump in JSON format.
+            parser: An elf_parser.ElfParser that loads the library.
 
         Returns:
             A list of strings, the global symbols that are in the dump but not
             in the library.
 
         Raises:
-            IOError if fails to load the dump.
             elf_parser.ElfError if fails to load the library.
         """
-        with open(dump_path, "r") as dump_file:
-            dump_symbols = set(line.strip() for line in dump_file
-                               if line.strip())
-        parser = elf_parser.ElfParser(lib_path)
-        try:
-            lib_symbols = parser.ListGlobalDynamicSymbols(include_weak=True)
-        finally:
-            parser.Close()
+        dump_symbols = self._LoadGlobalSymbolsFromDump(dump_obj)
+        lib_symbols = parser.ListGlobalDynamicSymbols(include_weak=True)
         return sorted(dump_symbols.difference(lib_symbols))
 
-    def _DiffVtables(self, dump_path, lib_path):
+    @staticmethod
+    def _DiffVtableComponent(offset, expected_symbol, vtable):
+        """Checks if a symbol is in a vtable entry.
+
+        Args:
+            offset: An integer, the offset of the expected symbol.
+            exepcted_symbol: A string, the name of the expected symbol.
+            vtable: A dict of {offset: [entry]} where offset is an integer and
+                    entry is an instance of vtable_dumper.VtableEntry.
+
+        Returns:
+            A list of strings, the actual possible symbols if expected_symbol
+            does not match the vtable entry.
+            None if expected_symbol matches the entry.
+        """
+        if offset not in vtable:
+            return []
+
+        entry = vtable[offset]
+        if not entry.names:
+            return [hex(entry.value).rstrip('L')]
+
+        if expected_symbol not in entry.names:
+            return entry.names
+
+    def _DiffVtableComponents(self, dump_obj, dumper):
         """Checks if a library includes all vtable entries in a dump.
 
         Args:
-            dump_path: The path to the dump file containing vtables.
-            lib_path: The path to the library.
+            dump_obj: A dict, the dump in JSON format.
+            dumper: An vtable_dumper.VtableDumper that loads the library.
 
         Returns:
-            A list of tuples (VTABLE, SYMBOL, EXPECTED_OFFSET, ACTUAL_OFFSET).
-            ACTUAL_OFFSET can be "missing" or numbers separated by comma.
+            A list of tuples (VTABLE, OFFSET, EXPECTED_SYMBOL, ACTUAL).
+            ACTUAL can be "missing", a list of symbol names, or an ELF virtual
+            address.
 
         Raises:
-            IOError if fails to load the dump.
-            vtable_parser.VtableError if fails to load the library.
+            vtable_dumper.VtableError if fails to dump vtable from the library.
         """
-        parser = vtable_parser.VtableParser(
-            os.path.join(self.data_file_path, "host"))
-        with open(dump_path, "r") as dump_file:
-            dump_vtables = parser.ParseVtablesFromString(dump_file.read())
+        function_kinds = [
+            "function_pointer",
+            "complete_dtor_pointer",
+            "deleting_dtor_pointer"
+        ]
+        non_function_kinds = [
+            "vcall_offset",
+            "vbase_offset",
+            "offset_to_top",
+            "rtti",
+            "unused_function_pointer"
+        ]
+        default_vtable_component_kind = "function_pointer"
 
-        lib_vtables = parser.ParseVtablesFromLibrary(lib_path)
-        # TODO(b/78316564): The dumper doesn't support SHT_ANDROID_RELA.
-        if not lib_vtables and self.run_as_compliance_test:
-            logging.warning("%s: Cannot dump vtables",
-                            os.path.relpath(lib_path, self._temp_dir))
-            return []
-        logging.debug("%s: %s", lib_path, lib_vtables)
-        diff = []
-        for vtable, dump_symbols in dump_vtables.iteritems():
-            lib_inv_vtable = dict()
-            if vtable in lib_vtables:
-                for off, sym in lib_vtables[vtable]:
-                    if sym not in lib_inv_vtable:
-                        lib_inv_vtable[sym] = [off]
-                    else:
-                        lib_inv_vtable[sym].append(off)
-            for off, sym in dump_symbols:
-                if sym not in lib_inv_vtable:
-                    diff.append((vtable, sym, str(off), "missing"))
-                elif off not in lib_inv_vtable[sym]:
-                    diff.append((vtable, sym, str(off),
-                                 ",".join(str(x) for x in lib_inv_vtable[sym])))
-        return diff
+        global_symbols = self._LoadGlobalSymbolsFromDump(dump_obj)
+
+        lib_vtables = {vtable.name: vtable
+                       for vtable in dumper.DumpVtables()}
+        logging.debug("\n\n".join(str(vtable)
+                                  for _, vtable in lib_vtables.iteritems()))
+
+        vtables_diff = []
+        for record_type in dump_obj.get("record_types", []):
+            type_name_symbol = record_type.get("unique_id", "")
+            vtable_symbol = type_name_symbol.replace("_ZTS", "_ZTV", 1)
+
+            # Skip if the vtable symbol isn't global.
+            if vtable_symbol not in global_symbols:
+                continue
+
+            # Collect vtable entries from library dump.
+            if vtable_symbol in lib_vtables:
+                lib_vtable = {entry.offset: entry
+                              for entry in lib_vtables[vtable_symbol].entries}
+            else:
+                lib_vtable = dict()
+
+            for index, entry in enumerate(record_type.get("vtable_components",
+                                                          [])):
+                entry_offset = index * int(self.abi_bitness) // 8
+                entry_kind = entry.get("kind", default_vtable_component_kind)
+                entry_symbol = entry.get("mangled_component_name", "")
+                entry_is_pure = entry.get("is_pure", False)
+
+                if entry_kind in non_function_kinds:
+                    continue
+
+                if entry_kind not in function_kinds:
+                    logging.warning("%s: Unexpected vtable entry kind %s",
+                                    vtable_symbol, entry_kind)
+
+                if entry_symbol not in global_symbols:
+                    # Itanium cxx abi doesn't specify pure virtual vtable
+                    # entry's behaviour. However we can still do some checks
+                    # based on compiler behaviour.
+                    # Even though we don't check weak symbols, we can still
+                    # issue a warning when a pure virtual function pointer
+                    # is missing.
+                    if entry_is_pure and entry_offset not in lib_vtable:
+                        logging.warning("%s: Expected pure virtual function"
+                                        "in %s offset %s",
+                                        vtable_symbol, vtable_symbol,
+                                        entry_offset)
+                    continue
+
+                diff_symbols = self._DiffVtableComponent(
+                    entry_offset, entry_symbol, lib_vtable)
+                if diff_symbols is None:
+                    continue
+
+                vtables_diff.append(
+                    (vtable_symbol, str(entry_offset), entry_symbol,
+                     (",".join(diff_symbols) if diff_symbols else "missing")))
+
+        return vtables_diff
 
     def _ScanLibDirs(self, dump_dir, lib_dirs, dump_version):
         """Compares dump files with libraries copied from device.
@@ -182,74 +243,70 @@
             An integer, number of incompatible libraries.
         """
         error_count = 0
-        symbol_dumps = dict()
-        vtable_dumps = dict()
+        dump_paths = dict()
         lib_paths = dict()
-        for dump_rel_path, dump_path in _IterateFiles(dump_dir):
-            if dump_rel_path.endswith("_symbol.dump"):
-                lib_name = dump_rel_path.rpartition("_symbol.dump")[0]
-                symbol_dumps[lib_name] = dump_path
-            elif dump_rel_path.endswith("_vtable.dump"):
-                lib_name = dump_rel_path.rpartition("_vtable.dump")[0]
-                vtable_dumps[lib_name] = dump_path
+        for parent_dir, dump_name in utils.iterate_files(dump_dir):
+            dump_path = os.path.join(parent_dir, dump_name)
+            if dump_path.endswith(".dump"):
+                lib_name = dump_name.rpartition(".dump")[0]
+                dump_paths[lib_name] = dump_path
             else:
                 logging.warning("Unknown dump: %s", dump_path)
-                continue
-            lib_paths[lib_name] = None
 
         for lib_dir in lib_dirs:
-            for lib_rel_path, lib_path in _IterateFiles(lib_dir):
-                try:
-                    vndk_dir = next(x for x in ("vndk", "vndk-sp") if
-                                    lib_rel_path.startswith(x + os.path.sep))
-                    lib_name = lib_rel_path.replace(
-                        vndk_dir, vndk_dir + "-" + dump_version, 1)
-                except StopIteration:
-                    lib_name = lib_rel_path
+            for parent_dir, lib_name in utils.iterate_files(lib_dir):
+                if lib_name not in lib_paths:
+                    lib_paths[lib_name] = os.path.join(parent_dir, lib_name)
 
-                if lib_name in lib_paths and not lib_paths[lib_name]:
-                    lib_paths[lib_name] = lib_path
-
-        for lib_name, lib_path in lib_paths.iteritems():
-            if not lib_path:
+        for lib_name, dump_path in dump_paths.iteritems():
+            if lib_name not in lib_paths:
                 logging.info("%s: Not found on target", lib_name)
                 continue
+            lib_path = lib_paths[lib_name]
             rel_path = os.path.relpath(lib_path, self._temp_dir)
 
             has_exception = False
             missing_symbols = []
             vtable_diff = []
-            # Compare symbols
-            if lib_name in symbol_dumps:
-                try:
-                    missing_symbols = self._DiffSymbols(
-                        symbol_dumps[lib_name], lib_path)
-                except (IOError, elf_parser.ElfError):
-                    logging.exception("%s: Cannot diff symbols", rel_path)
-                    has_exception = True
-            # Compare vtables
-            if lib_name in vtable_dumps:
-                try:
-                    vtable_diff = self._DiffVtables(
-                        vtable_dumps[lib_name], lib_path)
-                except (IOError, vtable_parser.VtableError):
-                    logging.exception("%s: Cannot diff vtables", rel_path)
-                    has_exception = True
+
+            try:
+                with open(dump_path, "r") as dump_file:
+                    dump_obj = json.load(dump_file)
+                with vtable_dumper.VtableDumper(lib_path) as dumper:
+                    missing_symbols = self._DiffElfSymbols(
+                        dump_obj, dumper)
+                    vtable_diff = self._DiffVtableComponents(
+                        dump_obj, dumper)
+            except (IOError,
+                    elf_parser.ElfError,
+                    vtable_dumper.VtableError) as e:
+                logging.exception("%s: Cannot diff ABI", rel_path)
+                has_exception = True
 
             if missing_symbols:
                 logging.error("%s: Missing Symbols:\n%s",
                               rel_path, "\n".join(missing_symbols))
             if vtable_diff:
                 logging.error("%s: Vtable Difference:\n"
-                              "vtable symbol expected actual\n%s",
+                              "vtable offset expected actual\n%s",
                               rel_path,
-                              "\n".join(" ".join(x) for x in vtable_diff))
-            if has_exception or missing_symbols or vtable_diff:
+                              "\n".join(" ".join(e) for e in vtable_diff))
+            if (has_exception or missing_symbols or vtable_diff):
                 error_count += 1
             else:
                 logging.info("%s: Pass", rel_path)
         return error_count
 
+    @staticmethod
+    def _GetLinkerSearchIndex(target_path):
+        """Returns the key for sorting linker search paths."""
+        index = 0
+        for prefix in ("/odm", "/vendor", "/system"):
+            if target_path.startswith(prefix):
+                return index
+            index += 1
+        return index
+
     def testAbiCompatibility(self):
         """Checks ABI compliance of VNDK libraries."""
         primary_abi = self._dut.getCpuAbiList()[0]
@@ -273,26 +330,20 @@
                 self._vndk_version, primary_abi, self.abi_bitness))
         logging.info("dump dir: %s", dump_dir)
 
-        odm_lib_dir = os.path.join(
-            self._temp_dir, "odm_lib_dir_" + self.abi_bitness)
-        vendor_lib_dir = os.path.join(
-            self._temp_dir, "vendor_lib_dir_" + self.abi_bitness)
-        system_lib_dir = os.path.join(
-            self._temp_dir, "system_lib_dir_" + self.abi_bitness)
-        logging.info("host lib dir: %s %s %s",
-                     odm_lib_dir, vendor_lib_dir, system_lib_dir)
-        self._PullOrCreateDir(
-            getattr(self, "_ODM_LIB_DIR_" + self.abi_bitness),
-            odm_lib_dir)
-        self._PullOrCreateDir(
-            getattr(self, "_VENDOR_LIB_DIR_" + self.abi_bitness),
-            vendor_lib_dir)
-        self._PullOrCreateDir(
-            getattr(self, "_SYSTEM_LIB_DIR_" + self.abi_bitness),
-            system_lib_dir)
+        target_vndk_dir = vndk_utils.GetVndkCoreDirectory(self.abi_bitness,
+                                                          self._vndk_version)
+        target_vndk_sp_dir = vndk_utils.GetVndkSpDirectory(self.abi_bitness,
+                                                           self._vndk_version)
+        target_dirs = vndk_utils.GetVndkExtDirectories(self.abi_bitness)
+        target_dirs += vndk_utils.GetVndkSpExtDirectories(self.abi_bitness)
+        target_dirs += [target_vndk_dir, target_vndk_sp_dir]
+        target_dirs.sort(key=self._GetLinkerSearchIndex)
 
-        error_count = self._ScanLibDirs(
-            dump_dir, [odm_lib_dir, vendor_lib_dir, system_lib_dir], dump_version)
+        host_dirs = [self._ToHostPath(x) for x in target_dirs]
+        for target_dir, host_dir in zip(target_dirs, host_dirs):
+            self._PullOrCreateDir(target_dir, host_dir)
+
+        error_count = self._ScanLibDirs(dump_dir, host_dirs, dump_version)
         asserts.assertEqual(error_count, 0,
                             "Total number of errors: " + str(error_count))
 
diff --git a/dependency/Android.mk b/dependency/Android.mk
index e527023..2c538db 100644
--- a/dependency/Android.mk
+++ b/dependency/Android.mk
@@ -21,7 +21,5 @@
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := VtsVndkDependency
-
-VTS_CONFIG_SRC_DIR := testcases/vndk/dependency
 include test/vts/tools/build/Android.host_config.mk
 
diff --git a/dependency/VtsVndkDependencyTest.py b/dependency/VtsVndkDependencyTest.py
index 094d84a..4878978 100644
--- a/dependency/VtsVndkDependencyTest.py
+++ b/dependency/VtsVndkDependencyTest.py
@@ -111,11 +111,7 @@
 
         sp_hal_strings = vndk_lists[0]
         self._sp_hal = [re.compile(x) for x in sp_hal_strings]
-        (self._ll_ndk,
-         self._vndk,
-         self._vndk_sp) = (
-            set(path_utils.TargetBaseName(path) for path in vndk_list)
-            for vndk_list in vndk_lists[1:])
+        (self._ll_ndk, self._vndk, self._vndk_sp) = vndk_lists[1:]
 
         logging.debug("LL_NDK: %s", self._ll_ndk)
         logging.debug("SP_HAL: %s", sp_hal_strings)
diff --git a/files/VtsVndkFilesTest.py b/files/VtsVndkFilesTest.py
index 5f08ccf..d88cd8a 100644
--- a/files/VtsVndkFilesTest.py
+++ b/files/VtsVndkFilesTest.py
@@ -68,20 +68,21 @@
         return target_file_utils.FindFiles(self._shell, dir_path, "*",
                                            "! -type d")
 
-    def _TestVndkDirectory(self, vndk_dir, *vndk_list_names):
+    def _TestVndkDirectory(self, vndk_dir, vndk_list_names):
         """Verifies that the VNDK directory doesn't contain extra files.
 
         Args:
             vndk_dir: The path to the VNDK directory on device.
-            *vndk_list_names: Strings, the categories of the VNDK libraries
-                              that can be in the directory.
+            vndk_list_names: Strings, the categories of the VNDK libraries
+                             that can be in the directory.
         """
         vndk_lists = vndk_data.LoadVndkLibraryLists(
             self.data_file_path, self._vndk_version, *vndk_list_names)
         asserts.assertTrue(vndk_lists, "Cannot load VNDK library lists.")
         vndk_set = set().union(*vndk_lists)
         logging.debug("vndk set: %s", vndk_set)
-        unexpected = set(self._ListFiles(vndk_dir)) - vndk_set
+        unexpected = [x for x in self._ListFiles(vndk_dir) if
+                      path_utils.TargetBaseName(x) not in vndk_set]
         if unexpected:
             logging.error("Unexpected files:\n%s", "\n".join(unexpected))
             asserts.fail("Total number of errors: %d" % len(unexpected))
@@ -99,9 +100,7 @@
         vndk_lists = vndk_data.LoadVndkLibraryLists(
             self.data_file_path, self._vndk_version, *vndk_list_names)
         asserts.assertTrue(vndk_lists, "Cannot load VNDK library lists.")
-        vndk_set = set()
-        for vndk_list in vndk_lists:
-            vndk_set.update(path_utils.TargetBaseName(x) for x in vndk_list)
+        vndk_set = set().union(*vndk_lists)
         vndk_set.difference_update(except_libs)
         logging.debug("vndk set: %s", vndk_set)
         unexpected = [x for x in self._ListFiles(vndk_dir) if
@@ -117,16 +116,14 @@
         self._TestVndkDirectory(
             vndk_utils.GetVndkCoreDirectory(
                 self.abi_bitness, self._vndk_version),
-            vndk_data.VNDK,
-            vndk_data.VNDK_PRIVATE)
+            (vndk_data.VNDK, vndk_data.VNDK_PRIVATE,))
 
     def testVndkSpDirectory(self):
         """Verifies that VNDK-SP directory doesn't contain extra files."""
         self._TestVndkDirectory(
             vndk_utils.GetVndkSpDirectory(
                 self.abi_bitness, self._vndk_version),
-            vndk_data.VNDK_SP,
-            vndk_data.VNDK_SP_PRIVATE)
+            (vndk_data.VNDK_SP, vndk_data.VNDK_SP_PRIVATE,))
 
     def testNoLlndkInVendor(self):
         """Verifies that vendor partition has no LL-NDK libraries."""
diff --git a/golden/Android.bp b/golden/Android.bp
new file mode 100644
index 0000000..20222e1
--- /dev/null
+++ b/golden/Android.bp
@@ -0,0 +1,28 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+python_binary_host {
+    name: "extract_lsdump",
+    main: "extract_lsdump.py",
+    srcs: ["extract_lsdump.py"],
+    version: {
+        py2: {
+            enabled: true,
+            embedded_launcher: true,
+        },
+        py3: {
+            enabled: false,
+        },
+    }
+}
diff --git a/golden/dump_abi.py b/golden/dump_abi.py
index 71f9f00..a5767ae 100755
--- a/golden/dump_abi.py
+++ b/golden/dump_abi.py
@@ -16,52 +16,11 @@
 #
 
 import argparse
-import csv
-import importlib
 import os
 import subprocess
 import sys
 
-
-class ExternalModules(object):
-    """This class imports modules dynamically and keeps them as attributes.
-
-    Assume the user runs this script in the source directory. The VTS modules
-    are outside the search path and thus have to be imported dynamically.
-
-    Attribtues:
-        ar_parser: The ar_parser module.
-        elf_parser: The elf_parser module.
-        vtable_parser: The vtable_parser module.
-    """
-    @classmethod
-    def ImportParsers(cls, import_dir):
-        """Imports elf_parser and vtable_parser.
-
-        Args:
-            import_dir: The directory containing vts.utils.python.library.*.
-        """
-        sys.path.append(import_dir)
-        cls.ar_parser = importlib.import_module(
-            "vts.utils.python.library.ar_parser")
-        cls.elf_parser = importlib.import_module(
-            "vts.utils.python.library.elf_parser")
-        cls.vtable_parser = importlib.import_module(
-            "vts.utils.python.library.vtable_parser")
-
-
-def _CreateAndWrite(path, data):
-    """Creates directories on a file path and writes data to it.
-
-    Args:
-        path: The path to the file.
-        data: The data to write.
-    """
-    dir_name = os.path.dirname(path)
-    if dir_name and not os.path.exists(dir_name):
-        os.makedirs(dir_name)
-    with open(path, "w") as f:
-        f.write(data)
+import extract_lsdump
 
 
 def _ExecuteCommand(cmd, **kwargs):
@@ -103,130 +62,43 @@
     return [line.split("=", 1)[1].strip("'") for line in stdout.splitlines()]
 
 
-def FindBinary(file_name):
-    """Finds an executable binary in environment variable PATH.
+def _LoadLibraryNamesFromTxt(vndk_lib_list_file):
+    """Loads VNDK and VNDK-SP library names from a VNDK library list.
 
     Args:
-        file_name: The file name to find.
-
-    Returns:
-        A string which is the path to the binary.
-    """
-    return _ExecuteCommand(["which", file_name])
-
-
-def DumpSymbols(lib_path, dump_path, exclude_symbols):
-    """Dump symbols from a library to a dump file.
-
-    The dump file is a sorted list of symbols. Each line contains one symbol.
-
-    Args:
-        lib_path: The path to the library.
-        dump_path: The path to the dump file.
-        exclude_symbols: A set of strings, the symbols that should not be
-                         written to the dump file.
-
-    Returns:
-        A list of strings which are the symbols written to the dump file.
-
-    Raises:
-        elf_parser.ElfError if fails to load the library.
-        IOError if fails to write to the dump.
-    """
-    elf_parser = ExternalModules.elf_parser
-    parser = None
-    try:
-        parser = elf_parser.ElfParser(lib_path)
-        symbols = [x for x in parser.ListGlobalDynamicSymbols()
-                   if x not in exclude_symbols]
-    finally:
-        if parser:
-            parser.Close()
-    if symbols:
-        symbols.sort()
-        _CreateAndWrite(dump_path, "\n".join(symbols) + "\n")
-    return symbols
-
-
-def DumpVtables(lib_path, dump_path, dumper_dir, include_symbols):
-    """Dump vtables from a library to a dump file.
-
-    The dump file is the raw output of vndk-vtable-dumper.
-
-    Args:
-        lib_path: The path to the library.
-        dump_path: The path to the text file.
-        dumper_dir: The path to the directory containing the dumper executable
-                    and library.
-        include_symbols: A set of strings. A vtable is written to the dump file
-                         only if its symbol is in the set.
-
-    Returns:
-        A string which is the content written to the dump file.
-
-    Raises:
-        vtable_parser.VtableError if fails to load the library.
-        IOError if fails to write to the dump.
-    """
-    vtable_parser = ExternalModules.vtable_parser
-    parser = vtable_parser.VtableParser(dumper_dir)
-
-    def GenerateLines():
-        for line in parser.CallVtableDumper(lib_path).split("\n"):
-            parsed_lines.append(line)
-            yield line
-
-    lines = GenerateLines()
-    dump_lines = []
-    try:
-        while True:
-            parsed_lines = []
-            vtable, entries = parser.ParseOneVtable(lines)
-            if vtable in include_symbols:
-                dump_lines.extend(parsed_lines)
-    except StopIteration:
-        pass
-
-    dump_string = "\n".join(dump_lines).strip("\n")
-    if dump_string:
-        dump_string += "\n"
-        _CreateAndWrite(dump_path, dump_string)
-    return dump_string
-
-
-def _LoadLibraryNamesFromCsv(csv_file):
-    """Loads VNDK and VNDK-SP library names from an eligible list.
-
-    Args:
-        csv_file: A file object of eligible-list.csv.
+        vndk_lib_list_file: A file object of
+                            build/make/target/product/vndk/current.txt
 
     Returns:
         A list of strings, the VNDK and VNDK-SP library names with vndk/vndk-sp
         directory prefixes.
     """
-    lib_names = []
-    # Skip header
-    next(csv_file)
-    reader = csv.reader(csv_file)
-    for cells in reader:
-        if cells[1] not in ("VNDK", "VNDK-SP"):
-            continue
-        lib_name = os.path.normpath(cells[0]).replace("/system/${LIB}/", "", 1)
-        if not (lib_name.startswith("vndk") or lib_name.startswith("vndk-sp")):
-            continue
-        lib_name = lib_name.replace("${VNDK_VER}", "{VNDK_VER}")
-        lib_names.append(lib_name)
-    return lib_names
+    tags = (
+        ("VNDK-core: ", len("VNDK-core: "), False),
+        ("VNDK-SP: ", len("VNDK-SP: "), False),
+        ("VNDK-private: ", len("VNDK-private: "), True),
+        ("VNDK-SP-private: ", len("VNDK-SP-private: "), True),
+    )
+    lib_names = set()
+    lib_names_exclude = set()
+    for line in vndk_lib_list_file:
+        for tag, tag_len, is_exclude in tags:
+            if line.startswith(tag):
+                lib_name = line[tag_len:].strip()
+                if is_exclude:
+                    lib_names_exclude.add(lib_name)
+                else:
+                    lib_names.add(lib_name)
+    return sorted(lib_names - lib_names_exclude)
 
 
 def _LoadLibraryNames(file_names):
     """Loads library names from files.
 
-    Each element in the input list can be a .so file, a text file, or a .csv
-    file. The returned list consists of:
+    Each element in the input list can be a .so file or a .txt file. The
+    returned list consists of:
     - The .so file names in the input list.
-    - The non-empty lines in the text files.
-    - The libraries tagged with VNDK or VNDK-SP in the CSV.
+    - The libraries tagged with VNDK-core or VNDK-SP in the .txt file.
 
     Args:
         file_names: A list of strings, the library or text file names.
@@ -239,143 +111,197 @@
     for file_name in file_names:
         if file_name.endswith(".so"):
             lib_names.append(file_name)
-        elif file_name.endswith(".csv"):
-            with open(file_name, "r") as csv_file:
-                lib_names.extend(_LoadLibraryNamesFromCsv(csv_file))
         else:
-            with open(file_name, "r") as lib_list:
-                lib_names.extend(line.strip() for line in lib_list
-                                 if line.strip())
+            with open(file_name, "r") as txt_file:
+                lib_names.extend(_LoadLibraryNamesFromTxt(txt_file))
     return lib_names
 
 
-def DumpAbi(output_dir, lib_names, lib_dir, object_dir, dumper_dir):
-    """Generates dump from libraries.
+def DumpAbi(output_dir, lib_names, lsdump_path):
+    """Generates ABI dumps from library lsdumps.
 
     Args:
         output_dir: The output directory of dump files.
         lib_names: The names of the libraries to dump.
-        lib_dir: The path to the directory containing the libraries to dump.
-        object_dir: The path to the directory containing intermediate objects.
-        dumper_dir: The path to the directory containing the vtable dumper
-                    executable and library.
+        lsdump_path: The path to the directory containing lsdumps.
 
     Returns:
-        A list of strings, the paths to the libraries not found in lib_dir.
+        A list of strings, the libraries whose ABI dump fails to be created.
     """
-    ar_parser = ExternalModules.ar_parser
-    static_symbols = set()
-    for ar_name in ("libgcc", "libatomic", "libcompiler_rt-extras"):
-        ar_path = os.path.join(
-            object_dir, "STATIC_LIBRARIES", ar_name + "_intermediates",
-            ar_name + ".a")
-        static_symbols.update(ar_parser.ListGlobalSymbols(ar_path))
-
-    missing_libs = []
-    dump_dir = os.path.join(output_dir, os.path.basename(lib_dir))
+    missing_dumps = []
     for lib_name in lib_names:
-        lib_path = os.path.join(lib_dir, lib_name)
-        symbol_dump_path = os.path.join(dump_dir, lib_name + "_symbol.dump")
-        vtable_dump_path = os.path.join(dump_dir, lib_name + "_vtable.dump")
-        print(lib_path)
-        if not os.path.isfile(lib_path):
-            missing_libs.append(lib_path)
-            print("Warning: Not found")
-            print("")
-            continue
-        symbols = DumpSymbols(lib_path, symbol_dump_path, static_symbols)
-        if symbols:
-            print("Output: " + symbol_dump_path)
+        dump_path = os.path.join(output_dir, lib_name + '.abi.dump')
+        lib_lsdump_path = os.path.join(lsdump_path, lib_name + '.lsdump')
+        if os.path.isfile(lib_lsdump_path + '.gz'):
+            lib_lsdump_path += '.gz'
+
+        print(lib_lsdump_path)
+        try:
+            extract_lsdump.ParseLsdumpFile(lib_lsdump_path, dump_path)
+        except extract_lsdump.LsdumpError as e:
+            missing_dumps.append(lib_name)
+            print(e)
         else:
-            print("No symbols")
-        vtables = DumpVtables(
-            lib_path, vtable_dump_path, dumper_dir, set(symbols))
-        if vtables:
-            print("Output: " + vtable_dump_path)
-        else:
-            print("No vtables")
-        print("")
-    return missing_libs
+            print('Output: ' + dump_path)
+        print('')
+    return missing_dumps
+
+
+def _GetTargetArchDir(target_arch, target_arch_variant):
+    if target_arch == target_arch_variant:
+        return target_arch
+    return '{}_{}'.format(target_arch, target_arch_variant)
+
+
+def _GetAbiBitnessFromArch(target_arch):
+    arch_bitness = {
+        'arm': '32',
+        'arm64': '64',
+        'x86': '32',
+        'x86_64': '64',
+    }
+    return arch_bitness[target_arch]
 
 
 def main():
     # Parse arguments
-    arg_parser = argparse.ArgumentParser()
+    description = (
+        'Generates VTS VNDK ABI test abidumps from lsdump. '
+        'Option values are read from build variables if no value is given. '
+        'If none of the options are specified, then abidumps for target second '
+        'arch are also generated.'
+    )
+    arg_parser = argparse.ArgumentParser(description=description)
     arg_parser.add_argument("file", nargs="*",
                             help="the libraries to dump. Each file can be "
-                                 ".so, text, or .csv. The text file contains "
-                                 "a list of paths. The CSV file follows the"
-                                 "format of eligible list output from VNDK"
-                                 "definition tool. {VNDK_VER} in the library"
-                                 "paths is replaced with "
-                                 "\"-\" + PLATFORM_VNDK_VERSION.")
-    arg_parser.add_argument("--dumper-dir", "-d", action="store",
-                            help="the path to the directory containing "
-                                 "bin/vndk-vtable-dumper.")
-    arg_parser.add_argument("--import-path", "-i", action="store",
-                            help="the directory for VTS python modules. "
-                                 "Default value is $ANDROID_BUILD_TOP/test")
+                                 ".so or .txt. The text file can be found at "
+                                 "build/make/target/product/vndk/current.txt.")
     arg_parser.add_argument("--output", "-o", action="store",
                             help="output directory for ABI reference dump. "
                                  "Default value is PLATFORM_VNDK_VERSION.")
+    arg_parser.add_argument('--platform-vndk-version',
+                            help='platform VNDK version. '
+                                 'Default value is PLATFORM_VNDK_VERSION.')
+    arg_parser.add_argument('--binder-bitness',
+                            choices=['32', '64'],
+                            help='bitness of binder interface. '
+                                 'Default value is 32 if BINDER32BIT is set '
+                                 'else is 64.')
+    arg_parser.add_argument('--target-main-arch',
+                            choices=['arm', 'arm64', 'x86', 'x86_64'],
+                            help='main CPU arch of the device. '
+                                 'Default value is TARGET_ARCH.')
+    arg_parser.add_argument('--target-arch',
+                            choices=['arm', 'arm64', 'x86', 'x86_64'],
+                            help='CPU arch of the libraries to dump. '
+                                 'Default value is TARGET_ARCH.')
+    arg_parser.add_argument('--target-arch-variant',
+                            help='CPU arch variant of the libraries to dump. '
+                                 'Default value is TARGET_ARCH_VARIANT.')
+
     args = arg_parser.parse_args()
 
-    # Get target architectures
     build_top_dir = os.getenv("ANDROID_BUILD_TOP")
     if not build_top_dir:
         sys.exit("env var ANDROID_BUILD_TOP is not set")
 
-    (binder_32_bit,
-     vndk_version,
-     target_arch,
-     target_2nd_arch) = GetBuildVariables(
-        build_top_dir, abs_path=False, vars=(
-            "BINDER32BIT",
-            "PLATFORM_VNDK_VERSION",
-            "TARGET_ARCH",
-            "TARGET_2ND_ARCH"))
+    # If some options are not specified, read build variables as default values.
+    if not all([args.platform_vndk_version,
+                args.binder_bitness,
+                args.target_main_arch,
+                args.target_arch,
+                args.target_arch_variant]):
+        [platform_vndk_version,
+         binder_32_bit,
+         target_arch,
+         target_arch_variant,
+         target_2nd_arch,
+         target_2nd_arch_variant] = GetBuildVariables(
+            build_top_dir,
+            False,
+            ['PLATFORM_VNDK_VERSION',
+             'BINDER32BIT',
+             'TARGET_ARCH',
+             'TARGET_ARCH_VARIANT',
+             'TARGET_2ND_ARCH',
+             'TARGET_2ND_ARCH_VARIANT']
+        )
+        target_main_arch = target_arch
+        binder_bitness = '32' if binder_32_bit else '64'
 
-    (target_lib_dir,
-     target_obj_dir,
-     target_2nd_lib_dir,
-     target_2nd_obj_dir) = GetBuildVariables(
-        build_top_dir, abs_path=True, vars=(
-            "TARGET_OUT_SHARED_LIBRARIES",
-            "TARGET_OUT_INTERMEDIATES",
-            "2ND_TARGET_OUT_SHARED_LIBRARIES",
-            "2ND_TARGET_OUT_INTERMEDIATES"))
+    if args.platform_vndk_version:
+        platform_vndk_version = args.platform_vndk_version
 
-    # Import elf_parser and vtable_parser
-    ExternalModules.ImportParsers(args.import_path if args.import_path else
-                                  os.path.join(build_top_dir, "test"))
+    if args.binder_bitness:
+        binder_bitness = args.binder_bitness
 
-    # Find vtable dumper
-    if args.dumper_dir:
-        dumper_dir = args.dumper_dir
-    else:
-        dumper_path = FindBinary(
-            ExternalModules.vtable_parser.VtableParser.VNDK_VTABLE_DUMPER)
-        dumper_dir = os.path.dirname(os.path.dirname(dumper_path))
-    print("DUMPER_DIR=" + dumper_dir)
+    if args.target_main_arch:
+        target_main_arch = args.target_main_arch
 
-    output_dir = os.path.join((args.output if args.output else vndk_version),
-                              ("binder32" if binder_32_bit else "binder64"),
-                              target_arch)
-    print("OUTPUT_DIR=" + output_dir)
+    if args.target_arch:
+        target_arch = args.target_arch
 
-    lib_names = [name.format(VNDK_VER="-" + vndk_version) for
-                 name in _LoadLibraryNames(args.file)]
+    if args.target_arch_variant:
+        target_arch_variant = args.target_arch_variant
 
-    missing_libs = DumpAbi(output_dir, lib_names, target_lib_dir,
-                           target_obj_dir, dumper_dir)
-    if target_2nd_arch:
-        missing_libs += DumpAbi(output_dir, lib_names, target_2nd_lib_dir,
-                                target_2nd_obj_dir, dumper_dir)
+    dump_targets = [(platform_vndk_version,
+                     binder_bitness,
+                     target_main_arch,
+                     target_arch,
+                     target_arch_variant)]
 
-    if missing_libs:
-        print("Warning: Could not find libraries:")
-        for lib_path in missing_libs:
-            print(lib_path)
+    # If all options are not specified, then also create dump for 2nd arch.
+    if not any([args.platform_vndk_version,
+                args.binder_bitness,
+                args.target_main_arch,
+                args.target_arch,
+                args.target_arch_variant]):
+        dump_targets.append((platform_vndk_version,
+                             binder_bitness,
+                             target_main_arch,
+                             target_2nd_arch,
+                             target_2nd_arch_variant))
+
+    for target_tuple in dump_targets:
+        (platform_vndk_version,
+         binder_bitness,
+         target_main_arch,
+         target_arch,
+         target_arch_variant) = target_tuple
+
+        # Determine abi_bitness from target architecture
+        abi_bitness = _GetAbiBitnessFromArch(target_arch)
+
+        # Generate ABI dump from lsdump in TOP/prebuilts/abi-dumps
+        lsdump_path = os.path.join(
+            build_top_dir,
+            'prebuilts',
+            'abi-dumps',
+            'vndk',
+            platform_vndk_version,
+            binder_bitness,
+            _GetTargetArchDir(target_arch, target_arch_variant),
+            'source-based')
+        if not os.path.exists(lsdump_path):
+            print('Warning: lsdump path does not exist: ' + lsdump_path)
+            print('No abidump created.')
+            continue
+
+        output_dir = os.path.join(
+            args.output if args.output else platform_vndk_version,
+            'binder' + binder_bitness,
+            target_main_arch,
+            'lib64' if abi_bitness == '64' else 'lib')
+        print("OUTPUT_DIR=" + output_dir)
+
+        lib_names = _LoadLibraryNames(args.file)
+
+        missing_dumps = DumpAbi(output_dir, lib_names, lsdump_path)
+
+        if missing_dumps:
+            print('Warning: Fails to create ABI dumps for libraries:')
+            for lib_name in missing_dumps:
+                print(lib_name)
 
 
 if __name__ == "__main__":
diff --git a/golden/extract_lsdump.py b/golden/extract_lsdump.py
new file mode 100755
index 0000000..45e9c38
--- /dev/null
+++ b/golden/extract_lsdump.py
@@ -0,0 +1,243 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2018 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import argparse
+import gzip
+import json
+import os
+
+
+class LsdumpError(Exception):
+    """The exception raised by ParseLsdumpFile."""
+    pass
+
+
+class AttrDict(dict):
+    """A dictionary with attribute accessors."""
+
+    def __getattr__(self, key):
+        """Returns self[key]."""
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError('Failed to get attribute: %s' % key)
+
+    def __setattr__(self, key, value):
+        """Assigns value to self[key]."""
+        self[key] = value
+
+
+def _OpenFileOrGzipped(file_name):
+    """Opens a file that is either in gzip or uncompressed format.
+
+    If file_name ends with '.gz' then return gzip.open(file_name, 'rb'),
+    else return open(file_name, 'rb').
+
+    Args:
+        file_name: The file name to open.
+
+    Returns:
+        A file object.
+
+    Raises:
+        IOError if fails to open.
+    """
+    if file_name.endswith('.gz'):
+        return gzip.open(file_name, 'rb')
+    return open(file_name, 'rb')
+
+
+def _ConsumeOffset(tok, beg=0):
+    """Consumes a <offset-number> in a thunk symbol."""
+    pos = tok.find('_', beg) + 1
+    return tok[:pos], tok[pos:]
+
+
+def _ConsumeCallOffset(tok):
+    """Consumes a <call-offset> in a thunk symbol."""
+    if tok[:1] == 'h':
+        lhs, rhs = _ConsumeOffset(tok, 1)
+    elif tok[:1] == 'v':
+        lhs, rhs = _ConsumeOffset(tok, 1)
+        lhs2, rhs = _ConsumeOffset(rhs)
+        if lhs and lhs2:
+            lhs = lhs + lhs2
+        else:
+            lhs, rhs = '', tok
+    else:
+        lhs, rhs = '', tok
+    return lhs, rhs
+
+
+def _FindThunkTarget(name):
+    """Finds thunk symbol's target function.
+
+    <thunk-symbol> ::= _ZT <call-offset> <base-encoding>
+                     | _ZTc <call-offset> <call-offset> <base-encoding>
+    <call-offset>  ::= h <nv-offset>
+                     | v <v-offset>
+    <nv-offset>    ::= <offset-number> _
+    <v-offset>     ::= <offset-number> _ <offset-number> _
+
+    Args:
+        name: A string, the symbol name to resolve.
+
+    Returns:
+        A string, symbol name of the nominal target function.
+        The input symbol name if it is not a thunk symbol.
+    """
+    if name.startswith('_ZTh') or name.startswith('_ZTv'):
+        lhs, rhs = _ConsumeCallOffset(name[len('_ZT'):])
+        if lhs:
+            return '_Z' + rhs
+    if name.startswith('_ZTc'):
+        lhs, rhs = _ConsumeCallOffset(name[len('_ZTc'):])
+        lhs2, rhs = _ConsumeCallOffset(rhs)
+        if lhs and lhs2:
+            return '_Z' + rhs
+    return name
+
+
+def _FilterElfFunctions(lsdump):
+    """Finds exported functions and thunks in lsdump.
+
+    Args:
+        lsdump: An AttrDict object containing the lsdump.
+
+    Yields:
+        The AttrDict objects in lsdump.elf_functions.
+    """
+    functions = {function.linker_set_key for function in lsdump.functions}
+
+    for elf_function in lsdump.elf_functions:
+        if elf_function.name in functions:
+            yield elf_function
+        elif _FindThunkTarget(elf_function.name) in functions:
+            yield elf_function
+
+
+def _FilterElfObjects(lsdump):
+    """Finds exported variables, type info, and vtables in lsdump.
+
+    Args:
+        lsdump: An AttrDict object containing the lsdump.
+
+    Yields:
+        The AttrDict objects in lsdump.elf_objects.
+    """
+    global_vars = {global_var.linker_set_key
+                   for global_var in lsdump.global_vars}
+    record_names = {record_type.unique_id[len('_ZTS'):]
+                    for record_type in lsdump.record_types}
+
+    for elf_object in lsdump.elf_objects:
+        name = elf_object.name
+        if name in global_vars:
+            yield elf_object
+        elif (name[:len('_ZTS')] in {'_ZTV', '_ZTT', '_ZTI', '_ZTS'} and
+                name[len('_ZTS'):] in record_names):
+            yield elf_object
+
+
+def _ParseSymbolsFromLsdump(lsdump, output_dump):
+    """Parses symbols from an lsdump.
+
+    Args:
+        lsdump: An AttrDict object containing the lsdump.
+        output_dump: An AttrDict object containing the output.
+    """
+    output_dump.elf_functions = list(_FilterElfFunctions(lsdump))
+    output_dump.elf_objects = list(_FilterElfObjects(lsdump))
+
+
+def _ParseVtablesFromLsdump(lsdump, output_dump):
+    """Parses vtables from an lsdump.
+
+    Args:
+        lsdump: An AttrDict object containing the lsdump.
+        output_dump: An AttrDict object containing the output.
+    """
+    vtable_symbols = {elf_object.name for elf_object in lsdump.elf_objects
+                      if elf_object.name.startswith('_ZTV')}
+
+    output_dump.record_types = []
+    for lsdump_record_type in lsdump.record_types:
+        type_symbol = lsdump_record_type.unique_id
+        vtable_symbol = '_ZTV' + type_symbol[len('_ZTS'):]
+        if vtable_symbol not in vtable_symbols:
+            continue
+        record_type = AttrDict()
+        record_type.unique_id = lsdump_record_type.unique_id
+        record_type.vtable_components = lsdump_record_type.vtable_components
+        output_dump.record_types.append(record_type)
+
+
+def ParseLsdumpFile(input_path, output_path):
+    """Converts an lsdump file to a dump file for the ABI test.
+
+    Args:
+        input_path: The path to the (gzipped) lsdump file.
+        output_path: The path to the output dump file.
+
+    Raises:
+        LsdumpError if fails to create the dump file.
+    """
+    try:
+        with _OpenFileOrGzipped(input_path) as lsdump_file:
+            lsdump = json.load(lsdump_file, object_hook=AttrDict)
+    except (IOError, ValueError) as e:
+        raise LsdumpError(e)
+
+    try:
+        output_dump = AttrDict()
+        _ParseVtablesFromLsdump(lsdump, output_dump)
+        _ParseSymbolsFromLsdump(lsdump, output_dump)
+    except AttributeError as e:
+        raise LsdumpError(e)
+
+    abs_output_path = os.path.abspath(output_path)
+    abs_output_dir = os.path.dirname(abs_output_path)
+
+    try:
+        if abs_output_dir and not os.path.exists(abs_output_dir):
+            os.makedirs(abs_output_dir)
+        with open(output_path, 'wb') as output_file:
+            json.dump(output_dump, output_file,
+                      indent=1, separators=(',', ':'))
+    except (IOError, OSError) as e:
+        raise LsdumpError(e)
+
+
+def main():
+    arg_parser = argparse.ArgumentParser(
+        description='This script converts an lsdump file to a dump file for '
+                    'the ABI test in VTS.')
+    arg_parser.add_argument('input_path',
+                            help='input lsdump file path.')
+    arg_parser.add_argument('output_path',
+                            help='output dump file path.')
+    args = arg_parser.parse_args()
+
+    try:
+        ParseLsdumpFile(args.input_path, args.output_path)
+    except LsdumpError as e:
+        print(e)
+        exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/golden/vndk_data.py b/golden/vndk_data.py
index 014453d..e215a91 100644
--- a/golden/vndk_data.py
+++ b/golden/vndk_data.py
@@ -14,32 +14,32 @@
 # limitations under the License.
 #
 
-import csv
+import collections
 import logging
 import os
 
-# The tags in VNDK spreadsheet:
+# The tags in VNDK list:
 # Low-level NDK libraries that can be used by framework and vendor modules.
-LL_NDK = "LL-NDK"
+LL_NDK = "LLNDK"
 
 # LL-NDK dependencies that vendor modules cannot directly access.
-LL_NDK_PRIVATE = "LL-NDK-Private"
+LL_NDK_PRIVATE = "LLNDK-private"
 
 # Same-process HAL implementation in vendor partition.
 SP_HAL = "SP-HAL"
 
 # Framework libraries that can be used by vendor modules except same-process HAL
 # and its dependencies in vendor partition.
-VNDK = "VNDK"
+VNDK = "VNDK-core"
 
 # VNDK dependencies that vendor modules cannot directly access.
-VNDK_PRIVATE = "VNDK-Private"
+VNDK_PRIVATE = "VNDK-core-private"
 
 # Same-process HAL dependencies in framework.
 VNDK_SP = "VNDK-SP"
 
 # VNDK-SP dependencies that vendor modules cannot directly access.
-VNDK_SP_PRIVATE = "VNDK-SP-Private"
+VNDK_SP_PRIVATE = "VNDK-SP-private"
 
 # The ABI dump directories. 64-bit comes before 32-bit in order to sequentially
 # search for longest prefix.
@@ -48,6 +48,8 @@
 # The data directory.
 _GOLDEN_DIR = os.path.join("vts", "testcases", "vndk", "golden")
 
+# Regular expression prefix for library name patterns.
+_REGEX_PREFIX = "[regex]"
 
 def LoadDefaultVndkVersion(data_file_path):
     """Loads the name of the data directory for devices with no VNDK version.
@@ -106,6 +108,52 @@
     return dump_dir
 
 
+def _LoadVndkLibraryListsFile(vndk_lists, tags, vndk_lib_list_path):
+    """Load VNDK libraries from the file to the specified tuple.
+
+    Args:
+        vndk_lists: The output tuple of lists containing library names.
+        tags: Strings, the tags of the libraries to find.
+        vndk_lib_list_path: The path to load the VNDK library list.
+    """
+
+    lib_sets = collections.defaultdict(set)
+
+    # Load VNDK tags from the list.
+    with open(vndk_lib_list_path) as vndk_lib_list_file:
+        for line in vndk_lib_list_file:
+            # Ignore comments.
+            if line.startswith('#'):
+                continue
+
+            # Split columns.
+            cells = line.split(': ', 1)
+            if len(cells) < 2:
+                continue
+            tag = cells[0]
+            lib_name = cells[1].strip()
+
+            lib_sets[tag].add(lib_name)
+
+    # Compute VNDK-core-private and VNDK-SP-private.
+    private = lib_sets.get('VNDK-private', set())
+
+    lib_sets[LL_NDK_PRIVATE].update(lib_sets[LL_NDK] & private)
+    lib_sets[VNDK_PRIVATE].update(lib_sets[VNDK] & private)
+    lib_sets[VNDK_SP_PRIVATE].update(lib_sets[VNDK_SP] & private)
+
+    lib_sets[LL_NDK].difference_update(private)
+    lib_sets[VNDK].difference_update(private)
+    lib_sets[VNDK_SP].difference_update(private)
+
+    # Update the output entries.
+    for index, tag in enumerate(tags):
+        for lib_name in lib_sets.get(tag, tuple()):
+            if lib_name.startswith(_REGEX_PREFIX):
+                lib_name = lib_name[len(_REGEX_PREFIX):]
+            vndk_lists[index].append(lib_name)
+
+
 def LoadVndkLibraryLists(data_file_path, version, *tags):
     """Find the VNDK libraries with specific tags.
 
@@ -125,25 +173,20 @@
     if not version_dir:
         return None
 
-    path = os.path.join(
-        data_file_path, _GOLDEN_DIR, version_dir, "eligible-list.csv")
-    if not os.path.isfile(path):
-        logging.warning("Cannot load %s.", path)
+    vndk_lib_list_path = os.path.join(
+        data_file_path, _GOLDEN_DIR, version_dir, "vndk-lib-list.txt")
+    if not os.path.isfile(vndk_lib_list_path):
+        logging.warning("Cannot load %s.", vndk_lib_list_path)
         return None
 
-    dir_suffix = "-" + version if version else ""
+    vndk_lib_extra_list_path = os.path.join(
+        data_file_path, _GOLDEN_DIR, version_dir, "vndk-lib-extra-list.txt")
+    if not os.path.isfile(vndk_lib_extra_list_path):
+        logging.warning("Cannot load %s.", vndk_lib_extra_list_path)
+        return None
+
     vndk_lists = tuple([] for x in tags)
-    with open(path) as csv_file:
-        # Skip header
-        next(csv_file)
-        reader = csv.reader(csv_file)
-        for cells in reader:
-            for tag_index, tag in enumerate(tags):
-                if tag == cells[1]:
-                    lib_name = cells[0].replace("${VNDK_VER}", dir_suffix)
-                    if lib_name.startswith("[regex]"):
-                        lib_name = lib_name[len("[regex]"):]
-                    vndk_lists[tag_index].extend(
-                        lib_name.replace("${LIB}", lib)
-                        for lib in ("lib", "lib64"))
+
+    _LoadVndkLibraryListsFile(vndk_lists, tags, vndk_lib_list_path)
+    _LoadVndkLibraryListsFile(vndk_lists, tags, vndk_lib_extra_list_path)
     return vndk_lists
diff --git a/open_libraries/VtsVndkOpenLibrariesTest.py b/open_libraries/VtsVndkOpenLibrariesTest.py
index f51502d..8dbfda6 100644
--- a/open_libraries/VtsVndkOpenLibrariesTest.py
+++ b/open_libraries/VtsVndkOpenLibrariesTest.py
@@ -23,6 +23,7 @@
 from vts.runners.host import keys
 from vts.runners.host import test_runner
 from vts.testcases.vndk.golden import vndk_data
+from vts.utils.python.os import path_utils
 from vts.utils.python.vndk import vndk_utils
 
 
@@ -110,19 +111,20 @@
             vndk_data.VNDK_SP,
             vndk_data.VNDK_SP_PRIVATE)
         asserts.assertTrue(vndk_lists, "Cannot load VNDK library lists.")
-        allowed_libs = set()
-        for vndk_list in vndk_lists:
-            allowed_libs.update(vndk_list)
+        allowed_libs = set().union(*vndk_lists)
         logging.debug("Allowed system libraries: %s", allowed_libs)
 
         asserts.assertTrue(self._dut.isAdbRoot,
                            "Must be root to find all libraries in use.")
         cmds = self._ListProcessCommands(lambda x: (x.startswith("/odm/") or
                                                     x.startswith("/vendor/")))
-        deps = self._ListOpenFiles(cmds.keys(),
-                                   lambda x: (x.startswith("/system/") and
-                                              x.endswith(".so") and
-                                              x not in allowed_libs))
+
+        def _IsDisallowedSystemLib(lib_path):
+            return (lib_path.startswith("/system/") and
+                    lib_path.endswith(".so") and
+                    path_utils.TargetBaseName(lib_path) not in allowed_libs)
+
+        deps = self._ListOpenFiles(cmds.keys(), _IsDisallowedSystemLib)
         if deps:
             error_lines = ["%s %s %s" % (pid, cmds[pid], libs)
                            for pid, libs in deps.iteritems()]