diff --git a/CODEOWNERS b/CODEOWNERS
index f89cc36d6d3..c3774cc98ef 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -311,6 +311,7 @@
 /scripts/elf_helper.py                    @andrewboie
 /scripts/sanity_chk/expr_parser.py        @nashif
 /scripts/gen_app_partitions.py            @andrewboie
+/scripts/dts/                             @ulfalizer @galak
 /arch/x86/gen_gdt.py                      @andrewboie
 /arch/x86/gen_idt.py                      @andrewboie
 /scripts/gen_kobject_list.py              @andrewboie
diff --git a/cmake/dts.cmake b/cmake/dts.cmake
index eab376283a0..9704f124e04 100644
--- a/cmake/dts.cmake
+++ b/cmake/dts.cmake
@@ -156,16 +156,39 @@ if(SUPPORTS_DTS)
     message(FATAL_ERROR "command failed with return code: ${ret}")
   endif()
 
+  #
+  # Run gen_defines.py to create a .conf file and a header file
+  #
+
+  set(CMD_NEW_EXTRACT ${PYTHON_EXECUTABLE} ${ZEPHYR_BASE}/scripts/dts/gen_defines.py
+  --dts ${BOARD}.dts.pre.tmp
+  --bindings-dir ${DTS_ROOT_BINDINGS}
+  --conf-out ${GENERATED_DTS_BOARD_CONF}
+  --header-out ${GENERATED_DTS_BOARD_UNFIXED_H}
+  )
+
+  execute_process(
+    COMMAND ${CMD_NEW_EXTRACT}
+    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    RESULT_VARIABLE ret
+    )
+  if(NOT "${ret}" STREQUAL "0")
+    message(FATAL_ERROR "new extractor failed with return code: ${ret}")
+  endif()
+
+  #
+  # Run extract_dts_includes.py (the older DT/binding parser) to generate some
+  # legacy identifiers (via --deprecated-only). This will go away later.
+  #
+
   set(CMD_EXTRACT_DTS_INCLUDES ${PYTHON_EXECUTABLE} ${ZEPHYR_BASE}/scripts/dts/extract_dts_includes.py
+    --deprecated-only
     --dts ${BOARD}.dts_compiled
     --yaml ${DTS_ROOT_BINDINGS}
-    --keyvalue ${GENERATED_DTS_BOARD_CONF}
-    --include ${GENERATED_DTS_BOARD_UNFIXED_H}
+    --include ${GENERATED_DTS_BOARD_UNFIXED_H}.deprecated
     --old-alias-names
     )
 
-  # Run extract_dts_includes.py to create a .conf and a header file that can be
-  # included into the CMake namespace
   execute_process(
     COMMAND ${CMD_EXTRACT_DTS_INCLUDES}
     WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
@@ -179,4 +202,5 @@ if(SUPPORTS_DTS)
 
 else()
   file(WRITE ${GENERATED_DTS_BOARD_UNFIXED_H} "/* WARNING. THIS FILE IS AUTO-GENERATED. DO NOT MODIFY! */")
+  file(WRITE ${GENERATED_DTS_BOARD_UNFIXED_H}.deprecated "/* WARNING. THIS FILE IS AUTO-GENERATED. DO NOT MODIFY! */")
 endif(SUPPORTS_DTS)
diff --git a/include/generated_dts_board.h b/include/generated_dts_board.h
index ea0615c872f..a48f3f858da 100644
--- a/include/generated_dts_board.h
+++ b/include/generated_dts_board.h
@@ -13,6 +13,8 @@
 
 #include <generated_dts_board_unfixed.h>
 
+#include <generated_dts_board_unfixed.h.deprecated>
+
 /* The following definitions fixup the generated include */
 
 #include <generated_dts_board_fixups.h>
diff --git a/scripts/dts/dtlib.py b/scripts/dts/dtlib.py
new file mode 100644
index 00000000000..373585e671a
--- /dev/null
+++ b/scripts/dts/dtlib.py
@@ -0,0 +1,1689 @@
+# Copyright (c) 2019, Nordic Semiconductor
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Tip: You can view just the documentation with 'pydoc3 dtlib'
+
+"""
+A library for extracting information from .dts (Device Tree) files. See the
+documentation for the DT and Node classes for more information.
+
+The top-level entry point of the library is the DT class. DT.__init__() takes a
+.dts file to parse and a list of directories to search for any /include/d
+files.
+"""
+
+import collections
+import errno
+import os
+import re
+import sys
+import textwrap
+
+# NOTE: testdtlib.py is the test suite for this library. It can be run directly.
+
+
+class DT:
+    """
+    Represents a device tree parsed from a .dts file (or from many files, if
+    the .dts file /include/s other files). Creating many instances of this
+    class is fine. The library has no global state.
+
+    These attributes are available on DT instances:
+
+    root:
+      A Node instance representing the root (/) node.
+
+    alias2node:
+      A dictionary that maps maps alias strings (from /aliases) to Node
+      instances
+
+    label2node:
+      A dictionary that maps each node label (a string) to the Node instance
+      for the node.
+
+    label2prop:
+      A dictionary that maps each property label (a string) to a Property
+      instance.
+
+    label2prop_offset:
+      A dictionary that maps each label (a string) within a property value
+      (e.g., 'x = label_1: < 1 label2: 2 >;') to a (prop, offset) tuple, where
+      'prop' is a Property instance and 'offset' the byte offset (0 for label_1
+      and 4 for label_2 in the example).
+
+    phandle2node:
+      A dictionary that maps each phandle (a number) to a Node instance.
+
+    memreserves:
+      A list of (labels, address, length) tuples for the /memreserve/s in the
+      .dts file, in the same order as they appear in the file.
+
+      'labels' is a possibly empty set with all labels preceding the memreserve
+      (e.g., 'label1: label2: /memreserve/ ...'). 'address' and 'length' are
+      numbers.
+
+    filename:
+      The filename passed to the DT constructor.
+    """
+
+    #
+    # Public interface
+    #
+
+    def __init__(self, filename, include_path=()):
+        """
+        Parses a DTS file to create a DT instance. Raises OSError if 'filename'
+        can't be opened, and DTError for any parse errors.
+
+        filename:
+          Path to the .dts file to parse.
+
+        include_path:
+          An iterable (e.g. list or tuple) containing paths to search for
+          /include/d and /incbin/'d files. By default, files are only looked up
+          relative to the .dts file that contains the /include/ or /incbin/.
+        """
+        self.filename = filename
+        self._include_path = include_path
+
+        with open(filename, encoding="utf-8") as f:
+            self._file_contents = f.read()
+
+        self._tok_i = self._tok_end_i = 0
+        self._filestack = []
+
+        self.alias2node = {}
+
+        self._lexer_state = _DEFAULT
+        self._saved_token = None
+
+        self._lineno = 1
+
+        self._is_parsing = True
+
+        self._parse_dt()
+
+        self._register_phandles()
+        self._fixup_props()
+        self._register_aliases()
+        self._remove_unreferenced()
+        self._register_labels()
+
+        self._is_parsing = False
+
+    def get_node(self, path):
+        """
+        Returns the Node instance for the node with path or alias 'path' (a
+        string). Raises DTError if the path or alias doesn't exist.
+
+        For example, both dt.get_node("/foo/bar") and dt.get_node("bar-alias")
+        will return the 'bar' node below:
+
+          /dts-v1/;
+
+          / {
+                  foo {
+                          bar_label: bar {
+                                  baz {
+                                  };
+                          };
+                  };
+
+                  aliases {
+                          bar-alias = &bar-label;
+                  };
+          };
+
+        Fetching subnodes via aliases is supported:
+        dt.get_node("bar-alias/baz") returns the 'baz' node.
+        """
+        if path.startswith("/"):
+            cur = self.root
+            component_i = 0
+            rest = path
+        else:
+            # Strip the first component from 'path' and store it in 'alias'.
+            # Use a separate 'rest' variable rather than directly modifying
+            # 'path' so that all of 'path' still shows up in error messages.
+            alias, _, rest = path.partition("/")
+            if alias not in self.alias2node:
+                raise DTError("node path does not start with '/'"
+                              if self._is_parsing else
+                              "no alias '{}' found -- did you forget the "
+                              "leading '/' in the node path?".format(alias))
+            cur = self.alias2node[alias]
+            component_i = 1
+
+        for component in rest.split("/"):
+            # Collapse multiple / in a row, and allow a / at the end
+            if not component:
+                continue
+
+            component_i += 1
+
+            if component not in cur.nodes:
+                raise DTError("component {} ({}) in path {} does not exist"
+                              .format(component_i, repr(component),
+                                      repr(path)))
+
+            cur = cur.nodes[component]
+
+        return cur
+
+    def has_node(self, path):
+        """
+        Returns True if the path or alias 'path' exists. See Node.get_node().
+        """
+        try:
+            self.get_node(path)
+            return True
+        except DTError:
+            return False
+
+    def node_iter(self):
+        """
+        Returns a generator for iterating over all nodes in the device tree.
+
+        For example, this will print the name of each node that has a property
+        called 'foo':
+
+          for node in dt.node_iter():
+              if "foo" in node.props:
+                  print(node.name)
+        """
+        yield from self.root.node_iter()
+
+    def __str__(self):
+        """
+        Returns a DTS representation of the device tree. Called automatically
+        if the DT instance is print()ed.
+        """
+        s = "/dts-v1/;\n\n"
+
+        if self.memreserves:
+            for labels, address, offset in self.memreserves:
+                # List the labels in a consistent order to help with testing
+                for label in labels:
+                    s += label + ": "
+                s += "/memreserve/ {:#018x} {:#018x};\n" \
+                     .format(address, offset)
+            s += "\n"
+
+        return s + str(self.root)
+
+    def __repr__(self):
+        """
+        Returns some information about the DT instance. Called automatically if
+        the DT instance is evaluated.
+        """
+        return "DT(filename='{}', include_path={})" \
+               .format(self.filename, self._include_path)
+
+    #
+    # Parsing
+    #
+
+    def _parse_dt(self):
+        # Top-level parsing loop
+
+        self._parse_header()
+        self._parse_memreserves()
+
+        self.root = None
+
+        while True:
+            tok = self._next_token()
+
+            if tok.val == "/":
+                # '/ { ... };', the root node
+                if not self.root:
+                    self.root = Node(name="/", parent=None, dt=self)
+                self._parse_node(self.root)
+
+            elif tok.id in (_T_LABEL, _T_REF):
+                # '&foo { ... };' or 'label: &foo { ... };'. The C tools only
+                # support a single label here too.
+
+                if tok.id is _T_LABEL:
+                    label = tok.val
+                    tok = self._next_token()
+                    if tok.id is not _T_REF:
+                        self._parse_error("expected label reference (&foo)")
+                else:
+                    label = None
+
+                try:
+                    node = self._ref2node(tok.val)
+                except DTError as e:
+                    self._parse_error(e)
+                node = self._parse_node(node)
+
+                if label:
+                    _append_no_dup(node.labels, label)
+
+            elif tok.id is _T_DEL_NODE:
+                try:
+                    self._del_node(self._next_ref2node())
+                except DTError as e:
+                    self._parse_error(e)
+                self._expect_token(";")
+
+            elif tok.id is _T_OMIT_IF_NO_REF:
+                try:
+                    self._next_ref2node()._omit_if_no_ref = True
+                except DTError as e:
+                    self._parse_error(e)
+                self._expect_token(";")
+
+            elif tok.id is _T_EOF:
+                if not self.root:
+                    self._parse_error("no root node defined")
+                return
+
+            else:
+                self._parse_error("expected '/' or label reference (&foo)")
+
+    def _parse_header(self):
+        # Parses /dts-v1/ (expected) and /plugin/ (unsupported) at the start of
+        # files. There may be multiple /dts-v1/ at the start of a file.
+
+        has_dts_v1 = False
+
+        while self._peek_token().id is _T_DTS_V1:
+            has_dts_v1 = True
+            self._next_token()
+            self._expect_token(";")
+            # /plugin/ always comes after /dts-v1/
+            if self._peek_token().id is _T_PLUGIN:
+                self._parse_error("/plugin/ is not supported")
+
+        if not has_dts_v1:
+            self._parse_error("expected '/dts-v1/;' at start of file")
+
+    def _parse_memreserves(self):
+        # Parses /memreserve/, which appears after /dts-v1/
+
+        self.memreserves = []
+        while True:
+            # Labels before /memreserve/
+            labels = []
+            while self._peek_token().id is _T_LABEL:
+                _append_no_dup(labels, self._next_token().val)
+
+            if self._peek_token().id is _T_MEMRESERVE:
+                self._next_token()
+                self.memreserves.append(
+                    (labels, self._eval_prim(), self._eval_prim()))
+                self._expect_token(";")
+            else:
+                if labels:
+                    self._parse_error("expected /memreserve/ after labels at "
+                                      "beginning of file")
+
+                return
+
+    def _parse_node(self, node):
+        # Parses the '{ ... };' part of 'node-name { ... };'. Returns the new
+        # Node.
+
+        self._expect_token("{")
+        while True:
+            labels, omit_if_no_ref = self._parse_propnode_labels()
+            tok = self._next_token()
+
+            if tok.id is _T_PROPNODENAME:
+                if self._peek_token().val == "{":
+                    # '<tok> { ...', expect node
+
+                    if tok.val.count("@") > 1:
+                        self._parse_error("multiple '@' in node name")
+
+                    # Fetch the existing node if it already exists. This
+                    # happens when overriding nodes.
+                    child = node.nodes.get(tok.val) or \
+                        Node(name=tok.val, parent=node, dt=self)
+
+                    for label in labels:
+                        _append_no_dup(child.labels, label)
+
+                    if omit_if_no_ref:
+                        child._omit_if_no_ref = True
+
+                    node.nodes[child.name] = child
+                    self._parse_node(child)
+
+                else:
+                    # Not '<tok> { ...', expect property assignment
+
+                    if omit_if_no_ref:
+                        self._parse_error(
+                            "/omit-if-no-ref/ can only be used on nodes")
+
+                    prop = self._node_prop(node, tok.val)
+
+                    if self._check_token("="):
+                        self._parse_assignment(prop)
+                    elif not self._check_token(";"):
+                        # ';' is for an empty property, like 'foo;'
+                        self._parse_error("expected '{', '=', or ';'")
+
+                    for label in labels:
+                        _append_no_dup(prop.labels, label)
+
+            elif tok.id is _T_DEL_NODE:
+                tok2 = self._next_token()
+                if tok2.id is not _T_PROPNODENAME:
+                    self._parse_error("expected node name")
+                if tok2.val in node.nodes:
+                    self._del_node(node.nodes[tok2.val])
+                self._expect_token(";")
+
+            elif tok.id is _T_DEL_PROP:
+                tok2 = self._next_token()
+                if tok2.id is not _T_PROPNODENAME:
+                    self._parse_error("expected property name")
+                node.props.pop(tok2.val, None)
+                self._expect_token(";")
+
+            elif tok.val == "}":
+                self._expect_token(";")
+                return node
+
+            else:
+                self._parse_error("expected node name, property name, or '}'")
+
+    def _parse_propnode_labels(self):
+        # _parse_node() helpers for parsing labels and /omit-if-no-ref/s before
+        # nodes and properties. Returns a (<label list>, <omit-if-no-ref bool>)
+        # tuple.
+
+        labels = []
+        omit_if_no_ref = False
+        while True:
+            tok = self._peek_token()
+            if tok.id is _T_LABEL:
+                _append_no_dup(labels, tok.val)
+            elif tok.id is _T_OMIT_IF_NO_REF:
+                omit_if_no_ref = True
+            elif (labels or omit_if_no_ref) and tok.id is not _T_PROPNODENAME:
+                # Got something like 'foo: bar: }'
+                self._parse_error("expected node or property name")
+            else:
+                return labels, omit_if_no_ref
+
+            self._next_token()
+
+    def _parse_assignment(self, prop):
+        # Parses the right-hand side of property assignment
+        #
+        # prop:
+        #   'Property' instance being assigned
+
+        # Remove any old value, path/phandle references, and in-value labels,
+        # in case the property value is being overridden
+        prop.value = b""
+        prop._markers = []
+
+        while True:
+            # Parse labels before the value (e.g., '..., label: < 0 >')
+            self._parse_value_labels(prop)
+
+            tok = self._next_token()
+
+            if tok.val == "<":
+                self._parse_cells(prop, 32)
+
+            elif tok.id is _T_BITS:
+                n_bits = self._expect_num()
+                if n_bits not in {8, 16, 32, 64}:
+                    self._parse_error("expected 8, 16, 32, or 64")
+                self._expect_token("<")
+                self._parse_cells(prop, n_bits)
+
+            elif tok.val == "[":
+                self._parse_bytes(prop)
+
+            elif tok.id is _T_CHAR_LITERAL:
+                val = self._unescape(tok.val.encode("utf-8"))
+                if len(val) != 1:
+                    self._parse_error("character literals must be length 1")
+                prop.value += val
+
+            elif tok.id is _T_STRING:
+                prop.value += self._unescape(tok.val.encode("utf-8")) + b"\0"
+
+            elif tok.id is _T_REF:
+                prop._add_marker(tok.val, _PATH)
+
+            elif tok.id is _T_INCBIN:
+                self._parse_incbin(prop)
+
+            else:
+                self._parse_error("malformed value")
+
+            # Parse labels after the value (e.g., '< 0 > label:, ...')
+            self._parse_value_labels(prop)
+
+            tok = self._next_token()
+            if tok.val == ";":
+                return
+            if tok.val == ",":
+                continue
+            self._parse_error("expected ';' or ','")
+
+    def _parse_cells(self, prop, bits):
+        # Parses '<...>'
+
+        while True:
+            tok = self._peek_token()
+            if tok.id is _T_REF:
+                self._next_token()
+                if bits != 32:
+                    self._parse_error("phandle references are only allowed in "
+                                      "arrays with 32-bit elements")
+                prop._add_marker(tok.val, _PHANDLE)
+
+            elif tok.id is _T_LABEL:
+                prop._add_marker(tok.val, _LABEL)
+                self._next_token()
+
+            elif self._check_token(">"):
+                return
+
+            else:
+                # Literal value
+                num = self._eval_prim()
+                try:
+                    prop.value += num.to_bytes(bits//8, "big")
+                except OverflowError:
+                    try:
+                        # Try again as a signed number, in case it's negative
+                        prop.value += num.to_bytes(bits//8, "big", signed=True)
+                    except OverflowError:
+                        self._parse_error("{} does not fit in {} bits"
+                                          .format(num, bits))
+
+    def _parse_bytes(self, prop):
+        # Parses '[ ... ]'
+
+        while True:
+            tok = self._next_token()
+            if tok.id is _T_BYTE:
+                prop.value += tok.val.to_bytes(1, "big")
+
+            elif tok.id is _T_LABEL:
+                prop._add_marker(tok.val, _LABEL)
+
+            elif tok.val == "]":
+                return
+
+            else:
+                self._parse_error("expected two-digit byte or ']'")
+
+    def _parse_incbin(self, prop):
+        # Parses
+        #
+        #   /incbin/ ("filename")
+        #
+        # and
+        #
+        #   /incbin/ ("filename", <offset>, <size>)
+
+        self._expect_token("(")
+
+        tok = self._next_token()
+        if tok.id is not _T_STRING:
+            self._parse_error("expected quoted filename")
+        filename = tok.val
+
+        tok = self._next_token()
+        if tok.val == ",":
+            offset = self._eval_prim()
+            self._expect_token(",")
+            size = self._eval_prim()
+            self._expect_token(")")
+        else:
+            if tok.val != ")":
+                self._parse_error("expected ',' or ')'")
+            offset = None
+
+        try:
+            with self._open(filename, "rb") as f:
+                if offset is None:
+                    prop.value += f.read()
+                else:
+                    f.seek(offset)
+                    prop.value += f.read(size)
+        except OSError as e:
+            self._parse_error("could not read '{}': {}"
+                              .format(filename, e))
+
+    def _parse_value_labels(self, prop):
+        # _parse_assignment() helper for parsing labels before/after each
+        # comma-separated value
+
+        while True:
+            tok = self._peek_token()
+            if tok.id is not _T_LABEL:
+                return
+            prop._add_marker(tok.val, _LABEL)
+            self._next_token()
+
+    def _node_prop(self, node, name):
+        # Returns the property named 'name' on the Node 'node', creating it if
+        # it doesn't already exist
+
+        prop = node.props.get(name)
+        if not prop:
+            prop = Property(node, name)
+            node.props[name] = prop
+        return prop
+
+    def _node_phandle(self, node):
+        # Returns the phandle for Node 'node', creating a new phandle if the
+        # node has no phandle, and fixing up the value for existing
+        # self-referential phandles (which get set to b'\0\0\0\0' initially).
+        # Self-referential phandles must be rewritten instead of recreated, so
+        # that labels are preserved.
+
+        if "phandle" in node.props:
+            phandle_prop = node.props["phandle"]
+        else:
+            phandle_prop = Property(node, "phandle")
+            phandle_prop.value = b'\0\0\0\0'
+
+        if phandle_prop.value == b'\0\0\0\0':
+            phandle_i = 1
+            while phandle_i in self.phandle2node:
+                phandle_i += 1
+            self.phandle2node[phandle_i] = node
+
+            phandle_prop.value = phandle_i.to_bytes(4, "big")
+            node.props["phandle"] = phandle_prop
+
+        return phandle_prop.value
+
+    def _del_node(self, node):
+        # Removes the Node 'node' from the tree
+
+        node.parent.nodes.pop(node.name)
+
+    # Expression evaluation
+
+    def _eval_prim(self):
+        tok = self._peek_token()
+        if tok.id in (_T_NUM, _T_CHAR_LITERAL):
+            return self._next_token().val
+
+        tok = self._next_token()
+        if tok.val != "(":
+            self._parse_error("expected number or parenthesized expression")
+        val = self._eval_ternary()
+        self._expect_token(")")
+        return val
+
+    def _eval_ternary(self):
+        val = self._eval_or()
+        if self._check_token("?"):
+            if_val = self._eval_ternary()
+            self._expect_token(":")
+            else_val = self._eval_ternary()
+            return if_val if val else else_val
+        return val
+
+    def _eval_or(self):
+        val = self._eval_and()
+        while self._check_token("||"):
+            val = 1 if self._eval_and() or val else 0
+        return val
+
+    def _eval_and(self):
+        val = self._eval_bitor()
+        while self._check_token("&&"):
+            val = 1 if self._eval_bitor() and val else 0
+        return val
+
+    def _eval_bitor(self):
+        val = self._eval_bitxor()
+        while self._check_token("|"):
+            val |= self._eval_bitxor()
+        return val
+
+    def _eval_bitxor(self):
+        val = self._eval_bitand()
+        while self._check_token("^"):
+            val ^= self._eval_bitand()
+        return val
+
+    def _eval_bitand(self):
+        val = self._eval_eq()
+        while self._check_token("&"):
+            val &= self._eval_eq()
+        return val
+
+    def _eval_eq(self):
+        val = self._eval_rela()
+        while True:
+            if self._check_token("=="):
+                val = 1 if val == self._eval_rela() else 0
+            elif self._check_token("!="):
+                val = 1 if val != self._eval_rela() else 0
+            else:
+                return val
+
+    def _eval_rela(self):
+        val = self._eval_shift()
+        while True:
+            if self._check_token("<"):
+                val = 1 if val < self._eval_shift() else 0
+            elif self._check_token(">"):
+                val = 1 if val > self._eval_shift() else 0
+            elif self._check_token("<="):
+                val = 1 if val <= self._eval_shift() else 0
+            elif self._check_token(">="):
+                val = 1 if val >= self._eval_shift() else 0
+            else:
+                return val
+
+    def _eval_shift(self):
+        val = self._eval_add()
+        while True:
+            if self._check_token("<<"):
+                val <<= self._eval_add()
+            elif self._check_token(">>"):
+                val >>= self._eval_add()
+            else:
+                return val
+
+    def _eval_add(self):
+        val = self._eval_mul()
+        while True:
+            if self._check_token("+"):
+                val += self._eval_mul()
+            elif self._check_token("-"):
+                val -= self._eval_mul()
+            else:
+                return val
+
+    def _eval_mul(self):
+        val = self._eval_unary()
+        while True:
+            if self._check_token("*"):
+                val *= self._eval_unary()
+            elif self._check_token("/"):
+                denom = self._eval_unary()
+                if not denom:
+                    self._parse_error("division by zero")
+                val //= denom
+            elif self._check_token("%"):
+                denom = self._eval_unary()
+                if not denom:
+                    self._parse_error("division by zero")
+                val %= denom
+            else:
+                return val
+
+    def _eval_unary(self):
+        if self._check_token("-"):
+            return -self._eval_unary()
+        if self._check_token("~"):
+            return ~self._eval_unary()
+        if self._check_token("!"):
+            return 0 if self._eval_unary() else 1
+        return self._eval_prim()
+
+    #
+    # Lexing
+    #
+
+    def _check_token(self, val):
+        if self._peek_token().val == val:
+            self._next_token()
+            return True
+        return False
+
+    def _peek_token(self):
+        if not self._saved_token:
+            self._saved_token = self._next_token()
+        return self._saved_token
+
+    def _next_token(self):
+        if self._saved_token:
+            tmp = self._saved_token
+            self._saved_token = None
+            return tmp
+
+        while True:
+            tok_id = None
+
+            match = _token_re.match(self._file_contents, self._tok_end_i)
+            if match:
+                tok_id = match.lastindex
+                tok_val = match.group(tok_id)
+
+            elif self._lexer_state is _DEFAULT:
+                match = _num_re.match(self._file_contents, self._tok_end_i)
+                if match:
+                    tok_id = _T_NUM
+                    num_s = match.group(1)
+                    tok_val = int(num_s,
+                                  16 if num_s.startswith(("0x", "0X")) else
+                                  8 if num_s[0] == "0" else
+                                  10)
+
+            elif self._lexer_state is _EXPECT_PROPNODENAME:
+                match = _propnodename_re.match(self._file_contents,
+                                               self._tok_end_i)
+                if match:
+                    tok_id = _T_PROPNODENAME
+                    tok_val = match.group(1)
+                    self._lexer_state = _DEFAULT
+
+            else:  # self._lexer_state is _EXPECT_BYTE
+                match = _byte_re.match(self._file_contents, self._tok_end_i)
+                if match:
+                    tok_id = _T_BYTE
+                    tok_val = int(match.group(), 16)
+
+
+            if not tok_id:
+                match = _misc_re.match(self._file_contents, self._tok_end_i)
+                if match:
+                    tok_id = _T_MISC
+                    tok_val = match.group()
+                else:
+                    self._tok_i = self._tok_end_i
+                    # Could get here due to a node/property naming appearing in
+                    # an unexpected context as well as for bad characters in
+                    # files. Generate a token for it so that the error can
+                    # trickle up to some context where we can give a more
+                    # helpful error message.
+                    return _Token(_T_BAD, "<unknown token>")
+
+            self._tok_i = match.start()
+            self._tok_end_i = match.end()
+
+            if tok_id is _T_SKIP:
+                self._lineno += tok_val.count("\n")
+                continue
+
+            # /include/ is handled in the lexer in the C tools as well, and can
+            # appear anywhere
+            if tok_id is _T_INCLUDE:
+                # Can have newlines between /include/ and the filename
+                self._lineno += tok_val.count("\n")
+                # Do this manual extraction instead of doing it in the regex so
+                # that we can properly count newlines
+                filename = tok_val[tok_val.find('"') + 1:-1]
+                self._enter_file(filename)
+                continue
+
+            if tok_id is _T_LINE:
+                # #line directive
+                self._lineno = int(tok_val.split()[0]) - 1
+                self.filename = tok_val[tok_val.find('"') + 1:-1]
+                continue
+
+            if tok_id is _T_EOF:
+                if self._filestack:
+                    self._leave_file()
+                    continue
+                return _Token(_T_EOF, "<EOF>")
+
+            # State handling
+
+            if tok_id in (_T_DEL_PROP, _T_DEL_NODE, _T_OMIT_IF_NO_REF) or \
+               tok_val in ("{", ";"):
+
+                self._lexer_state = _EXPECT_PROPNODENAME
+
+            elif tok_val == "[":
+                self._lexer_state = _EXPECT_BYTE
+
+            elif tok_id in (_T_MEMRESERVE, _T_BITS) or tok_val == "]":
+                self._lexer_state = _DEFAULT
+
+            return _Token(tok_id, tok_val)
+
+    def _expect_token(self, tok_val):
+        # Raises an error if the next token does not have the string value
+        # 'tok_val'. Returns the token.
+
+        tok = self._next_token()
+        if tok.val != tok_val:
+            self._parse_error("expected '{}', not '{}'"
+                              .format(tok_val, tok.val))
+
+        return tok
+
+    def _expect_num(self):
+        # Raises an error if the next token is not a number. Returns the token.
+
+        tok = self._next_token()
+        if tok.id is not _T_NUM:
+            self._parse_error("expected number")
+        return tok.val
+
+    def _parse_error(self, s):
+        raise DTError("{}:{} (column {}): parse error: {}".format(
+            self.filename, self._lineno,
+            # This works out for the first line of the file too, where rfind()
+            # returns -1
+            self._tok_i - self._file_contents.rfind("\n", 0, self._tok_i + 1),
+            s))
+
+    def _enter_file(self, filename):
+        # Enters the /include/d file 'filename', remembering the position in
+        # the /include/ing file for later
+
+        self._filestack.append((self.filename, self._lineno,
+                                self._file_contents, self._tok_end_i))
+
+        # Handle escapes in filenames, just for completeness
+        filename = self._unescape(filename.encode("utf-8"))
+        try:
+            filename = filename.decode("utf-8")
+        except UnicodeDecodeError:
+            self._parse_error("filename is not valid UTF-8")
+
+        with self._open(filename, "r") as f:
+            try:
+                self._file_contents = f.read()
+            except OSError as e:
+                self._parse_error(e)
+
+        # Check for recursive /include/
+        for i, parent in enumerate(self._filestack):
+            if filename == parent[0]:
+                self._parse_error("recursive /include/:\n" + " ->\n".join(
+                    ["{}:{}".format(parent[0], parent[1])
+                        for parent in self._filestack[i:]] +
+                    [filename]))
+
+        self.filename = f.name
+        self._lineno = 1
+        self._tok_end_i = 0
+
+    def _leave_file(self):
+        # Leaves an /include/d file, returning to the file that /include/d it
+
+        self.filename, self._lineno, self._file_contents, self._tok_end_i = \
+            self._filestack.pop()
+
+    def _next_ref2node(self):
+        # Checks that the next token is a label/path reference and returns the
+        # Node it points to
+
+        label = self._next_token()
+        if label.id is not _T_REF:
+            self._parse_error("expected label reference (&foo) or path")
+        return self._ref2node(label.val)
+
+    def _ref2node(self, s):
+        # Returns the Node the label/path reference 's' points to
+
+        if s[0] == "{":
+            # Will raise DTError if the path doesn't exist
+            return self.get_node(s[1:-1])
+
+        # node2label hasn't been filled in yet, and using it would get messy
+        # when nodes are deleted
+        for node in self.node_iter():
+            if s in node.labels:
+                return node
+
+        raise DTError("undefined node label '{}'".format(s))
+
+    #
+    # Post-processing
+    #
+
+    def _register_phandles(self):
+        # Registers any manually-inserted phandle properties in
+        # self.phandle2node, so that we can avoid allocating any phandles from
+        # that set. Also checks the format of the phandles and does misc.
+        # sanity checking.
+
+        self.phandle2node = {}
+        for node in self.node_iter():
+            phandle = node.props.get("phandle")
+            if phandle:
+                if len(phandle.value) != 4:
+                    raise DTError(
+                        "{}: bad phandle length ({}), expected 4 bytes"
+                        .format(node.path, len(phandle.value)))
+
+                is_self_referential = False
+                for marker in phandle._markers:
+                    _, ref, marker_type = marker
+                    if marker_type == _PHANDLE:
+                        # The phandle's value is itself a phandle reference
+                        if self._ref2node(ref) is node:
+                            # Alright to set a node's phandle equal to its own
+                            # phandle. It'll force a new phandle to be
+                            # allocated even if the node is otherwise
+                            # unreferenced.
+                            is_self_referential = True
+                            break
+
+                        raise DTError("{}: {} refers to another node"
+                                      .format(node.path, phandle.name))
+
+                # Could put on else on the 'for' above too, but keep it
+                # somewhat readable
+                if not is_self_referential:
+                    phandle_val = int.from_bytes(phandle.value, "big")
+
+                    if phandle_val in {0, 0xFFFFFFFF}:
+                        raise DTError("{}: bad value {:#010x} for {}"
+                                      .format(node.path, phandle_val,
+                                              phandle.name))
+
+                    if phandle_val in self.phandle2node:
+                        raise DTError(
+                            "{}: duplicated phandle {:#x} (seen before at {})"
+                            .format(node.path, phandle_val,
+                                    self.phandle2node[phandle_val].path))
+                    self.phandle2node[phandle_val] = node
+
+    def _fixup_props(self):
+        # Fills in node path and phandle references in property values, and
+        # registers labels within values. This must be done after parsing,
+        # since forwards references are allowed and nodes and properties might
+        # be deleted.
+
+        for node in self.node_iter():
+            # The tuple() avoids a 'dictionary changed size during iteration'
+            # error
+            for prop in tuple(node.props.values()):
+                # 'prev_pos' and 'pos' are indices in the unpatched
+                # property value. The result is built up in 'res'.
+                prev_pos = 0
+                res = b""
+
+                for pos, ref, ref_type in prop._markers:
+                    # Add data before the marker
+                    res += prop.value[prev_pos:pos]
+
+                    if ref_type is _LABEL:
+                        # This is a temporary format so that we can catch
+                        # duplicate references. prop.offset_labels is changed
+                        # to a dictionary that maps labels to offsets in
+                        # _register_labels().
+                        _append_no_dup(prop.offset_labels, (ref, len(res)))
+                    else:
+                        # Path or phandle reference
+                        try:
+                            ref_node = self._ref2node(ref)
+                        except DTError as e:
+                            raise DTError("{}: {}".format(prop.node.path, e))
+
+                        # For /omit-if-no-ref/
+                        ref_node._is_referenced = True
+
+                        if ref_type is _PATH:
+                            res += ref_node.path.encode("utf-8") + b'\0'
+                        else:  # ref_type is PHANDLE
+                            res += self._node_phandle(ref_node)
+                            # Skip over the dummy phandle placeholder
+                            pos += 4
+
+                    prev_pos = pos
+
+                # Add data after the last marker
+                prop.value = res + prop.value[prev_pos:]
+
+    def _register_aliases(self):
+        # Registers aliases from the /aliases node in self.alias2node. Also
+        # checks the format of the alias properties.
+
+        # We copy this to self.alias2node at the end to avoid get_node()
+        # looking up paths via other aliases while verifying aliases
+        alias2node = {}
+
+        alias_re = re.compile("[0-9a-z-]+$")
+
+        aliases = self.root.nodes.get("aliases")
+        if aliases:
+            for prop in aliases.props.values():
+                if not alias_re.match(prop.name):
+                    raise DTError("/aliases: alias property name '{}' should "
+                                  "include only characters from [0-9a-z-]"
+                                  .format(prop.name))
+
+                # Any errors this generates will already point to the property
+                # and /aliases
+                path = prop.to_string()
+
+                try:
+                    alias2node[prop.name] = self.get_node(path)
+                except DTError as e:
+                    raise DTError("/aliases: bad path for '{}': {}"
+                                  .format(prop.name, e))
+
+        self.alias2node = alias2node
+
+    def _remove_unreferenced(self):
+        # Removes any unreferenced nodes marked with /omit-if-no-ref/ from the
+        # tree
+
+        # tuple() is to avoid 'RuntimeError: dictionary changed size during
+        # iteration' errors
+        for node in tuple(self.node_iter()):
+            if node._omit_if_no_ref and not node._is_referenced:
+                self._del_node(node)
+
+    def _register_labels(self):
+        # Checks for duplicate labels and registers labels in label2node,
+        # label2prop, and label2prop_offset
+
+        label2things = collections.defaultdict(set)
+
+        self.label2node = {}
+        self.label2prop = {}
+        self.label2prop_offset = {}
+
+        # Register all labels and the nodes/props they point to in label2things
+        for node in self.node_iter():
+            for label in node.labels:
+                label2things[label].add(node)
+                self.label2node[label] = node
+
+            for prop in node.props.values():
+                for label in prop.labels:
+                    label2things[label].add(prop)
+                    self.label2prop[label] = prop
+
+                for label, offset in prop.offset_labels:
+                    label2things[label].add((prop, offset))
+                    self.label2prop_offset[label] = (prop, offset)
+
+                # See _fixup_props()
+                prop.offset_labels = {label: offset for label, offset in
+                                      prop.offset_labels}
+
+        for label, things in label2things.items():
+            if len(things) > 1:
+                strings = []
+                for thing in things:
+                    if isinstance(thing, Node):
+                        strings.append("on " + thing.path)
+                    elif isinstance(thing, Property):
+                        strings.append("on property '{}' of node {}"
+                                       .format(thing.name, thing.node.path))
+                    else:
+                        # Label within property value
+                        strings.append("in the value of property '{}' of node {}"
+                                       .format(thing[0].name,
+                                               thing[0].node.path))
+
+                # Give consistent error messages to help with testing
+                strings.sort()
+
+                raise DTError("Label '{}' appears ".format(label) +
+                              " and ".join(strings))
+
+
+    #
+    # Misc.
+    #
+
+    def _unescape(self, b):
+        # Replaces backslash escapes in the 'bytes' array 'b'. We can't do this at
+        # the string level, because the result might not be valid UTF-8 when
+        # octal/hex escapes are involved.
+
+        def sub(match):
+            esc = match.group(1)
+            if esc == b"\\": return b"\\"
+            if esc == b'"':  return b'"'
+            if esc == b"a":  return b"\a"
+            if esc == b"b":  return b"\b"
+            if esc == b"t":  return b"\t"
+            if esc == b"n":  return b"\n"
+            if esc == b"v":  return b"\v"
+            if esc == b"f":  return b"\f"
+            if esc == b"r":  return b"\r"
+
+            if esc.startswith(b"x"):
+                return int(esc[1:], 16).to_bytes(1, "big")
+
+            # Octal escape
+            try:
+                return int(esc, 8).to_bytes(1, "big")
+            except OverflowError:
+                self._parse_error("octal escape out of range (> 255)")
+
+        return _unescape_re.sub(sub, b)
+
+    def _open(self, filename, mode):
+        # Opens 'filename' in mode 'mode', returning the 'file' object.
+        # Searches the directory of the current file and the include path.
+
+        # The C tools support specifying stdin with '-' too
+        if filename == "-":
+            return sys.stdin.buffer if "b" in mode else sys.stdin
+
+        # Try the directory of the current file first
+        dirname = os.path.dirname(self.filename)
+        try:
+            return open(os.path.join(dirname, filename), mode)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                self._parse_error(e)
+
+            # Try each directory from the include path
+            for path in self._include_path:
+                try:
+                    return open(os.path.join(path, filename), mode)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        self._parse_error(e)
+                    continue
+
+            self._parse_error("'{}' could not be found".format(filename))
+
+
+class Node:
+    r"""
+    Represents a node in the device tree ('node-name { ... };').
+
+    These attributes are available on Node instances:
+
+    name:
+      The name of the node (a string).
+
+    unit_addr:
+      The portion after the '@' in the node's name, or the empty string if the
+      name has no '@' in it.
+
+      Note that this is a string. Run int(node.unit_addr, 16) to get an
+      integer.
+
+    props:
+      A dictionary that maps the properties defined on the node to their
+      values. 'props' is indexed by property name (a string), and values are
+      represented as 'bytes' arrays.
+
+      To convert property values to Python numbers or strings, use
+      dtlib.to_num(), dtlib.to_nums(), or dtlib.to_string().
+
+      Property values are represented as 'bytes' arrays to support the full
+      generality of DTS, which allows assignments like
+
+        x = "foo", < 0x12345678 >, [ 9A ];
+
+      This gives x the value b"foo\0\x12\x34\x56\x78\x9A". Numbers in DTS are
+      stored in big-endian format.
+
+    nodes:
+      A dictionary containing the subnodes of the node, indexed by name.
+
+    labels:
+      A list with all labels pointing to the node, in the same order as the
+      labels appear, but with duplicates removed.
+
+      'label_1: label_2: node { ... };' gives 'labels' the value
+      ["label_1", "label_2"].
+
+    parent:
+      The parent Node of the node. 'None' for the root node.
+
+    path:
+      The path to the node as a string, e.g. "/foo/bar".
+
+    dt:
+      The DT instance this node belongs to.
+    """
+
+    #
+    # Public interface
+    #
+
+    def __init__(self, name, parent, dt):
+        """
+        Node constructor. Not meant to be called directly by clients.
+        """
+        self.name = name
+        self.parent = parent
+        self.dt = dt
+
+        self.props = {}
+        self.nodes = {}
+        self.labels = []
+        self._omit_if_no_ref = False
+        self._is_referenced = False
+
+    @property
+    def unit_addr(self):
+        """
+        See the class documentation.
+        """
+        return self.name.partition("@")[2]
+
+    @property
+    def path(self):
+        """
+        See the class documentation.
+        """
+        node_names = []
+
+        cur = self
+        while cur.parent:
+            node_names.append(cur.name)
+            cur = cur.parent
+
+        return "/" + "/".join(reversed(node_names))
+
+    def node_iter(self):
+        """
+        Returns a generator for iterating over the node and its children,
+        recursively.
+
+        For example, this will iterate over all nodes in the tree (like
+        dt.node_iter()).
+
+          for node in dt.root.node_iter():
+              ...
+        """
+        yield self
+        for node in self.nodes.values():
+            yield from node.node_iter()
+
+    def __str__(self):
+        """
+        Returns a DTS representation of the node. Called automatically if the
+        node is print()ed.
+        """
+        s = "".join(label + ": " for label in self.labels)
+
+        s += "{} {{\n".format(self.name)
+
+        for prop in self.props.values():
+            s += "\t" + str(prop) + "\n"
+
+        for child in self.nodes.values():
+            s += textwrap.indent(child.__str__(), "\t") + "\n"
+
+        s += "};"
+
+        return s
+
+    def __repr__(self):
+        """
+        Returns some information about the Node instance. Called automatically
+        if the Node instance is evaluated.
+        """
+        return "<Node {} in '{}'>" \
+               .format(self.path, self.dt.filename)
+
+
+class Property:
+    """
+    Represents a property ('x = ...').
+
+    These attributes are available on Property instances:
+
+    name:
+      The name of the property (a string).
+
+    value:
+      The value of the property, as a 'bytes' string. Numbers are stored in
+      big-endian format, and strings are null-terminated. Putting multiple
+      comma-separated values in an assignment (e.g., 'x = < 1 >, "foo"') will
+      concatenate the values.
+
+      See the to_*() methods for converting the value to other types.
+
+    labels:
+      A list with all labels pointing to the property, in the same order as the
+      labels appear, but with duplicates removed.
+
+      'label_1: label2: x = ...' gives 'labels' the value
+      {"label_1", "label_2"}.
+
+    offset_labels:
+      A dictionary that maps any labels within the property's value to their
+      offset, in bytes. For example, 'x = < 0 label_1: 1 label_2: >' gives
+      'offset_labels' the value {"label_1": 4, "label_2": 8}.
+
+      Iteration order will match the order of the labels on Python versions
+      that preserve dict insertion order.
+
+    node:
+      The Node the property is on.
+    """
+
+    #
+    # Public interface
+    #
+
+    def __init__(self, node, name):
+        if "@" in name:
+            node.dt._parse_error("'@' is only allowed in node names")
+
+        self.name = name
+        self.node = node
+        self.value = b""
+        self.labels = []
+        self.offset_labels = []
+
+        # A list of (offset, label, type) tuples (sorted by offset), giving the
+        # locations of references within the value. 'type' is either _PATH, for
+        # a node path reference, _PHANDLE, for a phandle reference, or _LABEL,
+        # for a label on/within data. Node paths and phandles need to be
+        # patched in after parsing.
+        self._markers = []
+
+    def to_num(self, length=4, signed=False):
+        """
+        Returns the property value interpreted as a number.
+
+        length (default: 4):
+          The expected length of the value in bytes. Raises DTError if it has a
+          different length. This is provided as a simple type check.
+
+          Four bytes is the length of a cell, so the value of e.g.
+          'x = < 73 >;' can be fetched with a plain prop.to_num().
+
+          If 'length' is None, the entire property value is used, with no
+          length check.
+
+        signed (default: False):
+          If True, the value will be interpreted as signed rather than
+          unsigned.
+        """
+        try:
+            return to_num(self.value, length, signed)
+        except DTError as e:
+            self._err_with_context(e)
+
+    def to_nums(self, length=4, signed=False):
+        """
+        Returns the property value interpreted as a list of numbers.
+
+        length (default: 4):
+          The length in bytes of each number. Raises DTError if the length of
+          the value is not a multiple of 'length'.
+
+        signed (default: False):
+          If True, the values will be interpreted as signed rather than
+          unsigned.
+        """
+        try:
+            return to_nums(self.value, length, signed)
+        except DTError as e:
+            self._err_with_context(e)
+
+    def to_string(self):
+        """
+        Returns the property value interpreted as a string.
+
+        Raises DTError if the value is not valid UTF-8, is not null-terminated,
+        or if contains more than one null terminator (the null terminator is
+        stripped from the returned string). Strings in Device Tree (e.g., 'x =
+        "foo"') are implicitly null-terminated.
+        """
+        try:
+            return to_string(self.value)
+        except DTError as e:
+            self._err_with_context(e)
+
+    def to_strings(self):
+        """
+        Returns the property value interpreted as a list of strings.
+
+        Raises DTError if the value is not valid UTF-8 or is not
+        null-terminated (the null terminators are stripped from the returned
+        string). Strings in Device Tree (e.g., 'x = "foo"') are implicitly
+        null-terminated.
+        """
+        try:
+            return to_strings(self.value)
+        except DTError as e:
+            self._err_with_context(e)
+
+    def to_node(self):
+        """
+        Interprets the property value as a phandle and returns the
+        corresponding Node.
+
+        Raises DTError if the value is not a valid phandle or if no node with
+        that phandle exists.
+        """
+        phandle = self.to_num()
+        node = self.node.dt.phandle2node.get(phandle)
+        if not node:
+            self._err_with_context("non-existent phandle " + str(phandle))
+        return node
+
+    def __str__(self):
+        s = "".join(label + ": " for label in self.labels) + self.name
+
+        if not self.value:
+            return s + ";"
+
+        s += " = ["
+
+        offset_labels = [(offset, label)
+                         for label, offset in self.offset_labels.items()]
+
+        label_offset = offset = 0
+        for label_offset, label in offset_labels:
+            s += "".join(" {:02X}".format(byte)
+                         for byte in self.value[offset:label_offset]) \
+                 + " " + label + ":"
+            offset = label_offset
+
+        for byte in self.value[label_offset:]:
+            s += " {:02X}".format(byte)
+
+        return s + " ];"
+
+    def __repr__(self):
+        return "<Property '{}' at '{}' in '{}'>" \
+               .format(self.name, self.node.path, self.node.dt.filename)
+
+    #
+    # Internal functions
+    #
+
+    def _add_marker(self, ref, marker_type):
+        # Helper for registering markers in the value that are processed after
+        # parsing. See _fixup_props().
+
+        # len(self.value) gives the current offset. This function is called
+        # while the value is built.
+        self._markers.append((len(self.value), ref, marker_type))
+
+        # For phandle references, add a dummy value with the same length as a
+        # phandle. This is handy for the length check in _register_phandles().
+        if marker_type is _PHANDLE:
+            self.value += b"\0\0\0\0"
+
+    def _err_with_context(self, e):
+        raise DTError("{} (for property '{}' on {})"
+                      .format(e, self.name, self.node.path))
+
+
+#
+# Public functions
+#
+
+
+def to_num(data, length=None, signed=False):
+    """
+    Like Property.to_num(), but takes an arbitrary 'bytes' array. The value is
+    assumed to be in big-endian format, which is standard in Device Tree.
+
+    length (default: None):
+      The expected length of the value in bytes. See Property.to_num().
+
+      Unlike for Property.to_num(), 'length' defaults to None, meaning to skip
+      the length check and use the entire property value.
+    """
+    _check_is_bytes(data)
+    if length is not None:
+        _check_length_positive(length)
+        if len(data) != length:
+            raise DTError("{} is {} bytes long, expected {}"
+                          .format(data, len(data), length))
+
+    return int.from_bytes(data, "big", signed=signed)
+
+
+def to_nums(data, length=4, signed=False):
+    """
+    Like Property.to_nums(), but takes an arbitrary 'bytes' array. The values
+    are assumed to be in big-endian format, which is standard in Device Tree.
+    """
+    _check_is_bytes(data)
+    _check_length_positive(length)
+
+    if len(data) % length != 0:
+        raise DTError("{} is {} bytes long, expected a length that's a "
+                      "multiple of {}".format(data, len(data), length))
+
+    return [int.from_bytes(data[i:i + length], "big", signed=signed)
+            for i in range(0, len(data), length)]
+
+
+def to_string(data):
+    """
+    Like Property.to_string(), but takes an arbitrary 'bytes' array. The string
+    should be null-terminated, which is standard in Device Tree. The
+    null terminator is stripped from the returned value.
+    """
+    strings = to_strings(data)
+    if len(strings) != 1:
+        raise DTError("{} contains more than one string".format(data))
+    return strings[0]
+
+
+def to_strings(data):
+    """
+    Like Property.to_strings(), but takes an arbitrary 'bytes' array. The
+    strings should be null-terminated, which is standard in Device Tree. The
+    null terminators are stripped from the returned value.
+    """
+    _check_is_bytes(data)
+
+    try:
+        s = data.decode("utf-8")
+    except UnicodeDecodeError:
+        raise DTError("{} is not valid UTF-8".format(data))
+
+    if not s.endswith("\0"):
+        raise DTError("{} is not null-terminated".format(data))
+
+    return s.split("\0")[:-1]
+
+
+def _check_is_bytes(data):
+    if not isinstance(data, bytes):
+        raise DTError("'{}' has type '{}', expected 'bytes'"
+                      .format(data, type(data).__name__))
+
+
+def _check_length_positive(length):
+    if length < 1:
+        raise DTError("'size' must be greater than zero, was " + str(length))
+
+
+def _append_no_dup(lst, elm):
+    # Appends 'elm' to 'lst', but only if it isn't already in 'lst'. Lets us
+    # preserve order, which a set() doesn't.
+
+    if elm not in lst:
+        lst.append(elm)
+
+
+class DTError(Exception):
+    "Exception raised for Device Tree-related errors"
+
+
+_Token = collections.namedtuple("Token", "id val")
+
+# Lexer states
+_DEFAULT = 0
+_EXPECT_PROPNODENAME = 1
+_EXPECT_BYTE = 2
+
+_num_re = re.compile(r"(0[xX][0-9a-fA-F]+|[0-9]+)(?:ULL|UL|LL|U|L)?")
+
+# A leading \ is allowed property and node names, probably to allow weird node
+# names that would clash with other stuff
+_propnodename_re = re.compile(r"\\?([a-zA-Z0-9,._+*#?@-]+)")
+
+# Misc. tokens that are tried after a property/node name. This is important, as
+# there's overlap with the allowed characters in names.
+_misc_re = re.compile(
+    "|".join(re.escape(pat) for pat in (
+        "==", "!=", "!", "=", ",", ";", "+", "-", "*", "/", "%", "~", "?", ":",
+        "^", "(", ")", "{", "}", "[", "]", "<<", "<=", "<", ">>", ">=", ">",
+        "||", "|", "&&", "&")))
+
+_byte_re = re.compile(r"[0-9a-fA-F]{2}")
+
+# Matches a backslash escape within a 'bytes' array. Captures the 'x' part of
+# '\x'.
+_unescape_re = \
+    re.compile(br'\\(\\|"|a|b|t|n|v|f|r|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})')
+
+# #line directive (this is the regex the C tools use)
+_line_re = re.compile(
+    r'^#(?:line)?[ \t]+([0-9]+)[ \t]+"((?:[^\\"]|\\.)*)"(?:[ \t]+[0-9]+)?',
+    re.MULTILINE)
+
+
+def _init_tokens():
+    global _token_re
+    global _T_NUM
+    global _T_PROPNODENAME
+    global _T_MISC
+    global _T_BYTE
+    global _T_BAD
+
+    token_spec = (("_T_INCLUDE",        r'(/include/\s*"(?:[^\\"]|\\.)*")'),
+                  ("_T_LINE",  # #line directive
+                   r'^#(?:line)?[ \t]+([0-9]+[ \t]+"(?:[^\\"]|\\.)*")(?:[ \t]+[0-9]+)?'),
+                  ("_T_STRING",         r'"((?:[^\\"]|\\.)*)"'),
+                  ("_T_DTS_V1",         r"(/dts-v1/)"),
+                  ("_T_PLUGIN",         r"(/plugin/)"),
+                  ("_T_MEMRESERVE",     r"(/memreserve/)"),
+                  ("_T_BITS",           r"(/bits/)"),
+                  ("_T_DEL_PROP",       r"(/delete-property/)"),
+                  ("_T_DEL_NODE",       r"(/delete-node/)"),
+                  ("_T_OMIT_IF_NO_REF", r"(/omit-if-no-ref/)"),
+                  ("_T_LABEL",          r"([a-zA-Z_][a-zA-Z0-9_]*):"),
+                  ("_T_CHAR_LITERAL",   r"'((?:[^\\']|\\.)*)'"),
+                  ("_T_REF",
+                   r"&([a-zA-Z_][a-zA-Z0-9_]*|{[a-zA-Z0-9,._+*#?@/-]*})"),
+                  ("_T_INCBIN",         r"(/incbin/)"),
+                  # Whitespace, C comments, and C++ comments
+                  ("_T_SKIP", r"(\s+|(?:/\*(?:.|\n)*?\*/)|//.*$)"),
+                  # Return a token for end-of-file so that the parsing code can
+                  # always assume that there are more tokens when looking
+                  # ahead. This simplifies things.
+                  ("_T_EOF",            r"(\Z)"))
+
+    # MULTILINE is needed for C++ comments and #line directives
+    _token_re = re.compile("|".join(spec[1] for spec in token_spec),
+                           re.MULTILINE | re.ASCII)
+
+    for i, spec in enumerate(token_spec, 1):
+        globals()[spec[0]] = i
+
+    _T_NUM = i + 1
+    _T_PROPNODENAME = i + 2
+    _T_MISC = i + 3
+    _T_BYTE = i + 4
+    _T_BAD = i + 5
+
+
+_init_tokens()
+
+# Types of markers in property values (for references and in-value labels)
+_PATH = 0
+_PHANDLE = 1
+_LABEL = 2
diff --git a/scripts/dts/edtlib.py b/scripts/dts/edtlib.py
new file mode 100644
index 00000000000..485a8865fb9
--- /dev/null
+++ b/scripts/dts/edtlib.py
@@ -0,0 +1,1639 @@
+# Copyright (c) 2019 Nordic Semiconductor ASA
+# Copyright (c) 2019 Linaro Limited
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Tip: You can view just the documentation with 'pydoc3 edtlib'
+
+"""
+Library for working with .dts files and bindings at a higher level compared to
+dtlib. Deals with things at the level of devices, registers, interrupts,
+compatibles, bindings, etc., as opposed to dtlib, which is just a low-level
+device tree parser.
+
+Each device tree node (dtlib.Node) gets a Device instance, which has all the
+information related to the device, derived from both the device tree and from
+the binding for the device.
+
+Bindings are files that describe device tree nodes. Device tree nodes are
+usually mapped to bindings via their 'compatible = "..."' property, but binding
+data can also come from a 'sub-node:' key in the binding for the parent device
+tree node.
+
+The top-level entry point of the library is the EDT class. EDT.__init__() takes
+a .dts file to parse and the path of a directory containing bindings.
+"""
+
+import os
+import re
+import sys
+
+import yaml
+
+from dtlib import DT, DTError, to_num, to_nums
+
+# NOTE: testedtlib.py is the test suite for this library. It can be run
+# directly.
+
+# Implementation notes
+# --------------------
+#
+# A '_' prefix on an identifier in Python is a convention for marking it private.
+# Please do not access private things. Instead, think of what API you need, and
+# add it.
+#
+# This library is layered on top of dtlib, and is not meant to expose it to
+# clients. This keeps the header generation script simple.
+#
+# General biased advice:
+#
+# - Consider using @property for APIs that don't need parameters. It makes
+#   functions look like attributes, which is less awkward in clients, and makes
+#   it easy to switch back and forth between variables and functions.
+#
+# - Think about the data type of the thing you're exposing. Exposing something
+#   as e.g. a list or a dictionary is often nicer and more flexible than adding
+#   a function.
+#
+# - Avoid get_*() prefixes on functions. Name them after the thing they return
+#   instead. This often makes the code read more naturally in callers.
+#
+#   Also, consider using @property instead of get_*().
+#
+# - Don't expose dtlib stuff directly.
+#
+# - Add documentation for any new APIs you add.
+#
+#   The convention here is that docstrings (quoted strings) are used for public
+#   APIs, and "doc comments" for internal functions.
+#
+#   @properties are documented in the class docstring, as if they were
+#   variables. See the existing @properties for a template.
+#
+# - Please use ""-quoted strings instead of ''-quoted strings, just to make
+#   things consistent (''-quoting is more common otherwise in Python)
+
+#
+# Public classes
+#
+
+
+class EDT:
+    """
+    Represents a "high-level" view of a device tree, with a list of devices
+    that each have some number of registers, etc.
+
+    These attributes are available on EDT objects:
+
+    devices:
+      A list of Device objects for the devices
+
+    dts_path:
+      The .dts path passed to __init__()
+
+    bindings_dir:
+      The bindings directory path passed to __init__()
+    """
+    def __init__(self, dts, bindings_dir):
+        """
+        EDT constructor. This is the top-level entry point to the library.
+
+        dts:
+          Path to device tree .dts file
+
+        bindings_dir:
+          Path to directory containing bindings, in YAML format. This directory
+          is recursively searched for .yaml files.
+        """
+        self.dts_path = dts
+        self.bindings_dir = bindings_dir
+
+        self._dt = DT(dts)
+
+        self._init_compat2binding(bindings_dir)
+        self._init_devices()
+
+    def get_dev(self, path):
+        """
+        Returns the Device at the DT path or alias 'path'. Raises EDTError if
+        the path or alias doesn't exist.
+        """
+        try:
+            return self._node2dev[self._dt.get_node(path)]
+        except DTError as e:
+            _err(e)
+
+    def chosen_dev(self, name):
+        """
+        Returns the Device pointed at by the property named 'name' in /chosen,
+        or None if the property is missing
+        """
+        try:
+            chosen = self._dt.get_node("/chosen")
+        except DTError:
+            # No /chosen node
+            return None
+
+        if name not in chosen.props:
+            return None
+
+        path = chosen.props[name].to_string()
+        try:
+            return self._node2dev[self._dt.get_node(path)]
+        except DTError:
+            _err("{} in /chosen points to {}, which does not exist"
+                 .format(name, path))
+
+    def _init_compat2binding(self, bindings_dir):
+        # Creates self._compat2binding. This is a dictionary that maps
+        # (<compatible>, <bus>) tuples (both strings) to (<binding>, <path>)
+        # tuples. <binding> is the binding in parsed PyYAML format, and <path>
+        # the path to the binding (nice for binding-related error messages).
+        #
+        # For example, self._compat2binding["company,dev", "can"] contains the
+        # binding/path for the 'company,dev' device, when it appears on the CAN
+        # bus.
+        #
+        # For bindings that don't specify a bus, <bus> is None, so that e.g.
+        # self._compat2binding["company,notonbus", None] contains the binding.
+        #
+        # Only bindings for 'compatible' strings that appear in the device tree
+        # are loaded.
+
+        dt_compats = _dt_compats(self._dt)
+        self._binding_paths = _binding_paths(bindings_dir)
+
+        # Add '!include foo.yaml' handling.
+        #
+        # Do yaml.Loader.add_constructor() instead of yaml.add_constructor() to be
+        # compatible with both version 3.13 and version 5.1 of PyYAML.
+        #
+        # TODO: Is there some 3.13/5.1-compatible way to only do this once, even
+        # if multiple EDT objects are created?
+        yaml.Loader.add_constructor("!include", self._binding_include)
+
+        self._compat2binding = {}
+        for binding_path in self._binding_paths:
+            compat = _binding_compat(binding_path)
+            if compat in dt_compats:
+                binding = _load_binding(binding_path)
+                self._compat2binding[compat, _binding_bus(binding)] = \
+                    (binding, binding_path)
+
+    def _binding_include(self, loader, node):
+        # Implements !include. Returns a list with the YAML structures for the
+        # included files (a single-element list if the !include is for a single
+        # file).
+
+        if isinstance(node, yaml.ScalarNode):
+            # !include foo.yaml
+            return [self._binding_include_file(loader.construct_scalar(node))]
+
+        if isinstance(node, yaml.SequenceNode):
+            # !include [foo.yaml, bar.yaml]
+            return [self._binding_include_file(filename)
+                    for filename in loader.construct_sequence(node)]
+
+        _binding_inc_error("unrecognised node type in !include statement")
+
+    def _binding_include_file(self, filename):
+        # _binding_include() helper for loading an !include'd file. !include
+        # takes just the basename of the file, so we need to make sure there
+        # aren't multiple candidates.
+
+        paths = [path for path in self._binding_paths
+                 if os.path.basename(path) == filename]
+
+        if not paths:
+            _binding_inc_error("'{}' not found".format(filename))
+
+        if len(paths) > 1:
+            _binding_inc_error("multiple candidates for '{}' in !include: {}"
+                               .format(filename, ", ".join(paths)))
+
+        with open(paths[0], encoding="utf-8") as f:
+            return yaml.load(f, Loader=yaml.Loader)
+
+    def _init_devices(self):
+        # Creates a list of devices (Device objects) from the DT nodes, in
+        # self.devices. 'dt' is the dtlib.DT instance for the device tree.
+
+        # Maps dtlib.Node's to their corresponding Devices
+        self._node2dev = {}
+
+        self.devices = []
+
+        for node in self._dt.node_iter():
+            # Warning: Device.__init__() relies on parent Devices being created
+            # before their children. This is guaranteed by node_iter().
+            dev = Device(self, node)
+            self.devices.append(dev)
+            self._node2dev[node] = dev
+
+        for dev in self.devices:
+            # These depend on all Device objects having been created, so we do
+            # them separately
+            dev._init_interrupts()
+            dev._init_gpios()
+            dev._init_pwms()
+            dev._init_clocks()
+
+    def __repr__(self):
+        return "<EDT for '{}', binding directory '{}'>".format(
+            self.dts_path, self.bindings_dir)
+
+
+class Device:
+    """
+    Represents a device. There's a one-to-one correspondence between device
+    tree nodes and Devices.
+
+    These attributes are available on Device objects:
+
+    edt:
+      The EDT instance this device is from
+
+    name:
+      The name of the device. This is fetched from the node name.
+
+    unit_addr:
+      An integer with the ...@<unit-address> portion of the node name,
+      translated through any 'ranges' properties on parent nodes, or None if
+      the node name has no unit-address portion
+
+    path:
+      The device tree path of the device
+
+    label:
+      The text from the 'label' property on the DT node of the Device, or None
+      if the node has no 'label'
+
+    parent:
+      The parent Device, or None if there is no parent
+
+    enabled:
+      True unless the device's node has 'status = "disabled"'
+
+    read_only:
+      True if the DT node of the Device has a 'read-only' property, and False
+      otherwise
+
+    instance_no:
+      Dictionary that maps each 'compatible' string for the device to a unique
+      index among all devices that have that 'compatible' string.
+
+      As an example, 'instance_no["foo,led"] == 3' can be read as "this is the
+      fourth foo,led device".
+
+      Only enabled devices (status != "disabled") are counted. 'instance_no' is
+      meaningless for disabled devices.
+
+    matching_compat:
+      The 'compatible' string for the binding that matched the device, or
+      None if the device has no binding
+
+    description:
+      The description string from the binding file for the device, or None if
+      the device has no binding. Trailing whitespace (including newlines) is
+      removed.
+
+    binding_path:
+      The path to the binding file for the device, or None if the device has no
+      binding
+
+    compats:
+      A list of 'compatible' strings for the device, in the same order that
+      they're listed in the .dts file
+
+    regs:
+      A list of Register objects for the device's registers
+
+    props:
+      A dictionary that maps property names to Property objects. Property
+      objects are created for all DT properties on the device that are
+      mentioned in 'properties:' in the binding.
+
+    aliases:
+      A list of aliases for the device. This is fetched from the /aliases node.
+
+    interrupts:
+      A list of Interrupt objects for the interrupts generated by the device
+
+    gpios:
+      A dictionary that maps the <prefix> part in '<prefix>-gpios' properties
+      to a list of GPIO objects (see the GPIO class).
+
+      For example, 'foo-gpios = <&gpio1 1 2 &gpio2 3 4>' makes gpios["foo"] a
+      list of two GPIO objects.
+
+    pwms:
+      A list of PWM objects, derived from the 'pwms' property. The list is
+      empty if the device has no 'pwms' property.
+
+    clocks:
+      A list of Clock objects, derived from the 'clocks' property. The list is
+      empty if the device has no 'clocks' property.
+
+    bus:
+      The bus for the device as specified in its binding, e.g. "i2c" or "spi".
+      None if the binding doesn't specify a bus.
+
+    flash_controller:
+      The flash controller for the device. Only meaningful for devices
+      representing flash partitions.
+    """
+    @property
+    def name(self):
+        "See the class docstring"
+        return self._node.name
+
+    @property
+    def unit_addr(self):
+        "See the class docstring"
+
+        # TODO: Return a plain string here later, like dtlib.Node.unit_addr?
+
+        if "@" not in self.name:
+            return None
+
+        try:
+            addr = int(self.name.split("@", 1)[1], 16)
+        except ValueError:
+            _err("{!r} has non-hex unit address".format(self))
+
+        addr = _translate(addr, self._node)
+
+        if self.regs and self.regs[0].addr != addr:
+            _warn("unit-address and first reg (0x{:x}) don't match for {}"
+                  .format(self.regs[0].addr, self.name))
+
+        return addr
+
+    @property
+    def path(self):
+        "See the class docstring"
+        return self._node.path
+
+    @property
+    def label(self):
+        "See the class docstring"
+        if "label" in self._node.props:
+            return self._node.props["label"].to_string()
+        return None
+
+    @property
+    def parent(self):
+        "See the class docstring"
+        return self.edt._node2dev.get(self._node.parent)
+
+    @property
+    def enabled(self):
+        "See the class docstring"
+        return "status" not in self._node.props or \
+            self._node.props["status"].to_string() != "disabled"
+
+    @property
+    def read_only(self):
+        "See the class docstring"
+        return "read-only" in self._node.props
+
+    @property
+    def aliases(self):
+        "See the class docstring"
+        return [alias for alias, node in self._node.dt.alias2node.items()
+                if node is self._node]
+
+    @property
+    def bus(self):
+        "See the class docstring"
+        return _binding_bus(self._binding)
+
+    @property
+    def flash_controller(self):
+        "See the class docstring"
+
+        # The node path might be something like
+        # /flash-controller@4001E000/flash@0/partitions/partition@fc000. We go
+        # up two levels to get the flash and check its compat. The flash
+        # controller might be the flash itself (for cases like NOR flashes).
+        # For the case of 'soc-nv-flash', we assume the controller is the
+        # parent of the flash node.
+
+        if not self.parent or not self.parent.parent:
+            _err("flash partition {!r} lacks parent or grandparent node"
+                 .format(self))
+
+        controller = self.parent.parent
+        if controller.matching_compat == "soc-nv-flash":
+            return controller.parent
+        return controller
+
+    def __repr__(self):
+        return "<Device {} in '{}', {}>".format(
+            self.path, self.edt.dts_path,
+            "binding " + self.binding_path if self.binding_path
+                else "no binding")
+
+    def __init__(self, edt, node):
+        "Private constructor. Not meant to be called by clients."
+
+        # Interrupts, GPIOs, PWMs, and clocks are initialized separately,
+        # because they depend on all Devices existing
+
+        self.edt = edt
+        self._node = node
+
+        self._init_binding()
+        self._init_props()
+        self._init_regs()
+        self._set_instance_no()
+
+    def _init_binding(self):
+        # Initializes Device.matching_compat, Device._binding, and
+        # Device.binding_path.
+        #
+        # Device._binding holds the data from the device's binding file, in the
+        # format returned by PyYAML (plain Python lists, dicts, etc.), or None
+        # if the device has no binding.
+
+        # This relies on the parent of the Device having already been
+        # initialized, which is guaranteed by going through the nodes in
+        # node_iter() order.
+
+        if "compatible" in self._node.props:
+            self.compats = self._node.props["compatible"].to_strings()
+            bus = self._bus_from_parent_binding()
+
+            for compat in self.compats:
+                if (compat, bus) in self.edt._compat2binding:
+                    # Binding found
+                    self.matching_compat = compat
+                    self._binding, self.binding_path = \
+                        self.edt._compat2binding[compat, bus]
+
+                    self.description = self._binding.get("description")
+                    if self.description:
+                        self.description = self.description.rstrip()
+
+                    return
+        else:
+            # No 'compatible' property. See if the parent has a 'sub-node:' key
+            # that gives the binding.
+
+            self.compats = []
+
+            if self.parent and self.parent._binding and \
+                "sub-node" in self.parent._binding:
+
+                # Binding found
+                self._binding = self.parent._binding["sub-node"]
+                self.binding_path = self.parent.binding_path
+
+                self.description = self.parent._binding.get("description")
+                if self.description:
+                    self.description = self.description.rstrip()
+
+                self.matching_compat = self.parent.matching_compat
+                return
+
+        # No binding found
+        self.matching_compat = self._binding = self.binding_path = \
+            self.description = None
+
+    def _bus_from_parent_binding(self):
+        # _init_binding() helper. Returns the bus specified by
+        # 'child: bus: ...' in the parent binding, or None if missing.
+
+        if not self.parent:
+            return None
+
+        binding = self.parent._binding
+        if binding and "child" in binding:
+            return binding["child"].get("bus")
+        return None
+
+    def _init_props(self):
+        # Creates self.props. See the class docstring.
+
+        self.props = {}
+
+        if not self._binding or "properties" not in self._binding:
+            return
+
+        for name, options in self._binding["properties"].items():
+            self._init_prop(name, options)
+
+    def _init_prop(self, name, options):
+        # _init_props() helper for initializing a single property
+
+        # Skip properties that start with '#', like '#size-cells', and mapping
+        # properties like 'gpio-map'/'interrupt-map'
+        if name[0] == "#" or name.endswith("-map"):
+            return
+
+        prop_type = options.get("type")
+        if not prop_type:
+            _err("'{}' in {} lacks 'type'".format(name, self.binding_path))
+
+        # "Dummy" type for properties like '...-gpios', so that we can require
+        # all entries in 'properties:' to have a 'type: ...'. It might make
+        # sense to have gpios in 'properties:' for other reasons, e.g. to set
+        # 'category: required'.
+        if prop_type == "compound":
+            return
+
+        val = self._prop_val(name, prop_type,
+                             options.get("category") == "optional")
+        if val is None:
+            # 'category: optional' property that wasn't there
+            return
+
+        prop = Property()
+        prop.dev = self
+        prop.name = name
+        prop.description = options.get("description")
+        if prop.description:
+            prop.description = prop.description.rstrip()
+        prop.val = val
+        enum = options.get("enum")
+        if enum is None:
+            prop.enum_index = None
+        else:
+            if val not in enum:
+                _err("value ({}) for property ({}) is not in enumerated "
+                     "list {} for node {}".format(val, name, enum, self.name))
+
+            prop.enum_index = enum.index(val)
+
+        self.props[name] = prop
+
+    def _prop_val(self, name, prop_type, optional):
+        # _init_prop() helper for getting the property's value
+
+        node = self._node
+
+        if prop_type == "boolean":
+            # True/False
+            return name in node.props
+
+        prop = node.props.get(name)
+        if not prop:
+            if not optional and \
+                ("status" not in node.props or
+                 node.props["status"].to_string() != "disabled"):
+
+                _err("'{}' is marked as required in 'properties:' in {}, but "
+                     "does not appear in {!r}".format(
+                         name, self.binding_path, node))
+
+            return None
+
+        if prop_type == "int":
+            return prop.to_num()
+
+        if prop_type == "array":
+            return prop.to_nums()
+
+        if prop_type == "uint8-array":
+            return prop.value  # Plain 'bytes'
+
+        if prop_type == "string":
+            return prop.to_string()
+
+        if prop_type == "string-array":
+            return prop.to_strings()
+
+        _err("'{}' in 'properties:' in {} has unknown type '{}'"
+             .format(name, self.binding_path, prop_type))
+
+    def _init_regs(self):
+        # Initializes self.regs with a list of Register objects
+
+        node = self._node
+
+        self.regs = []
+
+        if "reg" not in node.props:
+            return
+
+        address_cells = _address_cells(node)
+        size_cells = _size_cells(node)
+
+        for raw_reg in _slice(node, "reg", 4*(address_cells + size_cells)):
+            reg = Register()
+            reg.dev = self
+            reg.addr = _translate(to_num(raw_reg[:4*address_cells]), node)
+            reg.size = to_num(raw_reg[4*address_cells:])
+            if size_cells != 0 and reg.size == 0:
+                _err("zero-sized 'reg' in {!r} seems meaningless (maybe you "
+                     "want a size of one or #size-cells = 0 instead)"
+                     .format(self._node))
+
+            self.regs.append(reg)
+
+        _add_names(node, "reg-names", self.regs)
+
+    def _init_interrupts(self):
+        # Initializes self.interrupts with a list of Interrupt objects
+
+        node = self._node
+
+        self.interrupts = []
+
+        for controller_node, spec in _interrupts(node):
+            controller = self.edt._node2dev[controller_node]
+
+            interrupt = Interrupt()
+            interrupt.dev = self
+            interrupt.controller = controller
+            interrupt.specifier = self._named_cells(controller, spec, "interrupt")
+
+            self.interrupts.append(interrupt)
+
+        _add_names(node, "interrupt-names", self.interrupts)
+
+    def _init_gpios(self):
+        # Initializes self.gpios
+
+        self.gpios = {}
+
+        for prefix, gpios in _gpios(self._node).items():
+            self.gpios[prefix] = []
+            for controller_node, spec in gpios:
+                controller = self.edt._node2dev[controller_node]
+
+                gpio = GPIO()
+                gpio.dev = self
+                gpio.controller = controller
+                gpio.specifier = self._named_cells(controller, spec, "GPIOS")
+                gpio.name = prefix
+
+                self.gpios[prefix].append(gpio)
+
+    def _init_clocks(self):
+        # Initializes self.clocks
+
+        node = self._node
+
+        self.clocks = []
+
+        for controller_node, spec in _clocks(node):
+            controller = self.edt._node2dev[controller_node]
+
+            clock = Clock()
+            clock.dev = self
+            clock.controller = controller
+            clock.specifier = self._named_cells(controller, spec, "clocks")
+            if "fixed-clock" in controller.compats:
+                if "clock-frequency" not in controller.props:
+                    _err("{!r} is a 'fixed-clock', but either lacks a "
+                         "'clock-frequency' property or does not have "
+                         "it specified in its binding".format(controller))
+
+                clock.frequency = controller.props["clock-frequency"].val
+            else:
+                clock.frequency = None
+
+            self.clocks.append(clock)
+
+        _add_names(node, "clock-names", self.clocks)
+
+    def _init_pwms(self):
+        # Initializes self.pwms
+
+        self.pwms = []
+
+        for controller_node, spec in _pwms(self._node):
+            controller = self.edt._node2dev[controller_node]
+
+            pwm = PWM()
+            pwm.dev = self
+            pwm.controller = controller
+            pwm.specifier = self._named_cells(controller, spec, "pwms")
+
+            self.pwms.append(pwm)
+
+        _add_names(self._node, "pwm-names", self.pwms)
+
+    def _named_cells(self, controller, spec, controller_s):
+        # _init_{interrupts,gpios}() helper. Returns a dictionary that maps
+        # #cell names given in the binding for 'controller' to cell values.
+        # 'spec' is the raw interrupt/GPIO data, and 'controller_s' a string
+        # that gives the context (for error messages).
+
+        if not controller._binding:
+            _err("{} controller {!r} for {!r} lacks binding"
+                 .format(controller_s, controller._node, self._node))
+
+        if "#cells" in controller._binding:
+            cell_names = controller._binding["#cells"]
+            if not isinstance(cell_names, list):
+                _err("binding for {} controller {!r} has malformed #cells array"
+                     .format(controller_s, controller._node))
+        else:
+            # Treat no #cells in the binding the same as an empty #cells, so
+            # that bindings don't have to have an empty #cells for e.g.
+            # '#clock-cells = <0>'.
+            cell_names = []
+
+        spec_list = to_nums(spec)
+        if len(spec_list) != len(cell_names):
+            _err("unexpected #cells length in binding for {!r} - {} instead "
+                 "of {}".format(controller._node, len(cell_names),
+                                len(spec_list)))
+
+        return dict(zip(cell_names, spec_list))
+
+    def _set_instance_no(self):
+        # Initializes self.instance_no
+
+        self.instance_no = {}
+
+        for compat in self.compats:
+            self.instance_no[compat] = 0
+            for other_dev in self.edt.devices:
+                if compat in other_dev.compats and other_dev.enabled:
+                    self.instance_no[compat] += 1
+
+
+class Register:
+    """
+    Represents a register on a device.
+
+    These attributes are available on Register objects:
+
+    dev:
+      The Device instance this register is from
+
+    name:
+      The name of the register as given in the 'reg-names' property, or None if
+      there is no 'reg-names' property
+
+    addr:
+      The starting address of the register, in the parent address space. Any
+      'ranges' properties are taken into account.
+
+    size:
+      The length of the register in bytes
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+        fields.append("addr: " + hex(self.addr))
+        fields.append("size: " + hex(self.size))
+
+        return "<Register, {}>".format(", ".join(fields))
+
+
+class Interrupt:
+    """
+    Represents an interrupt generated by a device.
+
+    These attributes are available on Interrupt objects:
+
+    dev:
+      The Device instance that generated the interrupt
+
+    name:
+      The name of the interrupt as given in the 'interrupt-names' property, or
+      None if there is no 'interrupt-names' property
+
+    controller:
+      The Device instance for the controller the interrupt gets sent to. Any
+      'interrupt-map' is taken into account, so that this is the final
+      controller node.
+
+    specifier:
+      A dictionary that maps names from the #cells portion of the binding to
+      cell values in the interrupt specifier. 'interrupts = <1 2>' might give
+      {"irq": 1, "level": 2}, for example.
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+
+        fields.append("target: {}".format(self.controller))
+        fields.append("specifier: {}".format(self.specifier))
+
+        return "<Interrupt, {}>".format(", ".join(fields))
+
+
+class GPIO:
+    """
+    Represents a GPIO used by a device.
+
+    These attributes are available on GPIO objects:
+
+    dev:
+      The Device instance that uses the GPIO
+
+    name:
+      The name of the gpio as extracted out of the "<NAME>-gpios" property. If
+      the property is just "gpios" than there is no name.
+
+    controller:
+      The Device instance for the controller of the GPIO
+
+    specifier:
+      A dictionary that maps names from the #cells portion of the binding to
+      cell values in the gpio specifier. 'foo-gpios = <&gpioc 5 0>' might give
+      {"pin": 5, "flags": 0}, for example.
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+
+        fields.append("target: {}".format(self.controller))
+        fields.append("specifier: {}".format(self.specifier))
+
+        return "<GPIO, {}>".format(", ".join(fields))
+
+
+class Clock:
+    """
+    Represents a clock used by a device.
+
+    These attributes are available on Clock objects:
+
+    dev:
+      The Device instance that uses the clock
+
+    name:
+      The name of the clock as given in the 'clock-names' property, or
+      None if there is no 'clock-names' property
+
+    controller:
+      The Device instance for the controller of the clock.
+
+    frequency:
+      The frequency of the clock for fixed clocks ('fixed-clock' in
+      'compatible'), as an integer. Derived from the 'clock-frequency'
+      property. None if the clock is not a fixed clock.
+
+    specifier:
+      A dictionary that maps names from the #cells portion of the binding to
+      cell values in the clock specifier
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+
+        if self.frequency is not None:
+            fields.append("frequency: {}".format(self.frequency))
+
+        fields.append("target: {}".format(self.controller))
+        fields.append("specifier: {}".format(self.specifier))
+
+        return "<Clock, {}>".format(", ".join(fields))
+
+
+class PWM:
+    """
+    Represents a PWM used by a device.
+
+    These attributes are available on PWM objects:
+
+    dev:
+      The Device instance that uses the PWM
+
+    name:
+      The name of the pwm as given in the 'pwm-names' property, or the
+      node name if the 'pwm-names' property doesn't exist.
+
+    controller:
+      The Device instance for the controller of the PWM
+
+    specifier:
+      A dictionary that maps names from the #cells portion of the binding to
+      cell values in the pwm specifier. 'pwms = <&pwm 0 5000000>' might give
+      {"channel": 0, "period": 5000000}, for example.
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+
+        fields.append("target: {}".format(self.controller))
+        fields.append("specifier: {}".format(self.specifier))
+
+        return "<PWM, {}>".format(", ".join(fields))
+
+
+class Property:
+    """
+    Represents a property on a Device, as set in its DT node and with
+    additional info from the 'properties:' section of the binding.
+
+    Only properties mentioned in 'properties:' get created.
+
+    These attributes are available on Property objects:
+
+    dev:
+      The Device instance the property is on
+
+    name:
+      The name of the property
+
+    description:
+      The description string from the property as given in the binding, or None
+      if missing. Trailing whitespace (including newlines) is removed.
+
+    val:
+      The value of the property, with the format determined by the 'type:'
+      key from the binding
+
+    enum_index:
+      The index of the property's value in the 'enum:' list in the binding, or
+      None if the binding has no 'enum:'
+    """
+    def __repr__(self):
+        fields = ["name: " + self.name,
+                  # repr() to deal with lists
+                  "value: " + repr(self.val)]
+
+        if self.enum_index is not None:
+            fields.append("enum index: {}".format(self.enum_index))
+
+        return "<Property, {}>".format(", ".join(fields))
+
+
+class EDTError(Exception):
+    "Exception raised for Extended Device Tree-related errors"
+
+
+#
+# Public global functions
+#
+
+
+def spi_dev_cs_gpio(dev):
+    # Returns an SPI device's GPIO chip select if it exists, as a GPIO
+    # instance, and None otherwise. See
+    # Documentation/devicetree/bindings/spi/spi-bus.txt in the Linux kernel.
+
+    if dev.bus == "spi" and dev.parent:
+        parent_cs = dev.parent.gpios.get("cs")
+        if parent_cs:
+            # cs-gpios is indexed by the unit address
+            cs_index = dev.regs[0].addr
+            if cs_index >= len(parent_cs):
+                _err("index from 'regs' in {!r} ({}) is >= number of cs-gpios "
+                     "in {!r} ({})".format(
+                         dev, cs_index, dev.parent, len(parent_cs)))
+
+            return parent_cs[cs_index]
+
+    return None
+
+
+#
+# Private global functions
+#
+
+
+def _dt_compats(dt):
+    # Returns a set() with all 'compatible' strings in the device tree
+    # represented by dt (a dtlib.DT instance)
+
+    return {compat
+            for node in dt.node_iter()
+                if "compatible" in node.props
+                    for compat in node.props["compatible"].to_strings()}
+
+
+def _binding_paths(bindings_dir):
+    # Returns a list with the paths to all bindings (.yaml files) in
+    # 'bindings_dir'
+
+    return [os.path.join(root, filename)
+            for root, _, filenames in os.walk(bindings_dir)
+                for filename in filenames
+                    if filename.endswith(".yaml")]
+
+
+def _binding_compat(binding_path):
+    # Returns the compatible string specified in the binding at 'binding_path'.
+    # Uses a regex to avoid having to parse the bindings, which is slow when
+    # done for all bindings.
+
+    with open(binding_path) as binding:
+        for line in binding:
+            match = re.match(r'\s+constraint:\s*"([^"]*)"', line)
+            if match:
+                return match.group(1)
+
+    return None
+
+
+def _binding_bus(binding):
+    # Returns the bus specified in 'binding' (the bus the device described by
+    # 'binding' is on), e.g. "i2c", or None if 'binding' is None or doesn't
+    # specify a bus
+
+    if binding and "parent" in binding:
+        return binding["parent"].get("bus")
+    return None
+
+
+def _binding_inc_error(msg):
+    # Helper for reporting errors in the !include implementation
+
+    raise yaml.constructor.ConstructorError(None, None, "error: " + msg)
+
+
+def _load_binding(path):
+    # Loads a top-level binding .yaml file from 'path', also handling any
+    # !include'd files. Returns the parsed PyYAML output (Python
+    # lists/dictionaries/strings/etc. representing the file).
+
+    with open(path, encoding="utf-8") as f:
+        return _merge_included_bindings(yaml.load(f, Loader=yaml.Loader), path)
+
+
+def _merge_included_bindings(binding, binding_path):
+    # Merges any bindings in the 'inherits:' section of 'binding' into the top
+    # level of 'binding'. !includes have already been processed at this point,
+    # and leave the data for the included binding(s) in 'inherits:'.
+    #
+    # Properties in 'binding' take precedence over properties from included
+    # bindings.
+
+    # Currently, we require that each !include'd file is a well-formed
+    # binding in itself
+    _check_binding(binding, binding_path)
+
+    if "inherits" in binding:
+        for inherited in binding.pop("inherits"):
+            _merge_props(
+                binding, _merge_included_bindings(inherited, binding_path),
+                None, binding_path)
+
+    return binding
+
+
+def _merge_props(to_dict, from_dict, parent, binding_path):
+    # Recursively merges 'from_dict' into 'to_dict', to implement !include. If
+    # a key exists in both 'from_dict' and 'to_dict', then the value in
+    # 'to_dict' takes precedence.
+    #
+    # 'parent' is the name of the parent key containing 'to_dict' and
+    # 'from_dict', and 'binding_path' is the path to the top-level binding.
+    # These are used to generate errors for sketchy property overwrites.
+
+    for prop in from_dict:
+        if isinstance(to_dict.get(prop), dict) and \
+           isinstance(from_dict[prop], dict):
+            _merge_props(to_dict[prop], from_dict[prop], prop, binding_path)
+        elif prop not in to_dict:
+            to_dict[prop] = from_dict[prop]
+        elif _bad_overwrite(to_dict, from_dict, prop):
+            _err("{} (in '{}'): '{}' from !included file overwritten "
+                 "('{}' replaced with '{}')".format(
+                     binding_path, parent, prop, from_dict[prop],
+                     to_dict[prop]))
+
+
+def _bad_overwrite(to_dict, from_dict, prop):
+    # _merge_props() helper. Returns True in cases where it's bad that
+    # to_dict[prop] takes precedence over from_dict[prop].
+
+    # These are overridden deliberately
+    if prop in {"title", "description"}:
+        return False
+
+    if to_dict[prop] == from_dict[prop]:
+        return False
+
+    # Allow a property to be made required when it previously was optional
+    # without a warning
+    if prop == "category" and to_dict["category"] == "required" and \
+                              from_dict["category"] == "optional":
+        return False
+
+    return True
+
+
+def _check_binding(binding, binding_path):
+    # Does sanity checking on 'binding'
+
+    for prop in "title", "description":
+        if prop not in binding:
+            _err("missing '{}' property in {}".format(prop, binding_path))
+
+    for prop in "title", "description":
+        if not isinstance(binding[prop], str) or not binding[prop]:
+            _err("missing, malformed, or empty '{}' in {}"
+                 .format(prop, binding_path))
+
+    ok_top = {"title", "description", "inherits", "properties", "#cells",
+              "parent", "child", "sub-node"}
+
+    for prop in binding:
+        if prop not in ok_top:
+            _err("unknown key '{}' in {}, expected one of {}"
+                 .format(prop, binding_path, ", ".join(ok_top)))
+
+    for pc in "parent", "child":
+        if pc in binding:
+            # Just 'bus:' is expected at the moment
+            if binding[pc].keys() != {"bus"}:
+                _err("expected (just) 'bus:' in '{}:' in {}"
+                     .format(pc, binding_path))
+
+            if not isinstance(binding[pc]["bus"], str):
+                _err("malformed '{}: bus:' value in {}, expected string"
+                     .format(pc, binding_path))
+
+    # Check properties
+
+    if "properties" not in binding:
+        return
+
+    ok_prop_keys = {"description", "type", "category", "constraint", "enum"}
+    ok_categories = {"required", "optional"}
+
+    for prop, keys in binding["properties"].items():
+        for key in keys:
+            if key not in ok_prop_keys:
+                _err("unknown setting '{}' in 'properties: {}: ...' in {}, "
+                     "expected one of {}".format(
+                         key, prop, binding_path, ", ".join(ok_prop_keys)))
+
+        if "category" in keys and keys["category"] not in ok_categories:
+            _err("unrecognized category '{}' for '{}' in 'properties' in {}, "
+                 "expected one of {}".format(
+                     keys["category"], prop, binding_path,
+                     ", ".join(ok_categories)))
+
+        if "description" in keys and not isinstance(keys["description"], str):
+            _err("missing, malformed, or empty 'description' for '{}' in "
+                 "'properties' in {}".format(prop, binding_path))
+
+
+def _translate(addr, node):
+    # Recursively translates 'addr' on 'node' to the address space(s) of its
+    # parent(s), by looking at 'ranges' properties. Returns the translated
+    # address.
+
+    if not node.parent or "ranges" not in node.parent.props:
+        # No translation
+        return addr
+
+    if not node.parent.props["ranges"].value:
+        # DT spec.: "If the property is defined with an <empty> value, it
+        # specifies that the parent and child address space is identical, and
+        # no address translation is required."
+        #
+        # Treat this the same as a 'range' that explicitly does a one-to-one
+        # mapping, as opposed to there not being any translation.
+        return _translate(addr, node.parent)
+
+    # Gives the size of each component in a translation 3-tuple in 'ranges'
+    child_address_cells = _address_cells(node)
+    parent_address_cells = _address_cells(node.parent)
+    child_size_cells = _size_cells(node)
+
+    # Number of cells for one translation 3-tuple in 'ranges'
+    entry_cells = child_address_cells + parent_address_cells + child_size_cells
+
+    for raw_range in _slice(node.parent, "ranges", 4*entry_cells):
+        child_addr = to_num(raw_range[:4*child_address_cells])
+        raw_range = raw_range[4*child_address_cells:]
+
+        parent_addr = to_num(raw_range[:4*parent_address_cells])
+        raw_range = raw_range[4*parent_address_cells:]
+
+        child_len = to_num(raw_range)
+
+        if child_addr <= addr < child_addr + child_len:
+            # 'addr' is within range of a translation in 'ranges'. Recursively
+            # translate it and return the result.
+            return _translate(parent_addr + addr - child_addr, node.parent)
+
+    # 'addr' is not within range of any translation in 'ranges'
+    return addr
+
+
+def _add_names(node, names_ident, objs):
+    # Helper for registering names from <foo>-names properties.
+    #
+    # node:
+    #   Device tree node
+    #
+    # names-ident:
+    #   name of property holding names, e.g. "reg-names"
+    #
+    # objs:
+    #   list of objects whose .name field should be set
+
+    if names_ident in node.props:
+        names = node.props[names_ident].to_strings()
+        if len(names) != len(objs):
+            _err("{} property in {} has {} strings, expected {} strings"
+                 .format(names_ident, node.name, len(names), len(objs)))
+
+        for obj, name in zip(objs, names):
+            obj.name = name
+    else:
+        for obj in objs:
+            obj.name = None
+
+
+def _interrupt_parent(node):
+    # Returns the node pointed at by the closest 'interrupt-parent', searching
+    # the parents of 'node'. As of writing, this behavior isn't specified in
+    # the DT spec., but seems to match what some .dts files except.
+
+    while node:
+        if "interrupt-parent" in node.props:
+            return node.props["interrupt-parent"].to_node()
+        node = node.parent
+
+    _err("{!r} has an 'interrupts' property, but neither the node nor any "
+         "of its parents has an 'interrupt-parent' property".format(node))
+
+
+def _interrupts(node):
+    # Returns a list of (<controller>, <specifier>) tuples, with one tuple per
+    # interrupt generated by 'node'. <controller> is the destination of the
+    # interrupt (possibly after mapping through an 'interrupt-map'), and
+    # <specifier> the data associated with the interrupt (as a 'bytes' object).
+
+    # Takes precedence over 'interrupts' if both are present
+    if "interrupts-extended" in node.props:
+        prop = node.props["interrupts-extended"]
+        return [_map_interrupt(node, iparent, spec)
+                for iparent, spec in _phandle_val_list(prop, _interrupt_cells)]
+
+    if "interrupts" in node.props:
+        # Treat 'interrupts' as a special case of 'interrupts-extended', with
+        # the same interrupt parent for all interrupts
+
+        iparent = _interrupt_parent(node)
+        interrupt_cells = _interrupt_cells(iparent)
+
+        return [_map_interrupt(node, iparent, raw)
+                for raw in _slice(node, "interrupts", 4*interrupt_cells)]
+
+    return []
+
+
+def _map_interrupt(child, parent, child_spec):
+    # Translates an interrupt headed from 'child' to 'parent' with specifier
+    # 'child_spec' through any 'interrupt-map' properties. Returns a
+    # (<controller>, <specifier>) tuple with the final destination after
+    # mapping.
+
+    if "interrupt-controller" in parent.props:
+        return (parent, child_spec)
+
+    def own_address_cells(node):
+        # Used for parents pointed at by 'interrupt-map'. We can't use
+        # _address_cells(), because it's the #address-cells property on 'node'
+        # itself that matters.
+
+        address_cells = node.props.get("#address-cells")
+        if not address_cells:
+            _err("missing #address-cells on {!r} (while handling interrupt-map)"
+                 .format(node))
+        return address_cells.to_num()
+
+    def spec_len_fn(node):
+        # Can't use _address_cells() here, because it's the #address-cells
+        # property on 'node' itself that matters
+        return 4*(own_address_cells(node) + _interrupt_cells(node))
+
+    parent, raw_spec = _map(
+        "interrupt", child, parent, _raw_unit_addr(child) + child_spec,
+        spec_len_fn)
+
+    # Strip the parent unit address part, if any
+    return (parent, raw_spec[4*own_address_cells(parent):])
+
+
+def _clocks(node):
+    # Returns a list of (<controller>, <specifier>) tuples for any 'clocks'
+    # property on 'node', or an empty list if 'node' has no 'clocks'.
+    # <controller> is a dtlib.Node.
+
+    if "clocks" not in node.props:
+        return []
+    return _phandle_val_list(node.props["clocks"], _clock_cells)
+
+
+def _pwms(node):
+    # Returns a list of (<controller>, <specifier>) tuples for any 'pwms'
+    # property on 'node', or an empty list if 'node' has no 'pwms'.
+    # <controller> is a dtlib.Node.
+
+    if "pwms" not in node.props:
+        return []
+    return _phandle_val_list(node.props["pwms"], _pwm_cells)
+
+
+def _gpios(node):
+    # Returns a dictionary that maps '<prefix>-gpios' prefixes to lists of
+    # (<controller>, <specifier>) tuples (possibly after mapping through an
+    # gpio-map). <controller> is a dtlib.Node.
+
+    res = {}
+
+    for name, prop in node.props.items():
+        if name.endswith("gpios"):
+            # Get the prefix from the property name:
+            #   - gpios     -> "" (deprecated, should have a prefix)
+            #   - foo-gpios -> "foo"
+            #   - etc.
+            prefix = name[:-5]
+            if prefix.endswith("-"):
+                prefix = prefix[:-1]
+
+            res[prefix] = [
+                _map_gpio(prop.node, controller, spec)
+                for controller, spec in _phandle_val_list(prop, _gpio_cells)
+            ]
+
+    return res
+
+
+def _map_gpio(child, parent, child_spec):
+    # Returns a (<controller>, <specifier>) tuple with the final destination
+    # after mapping through any 'gpio-map' properties. See _map_interrupt().
+
+    if "gpio-map" not in parent.props:
+        return (parent, child_spec)
+
+    return _map("gpio", child, parent, child_spec,
+                lambda node: 4*_gpio_cells(node))
+
+
+def _map(prefix, child, parent, child_spec, spec_len_fn):
+    # Common code for mapping through <prefix>-map properties, e.g.
+    # interrupt-map and gpio-map.
+    #
+    # prefix:
+    #   The prefix, e.g. "interrupt" or "gpio"
+    #
+    # child:
+    #   The "sender", e.g. the node with 'interrupts = <...>'
+    #
+    # parent:
+    #   The "receiver", e.g. a node with 'interrupt-map = <...>' or
+    #   'interrupt-controller' (no mapping)
+    #
+    # child_spec:
+    #   The data associated with the interrupt/GPIO/etc., as a 'bytes' object,
+    #   e.g. <1 2> for 'foo-gpios = <&gpio1 1 2>'.
+    #
+    # spec_len_fn:
+    #   Function called on a parent specified in a *-map property to get its
+    #   *-cells value, e.g. #interrupt-cells
+
+    map_prop = parent.props.get(prefix + "-map")
+    if not map_prop:
+        if prefix + "-controller" not in parent.props:
+            _err("expected '{}-controller' property on {!r} "
+                 "(referenced by {!r})".format(prefix, parent, child))
+
+        # No mapping
+        return (parent, child_spec)
+
+    masked_child_spec = _mask(prefix, child, parent, child_spec)
+
+    raw = map_prop.value
+    while raw:
+        if len(raw) < len(child_spec):
+            _err("bad value for {!r}, missing/truncated child specifier"
+                 .format(map_prop))
+        child_spec_entry = raw[:len(child_spec)]
+        raw = raw[len(child_spec):]
+
+        if len(raw) < 4:
+            _err("bad value for {!r}, missing/truncated phandle"
+                 .format(map_prop))
+        phandle = to_num(raw[:4])
+        raw = raw[4:]
+
+        # Parent specified in *-map
+        map_parent = parent.dt.phandle2node.get(phandle)
+        if not map_parent:
+            _err("bad phandle in " + repr(map_prop))
+
+        map_parent_spec_len = spec_len_fn(map_parent)
+        if len(raw) < map_parent_spec_len:
+            _err("bad value for {!r}, missing/truncated parent specifier"
+                 .format(map_prop))
+        parent_spec = raw[:map_parent_spec_len]
+        raw = raw[map_parent_spec_len:]
+
+        # Got one *-map row. Check if it matches the child specifier.
+        if child_spec_entry == masked_child_spec:
+            # Handle *-map-pass-thru
+            parent_spec = _pass_thru(
+                prefix, child, parent, child_spec, parent_spec)
+
+            # Found match. Recursively map and return it.
+            return _map(prefix, parent, map_parent, parent_spec, spec_len_fn)
+
+    _err("child specifier for {!r} ({}) does not appear in {!r}"
+         .format(child, child_spec, map_prop))
+
+
+def _mask(prefix, child, parent, child_spec):
+    # Common code for handling <prefix>-mask properties, e.g. interrupt-mask.
+    # See _map() for the parameters.
+
+    mask_prop = parent.props.get(prefix + "-map-mask")
+    if not mask_prop:
+        # No mask
+        return child_spec
+
+    mask = mask_prop.value
+    if len(mask) != len(child_spec):
+        _err("{!r}: expected '{}-mask' in {!r} to be {} bytes, is {} bytes"
+             .format(child, prefix, parent, len(child_spec), len(mask)))
+
+    return _and(child_spec, mask)
+
+
+def _pass_thru(prefix, child, parent, child_spec, parent_spec):
+    # Common code for handling <prefix>-map-thru properties, e.g.
+    # interrupt-pass-thru.
+    #
+    # parent_spec:
+    #   The parent specifier from the matched entry in the <prefix>-map
+    #   property
+    #
+    # See _map() for the other parameters.
+
+    pass_thru_prop = parent.props.get(prefix + "-map-pass-thru")
+    if not pass_thru_prop:
+        # No pass-thru
+        return parent_spec
+
+    pass_thru = pass_thru_prop.value
+    if len(pass_thru) != len(child_spec):
+        _err("{!r}: expected '{}-map-pass-thru' in {!r} to be {} bytes, is {} bytes"
+             .format(child, prefix, parent, len(child_spec), len(pass_thru)))
+
+    res = _or(_and(child_spec, pass_thru),
+              _and(parent_spec, _not(pass_thru)))
+
+    # Truncate to length of parent spec.
+    return res[-len(parent_spec):]
+
+
+def _raw_unit_addr(node):
+    # _map_interrupt() helper. Returns the unit address (derived from 'reg' and
+    # #address-cells) as a raw 'bytes'
+
+    if 'reg' not in node.props:
+        _err("{!r} lacks 'reg' property (needed for 'interrupt-map' unit "
+             "address lookup)".format(node))
+
+    addr_len = 4*_address_cells(node)
+
+    if len(node.props['reg'].value) < addr_len:
+        _err("{!r} has too short 'reg' property (while doing 'interrupt-map' "
+             "unit address lookup)".format(node))
+
+    return node.props['reg'].value[:addr_len]
+
+
+def _and(b1, b2):
+    # Returns the bitwise AND of the two 'bytes' objects b1 and b2. Pads
+    # with ones on the left if the lengths are not equal.
+
+    # Pad on the left, to equal length
+    maxlen = max(len(b1), len(b2))
+    return bytes(x & y for x, y in zip(b1.rjust(maxlen, b'\xff'),
+                                       b2.rjust(maxlen, b'\xff')))
+
+
+def _or(b1, b2):
+    # Returns the bitwise OR of the two 'bytes' objects b1 and b2. Pads with
+    # zeros on the left if the lengths are not equal.
+
+    # Pad on the left, to equal length
+    maxlen = max(len(b1), len(b2))
+    return bytes(x | y for x, y in zip(b1.rjust(maxlen, b'\x00'),
+                                       b2.rjust(maxlen, b'\x00')))
+
+
+def _not(b):
+    # Returns the bitwise not of the 'bytes' object 'b'
+
+    # ANDing with 0xFF avoids negative numbers
+    return bytes(~x & 0xFF for x in b)
+
+
+def _phandle_val_list(prop, n_cells_fn):
+    # Parses a '<phandle> <value> <phandle> <value> ...' value
+    #
+    # prop:
+    #   dtlib.Property with value to parse
+    #
+    # cells_fn:
+    #   A function that returns the number of cells for a <value>. Takes the
+    #   node pointed at by the preceding <phandle> as its argument.
+    #
+    # Returns a list of (<node>, <value>) tuples, where <node> is the node
+    # pointed at by <phandle>. 'cells_fn' is a function called on <node> to get
+    # the number of cells for <value>.
+
+    res = []
+
+    raw = prop.value
+    while raw:
+        if len(raw) < 4:
+            # Not enough room for phandle
+            _err("bad value for " + repr(prop))
+        phandle = to_num(raw[:4])
+        raw = raw[4:]
+
+        node = prop.node.dt.phandle2node.get(phandle)
+        if not node:
+            _err("bad phandle in " + repr(prop))
+
+        n_cells = n_cells_fn(node)
+        if len(raw) < 4*n_cells:
+            _err("missing data after phandle in " + repr(prop))
+
+        res.append((node, raw[:4*n_cells]))
+        raw = raw[4*n_cells:]
+
+    return res
+
+
+def _address_cells(node):
+    # Returns the #address-cells setting for 'node', giving the number of <u32>
+    # cells used to encode the address in the 'reg' property
+
+    if "#address-cells" in node.parent.props:
+        return node.parent.props["#address-cells"].to_num()
+    return 2  # Default value per DT spec.
+
+
+def _size_cells(node):
+    # Returns the #size-cells setting for 'node', giving the number of <u32>
+    # cells used to encode the size in the 'reg' property
+
+    if "#size-cells" in node.parent.props:
+        return node.parent.props["#size-cells"].to_num()
+    return 1  # Default value per DT spec.
+
+
+def _interrupt_cells(node):
+    # Returns the #interrupt-cells property value on 'node', erroring out if
+    # 'node' has no #interrupt-cells property
+
+    if "#interrupt-cells" not in node.props:
+        _err("{!r} lacks #interrupt-cells".format(node))
+    return node.props["#interrupt-cells"].to_num()
+
+
+def _gpio_cells(node):
+    if "#gpio-cells" not in node.props:
+        _err("{!r} lacks #gpio-cells".format(node))
+    return node.props["#gpio-cells"].to_num()
+
+
+def _pwm_cells(node):
+    if "#pwm-cells" not in node.props:
+        _err("{!r} lacks #pwm-cells".format(node))
+    return node.props["#pwm-cells"].to_num()
+
+
+def _clock_cells(node):
+    if "#clock-cells" not in node.props:
+        _err("{!r} lacks #clock-cells".format(node))
+    return node.props["#clock-cells"].to_num()
+
+
+def _slice(node, prop_name, size):
+    # Splits node.props[prop_name].value into 'size'-sized chunks, returning a
+    # list of chunks. Raises EDTError if the length of the property is not
+    # evenly divisible by 'size'.
+
+    raw = node.props[prop_name].value
+    if len(raw) % size:
+        _err("'{}' property in {!r} has length {}, which is not evenly "
+             "divisible by {}".format(prop_name, node, len(raw), size))
+
+    return [raw[i:i + size] for i in range(0, len(raw), size)]
+
+
+def _err(msg):
+    raise EDTError(msg)
+
+
+def _warn(msg):
+    print("warning: " + msg, file=sys.stderr)
diff --git a/scripts/dts/gen_defines.py b/scripts/dts/gen_defines.py
new file mode 100755
index 00000000000..720c2976157
--- /dev/null
+++ b/scripts/dts/gen_defines.py
@@ -0,0 +1,619 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Nordic Semiconductor ASA
+# Copyright (c) 2019 Linaro Limited
+# SPDX-License-Identifier: BSD-3-Clause
+
+# This script uses edtlib to generate a header file and a .conf file (both
+# containing the same values) from a device tree (.dts) file. Information from
+# binding files in YAML format is used as well.
+#
+# Bindings are files that describe device tree nodes. Device tree nodes are
+# usually mapped to bindings via their 'compatible = "..."' property.
+#
+# See the docstring/comments at the top of edtlib.py for more information.
+#
+# Note: Do not access private (_-prefixed) identifiers from edtlib here (and
+# also note that edtlib is not meant to expose the dtlib API directly).
+# Instead, think of what API you need, and add it as a public documented API in
+# edtlib. This will keep this script simple.
+
+import argparse
+import sys
+
+import edtlib
+
+
+def main():
+    global conf_file
+    global header_file
+
+    args = parse_args()
+
+    try:
+        edt = edtlib.EDT(args.dts, args.bindings_dir)
+    except edtlib.EDTError as e:
+        sys.exit("device tree error: " + str(e))
+
+    conf_file = open(args.conf_out, "w", encoding="utf-8")
+    header_file = open(args.header_out, "w", encoding="utf-8")
+
+    out_comment("Generated by gen_defines.py", blank_before=False)
+    out_comment("DTS input file: " + args.dts, blank_before=False)
+    out_comment("Directory with bindings: " + args.bindings_dir,
+                blank_before=False)
+
+    active_compats = set()
+
+    for dev in edt.devices:
+        if dev.enabled and dev.matching_compat:
+            # Skip 'fixed-partitions' devices since they are handled by
+            # write_flash() and would generate extra spurious #defines
+            if dev.matching_compat == "fixed-partitions":
+                continue
+
+            out_comment("Device tree node: " + dev.path)
+            out_comment("Binding (compatible = {}): {}".format(
+                            dev.matching_compat, dev.binding_path),
+                        blank_before=False)
+            out_comment("Binding description: " + dev.description,
+                        blank_before=False)
+
+            write_regs(dev)
+            write_irqs(dev)
+            write_gpios(dev)
+            write_pwms(dev)
+            write_clocks(dev)
+            write_spi_dev(dev)
+            write_props(dev)
+            write_bus(dev)
+            write_existence_flags(dev)
+
+            active_compats.update(dev.compats)
+
+    out_comment("Active compatibles (mentioned in DTS + binding found)")
+    for compat in active_compats:
+        #define DT_COMPAT_<COMPAT> 1
+        out("COMPAT_{}".format(str2ident(compat)), 1)
+
+    # These are derived from /chosen
+    write_addr_size(edt, "zephyr,sram", "SRAM")
+    write_addr_size(edt, "zephyr,ccm", "CCM")
+    write_addr_size(edt, "zephyr,dtcm", "DTCM")
+
+    # NOTE: These defines aren't used by the code and just used by
+    # the kconfig build system, we can remove them in the future
+    # if we provide a function in kconfigfunctions.py to get
+    # the same info
+    write_required_label("UART_CONSOLE_ON_DEV_NAME", edt.chosen_dev("zephyr,console"))
+    write_required_label("UART_SHELL_ON_DEV_NAME",   edt.chosen_dev("zephyr,shell-uart"))
+    write_required_label("BT_UART_ON_DEV_NAME",      edt.chosen_dev("zephyr,bt-uart"))
+    write_required_label("UART_PIPE_ON_DEV_NAME",    edt.chosen_dev("zephyr,uart-pipe"))
+    write_required_label("BT_MONITOR_ON_DEV_NAME",   edt.chosen_dev("zephyr,bt-mon-uart"))
+    write_required_label("UART_MCUMGR_ON_DEV_NAME",  edt.chosen_dev("zephyr,uart-mcumgr"))
+    write_required_label("BT_C2H_UART_ON_DEV_NAME",  edt.chosen_dev("zephyr,bt-c2h-uart"))
+
+    write_flash(edt.chosen_dev("zephyr,flash"))
+    write_code_partition(edt.chosen_dev("zephyr,code-partition"))
+
+    flash_index = 0
+    for dev in edt.devices:
+        if dev.name.startswith("partition@"):
+            write_flash_partition(dev, flash_index)
+            flash_index += 1
+
+    out_comment("Number of flash partitions")
+    if flash_index != 0:
+        out("FLASH_AREA_NUM", flash_index)
+
+    print("Device tree configuration written to " + args.conf_out)
+
+
+def parse_args():
+    # Returns parsed command-line arguments
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dts", required=True, help="DTS file")
+    parser.add_argument("--bindings-dir", required=True,
+                        help="directory with bindings in YAML format")
+    parser.add_argument("--header-out", required=True,
+                        help="path to write header to")
+    parser.add_argument("--conf-out", required=True,
+                        help="path to write configuration file to")
+
+    return parser.parse_args()
+
+
+def write_regs(dev):
+    # Writes address/size output for the registers in dev's 'reg' property
+
+    def reg_addr_name_alias(reg):
+        return str2ident(reg.name) + "_BASE_ADDRESS" if reg.name else None
+
+    def reg_size_name_alias(reg):
+        return str2ident(reg.name) + "_SIZE" if reg.name else None
+
+    for reg in dev.regs:
+        out_dev(dev, reg_addr_ident(reg), hex(reg.addr),
+                name_alias=reg_addr_name_alias(reg))
+
+        if reg.size:
+            out_dev(dev, reg_size_ident(reg), reg.size,
+                    name_alias=reg_size_name_alias(reg))
+
+
+def write_props(dev):
+    # Writes any properties defined in the "properties" section of the binding
+    # for the device
+
+    for prop in dev.props.values():
+        # Skip #size-cell and other property starting with #. Also skip mapping
+        # properties like 'gpio-map'.
+        if prop.name[0] == "#" or prop.name.endswith("-map"):
+            continue
+
+        # Skip properties that we handle elsewhere
+        if prop.name in {"reg", "interrupts", "pwms", "clocks", "compatible"} or \
+           prop.name.endswith("gpios"):
+            continue
+
+        if prop.description is not None:
+            out_comment(prop.description, blank_before=False)
+
+        ident = str2ident(prop.name)
+
+        if isinstance(prop.val, bool):
+            out_dev(dev, ident, 1 if prop.val else 0)
+        elif isinstance(prop.val, str):
+            out_dev_s(dev, ident, prop.val)
+        elif isinstance(prop.val, int):
+            out_dev(dev, ident, prop.val)
+        elif isinstance(prop.val, list):
+            for i, elm in enumerate(prop.val):
+                out_fn = out_dev_s if isinstance(elm, str) else out_dev
+                out_fn(dev, "{}_{}".format(ident, i), elm)
+        elif isinstance(prop.val, bytes):
+            out_dev(dev, ident,
+                    "{ " + ", ".join("0x{:02x}".format(b) for b in prop.val) + " }")
+
+        # Generate DT_..._ENUM if there's an 'enum:' key in the binding
+        if prop.enum_index is not None:
+            out_dev(dev, ident + "_ENUM", prop.enum_index)
+
+
+def write_bus(dev):
+    # Generate bus-related #defines
+
+    if not dev.bus:
+        return
+
+    if dev.parent.label is None:
+        _err("missing 'label' property on {!r}".format(dev.parent))
+
+    # #define DT_<DEV-IDENT>_BUS_NAME <BUS-LABEL>
+    out_dev_s(dev, "BUS_NAME", str2ident(dev.parent.label))
+
+    for compat in dev.compats:
+        # #define DT_<COMPAT>_BUS_<BUS-TYPE> 1
+        out("{}_BUS_{}".format(str2ident(compat), str2ident(dev.bus)), 1)
+
+
+def write_existence_flags(dev):
+    # Generate #defines of the form
+    #
+    #   #define DT_<COMPAT>_<INSTANCE> 1
+    #
+    # These are flags for which devices exist.
+
+    for compat in dev.compats:
+        out("{}_{}".format(str2ident(compat), dev.instance_no[compat]), 1)
+
+
+def reg_addr_ident(reg):
+    # Returns the identifier (e.g., macro name) to be used for the address of
+    # 'reg' in the output
+
+    dev = reg.dev
+
+    # NOTE: to maintain compat wit the old script we special case if there's
+    # only a single register (we drop the '_0').
+    if len(dev.regs) > 1:
+        return "BASE_ADDRESS_{}".format(dev.regs.index(reg))
+    else:
+        return "BASE_ADDRESS"
+
+
+def reg_size_ident(reg):
+    # Returns the identifier (e.g., macro name) to be used for the size of
+    # 'reg' in the output
+
+    dev = reg.dev
+
+    # NOTE: to maintain compat wit the old script we special case if there's
+    # only a single register (we drop the '_0').
+    if len(dev.regs) > 1:
+        return "SIZE_{}".format(dev.regs.index(reg))
+    else:
+        return "SIZE"
+
+
+def dev_ident(dev):
+    # Returns an identifier for the Device 'dev'. Used when building e.g. macro
+    # names.
+
+    # TODO: Handle PWM on STM
+    # TODO: Better document the rules of how we generate things
+
+    ident = ""
+
+    if dev.bus:
+        ident += "{}_{:X}_".format(
+            str2ident(dev.parent.matching_compat), dev.parent.unit_addr)
+
+    ident += "{}_".format(str2ident(dev.matching_compat))
+
+    if dev.unit_addr is not None:
+        ident += "{:X}".format(dev.unit_addr)
+    elif dev.parent.unit_addr is not None:
+        ident += "{:X}_{}".format(dev.parent.unit_addr, str2ident(dev.name))
+    else:
+        # This is a bit of a hack
+        ident += "{}".format(str2ident(dev.name))
+
+    return ident
+
+
+def dev_aliases(dev):
+    # Returns a list of aliases for the Device 'dev', used e.g. when building
+    # macro names
+
+    return dev_path_aliases(dev) + dev_instance_aliases(dev)
+
+
+def dev_path_aliases(dev):
+    # Returns a list of aliases for the Device 'dev', based on the aliases
+    # registered for the device, in the /aliases node. Used when building e.g.
+    # macro names.
+
+    if dev.matching_compat is None:
+        return []
+
+    compat_s = str2ident(dev.matching_compat)
+
+    aliases = []
+    for alias in dev.aliases:
+        aliases.append("ALIAS_{}".format(str2ident(alias)))
+        # TODO: See if we can remove or deprecate this form
+        aliases.append("{}_{}".format(compat_s, str2ident(alias)))
+
+    return aliases
+
+
+def dev_instance_aliases(dev):
+    # Returns a list of aliases for the Device 'dev', based on the instance
+    # number of the device (based on how many instances of that particular
+    # device there are).
+    #
+    # This is a list since a device can have multiple 'compatible' strings,
+    # each with their own instance number.
+
+    return ["INST_{}_{}".format(dev.instance_no[compat], str2ident(compat))
+            for compat in dev.compats]
+
+
+def write_addr_size(edt, prop_name, prefix):
+    # Writes <prefix>_BASE_ADDRESS and <prefix>_SIZE for the device
+    # pointed at by the /chosen property named 'prop_name', if it exists
+
+    dev = edt.chosen_dev(prop_name)
+    if not dev:
+        return
+
+    if not dev.regs:
+        err("missing 'reg' property in node pointed at by /chosen/{} ({!r})"
+            .format(prop_name, dev))
+
+    out_comment("/chosen/{} ({})".format(prop_name, dev.path))
+    out("{}_BASE_ADDRESS".format(prefix), hex(dev.regs[0].addr))
+    out("{}_SIZE".format(prefix), dev.regs[0].size//1024)
+
+
+def write_flash(flash_dev):
+    # Writes output for the node pointed at by the zephyr,flash property in
+    # /chosen
+
+    out_comment("/chosen/zephyr,flash ({})"
+                .format(flash_dev.path if flash_dev else "missing"))
+
+    if not flash_dev:
+        # No flash device. Write dummy values.
+        out("FLASH_BASE_ADDRESS", 0)
+        out("FLASH_SIZE", 0)
+        return
+
+    if len(flash_dev.regs) != 1:
+        err("expected zephyr,flash to have a single register, has {}"
+            .format(len(flash_dev.regs)))
+
+    if flash_dev.bus == "spi" and len(flash_dev.parent.regs) == 2:
+        reg = flash_dev.parent.regs[1]  # QSPI flash
+    else:
+        reg = flash_dev.regs[0]
+
+    out("FLASH_BASE_ADDRESS", hex(reg.addr))
+    if reg.size:
+        out("FLASH_SIZE", reg.size//1024)
+
+    if "erase-block-size" in flash_dev.props:
+        out("FLASH_ERASE_BLOCK_SIZE", flash_dev.props["erase-block-size"].val)
+
+    if "write-block-size" in flash_dev.props:
+        out("FLASH_WRITE_BLOCK_SIZE", flash_dev.props["write-block-size"].val)
+
+
+def write_code_partition(code_dev):
+    # Writes output for the node pointed at by the zephyr,code-partition
+    # property in /chosen
+
+    out_comment("/chosen/zephyr,code-partition ({})"
+                .format(code_dev.path if code_dev else "missing"))
+
+    if not code_dev:
+        # No code partition. Write dummy values.
+        out("CODE_PARTITION_OFFSET", 0)
+        out("CODE_PARTITION_SIZE", 0)
+        return
+
+    if not code_dev.regs:
+        err("missing 'regs' property on {!r}".format(code_dev))
+
+    out("CODE_PARTITION_OFFSET", code_dev.regs[0].addr)
+    out("CODE_PARTITION_SIZE", code_dev.regs[0].size)
+
+
+def write_flash_partition(partition_dev, index):
+    out_comment("Flash partition at " + partition_dev.path)
+
+    if partition_dev.label is None:
+        err("missing 'label' property on {!r}".format(partition_dev))
+
+    # Generate label-based identifiers
+    write_flash_partition_prefix(
+        "FLASH_AREA_" + str2ident(partition_dev.label), partition_dev, index)
+
+    # Generate index-based identifiers
+    write_flash_partition_prefix(
+        "FLASH_AREA_{}".format(index), partition_dev, index)
+
+
+def write_flash_partition_prefix(prefix, partition_dev, index):
+    # write_flash_partition() helper. Generates identifiers starting with
+    # 'prefix'.
+
+    out("{}_ID".format(prefix), index)
+
+    out("{}_READ_ONLY".format(prefix), 1 if partition_dev.read_only else 0)
+
+    for i, reg in enumerate(partition_dev.regs):
+        # Also add aliases that point to the first sector (TODO: get rid of the
+        # aliases?)
+        out("{}_OFFSET_{}".format(prefix, i), reg.addr,
+            aliases=["{}_OFFSET".format(prefix)] if i == 0 else [])
+        out("{}_SIZE_{}".format(prefix, i), reg.size,
+            aliases=["{}_SIZE".format(prefix)] if i == 0 else [])
+
+    controller = partition_dev.flash_controller
+    if controller.label is not None:
+        out_s("{}_DEV".format(prefix), controller.label)
+
+
+def write_required_label(ident, dev):
+    # Helper function. Writes '#define <ident> "<label>"', where <label>
+    # is the value of the 'label' property from 'dev'. Does nothing if
+    # 'dev' is None.
+    #
+    # Errors out if 'dev' exists but has no label.
+
+    if not dev:
+        return
+
+    if dev.label is None:
+        err("missing 'label' property on {!r}".format(dev))
+
+    out_s(ident, dev.label)
+
+
+def write_irqs(dev):
+    # Writes IRQ num and data for the interrupts in dev's 'interrupt' property
+
+    def irq_name_alias(irq, cell_name):
+        if not irq.name:
+            return None
+
+        alias = "IRQ_{}".format(str2ident(irq.name))
+        if cell_name != "irq":
+            alias += "_" + str2ident(cell_name)
+        return alias
+
+    for irq_i, irq in enumerate(dev.interrupts):
+        # We ignore the controller for now
+        for cell_name, cell_value in irq.specifier.items():
+            ident = "IRQ_{}".format(irq_i)
+            if cell_name != "irq":
+                ident += "_" + str2ident(cell_name)
+
+            out_dev(dev, ident, cell_value,
+                    name_alias=irq_name_alias(irq, cell_name))
+
+
+def write_gpios(dev):
+    # Writes GPIO controller data for the gpios in dev's 'gpios' property
+
+    for gpios in dev.gpios.values():
+        for gpio_i, gpio in enumerate(gpios):
+            write_gpio(dev, gpio, gpio_i if len(gpios) > 1 else None)
+
+
+def write_gpio(dev, gpio, index=None):
+    # Writes GPIO controller & data for the GPIO object 'gpio'. If 'index' is
+    # not None, it is added as a suffix to identifiers.
+
+    ctrl_ident = "GPIOS_CONTROLLER"
+    if gpio.name:
+        ctrl_ident = str2ident(gpio.name) + "_" + ctrl_ident
+    if index is not None:
+        ctrl_ident += "_{}".format(index)
+
+    out_dev_s(dev, ctrl_ident, gpio.controller.label)
+
+    for cell, val in gpio.specifier.items():
+        cell_ident = "GPIOS_" + str2ident(cell)
+        if gpio.name:
+            cell_ident = str2ident(gpio.name) + "_" + cell_ident
+        if index is not None:
+            cell_ident += "_{}".format(index)
+
+        out_dev(dev, cell_ident, val)
+
+
+def write_spi_dev(dev):
+    # Writes SPI device GPIO chip select data if there is any
+
+    cs_gpio = edtlib.spi_dev_cs_gpio(dev)
+    if cs_gpio is not None:
+        write_gpio(dev, cs_gpio)
+
+
+def write_pwms(dev):
+    # Writes PWM controller and specifier info for the PWMs in dev's 'pwms'
+    # property
+
+    for pwm in dev.pwms:
+        if pwm.controller.label is not None:
+            out_dev_s(dev, "PWMS_CONTROLLER", pwm.controller.label)
+
+        for spec, val in pwm.specifier.items():
+            out_dev(dev, "PWMS_" + str2ident(spec), val)
+
+
+def write_clocks(dev):
+    # Writes clock controller and specifier info for the clock in dev's 'clock'
+    # property
+
+    for clock_i, clock in enumerate(dev.clocks):
+        if clock.controller.label is not None:
+            out_dev_s(dev, "CLOCK_CONTROLLER", clock.controller.label)
+
+        if clock.frequency is not None:
+            out_dev(dev, "CLOCKS_CLOCK_FREQUENCY", clock.frequency)
+
+        for spec, val in clock.specifier.items():
+            if clock_i == 0:
+                clk_name_alias = "CLOCK_" + str2ident(spec)
+            else:
+                clk_name_alias = None
+
+            out_dev(dev, "CLOCK_{}_{}".format(str2ident(spec), clock_i), val,
+                    name_alias=clk_name_alias)
+
+
+def str2ident(s):
+    # Converts 's' to a form suitable for (part of) an identifier
+
+    return s.replace("-", "_") \
+            .replace(",", "_") \
+            .replace("@", "_") \
+            .replace("/", "_") \
+            .replace("+", "PLUS") \
+            .upper()
+
+
+def out_dev(dev, ident, val, name_alias=None):
+    # Writes an
+    #
+    #   <device prefix>_<ident> = <val>
+    #
+    # assignment, along with a set of
+    #
+    #   <device alias>_<ident>
+    #
+    # aliases, for each device alias. If 'name_alias' (a string) is passed,
+    # then these additional aliases are generated:
+    #
+    #   <device prefix>_<name alias>
+    #   <device alias>_<name alias> (for each device alias)
+    #
+    # 'name_alias' is used for reg-names and the like.
+
+    dev_prefix = dev_ident(dev)
+
+    aliases = [alias + "_" + ident for alias in dev_aliases(dev)]
+    if name_alias is not None:
+        aliases.append(dev_prefix + "_" + name_alias)
+        aliases += [alias + "_" + name_alias for alias in dev_aliases(dev)]
+
+    out(dev_prefix + "_" + ident, val, aliases)
+
+
+def out_dev_s(dev, ident, s):
+    # Like out_dev(), but puts quotes around 's' and escapes any double quotes
+    # and backslashes within it
+
+    # \ must be escaped before " to avoid double escaping
+    out_dev(dev, ident, '"{}"'.format(escape(s)))
+
+
+def out_s(ident, val):
+    # Like out(), but puts quotes around 's' and escapes any double quotes and
+    # backslashes within it
+
+    out(ident, '"{}"'.format(escape(val)))
+
+
+def out(ident, val, aliases=()):
+    # Writes '#define <ident> <val>' to the header and '<ident>=<val>' to the
+    # the configuration file.
+    #
+    # Also writes any aliases listed in 'aliases' (an iterable). For the
+    # header, these look like '#define <alias> <ident>'. For the configuration
+    # file, the value is just repeated as '<alias>=<val>' for each alias.
+
+    print("#define DT_{:40} {}".format(ident, val), file=header_file)
+    print("DT_{}={}".format(ident, val), file=conf_file)
+
+    for alias in aliases:
+        if alias != ident:
+            print("#define DT_{:40} DT_{}".format(alias, ident),
+                  file=header_file)
+            # For the configuration file, the value is just repeated for all
+            # the aliases
+            print("DT_{}={}".format(alias, val), file=conf_file)
+
+
+def out_comment(s, blank_before=True):
+    # Writes 's' as a comment to the header and configuration file. 's' is
+    # allowed to have multiple lines. blank_before=True adds a blank line
+    # before the comment.
+
+    if blank_before:
+        print(file=header_file)
+        print(file=conf_file)
+
+    # Double-space in header for readability
+    print("/*  " + s + "  */", file=header_file)
+    print("\n".join("# " + line for line in s.splitlines()), file=conf_file)
+
+
+def escape(s):
+    # Backslash-escapes any double quotes and backslashes in 's'
+
+    # \ must be escaped before " to avoid double escaping
+    return s.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def err(s):
+    raise Exception(s)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/dts/test-bindings/child.yaml b/scripts/dts/test-bindings/child.yaml
new file mode 100644
index 00000000000..34f982973e0
--- /dev/null
+++ b/scripts/dts/test-bindings/child.yaml
@@ -0,0 +1,14 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Child binding
+description: Child binding
+
+inherits:
+    !include grandchild.yaml
+
+properties:
+    bar:
+        category: required
+        type: int
diff --git a/scripts/dts/test-bindings/clock-1-cell.yaml b/scripts/dts/test-bindings/clock-1-cell.yaml
new file mode 100644
index 00000000000..0bc80a951ab
--- /dev/null
+++ b/scripts/dts/test-bindings/clock-1-cell.yaml
@@ -0,0 +1,14 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Clock source with one cell
+description: Clock source with one cell
+
+properties:
+    compatible:
+        constraint: "clock-one-cell"
+        type: string-array
+
+"#cells":
+  - one
diff --git a/scripts/dts/test-bindings/clock-2-cell.yaml b/scripts/dts/test-bindings/clock-2-cell.yaml
new file mode 100644
index 00000000000..88bffcae479
--- /dev/null
+++ b/scripts/dts/test-bindings/clock-2-cell.yaml
@@ -0,0 +1,15 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Clock source with two cells
+description: Clock source with two cells
+
+properties:
+    compatible:
+        constraint: "clock-two-cell"
+        type: string-array
+
+"#cells":
+  - one
+  - two
diff --git a/scripts/dts/test-bindings/fixed-clock.yaml b/scripts/dts/test-bindings/fixed-clock.yaml
new file mode 100644
index 00000000000..ce6d6bdbf21
--- /dev/null
+++ b/scripts/dts/test-bindings/fixed-clock.yaml
@@ -0,0 +1,14 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Fixed clock
+description: Fixed clock
+
+properties:
+    compatible:
+        constraint: "fixed-clock"
+        type: string-array
+
+    clock-frequency:
+        type: int
diff --git a/scripts/dts/test-bindings/gpio-1-cell.yaml b/scripts/dts/test-bindings/gpio-1-cell.yaml
new file mode 100644
index 00000000000..0bbe1f257f4
--- /dev/null
+++ b/scripts/dts/test-bindings/gpio-1-cell.yaml
@@ -0,0 +1,14 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: GPIO controller with one cell
+description: GPIO controller with one cell
+
+properties:
+    compatible:
+        constraint: "gpio-one-cell"
+        type: string-array
+
+"#cells":
+  - one
diff --git a/scripts/dts/test-bindings/gpio-2-cell.yaml b/scripts/dts/test-bindings/gpio-2-cell.yaml
new file mode 100644
index 00000000000..c4a7cff5a1b
--- /dev/null
+++ b/scripts/dts/test-bindings/gpio-2-cell.yaml
@@ -0,0 +1,15 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: GPIO controller with two cells
+description: GPIO controller with two cells
+
+properties:
+    compatible:
+        constraint: "gpio-two-cell"
+        type: string-array
+
+"#cells":
+  - one
+  - two
diff --git a/scripts/dts/test-bindings/grandchild.yaml b/scripts/dts/test-bindings/grandchild.yaml
new file mode 100644
index 00000000000..f037a5fb464
--- /dev/null
+++ b/scripts/dts/test-bindings/grandchild.yaml
@@ -0,0 +1,15 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Grandchild binding
+description: Grandchild binding
+
+properties:
+    foo:
+        category: optional
+        type: int
+
+    baz:
+        category: required
+        type: int
diff --git a/scripts/dts/test-bindings/interrupt-1-cell.yaml b/scripts/dts/test-bindings/interrupt-1-cell.yaml
new file mode 100644
index 00000000000..2100339e194
--- /dev/null
+++ b/scripts/dts/test-bindings/interrupt-1-cell.yaml
@@ -0,0 +1,14 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Interrupt controller with one cell
+description: Interrupt controller with one cell
+
+properties:
+    compatible:
+        constraint: "interrupt-one-cell"
+        type: string-array
+
+"#cells":
+  - one
diff --git a/scripts/dts/test-bindings/interrupt-2-cell.yaml b/scripts/dts/test-bindings/interrupt-2-cell.yaml
new file mode 100644
index 00000000000..5f475320899
--- /dev/null
+++ b/scripts/dts/test-bindings/interrupt-2-cell.yaml
@@ -0,0 +1,15 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Interrupt controller with two cells
+description: Interrupt controller with two cells
+
+properties:
+    compatible:
+        constraint: "interrupt-two-cell"
+        type: string-array
+
+"#cells":
+  - one
+  - two
diff --git a/scripts/dts/test-bindings/interrupt-3-cell.yaml b/scripts/dts/test-bindings/interrupt-3-cell.yaml
new file mode 100644
index 00000000000..356535198fe
--- /dev/null
+++ b/scripts/dts/test-bindings/interrupt-3-cell.yaml
@@ -0,0 +1,16 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Interrupt controller with three cells
+description: Interrupt controller with three cells
+
+properties:
+    compatible:
+        constraint: "interrupt-three-cell"
+        type: string-array
+
+"#cells":
+  - one
+  - two
+  - three
diff --git a/scripts/dts/test-bindings/parent.yaml b/scripts/dts/test-bindings/parent.yaml
new file mode 100644
index 00000000000..cfaec0e1e1a
--- /dev/null
+++ b/scripts/dts/test-bindings/parent.yaml
@@ -0,0 +1,19 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Parent binding
+description: Parent binding
+
+inherits:
+    !include child.yaml
+
+properties:
+    compatible:
+        constraint: "binding-include-test"
+        type: string-array
+
+    foo:
+        # Changed from "optional" in grandchild.yaml
+        category: required
+        # Type set in grandchild
diff --git a/scripts/dts/test-bindings/props.yaml b/scripts/dts/test-bindings/props.yaml
new file mode 100644
index 00000000000..64aeef001c6
--- /dev/null
+++ b/scripts/dts/test-bindings/props.yaml
@@ -0,0 +1,26 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Device.props test
+description: Device.props test
+
+properties:
+    compatible:
+        constraint: "props"
+        type: string-array
+
+    int:
+        type: int
+
+    array:
+        type: array
+
+    uint8-array:
+        type: uint8-array
+
+    string:
+        type: string
+
+    string-array:
+        type: string-array
diff --git a/scripts/dts/test-bindings/pwm-0-cell.yaml b/scripts/dts/test-bindings/pwm-0-cell.yaml
new file mode 100644
index 00000000000..667aadb238b
--- /dev/null
+++ b/scripts/dts/test-bindings/pwm-0-cell.yaml
@@ -0,0 +1,11 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: PWM source with zero cells
+description: PWM source with zero cells
+
+properties:
+    compatible:
+        constraint: "pwm-zero-cell"
+        type: string-array
diff --git a/scripts/dts/test-bindings/pwm-1-cell.yaml b/scripts/dts/test-bindings/pwm-1-cell.yaml
new file mode 100644
index 00000000000..f805afec518
--- /dev/null
+++ b/scripts/dts/test-bindings/pwm-1-cell.yaml
@@ -0,0 +1,14 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: PWM source with one cell
+description: PWM source with one cell
+
+properties:
+    compatible:
+        constraint: "pwm-one-cell"
+        type: string-array
+
+"#cells":
+  - one
diff --git a/scripts/dts/test-bindings/sub-node-parent.yaml b/scripts/dts/test-bindings/sub-node-parent.yaml
new file mode 100644
index 00000000000..37f781dddb8
--- /dev/null
+++ b/scripts/dts/test-bindings/sub-node-parent.yaml
@@ -0,0 +1,21 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+title: Sub-node test
+description: Sub-node test
+
+properties:
+    compatible:
+        constraint: "parent-with-sub-node"
+        type: string-array
+
+sub-node:
+    properties:
+        foo:
+            required: true
+            type: int
+
+        bar:
+            required: True
+            type: int
diff --git a/scripts/dts/test.dts b/scripts/dts/test.dts
new file mode 100644
index 00000000000..29b2353ed51
--- /dev/null
+++ b/scripts/dts/test.dts
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) 2019, Nordic Semiconductor
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Used by testedtlib.py
+
+/dts-v1/;
+
+/ {
+	//
+	// Interrupts
+	//
+
+	interrupt-parent-test {
+		controller {
+			compatible = "interrupt-three-cell";
+			#interrupt-cells = <3>;
+			interrupt-controller;
+		};
+		node {
+			interrupts = <1 2 3 4 5 6>;
+			interrupt-names = "foo", "bar";
+			interrupt-parent = <&{/interrupt-parent-test/controller}>;
+		};
+	};
+	interrupts-extended-test {
+		controller-0 {
+			compatible = "interrupt-one-cell";
+			#interrupt-cells = <1>;
+			interrupt-controller;
+		};
+		controller-1 {
+			compatible = "interrupt-two-cell";
+			#interrupt-cells = <2>;
+			interrupt-controller;
+		};
+		controller-2 {
+			compatible = "interrupt-three-cell";
+			#interrupt-cells = <3>;
+			interrupt-controller;
+		};
+		node {
+			interrupts-extended = <
+				&{/interrupts-extended-test/controller-0} 1
+				&{/interrupts-extended-test/controller-1} 2 3
+				&{/interrupts-extended-test/controller-2} 4 5 6>;
+		};
+	};
+	interrupt-map-test {
+		#address-cells = <2>;
+		#size-cells = <0>;
+
+		controller-0 {
+			compatible = "interrupt-one-cell";
+			#address-cells = <1>;
+			#interrupt-cells = <1>;
+			interrupt-controller;
+		};
+		controller-1 {
+			compatible = "interrupt-two-cell";
+			#address-cells = <2>;
+			#interrupt-cells = <2>;
+			interrupt-controller;
+		};
+		controller-2 {
+			compatible = "interrupt-three-cell";
+			#address-cells = <3>;
+			#interrupt-cells = <3>;
+			interrupt-controller;
+		};
+		nexus {
+			#interrupt-cells = <2>;
+			interrupt-map = <
+				0 0  0 0  &{/interrupt-map-test/controller-0}  0      0
+				0 0  0 1  &{/interrupt-map-test/controller-1}  0 0    0 1
+				0 0  0 2  &{/interrupt-map-test/controller-2}  0 0 0  0 0 2
+				0 1  0 0  &{/interrupt-map-test/controller-0}  0      3
+				0 1  0 1  &{/interrupt-map-test/controller-1}  0 0    0 4
+				0 1  0 2  &{/interrupt-map-test/controller-2}  0 0 0  0 0 5>;
+		};
+		node@0 {
+			reg = <0 0>;
+			interrupts = <0 0 0 1 0 2>;
+			interrupt-parent = <&{/interrupt-map-test/nexus}>;
+		};
+		node@1 {
+			reg = <0 1>;
+			interrupts-extended = <
+			    &{/interrupt-map-test/nexus} 0 0
+			    &{/interrupt-map-test/nexus} 0 1
+			    &{/interrupt-map-test/nexus} 0 2>;
+		};
+	};
+	interrupt-map-bitops-test {
+		#address-cells = <2>;
+		#size-cells = <0>;
+
+		controller {
+			compatible = "interrupt-two-cell";
+			#address-cells = <0>;
+			#interrupt-cells = <2>;
+			interrupt-controller;
+		};
+		nexus {
+			#interrupt-cells = <2>;
+			interrupt-map = <
+			    6 6  6 6  &{/interrupt-map-bitops-test/controller}  2 1
+			>;
+			interrupt-map-mask = <0xE 0x7 0xE 0x7>;
+			// Not specified in the DT spec., but shows up due to
+			// common code with GPIO. Might as well test it here.
+			interrupt-map-pass-thru = <1 2 3 3>;
+		};
+		// Child unit specifier: 00000007 0000000E 00000007 0000000E
+		// Mask:                 0000000E 00000007 0000000E 00000007
+		// Pass-thru:            00000001 00000002 00000003 00000003
+		node@70000000E {
+			reg = <0x7 0xE>;
+			interrupt-parent = <&{/interrupt-map-bitops-test/nexus}>;
+			interrupts = <0x7 0xE>;
+		};
+	};
+
+	//
+	// GPIOS
+	//
+
+	gpio-test {
+		controller-1 {
+			compatible = "gpio-two-cell";
+			#gpio-cells = <2>;
+			gpio-controller;
+		};
+		node {
+			gpios = <&{/gpio-test/controller-0} 1
+				 &{/gpio-test/controller-1} 2 3>;
+			foo-gpios = <&{/gpio-test/controller-1} 4 5>;
+			bar-gpios = <&{/gpio-test/controller-1} 6 7>;
+		};
+		// Putting this controller last gives us some coverage for ordering
+		// issues during initialization
+		controller-0 {
+			compatible = "gpio-one-cell";
+			#gpio-cells = <1>;
+			gpio-controller;
+		};
+	};
+
+	//
+	// Clocks
+	//
+
+	clock-test {
+		fixed-clock {
+			// 'fixed-clock' is currently special-cased in the code
+			compatible = "fixed-clock";
+			#clock-cells = <0>;
+			clock-frequency = <123>;
+		};
+		clock-1 {
+			compatible = "clock-one-cell";
+			#clock-cells = <1>;
+		};
+		clock-2 {
+			compatible = "clock-two-cell";
+			#clock-cells = <2>;
+		};
+		node {
+			clocks = <&{/clock-test/fixed-clock}
+				  &{/clock-test/clock-1} 1
+				  &{/clock-test/clock-2} 1 2>;
+			clock-names = "fixed", "one-cell", "two-cell";
+		};
+	};
+
+	//
+	// PWMs
+	//
+
+	pwm-test {
+		pwm-0 {
+			compatible = "pwm-zero-cell";
+			#pwm-cells = <0>;
+		};
+		pwm-1 {
+			compatible = "pwm-one-cell";
+			#pwm-cells = <1>;
+		};
+		node {
+			pwms = <&{/pwm-test/pwm-0}
+				&{/pwm-test/pwm-1} 1>;
+			pwm-names = "zero-cell", "one-cell";
+		};
+	};
+
+	//
+	// 'reg'
+	//
+
+	reg-zero-address-cells {
+		#address-cells = <0>;
+		#size-cells = <1>;
+
+		node {
+			reg = <1 2>;
+		};
+	};
+	reg-zero-size-cells {
+		#address-cells = <1>;
+		#size-cells = <0>;
+
+		node {
+			reg = <1 2>;
+		};
+	};
+	// Use implied #size-cells = <1>
+	reg-ranges {
+		#address-cells = <2>;
+
+		parent {
+			#address-cells = <1>;
+			ranges = <1  0xA 0xB  1 /* 1    -> 0xA 0xB */
+				  2  0xC 0xD  2 /* 2..3 -> 0xC 0xD */
+				  4  0xE 0xF  1 /* 4    -> 0xE 0xF */
+				 >;
+
+			node {
+				reg = <5 1 /* Matches no range */
+				       4 1 /* Matches third range */
+				       3 1 /* Matches second range */
+				       2 1 /* Matches second range */
+				       1 1 /* Matches first range */
+				       0 1 /* Matches no range */
+				       >;
+			};
+		};
+	};
+	// Build up <3 2 1> address with nested 'ranges'
+	reg-nested-ranges {
+		#address-cells = <3>;
+
+		grandparent {
+			#address-cells = <2>;
+			#size-cells = <2>;
+			ranges = <0 0  3 0 0  2 2>;
+
+			parent {
+				#address-cells = <1>;
+				ranges = <0  2 0  2>;
+
+				node {
+					reg = <1 1>;
+				};
+			};
+		};
+	};
+
+	//
+	// !include in bindings
+	//
+
+	binding-include {
+		compatible = "binding-include-test";
+		foo = <0>;
+		bar = <1>;
+		baz = <2>;
+	};
+
+	//
+	// For testing Device.props (derived from 'properties:' in the binding)
+	//
+
+	props {
+		compatible = "props";
+		int = <1>;
+		array = <1 2 3>;
+		uint8-array = [ 12 34 ];
+		string = "foo";
+		string-array = "foo", "bar", "baz";
+		// Does not appear in the binding, so won't create an entry in
+		// Device.props
+		not-speced = <0>;
+	};
+
+	//
+	// Parent with 'sub-node:' in binding
+	//
+
+	parent-with-sub-node {
+		compatible = "parent-with-sub-node";
+		node {
+			foo = <1>;
+			bar = <2>;
+			not-speced = <0>;
+		};
+	};
+};
diff --git a/scripts/dts/testdtlib.py b/scripts/dts/testdtlib.py
new file mode 100755
index 00000000000..06d9d3174ec
--- /dev/null
+++ b/scripts/dts/testdtlib.py
@@ -0,0 +1,2025 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019, Nordic Semiconductor
+# SPDX-License-Identifier: BSD-3-Clause
+
+import os
+import shutil
+import sys
+
+import dtlib
+
+# Test suite for dtlib.py. Can be run directly as an executable.
+#
+# This script expects to be run from the directory its in. This simplifies
+# things, as paths in the output can be assumed below.
+
+# TODO: Factor out common code from error tests
+
+
+def run():
+    """
+    Runs all dtlib tests. Immediately exits with status 1 and a message on
+    stderr on test suite failures.
+    """
+    # Note: All code is within this function, even though some triple-quoted
+    # strings are unindented to make things less awkward
+
+    def fail(msg):
+        sys.exit("test failed: {}".format(msg))
+
+    def parse(dts, include_path=()):
+        open(".tmp.dts", "w").write(dts)
+        return dtlib.DT(".tmp.dts", include_path)
+
+    def verify_parse(dts, expected, include_path=()):
+        # The [1:] is so that the first line can be put on a separate line
+        # after """
+        dt = parse(dts[1:], include_path)
+
+        actual = str(dt)
+        expected = expected[1:-1]
+        if actual != expected:
+            fail("expected '{}' to parse as '{}', parsed as '{}'"
+                 .format(dts, expected, actual))
+
+        return dt
+
+    def verify_error(dts, msg):
+        prefix = "expected '{}' to generate the error '{}', generated" \
+                 .format(dts, msg)
+        try:
+            parse(dts[1:])
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    # These might already exist from failed earlier runs
+
+    try:
+        os.mkdir(".tmp")
+    except OSError:
+        pass
+
+    try:
+        os.mkdir(".tmp2")
+    except OSError:
+        pass
+
+    #
+    # Test cell parsing
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = < >;
+	b = < 10 20 >;
+	c = < 0U 1L 2UL 3LL 4ULL >;
+	d = < 0x10 0x20 >;
+	e = < 010 020 >;
+	f = /bits/ 8 < 0x10 0x20 (-1) >;
+	g = /bits/ 16 < 0x10 0x20 (-1) >;
+	h = /bits/ 32 < 0x10 0x20 (-1) >;
+	i = /bits/ 64 < 0x10 0x20 (-1) >;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a;
+	b = [ 00 00 00 0A 00 00 00 14 ];
+	c = [ 00 00 00 00 00 00 00 01 00 00 00 02 00 00 00 03 00 00 00 04 ];
+	d = [ 00 00 00 10 00 00 00 20 ];
+	e = [ 00 00 00 08 00 00 00 10 ];
+	f = [ 10 20 FF ];
+	g = [ 00 10 00 20 FF FF ];
+	h = [ 00 00 00 10 00 00 00 20 FF FF FF FF ];
+	i = [ 00 00 00 00 00 00 00 10 00 00 00 00 00 00 00 20 FF FF FF FF FF FF FF FF ];
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	a = /bits/ 16 < 0x10000 >;
+};
+""",
+".tmp.dts:4 (column 18): parse error: 65536 does not fit in 16 bits")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	a = < 0x100000000 >;
+};
+""",
+".tmp.dts:4 (column 8): parse error: 4294967296 does not fit in 32 bits")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	a = /bits/ 128 < 0 >;
+};
+""",
+".tmp.dts:4 (column 13): parse error: expected 8, 16, 32, or 64")
+
+    #
+    # Test bytes parsing
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = [ ];
+	b = [ 12 34 ];
+	c = [ 1234 ];
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a;
+	b = [ 12 34 ];
+	c = [ 12 34 ];
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	a = [ 123 ];
+};
+""",
+".tmp.dts:4 (column 10): parse error: expected two-digit byte or ']'")
+
+    #
+    # Test string parsing
+    #
+
+    verify_parse(r"""
+/dts-v1/;
+
+/ {
+	a = "";
+	b = "ABC";
+	c = "\\\"\xAB\377\a\b\t\n\v\f\r";
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = [ 00 ];
+	b = [ 41 42 43 00 ];
+	c = [ 5C 22 AB FF 07 08 09 0A 0B 0C 0D 00 ];
+};
+""")
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	a = "\400";
+};
+""",
+".tmp.dts:4 (column 6): parse error: octal escape out of range (> 255)")
+
+    #
+    # Test /incbin/
+    #
+
+    open(".tmp.bin", "wb").write(b"\00\01\02\03")
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = /incbin/ (".tmp.bin");
+	b = /incbin/ (".tmp.bin", 1, 1);
+	c = /incbin/ (".tmp.bin", 1, 2);
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = [ 00 01 02 03 ];
+	b = [ 01 ];
+	c = [ 01 02 ];
+};
+""")
+
+    open(".tmp/in_subdir", "wb").write(b"\00\01\02")
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = /incbin/ ("in_subdir");
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = [ 00 01 02 ];
+};
+""",
+    include_path=(".tmp",))
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	a = /incbin/ ("missing");
+};
+""",
+".tmp.dts:4 (column 25): parse error: 'missing' could not be found")
+
+    #
+    # Test node merging
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	l1: l2: l1: foo {
+		foo1 = [ 01 ];
+		l4: l5: bar {
+			bar1 = [ 01 ];
+		};
+	};
+};
+
+l3: &l1 {
+	foo2 = [ 02 ];
+	l6: l7: bar {
+		bar2 = [ 02 ];
+	};
+};
+
+&l3 {
+	foo3 = [ 03 ];
+};
+
+&{/foo} {
+	foo4 = [ 04 ];
+};
+
+&{/foo/bar} {
+	bar3 = [ 03 ];
+	l8: baz {};
+};
+
+/ {
+};
+
+/ {
+	top = [ 01 ];
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	top = [ 01 ];
+	l1: l2: l3: foo {
+		foo1 = [ 01 ];
+		foo2 = [ 02 ];
+		foo3 = [ 03 ];
+		foo4 = [ 04 ];
+		l4: l5: l6: l7: bar {
+			bar1 = [ 01 ];
+			bar2 = [ 02 ];
+			bar3 = [ 03 ];
+			l8: baz {
+			};
+		};
+	};
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+};
+
+&missing {
+};
+""",
+".tmp.dts:6 (column 1): parse error: undefined node label 'missing'")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+};
+
+&{foo} {
+};
+""",
+".tmp.dts:6 (column 1): parse error: node path does not start with '/'")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+};
+
+&{/foo} {
+};
+""",
+".tmp.dts:6 (column 1): parse error: component 1 ('foo') in path '/foo' does not exist")
+
+    #
+    # Test property labels
+    #
+
+    def verify_label2prop(label, expected):
+        actual = dt.label2prop[label].name
+        if actual != expected:
+            fail("expected label '{}' to map to prop '{}', mapped to prop '{}'"
+                 .format(label, expected, actual))
+
+    dt = verify_parse("""
+/dts-v1/;
+
+/ {
+	a;
+	b;
+	l2: c;
+	l4: l5: l5: l4: d = < 0 >;
+};
+
+/ {
+	l1: b;
+	l3: c;
+	l6: d;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a;
+	l1: b;
+	l2: l3: c;
+	l4: l5: l6: d = [ 00 00 00 00 ];
+};
+""")
+
+    verify_label2prop("l1", "b")
+    verify_label2prop("l2", "c")
+    verify_label2prop("l3", "c")
+    verify_label2prop("l4", "d")
+    verify_label2prop("l5", "d")
+    verify_label2prop("l6", "d")
+
+    #
+    # Test offset labels
+    #
+
+    def verify_label2offset(label, expected_prop, expected_offset):
+        actual_prop, actual_offset = dt.label2prop_offset[label]
+        actual_prop = actual_prop.name
+        if (actual_prop, actual_offset) != (expected_prop, expected_offset):
+            fail("expected label '{}' to map to offset {} on prop '{}', "
+                 "mapped to offset {} on prop '{}'"
+                 .format(label, expected_offset, expected_prop, actual_offset,
+                         actual_prop))
+
+    dt = verify_parse("""
+/dts-v1/;
+
+/ {
+    a = l01: l02: < l03: l04: &node l05: l06: 2 l07: l08: > l09: l10:,
+        l11: l12: [ l13: l14: 03 l15: l16: 04 l17: l18: ] l19: l20:,
+        l21: l22: "A";
+
+    b = < 0 > l23: l24:;
+
+    node: node {
+    };
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = [ l01: l02: l03: l04: 00 00 00 01 l05: l06: 00 00 00 02 l07: l08: l09: l10: l11: l12: l13: l14: 03 l15: l16: 04 l17: l18: l19: l20: l21: l22: 41 00 ];
+	b = [ 00 00 00 00 l23: l24: ];
+	node: node {
+		phandle = [ 00 00 00 01 ];
+	};
+};
+""")
+
+    verify_label2offset("l01", "a", 0)
+    verify_label2offset("l04", "a", 0)
+    verify_label2offset("l05", "a", 4)
+    verify_label2offset("l14", "a", 8)
+    verify_label2offset("l15", "a", 9)
+    verify_label2offset("l22", "a", 10)
+
+    verify_label2offset("l23", "b", 4)
+    verify_label2offset("l24", "b", 4)
+
+    #
+    # Test unit_addr
+    #
+
+    def verify_unit_addr(path, expected):
+        node = dt.get_node(path)
+        if node.unit_addr != expected:
+            fail("expected {!r} to have unit_addr '{}', was '{}'"
+                 .format(node, expected, node.unit_addr))
+
+    dt = verify_parse("""
+/dts-v1/;
+
+/ {
+	no-unit-addr {
+	};
+
+	unit-addr@ABC {
+	};
+
+	unit-addr-non-numeric@foo-bar {
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	no-unit-addr {
+	};
+	unit-addr@ABC {
+	};
+	unit-addr-non-numeric@foo-bar {
+	};
+};
+""")
+
+    verify_unit_addr("/no-unit-addr", "")
+    verify_unit_addr("/unit-addr@ABC", "ABC")
+    verify_unit_addr("/unit-addr-non-numeric@foo-bar", "foo-bar")
+
+    #
+    # Test node path references
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = &label;
+	b = &{/abc};
+	label: abc {
+		c = &label;
+		d = &{/abc};
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = [ 2F 61 62 63 00 ];
+	b = [ 2F 61 62 63 00 ];
+	label: abc {
+		c = [ 2F 61 62 63 00 ];
+		d = [ 2F 61 62 63 00 ];
+	};
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		x = &missing;
+	};
+};
+""",
+"/sub: undefined node label 'missing'")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		x = &{/sub/missing};
+	};
+};
+""",
+"/sub: component 2 ('missing') in path '/sub/missing' does not exist")
+
+    #
+    # Test phandles
+    #
+
+    # Check that existing phandles are used (and not reused)
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = < &a &{/b} &c >;
+
+	dummy1 {
+		phandle = < 1 >;
+	};
+
+	dummy2 {
+		phandle = < 3 >;
+	};
+
+	a: a {
+	};
+
+	b {
+	};
+
+	c: c {
+		phandle = < 0xFF >;
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ 00 00 00 02 00 00 00 04 00 00 00 FF ];
+	dummy1 {
+		phandle = [ 00 00 00 01 ];
+	};
+	dummy2 {
+		phandle = [ 00 00 00 03 ];
+	};
+	a: a {
+		phandle = [ 00 00 00 02 ];
+	};
+	b {
+		phandle = [ 00 00 00 04 ];
+	};
+	c: c {
+		phandle = [ 00 00 00 FF ];
+	};
+};
+""")
+
+    # Check that a node can be assigned a phandle to itself. This just forces a
+    # phandle to be allocated on it. The C tools support this too.
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	dummy {
+		phandle = < 1 >;
+	};
+
+	a {
+                foo: phandle = < &{/a} >;
+	};
+
+	label: b {
+                bar: phandle = < &label >;
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	dummy {
+		phandle = [ 00 00 00 01 ];
+	};
+	a {
+		foo: phandle = [ 00 00 00 02 ];
+	};
+	label: b {
+		bar: phandle = [ 00 00 00 03 ];
+	};
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		x = < &missing >;
+	};
+};
+""",
+"/sub: undefined node label 'missing'")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	a: sub {
+		x = /bits/ 16 < &a >;
+	};
+};
+""",
+".tmp.dts:5 (column 19): parse error: phandle references are only allowed in arrays with 32-bit elements")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = [ 00 ];
+	};
+};
+""",
+"/foo: bad phandle length (1), expected 4 bytes")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < 0 >;
+	};
+};
+""",
+"/foo: bad value 0x00000000 for phandle")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < (-1) >;
+	};
+};
+""",
+"/foo: bad value 0xffffffff for phandle")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < 17 >;
+	};
+
+	bar {
+		phandle = < 17 >;
+	};
+};
+""",
+"/bar: duplicated phandle 0x11 (seen before at /foo)")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < &{/bar} >;
+	};
+
+	bar {
+	};
+};
+""",
+"/foo: phandle refers to another node")
+
+    # Test phandle2node
+
+    def verify_phandle2node(prop, offset, expected_name):
+        phandle = dtlib.to_num(dt.root.props[prop].value[offset:offset + 4])
+        actual_name = dt.phandle2node[phandle].name
+
+        if actual_name != expected_name:
+            fail("expected {} to be a phandle for {}, was a phandle for {}"
+                 .format(prop, expected_name, actual_name))
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	phandle_ = < &{/node1} 0 1 >;
+	phandles = < 0 &{/node2} 1 &{/node3} >;
+
+	node1 {
+		phandle = < 123 >;
+	};
+
+	node2 {
+	};
+
+	node3 {
+	};
+};
+""")
+
+    verify_phandle2node("phandle_", 0, "node1")
+    verify_phandle2node("phandles", 4, "node2")
+    verify_phandle2node("phandles", 12, "node3")
+
+    #
+    # Test mixed value type assignments
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = /bits/ 8 < 0xFF 0xFF >,
+	    &abc,
+	    < 0xFF &abc 0xFF &abc >,
+	    &abc,
+	    [ FF FF ],
+	    "abc";
+
+	abc: abc {
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ FF FF 2F 61 62 63 00 00 00 00 FF 00 00 00 01 00 00 00 FF 00 00 00 01 2F 61 62 63 00 FF FF 61 62 63 00 ];
+	abc: abc {
+		phandle = [ 00 00 00 01 ];
+	};
+};
+""")
+
+    #
+    # Test property deletion
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	keep = < 1 >;
+	delete = < &sub >, &sub;
+	/delete-property/ missing;
+	/delete-property/ delete;
+	sub: sub {
+		y = < &sub >, &sub;
+	};
+};
+
+&sub {
+	/delete-property/ y;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	keep = [ 00 00 00 01 ];
+	sub: sub {
+	};
+};
+""")
+
+    #
+    # Test node deletion
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	sub1 {
+		x = < 1 >;
+		sub2 {
+			x = < &sub >, &sub;
+		};
+		/delete-node/ sub2;
+	};
+
+	sub3: sub3 {
+		x = < &sub >, &sub;
+	};
+
+	sub4 {
+		x = < &sub >, &sub;
+	};
+};
+
+/delete-node/ &sub3;
+/delete-node/ &{/sub4};
+""",
+"""
+/dts-v1/;
+
+/ {
+	sub1 {
+		x = [ 00 00 00 01 ];
+	};
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+};
+
+/delete-node/ &missing;
+""",
+".tmp.dts:6 (column 15): parse error: undefined node label 'missing'")
+
+    #
+    # Test /include/ (which is handled in the lexer)
+    #
+
+    # Verify that /include/ searches the current directory
+
+    open(".tmp/same-dir-1", "w").write("""
+	x = [ 00 ];
+	/include/ "same-dir-2"
+""")
+    open(".tmp/same-dir-2", "w").write("""
+	y = [ 01 ];
+	/include/ "same-dir-3"
+""")
+    open(".tmp/same-dir-3", "w").write("""
+	z = [ 02 ];
+""")
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	/include/ ".tmp/same-dir-1"
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ 00 ];
+	y = [ 01 ];
+	z = [ 02 ];
+};
+""")
+
+    # Test tricky includes and include paths
+
+    open(".tmp2.dts", "w").write("""
+/dts-v1/;
+/ {
+""")
+    open(".tmp3.dts", "w").write("""
+    x = <1>;
+""")
+    open(".tmp/via-include-path-1", "w").write("""
+      = /include/ "via-include-path-2"
+""")
+    open(".tmp2/via-include-path-2", "w").write("""
+        <2>;
+};
+""")
+
+    verify_parse("""
+/include/ ".tmp2.dts"
+/include/ ".tmp3.dts"
+y /include/ "via-include-path-1"
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ 00 00 00 01 ];
+	y = [ 00 00 00 02 ];
+};
+""",
+    include_path=(".tmp", ".tmp2",))
+
+    verify_error("""
+/include/ "missing"
+""",
+".tmp.dts:1 (column 1): parse error: 'missing' could not be found")
+
+    # Verify that an error in an included file points to the right location
+
+    open(".tmp2.dts", "w").write("""\
+
+
+  x
+""")
+
+    verify_error("""
+
+
+/include/ ".tmp2.dts"
+""",
+".tmp2.dts:3 (column 3): parse error: expected '/dts-v1/;' at start of file")
+
+# Test recursive /include/ detection
+
+    open(".tmp2.dts", "w").write("""\
+/include/ ".tmp3.dts"
+""")
+    open(".tmp3.dts", "w").write("""\
+/include/ ".tmp.dts"
+""")
+
+    verify_error("""
+/include/ ".tmp2.dts"
+""",
+"""\
+.tmp3.dts:1 (column 1): parse error: recursive /include/:
+.tmp.dts:1 ->
+.tmp2.dts:1 ->
+.tmp3.dts:1 ->
+.tmp.dts\
+""")
+
+    verify_error("""
+/include/ ".tmp.dts"
+""",
+"""\
+.tmp.dts:1 (column 1): parse error: recursive /include/:
+.tmp.dts:1 ->
+.tmp.dts\
+""")
+
+    #
+    # Test /omit-if-no-ref/
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = < &{/referenced} >, &referenced2;
+
+	/omit-if-no-ref/ referenced {
+	};
+
+	referenced2: referenced2 {
+	};
+
+	/omit-if-no-ref/ unreferenced {
+	};
+
+	l1: /omit-if-no-ref/ unreferenced2 {
+	};
+
+	/omit-if-no-ref/ l2: unreferenced3 {
+	};
+
+	unreferenced4: unreferenced4 {
+	};
+
+	unreferenced5 {
+	};
+};
+
+/omit-if-no-ref/ &referenced2;
+/omit-if-no-ref/ &unreferenced4;
+/omit-if-no-ref/ &{/unreferenced5};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ 00 00 00 01 2F 72 65 66 65 72 65 6E 63 65 64 32 00 ];
+	referenced {
+		phandle = [ 00 00 00 01 ];
+	};
+	referenced2: referenced2 {
+	};
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ x = "";
+};
+""",
+".tmp.dts:4 (column 21): parse error: /omit-if-no-ref/ can only be used on nodes")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ x;
+};
+""",
+".tmp.dts:4 (column 20): parse error: /omit-if-no-ref/ can only be used on nodes")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ {
+	};
+};
+""",
+".tmp.dts:4 (column 19): parse error: expected node or property name")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ = < 0 >;
+};
+""",
+".tmp.dts:4 (column 19): parse error: expected node or property name")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+};
+
+/omit-if-no-ref/ &missing;
+""",
+".tmp.dts:6 (column 18): parse error: undefined node label 'missing'")
+
+    #
+    # Test expressions
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	ter1        = < (0 ? 1 : 0 ? 2 : 3) >;
+	ter2        = < (0 ? 1 : 1 ? 2 : 3) >;
+	ter3        = < (1 ? 1 : 0 ? 2 : 3) >;
+	ter4        = < (1 ? 1 : 1 ? 2 : 3) >;
+	or1         = < (0 || 0) >;
+	or2         = < (0 || 1) >;
+	or3         = < (1 || 0) >;
+	or4         = < (1 || 1) >;
+	and1        = < (0 && 0) >;
+	and2        = < (0 && 1) >;
+	and3        = < (1 && 0) >;
+	and4        = < (1 && 1) >;
+	bitor       = < (1 | 2) >;
+	bitxor      = < (7 ^ 2) >;
+	bitand      = < (3 & 6) >;
+	eq1         = < (1 == 0) >;
+	eq2         = < (1 == 1) >;
+	neq1        = < (1 != 0) >;
+	neq2        = < (1 != 1) >;
+	lt1         = < (1 < 2) >;
+	lt2         = < (2 < 2) >;
+	lt3         = < (3 < 2) >;
+	lteq1       = < (1 <= 2) >;
+	lteq2       = < (2 <= 2) >;
+	lteq3       = < (3 <= 2) >;
+	gt1         = < (1 > 2) >;
+	gt2         = < (2 > 2) >;
+	gt3         = < (3 > 2) >;
+	gteq1       = < (1 >= 2) >;
+	gteq2       = < (2 >= 2) >;
+	gteq3       = < (3 >= 2) >;
+	lshift      = < (2 << 3) >;
+	rshift      = < (16 >> 3) >;
+	add         = < (3 + 4) >;
+	sub         = < (7 - 4) >;
+	mul         = < (3 * 4) >;
+	div         = < (11 / 3) >;
+	mod         = < (11 % 3) >;
+	unary_minus = < (-3) >;
+	bitnot      = < (~1) >;
+	not0        = < (!-1) >;
+	not1        = < (!0) >;
+	not2        = < (!1) >;
+	not3        = < (!2) >;
+	nest        = < (((--3) + (-2)) * (--(-2))) >;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	ter1 = [ 00 00 00 03 ];
+	ter2 = [ 00 00 00 02 ];
+	ter3 = [ 00 00 00 01 ];
+	ter4 = [ 00 00 00 01 ];
+	or1 = [ 00 00 00 00 ];
+	or2 = [ 00 00 00 01 ];
+	or3 = [ 00 00 00 01 ];
+	or4 = [ 00 00 00 01 ];
+	and1 = [ 00 00 00 00 ];
+	and2 = [ 00 00 00 00 ];
+	and3 = [ 00 00 00 00 ];
+	and4 = [ 00 00 00 01 ];
+	bitor = [ 00 00 00 03 ];
+	bitxor = [ 00 00 00 05 ];
+	bitand = [ 00 00 00 02 ];
+	eq1 = [ 00 00 00 00 ];
+	eq2 = [ 00 00 00 01 ];
+	neq1 = [ 00 00 00 01 ];
+	neq2 = [ 00 00 00 00 ];
+	lt1 = [ 00 00 00 01 ];
+	lt2 = [ 00 00 00 00 ];
+	lt3 = [ 00 00 00 00 ];
+	lteq1 = [ 00 00 00 01 ];
+	lteq2 = [ 00 00 00 01 ];
+	lteq3 = [ 00 00 00 00 ];
+	gt1 = [ 00 00 00 00 ];
+	gt2 = [ 00 00 00 00 ];
+	gt3 = [ 00 00 00 01 ];
+	gteq1 = [ 00 00 00 00 ];
+	gteq2 = [ 00 00 00 01 ];
+	gteq3 = [ 00 00 00 01 ];
+	lshift = [ 00 00 00 10 ];
+	rshift = [ 00 00 00 02 ];
+	add = [ 00 00 00 07 ];
+	sub = [ 00 00 00 03 ];
+	mul = [ 00 00 00 0C ];
+	div = [ 00 00 00 03 ];
+	mod = [ 00 00 00 02 ];
+	unary_minus = [ FF FF FF FD ];
+	bitnot = [ FF FF FF FE ];
+	not0 = [ 00 00 00 00 ];
+	not1 = [ 00 00 00 01 ];
+	not2 = [ 00 00 00 00 ];
+	not3 = [ 00 00 00 00 ];
+	nest = [ FF FF FF FE ];
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	a = < (1/(-1 + 1)) >;
+};
+""",
+".tmp.dts:4 (column 18): parse error: division by zero")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	a = < (1%0) >;
+};
+""",
+".tmp.dts:4 (column 11): parse error: division by zero")
+
+    #
+    # Test comment removal
+    #
+
+    verify_parse("""
+/**//dts-v1//**/;//
+//
+// foo
+/ /**/{// foo
+x/**/=/*
+foo
+*/</**/1/***/>/****/;/**/}/*/**/;
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ 00 00 00 01 ];
+};
+""")
+
+    #
+    # Test get_node()
+    #
+
+    def verify_path_is(path, node_name):
+        try:
+            node = dt.get_node(path)
+            if node.name != node_name:
+                fail("expected {} to lead to {}, lead to {}"
+                     .format(path, node_name, node.name))
+        except dtlib.DTError:
+            fail("no node found for path " + alias)
+
+    def verify_path_error(path, msg):
+        prefix = "expected looking up '{}' to generate the error '{}', " \
+                 "generated ".format(path, msg)
+        try:
+            dt.get_node(path)
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    def verify_path_exists(path):
+        if not dt.has_node(path):
+            fail("expected path '{}' to exist, didn't".format(path))
+
+    def verify_path_missing(path):
+        if dt.has_node(path):
+            fail("expected path '{}' to not exist, did".format(path))
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	foo {
+		bar {
+		};
+	};
+
+	baz {
+	};
+};
+""")
+
+    verify_path_is("/", "/")
+    verify_path_is("//", "/")
+    verify_path_is("///", "/")
+    verify_path_is("/foo", "foo")
+    verify_path_is("//foo", "foo")
+    verify_path_is("///foo", "foo")
+    verify_path_is("/foo/bar", "bar")
+    verify_path_is("//foo//bar", "bar")
+    verify_path_is("///foo///bar", "bar")
+    verify_path_is("/baz", "baz")
+
+    verify_path_error("", "no alias '' found -- did you forget the leading '/' in the node path?")
+    verify_path_error("missing", "no alias 'missing' found -- did you forget the leading '/' in the node path?")
+    verify_path_error("/missing", "component 1 ('missing') in path '/missing' does not exist")
+    verify_path_error("/foo/missing", "component 2 ('missing') in path '/foo/missing' does not exist")
+
+    verify_path_exists("/")
+    verify_path_exists("/foo")
+    verify_path_exists("/foo/bar")
+
+    verify_path_missing("/missing")
+    verify_path_missing("/foo/missing")
+
+    #
+    # Test /aliases
+    #
+
+    def verify_alias_target(alias, node_name):
+        verify_path_is(alias, node_name)
+        if alias not in dt.alias2node:
+            fail("expected {} to be in alias2node".format(alias))
+        if dt.alias2node[alias].name != node_name:
+            fail("expected alias {} to lead to {}, lead to {}"
+                 .format(alias, node_name, dt.alias2node[alias].name))
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	aliases {
+		alias1 = &l1;
+		alias2 = &l2;
+		alias3 = &{/sub/node3};
+		alias4 = [2F 6E 6F 64 65 34 00]; // "/node4";
+	};
+
+	l1: node1 {
+	};
+
+	l2: node2 {
+	};
+
+	sub {
+		node3 {
+		};
+	};
+
+	node4 {
+		node5 {
+		};
+	};
+};
+""")
+
+    verify_alias_target("alias1", "node1")
+    verify_alias_target("alias2", "node2")
+    verify_alias_target("alias3", "node3")
+    verify_alias_target("alias4", "node4")
+    verify_path_is("alias4/node5", "node5")
+
+    verify_path_error("alias4/node5/node6",
+                      "component 3 ('node6') in path 'alias4/node5/node6' does not exist")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	aliases {
+		A = "/aliases";
+	};
+};
+""",
+"/aliases: alias property name 'A' should include only characters from [0-9a-z-]")
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	aliases {
+		a = "\xFF";
+	};
+};
+""",
+r"b'\xff\x00' is not valid UTF-8 (for property 'a' on /aliases)")
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	aliases {
+		a = [ 41 ]; // "A"
+	};
+};
+""",
+"b'A' is not null-terminated (for property 'a' on /aliases)")
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	aliases {
+		a = "/missing";
+	};
+};
+""",
+"/aliases: bad path for 'a': component 1 ('missing') in path '/missing' does not exist")
+
+    #
+    # Test to_{num,nums,string,strings,node}()
+    #
+
+    def verify_to_num(prop, size, signed, expected):
+        try:
+            actual = dt.root.props[prop].to_num(size, signed)
+        except dtlib.DTError as e:
+            fail("failed to convert {} to {} number with {} bytes: {}"
+                 .format(prop, "a signed" if signed else "an unsigned", size,
+                         e))
+
+        if actual != expected:
+            fail("expected {} to have the {} numeric value {:#x}, had the "
+                 "value {:#x}".format(prop, "signed" if signed else "unsigned",
+                                      expected, actual))
+
+    def verify_to_num_error(prop, size, msg):
+        prefix = "expected {} converted from {} bytes to generate the error " \
+                 "'{}', generated".format(prop, size, msg)
+        try:
+            dt.root.props[prop].to_num(size)
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    def verify_to_nums(prop, size, signed, expected):
+        try:
+            actual = dt.root.props[prop].to_nums(size, signed)
+        except dtlib.DTError as e:
+            fail("failed to convert {} to {} numbers with {} bytes each: {}"
+                 .format(prop, "signed" if signed else "unsigned", size, e))
+
+        if actual != expected:
+            fail("expected {} to give the {} numbers {} for size {}, gave {}"
+                 .format(prop, "signed" if signed else "unsigned", expected,
+                         size, actual))
+
+    def verify_to_nums_error(prop, size, msg):
+        prefix = "expected {} converted to numbers with {} bytes each to " \
+                 "generate the error '{}', generated".format(prop, size, msg)
+        try:
+            dt.root.props[prop].to_nums(size)
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    def verify_raw_to_num_error(fn, data, size, msg):
+        prefix = "expected {}() called with data='{}', size='{}' to generate " \
+                 "the error '{}', generated".format(fn.__name__, data, size, msg)
+        try:
+            dtlib.to_num(data, size)
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    def verify_to_string(prop, expected):
+        try:
+            actual = dt.root.props[prop].to_string()
+        except dtlib.DTError as e:
+            fail("failed to convert {} to string: {}".format(prop, e))
+
+        if actual != expected:
+            fail("expected {} to have the value '{}', had the value '{}'"
+                 .format(prop, expected, actual))
+
+    def verify_to_string_error(prop, msg):
+        prefix = "expected converting {} to string to generate the error " \
+                 "'{}', generated".format(prop, msg)
+        try:
+            dt.root.props[prop].to_string()
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    def verify_raw_to_string_error(data, msg):
+        prefix = "expected to_string() called with data='{}' to generate " \
+                 "the error '{}', generated".format(data, msg)
+        try:
+            dtlib.to_string(data)
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    def verify_to_strings(prop, expected):
+        try:
+            actual = dt.root.props[prop].to_strings()
+        except dtlib.DTError as e:
+            fail("failed to convert {} to strings: {}".format(prop, e))
+
+        if actual != expected:
+            fail("expected {} to have the value '{}', had the value '{}'"
+                 .format(prop, expected, actual))
+
+    def verify_to_strings_error(prop, msg):
+        prefix = "expected converting {} to strings to generate the error " \
+                 "'{}', generated".format(prop, msg)
+        try:
+            dt.root.props[prop].to_string()
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    def verify_to_node(prop, path):
+        try:
+            actual = dt.root.props[prop].to_node().path
+        except dtlib.DTError as e:
+            fail("failed to convert {} to node: {}".format(prop, e))
+
+        if actual != path:
+            fail("expected {} to point to {}, pointed to {}"
+                 .format(prop, path, actual))
+
+    def verify_to_node_error(prop, msg):
+        prefix = "expected converting {} to node to generate the error " \
+                 "'{}', generated".format(prop, msg)
+        try:
+            dt.root.props[prop].to_node()
+            fail(prefix + " no error")
+        except dtlib.DTError as e:
+            if str(e) != msg:
+                fail("{} the error '{}'".format(prefix, e))
+        except Exception as e:
+            fail("{} the non-DTError '{}'".format(prefix, e))
+
+    dt = parse(r"""
+/dts-v1/;
+
+/ {
+	empty;
+	u1 = /bits/ 8 < 0x01 >;
+	u2 = /bits/ 8 < 0x01 0x02 >;
+	u3 = /bits/ 8 < 0x01 0x02 0x03 >;
+	u4 = /bits/ 8 < 0x01 0x02 0x03 0x04 >;
+	s1 = /bits/ 8 < 0xFF >;
+	s2 = /bits/ 8 < 0xFF 0xFE >;
+	s3 = /bits/ 8 < 0xFF 0xFF 0xFD >;
+	s4 = /bits/ 8 < 0xFF 0xFF 0xFF 0xFC >;
+	empty_string = "";
+	string = "foo\tbar baz";
+	invalid_string = "\xff";
+	non_null_terminated_string = [ 41 ]; // A
+	strings = "foo", "bar", "baz";
+	invalid_strings = "foo", "\xff", "bar";
+	non_null_terminated_strings = "foo", "bar", [ 01 ];
+	ref = <&{/target}>;
+	missingref = < 123 >;
+	badref;
+
+	target {
+	};
+};
+""")
+
+    # Test to_num()
+
+    verify_to_num("u1", 1, False, 0x01)
+    verify_to_num("u2", 2, False, 0x0102)
+    verify_to_num("u3", 3, False, 0x010203)
+    verify_to_num("u4", 4, False, 0x01020304)
+    verify_to_num("s1", 1, False, 0xFF)
+    verify_to_num("s2", 2, False, 0xFFFE)
+    verify_to_num("s3", 3, False, 0xFFFFFD)
+    verify_to_num("s4", 4, False, 0xFFFFFFFC)
+
+    verify_to_num("u1", 1, True, 0x01)
+    verify_to_num("u2", 2, True, 0x0102)
+    verify_to_num("u3", 3, True, 0x010203)
+    verify_to_num("u4", 4, True, 0x01020304)
+    verify_to_num("s1", 1, True, -1)
+    verify_to_num("s2", 2, True, -2)
+    verify_to_num("s3", 3, True, -3)
+    verify_to_num("s4", 4, True, -4)
+
+    verify_to_num("u1", None, False, 0x01)
+    verify_to_num("u2", None, False, 0x0102)
+    verify_to_num("u3", None, False, 0x010203)
+    verify_to_num("u4", None, False, 0x01020304)
+    verify_to_num("s1", None, False, 0xFF)
+    verify_to_num("s2", None, False, 0xFFFE)
+    verify_to_num("s3", None, False, 0xFFFFFD)
+    verify_to_num("s4", None, False, 0xFFFFFFFC)
+
+    verify_to_num("u1", None, True, 0x01)
+    verify_to_num("u2", None, True, 0x0102)
+    verify_to_num("u3", None, True, 0x010203)
+    verify_to_num("u4", None, True, 0x01020304)
+    verify_to_num("s1", None, True, -1)
+    verify_to_num("s2", None, True, -2)
+    verify_to_num("s3", None, True, -3)
+    verify_to_num("s4", None, True, -4)
+
+    verify_to_num_error("u1", 0, "'size' must be greater than zero, was 0 (for property 'u1' on /)")
+    verify_to_num_error("u1", -1, "'size' must be greater than zero, was -1 (for property 'u1' on /)")
+    verify_to_num_error("u1", 2, r"b'\x01' is 1 bytes long, expected 2 (for property 'u1' on /)")
+    verify_to_num_error("u2", 1, r"b'\x01\x02' is 2 bytes long, expected 1 (for property 'u2' on /)")
+
+    verify_raw_to_num_error(dtlib.to_num, 0, 0, "'0' has type 'int', expected 'bytes'")
+    verify_raw_to_num_error(dtlib.to_num, b"", 0, "'size' must be greater than zero, was 0")
+
+    # Test to_nums()
+
+    verify_to_nums("empty", 1, False, [])
+    verify_to_nums("u1", 1, False, [1])
+    verify_to_nums("u2", 1, False, [1, 2])
+    verify_to_nums("u3", 1, False, [1, 2, 3])
+    verify_to_nums("u4", 1, False, [1, 2, 3, 4])
+    verify_to_nums("s1", 1, False, [0xFF])
+    verify_to_nums("s2", 1, False, [0xFF, 0xFE])
+    verify_to_nums("s3", 1, False, [0xFF, 0xFF, 0xFD])
+    verify_to_nums("s4", 1, False, [0xFF, 0xFF, 0xFF, 0xFC])
+
+    verify_to_nums("u2", 2, False, [0x0102])
+    verify_to_nums("u4", 2, False, [0x0102, 0x0304])
+
+    verify_to_nums("u1", 1, True, [1])
+    verify_to_nums("u2", 1, True, [1, 2])
+    verify_to_nums("u3", 1, True, [1, 2, 3])
+    verify_to_nums("u4", 1, True, [1, 2, 3, 4])
+    verify_to_nums("s1", 1, True, [-1])
+    verify_to_nums("s2", 1, True, [-1, -2])
+    verify_to_nums("s3", 1, True, [-1, -1, -3])
+    verify_to_nums("s4", 1, True, [-1, -1, -1, -4])
+
+    verify_to_nums("s2", 2, True, [-2])
+    verify_to_nums("s4", 2, True, [-1, -4])
+
+    verify_to_nums_error("u1", 0, "'size' must be greater than zero, was 0 (for property 'u1' on /)")
+    verify_to_nums_error("u1", 2, r"b'\x01' is 1 bytes long, expected a length that's a multiple of 2 (for property 'u1' on /)")
+    verify_to_nums_error("u2", 3, r"b'\x01\x02' is 2 bytes long, expected a length that's a multiple of 3 (for property 'u2' on /)")
+
+    verify_raw_to_num_error(dtlib.to_nums, 0, 0, "'0' has type 'int', expected 'bytes'")
+    verify_raw_to_num_error(dtlib.to_nums, b"", 0, "'size' must be greater than zero, was 0")
+
+    # Test to_string()
+
+    verify_to_string("empty_string", "")
+    verify_to_string("string", "foo\tbar baz")
+
+    verify_to_string_error("invalid_string", r"b'\xff\x00' is not valid UTF-8 (for property 'invalid_string' on /)")
+    verify_to_string_error("non_null_terminated_string", "b'A' is not null-terminated (for property 'non_null_terminated_string' on /)")
+
+    verify_raw_to_string_error(0, "'0' has type 'int', expected 'bytes'")
+
+    # Test to_strings()
+
+    verify_to_strings("empty_string", [""])
+    verify_to_strings("string", ["foo\tbar baz"])
+    verify_to_strings("strings", ["foo", "bar", "baz"])
+
+    verify_to_strings_error("invalid_strings", r"b'foo\x00\xff\x00bar\x00' is not valid UTF-8 (for property 'invalid_strings' on /)")
+    verify_to_strings_error("non_null_terminated_strings", r"b'foo\x00bar\x00\x01' is not null-terminated (for property 'non_null_terminated_strings' on /)")
+
+    # Test to_node()
+
+    verify_to_node("ref", "/target")
+
+    verify_to_node_error("missingref", "non-existent phandle 123 (for property 'missingref' on /)")
+    verify_to_node_error("badref", "b'' is 0 bytes long, expected 4 (for property 'badref' on /)")
+
+    #
+    # Test duplicate label error
+    #
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub1 {
+		label: foo {
+		};
+	};
+
+	sub2 {
+		label: bar {
+		};
+	};
+};
+""",
+"Label 'label' appears on /sub1/foo and on /sub2/bar")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		label: foo {
+		};
+	};
+};
+/ {
+	sub {
+		label: bar {
+		};
+	};
+};
+""",
+"Label 'label' appears on /sub/bar and on /sub/foo")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo: a = < 0 >;
+	foo: node {
+	};
+};
+""",
+"Label 'foo' appears on /node and on property 'a' of node /")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo: a = < 0 >;
+	node {
+		foo: b = < 0 >;
+	};
+};
+""",
+"Label 'foo' appears on property 'a' of node / and on property 'b' of node /node")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo: a = foo: < 0 >;
+};
+""",
+"Label 'foo' appears in the value of property 'a' of node / and on property 'a' of node /")
+
+    # Giving the same label twice for the same node is fine
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	sub {
+		label: foo {
+		};
+	};
+};
+/ {
+
+	sub {
+		label: foo {
+		};
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	sub {
+		label: foo {
+		};
+	};
+};
+""")
+
+    # Duplicate labels are fine if one of the nodes is deleted
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	label: foo {
+	};
+	label: bar {
+	};
+};
+
+/delete-node/ &{/bar};
+""",
+"""
+/dts-v1/;
+
+/ {
+	label: foo {
+	};
+};
+""")
+
+    #
+    # Test overriding/deleting a property with references
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = &foo, < &foo >;
+	y = &foo, < &foo >;
+	foo: foo {
+	};
+};
+
+/ {
+	x = < 1 >;
+	/delete-property/ y;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ 00 00 00 01 ];
+	foo: foo {
+	};
+};
+""")
+
+    #
+    # Test self-referential node
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	label: foo {
+		x = &{/foo}, &label, < &label >;
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	label: foo {
+		x = [ 2F 66 6F 6F 00 2F 66 6F 6F 00 00 00 00 01 ];
+		phandle = [ 00 00 00 01 ];
+	};
+};
+""")
+
+    #
+    # Test /memreserve/
+    #
+
+    dt = verify_parse("""
+/dts-v1/;
+
+l1: l2: /memreserve/ (1 + 1) (2 * 2);
+/memreserve/ 0x100 0x200;
+
+/ {
+};
+""",
+"""
+/dts-v1/;
+
+l1: l2: /memreserve/ 0x0000000000000002 0x0000000000000004;
+/memreserve/ 0x0000000000000100 0x0000000000000200;
+
+/ {
+};
+""")
+
+    expected = [(["l1", "l2"], 2, 4), ([], 0x100, 0x200)]
+    if dt.memreserves != expected:
+        fail("expected {} for dt.memreserve, got {}"
+             .format(expected, dt.memreserves))
+
+    #
+    # Test __repr__() functions
+    #
+
+    def verify_repr(obj, expected):
+        if repr(obj) != expected:
+            fail("expected repr() to be '{}', was '{}'"
+                 .format(expected, repr(obj)))
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	x = < 0 >;
+	sub {
+		y = < 1 >;
+	};
+};
+""",
+    include_path=("foo", "bar"))
+
+    verify_repr(dt, "DT(filename='.tmp.dts', include_path=('foo', 'bar'))")
+    verify_repr(dt.root.props["x"], "<Property 'x' at '/' in '.tmp.dts'>")
+    verify_repr(dt.root.nodes["sub"], "<Node /sub in '.tmp.dts'>")
+
+    #
+    # Test names
+    #
+
+    # The C tools disallow '@' in property names, but otherwise accept the same
+    # characters in node and property names. Emulate that instead of the DT spec
+    # (v0.2), which gives different characters for nodes and properties.
+    verify_parse(r"""
+/dts-v1/;
+
+/ {
+	// A leading \ is accepted but ignored in node/propert names
+	\aA0,._+*#?- = &_, &{/aA0,._+*#?@-};
+
+	// Names that overlap with operators
+	+ = [ 00 ];
+	* = [ 02 ];
+	- = [ 01 ];
+	? = [ 03 ];
+
+	_: \aA0,._+*#?@- {
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	aA0,._+*#?- = [ 2F 61 41 30 2C 2E 5F 2B 2A 23 3F 40 2D 00 2F 61 41 30 2C 2E 5F 2B 2A 23 3F 40 2D 00 ];
+	+ = [ 00 ];
+	* = [ 02 ];
+	- = [ 01 ];
+	? = [ 03 ];
+	_: aA0,._+*#?@- {
+	};
+};
+""")
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	foo@3;
+};
+""",
+".tmp.dts:4 (column 7): parse error: '@' is only allowed in node names")
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	foo@3 = < 0 >;
+};
+""",
+".tmp.dts:4 (column 8): parse error: '@' is only allowed in node names")
+
+    verify_error(r"""
+/dts-v1/;
+
+/ {
+	foo@2@3 {
+	};
+};
+""",
+".tmp.dts:4 (column 10): parse error: multiple '@' in node name")
+
+    #
+    # Test bad formatting
+    #
+
+    verify_parse("""
+/dts-v1/;/{l1:l2:foo{l3:l4:bar{l5:x=l6:/bits/8<l7:1 l8:2>l9:,[03],"a";};};};
+""",
+"""
+/dts-v1/;
+
+/ {
+	l1: l2: foo {
+		l3: l4: bar {
+			l5: x = [ l6: l7: 01 l8: 02 l9: 03 61 00 ];
+		};
+	};
+};
+""")
+
+    #
+    # Test misc. errors and non-errors
+    #
+
+    verify_error("", ".tmp.dts:1 (column 1): parse error: expected '/dts-v1/;' at start of file")
+
+    verify_error("""
+/dts-v1/;
+""",
+".tmp.dts:2 (column 1): parse error: no root node defined")
+
+    verify_error("""
+/dts-v1/; /plugin/;
+""",
+".tmp.dts:1 (column 11): parse error: /plugin/ is not supported")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo: foo {
+	};
+};
+
+// Only one label supported before label references at the top level
+l1: l2: &foo {
+};
+""",
+".tmp.dts:9 (column 5): parse error: expected label reference (&foo)")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+        foo: {};
+};
+""",
+".tmp.dts:4 (column 14): parse error: expected node or property name")
+
+    # Multiple /dts-v1/ at the start of a file is fine
+    verify_parse("""
+/dts-v1/;
+/dts-v1/;
+
+/ {
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+};
+""")
+
+    print("all tests passed")
+
+    # Only remove these if tests succeed. They're handy to have around otherwise.
+    shutil.rmtree(".tmp")
+    shutil.rmtree(".tmp2")
+    os.remove(".tmp.dts")
+    os.remove(".tmp2.dts")
+    os.remove(".tmp3.dts")
+    os.remove(".tmp.bin")
+
+
+if __name__ == "__main__":
+    run()
diff --git a/scripts/dts/testedtlib.py b/scripts/dts/testedtlib.py
new file mode 100755
index 00000000000..094e5771ae6
--- /dev/null
+++ b/scripts/dts/testedtlib.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Nordic Semiconductor ASA
+# SPDX-License-Identifier: BSD-3-Clause
+
+import edtlib
+
+# Test suite for edtlib.py. Mostly uses string comparisons via the various
+# __repr__() methods. Can be run directly as an executable.
+#
+# This script expects to be run from the directory its in. This simplifies
+# things, as paths in the output can be assumed below.
+#
+# test.dts is the test file, and test-bindings/ has bindings.
+
+
+def run():
+    """
+    Runs all edtlib tests. Immediately exits with status 1 and a message on
+    stderr on test suite failures.
+    """
+
+    def fail(msg):
+        raise Exception("test failed: " + msg)
+
+    def verify_streq(actual, expected):
+        actual = str(actual)
+        if actual != expected:
+            # Put values on separate lines to make it easy to spot differences
+            fail("not equal (expected value last):\n'{}'\n'{}'"
+                 .format(actual, expected))
+
+    edt = edtlib.EDT("test.dts", "test-bindings")
+
+    #
+    # Test interrupts
+    #
+
+    verify_streq(edt.get_dev("/interrupt-parent-test/node").interrupts,
+                 "[<Interrupt, name: foo, target: <Device /interrupt-parent-test/controller in 'test.dts', binding test-bindings/interrupt-3-cell.yaml>, specifier: {'one': 1, 'two': 2, 'three': 3}>, <Interrupt, name: bar, target: <Device /interrupt-parent-test/controller in 'test.dts', binding test-bindings/interrupt-3-cell.yaml>, specifier: {'one': 4, 'two': 5, 'three': 6}>]")
+
+    verify_streq(edt.get_dev("/interrupts-extended-test/node").interrupts,
+                 "[<Interrupt, target: <Device /interrupts-extended-test/controller-0 in 'test.dts', binding test-bindings/interrupt-1-cell.yaml>, specifier: {'one': 1}>, <Interrupt, target: <Device /interrupts-extended-test/controller-1 in 'test.dts', binding test-bindings/interrupt-2-cell.yaml>, specifier: {'one': 2, 'two': 3}>, <Interrupt, target: <Device /interrupts-extended-test/controller-2 in 'test.dts', binding test-bindings/interrupt-3-cell.yaml>, specifier: {'one': 4, 'two': 5, 'three': 6}>]")
+
+    verify_streq(edt.get_dev("/interrupt-map-test/node@0").interrupts,
+                 "[<Interrupt, target: <Device /interrupt-map-test/controller-0 in 'test.dts', binding test-bindings/interrupt-1-cell.yaml>, specifier: {'one': 0}>, <Interrupt, target: <Device /interrupt-map-test/controller-1 in 'test.dts', binding test-bindings/interrupt-2-cell.yaml>, specifier: {'one': 0, 'two': 1}>, <Interrupt, target: <Device /interrupt-map-test/controller-2 in 'test.dts', binding test-bindings/interrupt-3-cell.yaml>, specifier: {'one': 0, 'two': 0, 'three': 2}>]")
+
+    verify_streq(edt.get_dev("/interrupt-map-test/node@1").interrupts,
+                 "[<Interrupt, target: <Device /interrupt-map-test/controller-0 in 'test.dts', binding test-bindings/interrupt-1-cell.yaml>, specifier: {'one': 3}>, <Interrupt, target: <Device /interrupt-map-test/controller-1 in 'test.dts', binding test-bindings/interrupt-2-cell.yaml>, specifier: {'one': 0, 'two': 4}>, <Interrupt, target: <Device /interrupt-map-test/controller-2 in 'test.dts', binding test-bindings/interrupt-3-cell.yaml>, specifier: {'one': 0, 'two': 0, 'three': 5}>]")
+
+    verify_streq(edt.get_dev("/interrupt-map-bitops-test/node@70000000E").interrupts,
+                 "[<Interrupt, target: <Device /interrupt-map-bitops-test/controller in 'test.dts', binding test-bindings/interrupt-2-cell.yaml>, specifier: {'one': 3, 'two': 2}>]")
+
+    #
+    # Test GPIOs
+    #
+
+    verify_streq(edt.get_dev("/gpio-test/node").gpios,
+                 "{'': [<GPIO, name: , target: <Device /gpio-test/controller-0 in 'test.dts', binding test-bindings/gpio-1-cell.yaml>, specifier: {'one': 1}>, <GPIO, name: , target: <Device /gpio-test/controller-1 in 'test.dts', binding test-bindings/gpio-2-cell.yaml>, specifier: {'one': 2, 'two': 3}>], 'foo': [<GPIO, name: foo, target: <Device /gpio-test/controller-1 in 'test.dts', binding test-bindings/gpio-2-cell.yaml>, specifier: {'one': 4, 'two': 5}>], 'bar': [<GPIO, name: bar, target: <Device /gpio-test/controller-1 in 'test.dts', binding test-bindings/gpio-2-cell.yaml>, specifier: {'one': 6, 'two': 7}>]}")
+
+    #
+    # Test clocks
+    #
+
+    verify_streq(edt.get_dev("/clock-test/node").clocks,
+                 "[<Clock, name: fixed, frequency: 123, target: <Device /clock-test/fixed-clock in 'test.dts', binding test-bindings/fixed-clock.yaml>, specifier: {}>, <Clock, name: one-cell, target: <Device /clock-test/clock-1 in 'test.dts', binding test-bindings/clock-1-cell.yaml>, specifier: {'one': 1}>, <Clock, name: two-cell, target: <Device /clock-test/clock-2 in 'test.dts', binding test-bindings/clock-2-cell.yaml>, specifier: {'one': 1, 'two': 2}>]")
+
+    #
+    # Test PWMs
+    #
+
+    verify_streq(edt.get_dev("/pwm-test/node").pwms,
+                 "[<PWM, name: zero-cell, target: <Device /pwm-test/pwm-0 in 'test.dts', binding test-bindings/pwm-0-cell.yaml>, specifier: {}>, <PWM, name: one-cell, target: <Device /pwm-test/pwm-1 in 'test.dts', binding test-bindings/pwm-1-cell.yaml>, specifier: {'one': 1}>]")
+
+    #
+    # Test 'reg'
+    #
+
+    verify_streq(edt.get_dev("/reg-zero-address-cells/node").regs,
+                 "[<Register, addr: 0x0, size: 0x1>, <Register, addr: 0x0, size: 0x2>]")
+
+    verify_streq(edt.get_dev("/reg-zero-size-cells/node").regs,
+                 "[<Register, addr: 0x1, size: 0x0>, <Register, addr: 0x2, size: 0x0>]")
+
+    verify_streq(edt.get_dev("/reg-ranges/parent/node").regs,
+                 "[<Register, addr: 0x5, size: 0x1>, <Register, addr: 0xe0000000f, size: 0x1>, <Register, addr: 0xc0000000e, size: 0x1>, <Register, addr: 0xc0000000d, size: 0x1>, <Register, addr: 0xa0000000b, size: 0x1>, <Register, addr: 0x0, size: 0x1>]")
+
+    verify_streq(edt.get_dev("/reg-nested-ranges/grandparent/parent/node").regs,
+                 "[<Register, addr: 0x30000000200000001, size: 0x1>]")
+
+    #
+    # Test !include in bindings
+    #
+
+    verify_streq(edt.get_dev("/binding-include").description,
+                 "Parent binding")
+
+    verify_streq(edt.get_dev("/binding-include").props,
+                 "{'compatible': <Property, name: compatible, value: ['binding-include-test']>, 'foo': <Property, name: foo, value: 0>, 'bar': <Property, name: bar, value: 1>, 'baz': <Property, name: baz, value: 2>}")
+
+    #
+    # Test 'sub-node:' in binding
+    #
+
+    verify_streq(edt.get_dev("/parent-with-sub-node/node").description,
+                 "Sub-node test")
+
+    verify_streq(edt.get_dev("/parent-with-sub-node/node").props,
+                 "{'foo': <Property, name: foo, value: 1>, 'bar': <Property, name: bar, value: 2>}")
+
+    #
+    # Test Device.property (derived from DT and 'properties:' in the binding)
+    #
+
+    verify_streq(edt.get_dev("/props").props,
+                 r"{'compatible': <Property, name: compatible, value: ['props']>, 'int': <Property, name: int, value: 1>, 'array': <Property, name: array, value: [1, 2, 3]>, 'uint8-array': <Property, name: uint8-array, value: b'\x124'>, 'string': <Property, name: string, value: 'foo'>, 'string-array': <Property, name: string-array, value: ['foo', 'bar', 'baz']>}")
+
+
+    print("all tests passed")
+
+
+if __name__ == "__main__":
+    run()