commit 5a300551574451fbf509685d11095bda4fcb20be
Author: Andreas Kling <andreas@ladybird.org>
Date:   Wed Oct 10 11:53:07 2018 +0200

    Import all this stuff into a single repo called Serenity.

Notes:
    Author: https://github.com/awesomekling 🔰
    Commit: https://github.com/SerenityOS/serenity/commit/5a300551574

diff --git a/AK/.gitignore b/AK/.gitignore
new file mode 100644
index 00000000000..516ac8b0150
--- /dev/null
+++ b/AK/.gitignore
@@ -0,0 +1 @@
+akit-test
diff --git a/AK/Assertions.h b/AK/Assertions.h
new file mode 100644
index 00000000000..f78ccd921b2
--- /dev/null
+++ b/AK/Assertions.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <assert.h>
+
+#define ASSERT(x) assert(x)
+#define ASSERT_NOT_REACHED() assert(false)
+
+namespace AK {
+
+inline void notImplemented() { assert(false); }
+
+}
+
+using AK::notImplemented;
+
diff --git a/AK/Bitmap.h b/AK/Bitmap.h
new file mode 100644
index 00000000000..553d1b12b10
--- /dev/null
+++ b/AK/Bitmap.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include "StdLib.h"
+#include "Types.h"
+#include "kmalloc.h"
+
+namespace AK {
+
+class Bitmap {
+public:
+    // NOTE: A wrapping Bitmap won't try to free the wrapped data.
+    static Bitmap wrap(byte* data, unsigned size)
+    {
+        return Bitmap(data, size);
+    }
+
+    static Bitmap create(unsigned size)
+    {
+        return Bitmap(size);
+    }
+
+    ~Bitmap()
+    {
+        if (m_owned)
+            kfree(m_data);
+        m_data = nullptr;
+    }
+
+    unsigned size() const { return m_size; }
+    bool get(unsigned index) const
+    {
+        ASSERT(index < m_size);
+        return 0 != (m_data[index / 8] & (1u << (index % 8)));
+    }
+    void set(unsigned index, bool value) const
+    {
+        ASSERT(index < m_size);
+        if (value)
+            m_data[index / 8] |= static_cast<byte>((1u << (index % 8)));
+        else
+            m_data[index / 8] &= static_cast<byte>(~(1u << (index % 8)));
+    }
+
+    byte* data() { return m_data; }
+    const byte* data() const { return m_data; }
+
+private:
+    explicit Bitmap(unsigned size)
+        : m_size(size)
+        , m_owned(true)
+    {
+        ASSERT(m_size != 0);
+        m_data = reinterpret_cast<byte*>(kmalloc(ceilDiv(size, 8u)));
+    }
+
+    Bitmap(byte* data, unsigned size)
+        : m_data(data)
+        , m_size(size)
+        , m_owned(false)
+    {
+    }
+
+    byte* m_data { nullptr };
+    unsigned m_size { 0 };
+    bool m_owned { false };
+};
+
+}
+
+using AK::Bitmap;
+
diff --git a/AK/Buffer.h b/AK/Buffer.h
new file mode 100644
index 00000000000..21d2da49eda
--- /dev/null
+++ b/AK/Buffer.h
@@ -0,0 +1,120 @@
+#pragma once
+
+#include "Assertions.h"
+#include "Retainable.h"
+#include "RetainPtr.h"
+#include <cstdlib>
+#include <cstring>
+#include "kmalloc.h"
+
+namespace AK {
+
+template<typename T>
+class Buffer : public Retainable<Buffer<T>> {
+public:
+    static RetainPtr<Buffer> createUninitialized(size_t count);
+    static RetainPtr<Buffer> copy(const T*, size_t count);
+    static RetainPtr<Buffer> wrap(T*, size_t count);
+    static RetainPtr<Buffer> adopt(T*, size_t count);
+
+    ~Buffer() { clear(); }
+
+    void clear()
+    {
+        if (!m_elements)
+            return;
+        kfree(m_elements);
+        m_elements = nullptr;
+    }
+
+    T& operator[](size_t i) { ASSERT(i < m_size); return m_elements[i]; }
+    const T& operator[](size_t i) const { ASSERT(i < m_size); return m_elements[i]; }
+    bool isEmpty() const { return !m_size; }
+    size_t size() const { return m_size; }
+
+    T* pointer() { return m_elements; }
+    const T* pointer() const { return m_elements; }
+
+    T* offsetPointer(size_t offset) { return m_elements + offset; }
+    const T* offsetPointer(size_t offset) const { return m_elements + offset; }
+
+    const void* endPointer() const { return m_elements + m_size; }
+
+    // NOTE: trim() does not reallocate.
+    void trim(size_t size)
+    {
+        ASSERT(size <= m_size);
+        m_size = size;
+    }
+
+private:
+    enum ConstructionMode { Uninitialized, Copy, Wrap, Adopt };
+    explicit Buffer(size_t); // For ConstructionMode=Uninitialized
+    Buffer(const T*, size_t, ConstructionMode); // For ConstructionMode=Copy
+    Buffer(T*, size_t, ConstructionMode); // For ConstructionMode=Wrap/Adopt
+    Buffer() { }
+
+    T* m_elements { nullptr };
+    size_t m_size { 0 };
+    bool m_owned { false };
+};
+
+template<typename T>
+inline Buffer<T>::Buffer(size_t size)
+    : m_size(size)
+{
+    m_elements = static_cast<T*>(kmalloc(size * sizeof(T)));
+    m_owned = true;
+}
+
+template<typename T>
+inline Buffer<T>::Buffer(const T* elements, size_t size, ConstructionMode mode)
+    : m_size(size)
+{
+    ASSERT(mode == Copy);
+    m_elements = static_cast<T*>(kmalloc(size * sizeof(T)));
+    memcpy(m_elements, elements, size * sizeof(T));
+    m_owned = true;
+}
+
+template<typename T>
+inline Buffer<T>::Buffer(T* elements, size_t size, ConstructionMode mode)
+    : m_elements(elements)
+    , m_size(size)
+{
+    if (mode == Adopt) {
+        m_owned = true;
+    } else if (mode == Wrap) {
+        m_owned = false;
+    }
+
+}
+
+template<typename T>
+inline RetainPtr<Buffer<T>> Buffer<T>::createUninitialized(size_t size)
+{
+    return ::adopt(*new Buffer<T>(size));
+}
+
+template<typename T>
+inline RetainPtr<Buffer<T>> Buffer<T>::copy(const T* elements, size_t size)
+{
+    return ::adopt(*new Buffer<T>(elements, size, Copy));
+}
+
+template<typename T>
+inline RetainPtr<Buffer<T>> Buffer<T>::wrap(T* elements, size_t size)
+{
+    return ::adopt(*new Buffer<T>(elements, size, Wrap));
+}
+
+template<typename T>
+inline RetainPtr<Buffer<T>> Buffer<T>::adopt(T* elements, size_t size)
+{
+    return ::adopt(*new Buffer<T>(elements, size, Adopt));
+}
+
+}
+
+using AK::Buffer;
+
diff --git a/AK/ByteBuffer.h b/AK/ByteBuffer.h
new file mode 100644
index 00000000000..ee84e2091f0
--- /dev/null
+++ b/AK/ByteBuffer.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "Buffer.h"
+#include "Types.h"
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+
+namespace AK {
+
+class ByteBuffer {
+public:
+    ByteBuffer() { }
+    ByteBuffer(std::nullptr_t) { }
+    ByteBuffer(const ByteBuffer& other)
+        : m_impl(other.m_impl.copyRef())
+    {
+    }
+    ByteBuffer(ByteBuffer&& other)
+        : m_impl(std::move(other.m_impl))
+    {
+    }
+    ByteBuffer& operator=(ByteBuffer&& other)
+    {
+        if (this != &other)
+            m_impl = std::move(other.m_impl);
+        return *this;
+    }
+
+    static ByteBuffer createUninitialized(size_t size) { return ByteBuffer(Buffer<byte>::createUninitialized(size)); }
+    static ByteBuffer copy(const byte* data, size_t size) { return ByteBuffer(Buffer<byte>::copy(data, size)); }
+    static ByteBuffer wrap(byte* data, size_t size) { return ByteBuffer(Buffer<byte>::wrap(data, size)); }
+    static ByteBuffer adopt(byte* data, size_t size) { return ByteBuffer(Buffer<byte>::adopt(data, size)); }
+
+    ~ByteBuffer() { clear(); }
+    void clear() { m_impl = nullptr; }
+
+    operator bool() const { return !isNull(); }
+    bool operator!() const { return isNull(); }
+    bool isNull() const { return m_impl == nullptr; }
+
+    byte& operator[](size_t i) { ASSERT(m_impl); return (*m_impl)[i]; }
+    byte operator[](size_t i) const { ASSERT(m_impl); return (*m_impl)[i]; }
+    bool isEmpty() const { return !m_impl || m_impl->isEmpty(); }
+    size_t size() const { return m_impl ? m_impl->size() : 0; }
+
+    byte* pointer() { return m_impl ? m_impl->pointer() : nullptr; }
+    const byte* pointer() const { return m_impl ? m_impl->pointer() : nullptr; }
+
+    byte* offsetPointer(size_t offset) { return m_impl ? m_impl->offsetPointer(offset) : nullptr; }
+    const byte* offsetPointer(size_t offset) const { return m_impl ? m_impl->offsetPointer(offset) : nullptr; }
+
+    const void* endPointer() const { return m_impl ? m_impl->endPointer() : nullptr; }
+
+    // NOTE: trim() does not reallocate.
+    void trim(size_t size)
+    {
+        if (m_impl)
+            m_impl->trim(size);
+    }
+
+    ByteBuffer slice(size_t offset, size_t size) const
+    {
+        if (isNull())
+            return { };
+        if (offset >= this->size())
+            return { };
+        if (offset + size >= this->size())
+            size = this->size() - offset;
+        return copy(offsetPointer(offset), size);
+    }
+
+private:
+    explicit ByteBuffer(RetainPtr<Buffer<byte>>&& impl)
+        : m_impl(std::move(impl))
+    {
+    }
+
+    RetainPtr<Buffer<byte>> m_impl;
+};
+
+}
+
+using AK::ByteBuffer;
+
diff --git a/AK/HashMap.h b/AK/HashMap.h
new file mode 100644
index 00000000000..7707fc9cabd
--- /dev/null
+++ b/AK/HashMap.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include "HashTable.h"
+#include <utility>
+
+namespace AK {
+
+template<typename K, typename V>
+class HashMap {
+private:
+    struct Entry {
+        K key;
+        V value;
+
+        bool operator==(const Entry& other)
+        {
+            return key == other.key;
+        }
+    };
+
+    struct EntryTraits {
+        static unsigned hash(const Entry& entry) { return Traits<K>::hash(entry.key); }
+        static void dump(const Entry& entry)
+        {
+            printf("key=");
+            Traits<K>::dump(entry.key);
+            printf(" value=");
+            Traits<V>::dump(entry.value);
+        }
+    };
+
+public:
+    HashMap() { }
+
+    HashMap(HashMap&& other)
+        : m_table(std::move(other.m_table))
+    {
+    }
+
+    HashMap& operator=(HashMap&& other)
+    {
+        if (this != &other) {
+            m_table = std::move(other.m_table);
+        }
+        return *this;
+    }
+
+    bool isEmpty() const { return m_table.isEmpty(); }
+    unsigned size() const { return m_table.size(); }
+    unsigned capacity() const { return m_table.capacity(); }
+
+    void set(const K&, V&&);
+
+    typedef HashTable<Entry, EntryTraits> HashTableType;
+    typedef typename HashTableType::Iterator IteratorType;
+    typedef typename HashTableType::ConstIterator ConstIteratorType;
+
+    IteratorType begin() { return m_table.begin(); }
+    IteratorType end() { return m_table.end(); }
+    IteratorType find(const K&);
+
+    ConstIteratorType begin() const { return m_table.begin(); }
+    ConstIteratorType end() const { return m_table.end(); }
+    ConstIteratorType find(const K&) const;
+
+    void dump() const { m_table.dump(); }
+
+private:
+    HashTable<Entry, EntryTraits> m_table;
+};
+
+template<typename K, typename V>
+void HashMap<K, V>::set(const K& key, V&& value)
+{
+    m_table.set(Entry{key, std::move(value)});
+}
+
+template<typename K, typename V>
+auto HashMap<K, V>::find(const K& key) -> IteratorType
+{
+    Entry dummy { key, V() };
+    return m_table.find(dummy);
+}
+
+template<typename K, typename V>
+auto HashMap<K, V>::find(const K& key) const -> ConstIteratorType
+{
+    Entry dummy { key, V() };
+    return m_table.find(dummy);
+}
+
+}
+
+using AK::HashMap;
+
diff --git a/AK/HashTable.h b/AK/HashTable.h
new file mode 100644
index 00000000000..90c195e5201
--- /dev/null
+++ b/AK/HashTable.h
@@ -0,0 +1,360 @@
+#pragma once
+
+#include "Assertions.h"
+#include "SinglyLinkedList.h"
+#include "Traits.h"
+#include <cstdlib>
+#include <utility>
+
+//#define HASHTABLE_DEBUG
+
+namespace AK {
+
+template<typename T, typename = Traits<T>> class HashTable;
+
+template<typename T, typename TraitsForT>
+class HashTable {
+private:
+    struct Bucket {
+        SinglyLinkedList<T> chain;
+    };
+
+public:
+    HashTable() { }
+    explicit HashTable(HashTable&& other)
+        : m_buckets(other.m_buckets)
+        , m_size(other.m_size)
+        , m_capacity(other.m_capacity)
+    {
+        other.m_size = 0;
+        other.m_capacity = 0;
+        other.m_buckets = nullptr;
+    }
+    HashTable& operator=(HashTable&& other)
+    {
+        if (this != &other) {
+            m_buckets = other.m_buckets;
+            m_size = other.m_size;
+            m_capacity = other.m_capacity;
+            other.m_size = 0;
+            other.m_capacity = 0;
+            other.m_buckets = nullptr;
+        }
+        return *this;
+    }
+
+    ~HashTable() { clear(); }
+    bool isEmpty() const { return !m_size; }
+    unsigned size() const { return m_size; }
+    unsigned capacity() const { return m_capacity; }
+
+    void set(T&&);
+    bool contains(const T&) const;
+    void clear();
+
+    void dump() const;
+
+    class Iterator {
+    public:
+        bool operator!=(const Iterator& other)
+        {
+            if (m_isEnd && other.m_isEnd)
+                return false;
+            return &m_table != &other.m_table
+                || m_isEnd != other.m_isEnd
+                || m_bucketIndex != other.m_bucketIndex
+                || m_bucketIterator != other.m_bucketIterator;
+        }
+        T& operator*()
+        {
+#ifdef HASHTABLE_DEBUG
+            printf("retrieve { bucketIndex: %u, isEnd: %u }\n", m_bucketIndex, m_isEnd);
+#endif
+            return *m_bucketIterator;
+        }
+        Iterator& operator++()
+        {
+            skipToNext();
+            return *this;
+        }
+
+        void skipToNext()
+        {
+#ifdef HASHTABLE_DEBUG
+            unsigned pass = 0;
+#endif
+            while (!m_isEnd) {
+#ifdef HASHTABLE_DEBUG
+                ++pass;
+                printf("skipToNext pass %u, m_bucketIndex=%u\n", pass, m_bucketIndex);
+#endif
+                if (m_bucketIterator.isEnd()) {
+                    ++m_bucketIndex;
+                    if (m_bucketIndex >= m_table.capacity()) {
+                        m_isEnd = true;
+                        return;
+                    }
+                    m_bucketIterator = m_table.m_buckets[m_bucketIndex].chain.begin();
+                } else {
+                    ++m_bucketIterator;
+                }
+                if (!m_bucketIterator.isEnd())
+                    return;
+            }
+        }
+    private:
+        friend class HashTable;
+        explicit Iterator(HashTable& table, bool isEnd, typename SinglyLinkedList<T>::Iterator bucketIterator = SinglyLinkedList<T>::Iterator::universalEnd())
+            : m_table(table)
+            , m_isEnd(isEnd)
+            , m_bucketIterator(bucketIterator)
+        {
+            if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != SinglyLinkedList<T>::Iterator::universalEnd())) {
+#ifdef HASHTABLE_DEBUG
+                printf("bucket iterator init!\n");
+#endif
+                m_bucketIterator = m_table.m_buckets[0].chain.begin();
+                if (m_bucketIterator.isEnd())
+                    skipToNext();
+            }
+        }
+
+        HashTable& m_table;
+        unsigned m_bucketIndex { 0 };
+        bool m_isEnd { false };
+        typename SinglyLinkedList<T>::Iterator m_bucketIterator;
+    };
+
+    Iterator begin() { return Iterator(*this, false); }
+    Iterator end() { return Iterator(*this, true); }
+
+    class ConstIterator {
+    public:
+        bool operator!=(const ConstIterator& other)
+        {
+            if (m_isEnd && other.m_isEnd)
+                return false;
+            return &m_table != &other.m_table
+                || m_isEnd != other.m_isEnd
+                || m_bucketIndex != other.m_bucketIndex
+                || m_bucketIterator != other.m_bucketIterator;
+        }
+        const T& operator*() const
+        {
+#ifdef HASHTABLE_DEBUG
+            printf("retrieve { bucketIndex: %u, isEnd: %u }\n", m_bucketIndex, m_isEnd);
+#endif
+            return *m_bucketIterator;
+        }
+        ConstIterator& operator++()
+        {
+            skipToNext();
+            return *this;
+        }
+
+        void skipToNext()
+        {
+#ifdef HASHTABLE_DEBUG
+            unsigned pass = 0;
+#endif
+            while (!m_isEnd) {
+#ifdef HASHTABLE_DEBUG
+                ++pass;
+                printf("skipToNext pass %u, m_bucketIndex=%u\n", pass, m_bucketIndex);
+#endif
+                if (m_bucketIterator.isEnd()) {
+                    ++m_bucketIndex;
+                    if (m_bucketIndex >= m_table.capacity()) {
+                        m_isEnd = true;
+                        return;
+                    }
+                    const SinglyLinkedList<T>& chain = m_table.m_buckets[m_bucketIndex].chain;
+                    m_bucketIterator = chain.begin();
+                } else {
+                    ++m_bucketIterator;
+                }
+                if (!m_bucketIterator.isEnd())
+                    return;
+            }
+        }
+    private:
+        friend class HashTable;
+        ConstIterator(const HashTable& table, bool isEnd, typename SinglyLinkedList<T>::ConstIterator bucketIterator = SinglyLinkedList<T>::ConstIterator::universalEnd())
+            : m_table(table)
+            , m_isEnd(isEnd)
+            , m_bucketIterator(bucketIterator)
+        {
+            if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != SinglyLinkedList<T>::ConstIterator::universalEnd())) {
+#ifdef HASHTABLE_DEBUG
+                printf("bucket iterator init!\n");
+#endif
+                const SinglyLinkedList<T>& chain = m_table.m_buckets[0].chain;
+                m_bucketIterator = chain.begin();
+                
+                skipToNext();
+            }
+        }
+
+        const HashTable& m_table;
+        unsigned m_bucketIndex { 0 };
+        bool m_isEnd { false };
+        typename SinglyLinkedList<T>::ConstIterator m_bucketIterator;
+    };
+
+    ConstIterator begin() const { return ConstIterator(*this, false); }
+    ConstIterator end() const { return ConstIterator(*this, true); }
+
+    Iterator find(const T&);
+    ConstIterator find(const T&) const;
+
+private:
+    Bucket& lookup(const T&);
+    const Bucket& lookup(const T&) const;
+    void rehash(unsigned capacity);
+    void insert(T&&);
+
+    Bucket* m_buckets { nullptr };
+
+    unsigned m_size { 0 };
+    unsigned m_capacity { 0 };
+};
+
+template<typename T, typename TraitsForT>
+void HashTable<T, TraitsForT>::set(T&& value)
+{
+    if (!m_capacity)
+        rehash(1);
+    auto& bucket = lookup(value);
+    for (auto& e : bucket.chain) {
+        if (e == value)
+            return;
+    }
+    if (size() >= capacity()) {
+        rehash(size() + 1);
+        insert(std::move(value));
+    } else {
+        bucket.chain.append(std::move(value));
+    }
+    m_size++;
+}
+
+template<typename T, typename TraitsForT>
+void HashTable<T, TraitsForT>::rehash(unsigned newCapacity)
+{
+    newCapacity *= 2;
+#ifdef HASHTABLE_DEBUG
+    printf("rehash to %u buckets\n", newCapacity);
+#endif
+    auto* newBuckets = new Bucket[newCapacity];
+    auto* oldBuckets = m_buckets;
+    unsigned oldCapacity = m_capacity;
+    m_buckets = newBuckets;
+    m_capacity = newCapacity;
+
+#ifdef HASHTABLE_DEBUG
+    printf("reinsert %u buckets\n", oldCapacity);
+#endif
+    for (unsigned i = 0; i < oldCapacity; ++i) {
+        for (auto& value : oldBuckets[i].chain) {
+            insert(std::move(value));
+        }
+    }
+
+    delete [] oldBuckets;
+}
+
+template<typename T, typename TraitsForT>
+void HashTable<T, TraitsForT>::clear()
+{
+    delete [] m_buckets;
+    m_capacity = 0;
+    m_size = 0;
+}
+
+template<typename T, typename TraitsForT>
+void HashTable<T, TraitsForT>::insert(T&& value)
+{
+    auto& bucket = lookup(value);
+    bucket.chain.append(std::move(value));
+}
+
+template<typename T, typename TraitsForT>
+bool HashTable<T, TraitsForT>::contains(const T& value) const
+{
+    if (isEmpty())
+        return false;
+    auto& bucket = lookup(value);
+    for (auto& e : bucket.chain) {
+        if (e == value)
+            return true;
+    }
+    return false;
+}
+
+template<typename T, typename TraitsForT>
+auto HashTable<T, TraitsForT>::find(const T& value) -> Iterator
+{
+    if (isEmpty())
+        return end();
+    auto& bucket = lookup(value);
+    auto bucketIterator = bucket.chain.find(value);
+    if (bucketIterator != bucket.chain.end())
+        return Iterator(*this, false, bucketIterator);
+    return end();
+}
+
+template<typename T, typename TraitsForT>
+auto HashTable<T, TraitsForT>::find(const T& value) const -> ConstIterator
+{
+    if (isEmpty())
+        return end();
+    auto& bucket = lookup(value);
+    auto bucketIterator = bucket.chain.find(value);
+    if (bucketIterator != bucket.chain.end())
+        return ConstIterator(*this, false, bucketIterator);
+    return end();
+}
+
+template<typename T, typename TraitsForT>
+typename HashTable<T, TraitsForT>::Bucket& HashTable<T, TraitsForT>::lookup(const T& value)
+{
+    unsigned hash = TraitsForT::hash(value);
+#ifdef HASHTABLE_DEBUG
+    printf("hash for ");
+    TraitsForT::dump(value);
+    printf(" is %u\n", hash);
+#endif
+    return m_buckets[hash % m_capacity];
+}
+
+template<typename T, typename TraitsForT>
+const typename HashTable<T, TraitsForT>::Bucket& HashTable<T, TraitsForT>::lookup(const T& value) const
+{
+    unsigned hash = TraitsForT::hash(value);
+#ifdef HASHTABLE_DEBUG
+    printf("hash for ");
+    TraitsForT::dump(value);
+    printf(" is %u\n", hash);
+#endif
+    return m_buckets[hash % m_capacity];
+}
+
+template<typename T, typename TraitsForT>
+void HashTable<T, TraitsForT>::dump() const
+{
+    printf("HashTable{%p} m_size=%u, m_capacity=%u, m_buckets=%p\n", this, m_size, m_capacity, m_buckets);
+    for (unsigned i = 0; i < m_capacity; ++i) {
+        auto& bucket = m_buckets[i];
+        printf("Bucket %u\n", i);
+        for (auto& e : bucket.chain) {
+            printf("  > ");
+            TraitsForT::dump(e);
+            printf("\n");
+        }
+    }
+}
+
+}
+
+using AK::HashTable;
+
diff --git a/AK/Makefile b/AK/Makefile
new file mode 100644
index 00000000000..db2dbde8cc2
--- /dev/null
+++ b/AK/Makefile
@@ -0,0 +1,18 @@
+PROGRAM = akit-test
+OBJS = StringImpl.o String.o MappedFile.o TemporaryFile.o SimpleMalloc.o kmalloc.o test.o
+
+CXXFLAGS = -std=c++17 -O0 -W -Wall -ggdb3
+
+all:	$(PROGRAM)
+
+test.o: Vector.h String.h StringImpl.h MappedFile.h HashTable.h SinglyLinkedList.h Traits.h HashMap.h TemporaryFile.h Buffer.h
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) -o $@ -c $<
+
+clean:
+	rm -f $(OBJS) $(PROGRAM)
+
+$(PROGRAM): $(OBJS)
+	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
+
diff --git a/AK/MappedFile.cpp b/AK/MappedFile.cpp
new file mode 100644
index 00000000000..0afec761855
--- /dev/null
+++ b/AK/MappedFile.cpp
@@ -0,0 +1,48 @@
+#include "MappedFile.h"
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <cstdio>
+
+namespace AK {
+
+MappedFile::MappedFile(String&& fileName)
+    : m_fileName(std::move(fileName))
+{
+    m_fileLength = 1024;
+    m_fd = open(m_fileName.characters(), O_RDONLY);
+    
+    if (m_fd != -1) {
+        struct stat st;
+        fstat(m_fd, &st);
+        m_fileLength = st.st_size;
+        m_map = mmap(nullptr, m_fileLength, PROT_READ, MAP_SHARED, m_fd, 0);
+
+        if (m_map == MAP_FAILED)
+            perror("");
+    }
+
+    printf("MappedFile{%s} := { m_fd=%d, m_fileLength=%u, m_map=%p }\n", m_fileName.characters(), m_fd, m_fileLength, m_map);
+}
+
+MappedFile::~MappedFile()
+{
+    if (m_map != (void*)-1) {
+        ASSERT(m_fd != -1);
+        munmap(m_map, m_fileLength);
+    }
+}
+
+MappedFile::MappedFile(MappedFile&& other)
+    : m_fileName(std::move(other.m_fileName))
+    , m_fileLength(other.m_fileLength)
+    , m_fd(other.m_fd)
+    , m_map(other.m_map)
+{
+    other.m_fileLength = 0;
+    other.m_fd = -1;
+    other.m_map = (void*)-1;
+}
+
+}
+
diff --git a/AK/MappedFile.h b/AK/MappedFile.h
new file mode 100644
index 00000000000..d93908c8545
--- /dev/null
+++ b/AK/MappedFile.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "String.h"
+
+namespace AK {
+
+class MappedFile {
+public:
+    MappedFile() { }
+    explicit MappedFile(String&& fileName);
+    MappedFile(MappedFile&&);
+    ~MappedFile();
+
+    bool isValid() const { return m_map != (void*)-1; }
+
+    void* pointer() { return m_map; }
+    const void* pointer() const { return m_map; }
+    size_t fileLength() const { return m_fileLength; }
+
+private:
+    String m_fileName;
+    size_t m_fileLength { 0 };
+    int m_fd { -1 };
+    void* m_map { (void*)-1 };
+};
+
+}
+
+using AK::MappedFile;
+
diff --git a/AK/OwnPtr.h b/AK/OwnPtr.h
new file mode 100644
index 00000000000..91976314050
--- /dev/null
+++ b/AK/OwnPtr.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#include <cstddef>
+#include <utility>
+
+namespace AK {
+
+template<typename T>
+class OwnPtr {
+public:
+    OwnPtr() { }
+    explicit OwnPtr(T* ptr) : m_ptr(ptr) { }
+    OwnPtr(OwnPtr&& other) : m_ptr(other.leakPtr()) { }
+    template<typename U> OwnPtr(OwnPtr<U>&& other) : m_ptr(static_cast<T*>(other.leakPtr())) { }
+    ~OwnPtr() { clear(); }
+    OwnPtr(std::nullptr_t) { };
+
+    OwnPtr& operator=(OwnPtr&& other)
+    {
+        if (this != &other) {
+            delete m_ptr;
+            m_ptr = other.leakPtr();
+        }
+        return *this;
+    }
+
+    template<typename U>
+    OwnPtr& operator=(OwnPtr<U>&& other)
+    {
+        if (this != static_cast<void*>(&other)) {
+            delete m_ptr;
+            m_ptr = other.leakPtr();
+        }
+        return *this;
+    }
+
+    OwnPtr& operator=(T* ptr)
+    {
+        if (m_ptr != ptr)
+            delete m_ptr;
+        m_ptr = ptr;
+        return *this;
+    }
+
+    OwnPtr& operator=(std::nullptr_t)
+    {
+        clear();
+        return *this;
+    }
+
+    void clear()
+    {
+        delete m_ptr;
+        m_ptr = nullptr;
+    }
+
+    bool operator!() const { return !m_ptr; }
+
+    typedef T* OwnPtr::*UnspecifiedBoolType;
+    operator UnspecifiedBoolType() const { return m_ptr ? &OwnPtr::m_ptr : nullptr; }
+
+    T* leakPtr()
+    {
+        T* leakedPtr = m_ptr;
+        m_ptr = nullptr;
+        return leakedPtr;
+    }
+
+    T* ptr() { return m_ptr; }
+    const T* ptr() const { return m_ptr; }
+
+    T* operator->() { return m_ptr; }
+    const T* operator->() const { return m_ptr; }
+
+    T& operator*() { return *m_ptr; }
+    const T& operator*() const { return *m_ptr; }
+
+    operator bool() { return !!m_ptr; }
+
+private:
+    T* m_ptr = nullptr;
+};
+
+template<class T, class... Args> inline OwnPtr<T>
+make(Args&&... args)
+{
+    return OwnPtr<T>(new T(std::forward<Args>(args)...));
+}
+
+}
+
+using AK::OwnPtr;
+using AK::make;
+
diff --git a/AK/RetainPtr.h b/AK/RetainPtr.h
new file mode 100644
index 00000000000..f4af4d860ba
--- /dev/null
+++ b/AK/RetainPtr.h
@@ -0,0 +1,128 @@
+#pragma once
+
+#include <cstddef>
+#include <utility>
+
+namespace AK {
+
+template<typename T>
+inline void retainIfNotNull(T* ptr)
+{
+    if (ptr)
+        ptr->retain();
+}
+
+template<typename T>
+inline void releaseIfNotNull(T* ptr)
+{
+    if (ptr)
+        ptr->release();
+}
+
+template<typename T>
+class RetainPtr {
+public:
+    enum AdoptTag { Adopt };
+
+    RetainPtr() { }
+    RetainPtr(const T* ptr) : m_ptr(const_cast<T*>(ptr)) { retainIfNotNull(m_ptr); }
+    RetainPtr(T* ptr) : m_ptr(ptr) { retainIfNotNull(m_ptr); }
+    RetainPtr(T& object) : m_ptr(&object) { m_ptr->retain(); }
+    RetainPtr(AdoptTag, T& object) : m_ptr(&object) { }
+    RetainPtr(RetainPtr&& other) : m_ptr(other.leakRef()) { }
+    template<typename U> RetainPtr(RetainPtr<U>&& other) : m_ptr(static_cast<T*>(other.leakRef())) { }
+    ~RetainPtr() { clear(); }
+    RetainPtr(std::nullptr_t) { }
+
+    RetainPtr& operator=(RetainPtr&& other)
+    {
+        if (this != &other) {
+            releaseIfNotNull(m_ptr);
+            m_ptr = other.leakRef();
+        }
+        return *this;
+    }
+
+    template<typename U>
+    RetainPtr& operator=(RetainPtr<U>&& other)
+    {
+        if (this != static_cast<void*>(&other)) {
+            releaseIfNotNull(m_ptr);
+            m_ptr = other.leakRef();
+        }
+        return *this;
+    }
+
+    RetainPtr& operator=(T* ptr)
+    {
+        if (m_ptr != ptr)
+            releaseIfNotNull(m_ptr);
+        m_ptr = ptr;
+        retainIfNotNull(m_ptr);
+        return *this;
+    }
+
+    RetainPtr& operator=(T& object)
+    {
+        if (m_ptr != &object)
+            releaseIfNotNull(m_ptr);
+        m_ptr = &object;
+        retainIfNotNull(m_ptr);
+        return *this;
+    }
+
+    RetainPtr& operator=(std::nullptr_t)
+    {
+        clear();
+        return *this;
+    }
+
+    RetainPtr copyRef() const
+    {
+        return RetainPtr(m_ptr);
+    }
+
+    void clear()
+    {
+        releaseIfNotNull(m_ptr);
+        m_ptr = nullptr;
+    }
+
+    bool operator!() const { return !m_ptr; }
+
+    typedef T* RetainPtr::*UnspecifiedBoolType;
+    operator UnspecifiedBoolType() const { return m_ptr ? &RetainPtr::m_ptr : nullptr; }
+
+    T* leakRef()
+    {
+        T* leakedPtr = m_ptr;
+        m_ptr = nullptr;
+        return leakedPtr;
+    }
+
+    T* ptr() { return m_ptr; }
+    const T* ptr() const { return m_ptr; }
+
+    T* operator->() { return m_ptr; }
+    const T* operator->() const { return m_ptr; }
+
+    T& operator*() { return *m_ptr; }
+    const T& operator*() const { return *m_ptr; }
+
+    operator bool() { return !!m_ptr; }
+
+private:
+    T* m_ptr = nullptr;
+};
+
+template<typename T>
+inline RetainPtr<T> adopt(T& object)
+{
+    return RetainPtr<T>(RetainPtr<T>::Adopt, object);
+}
+
+}
+
+using AK::RetainPtr;
+using AK::adopt;
+
diff --git a/AK/Retainable.h b/AK/Retainable.h
new file mode 100644
index 00000000000..e8be166af32
--- /dev/null
+++ b/AK/Retainable.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "Assertions.h"
+
+namespace AK {
+
+template<typename T>
+class Retainable {
+public:
+    Retainable() { }
+
+    void retain()
+    {
+        ASSERT(m_retainCount);
+        ++m_retainCount;
+    }
+
+    void release()
+    {
+        assert(m_retainCount);
+        if (!--m_retainCount)
+            delete static_cast<const T*>(this);
+    }
+
+    int retainCount() const
+    {
+        return m_retainCount;
+    }
+
+protected:
+    ~Retainable()
+    {
+        ASSERT(!m_retainCount);
+    }
+
+private:
+    int m_retainCount { 1 };
+};
+
+}
+
+using AK::Retainable;
+
diff --git a/AK/SimpleMalloc.cpp b/AK/SimpleMalloc.cpp
new file mode 100644
index 00000000000..ef8c8483af1
--- /dev/null
+++ b/AK/SimpleMalloc.cpp
@@ -0,0 +1,254 @@
+#include "SimpleMalloc.h"
+#include "Assertions.h"
+#include "Types.h"
+#include <sys/mman.h>
+#include <cstring>
+#include <cstdio>
+
+namespace SimpleMalloc {
+
+class AllocationBitmap {
+public:
+    static AllocationBitmap wrap(byte* data, unsigned size)
+    {
+        return AllocationBitmap(data, size);
+    }
+
+    ~AllocationBitmap()
+    {
+    }
+
+    unsigned size() const { return m_size; }
+    bool get(unsigned index) const
+    {
+        ASSERT(index < m_size);
+        return 0 != (m_data[index / 8] & (1u << (index % 8)));
+    }
+    void set(unsigned index, bool value) const
+    {
+        ASSERT(index < m_size);
+        if (value)
+            m_data[index / 8] |= static_cast<byte>((1u << (index % 8)));
+        else
+            m_data[index / 8] &= static_cast<byte>(~(1u << (index % 8)));
+    }
+
+private:
+    AllocationBitmap(byte* data, unsigned size)
+        : m_data(data)
+        , m_size(size)
+    {
+    }
+
+    byte* m_data { nullptr };
+    unsigned m_size { 0 };
+};
+
+template<dword chunkSize>
+class ChunkAllocator {
+public:
+    void initialize(byte* base)
+    {
+        m_base = base;
+        m_free = capacityInAllocations();
+        dump();
+    }
+
+    static constexpr dword capacityInAllocations()
+    {
+        return 1048576 / chunkSize;
+    }
+
+    static constexpr dword capacityInBytes()
+    {
+        return capacityInAllocations() * chunkSize;
+    }
+
+    byte* allocate()
+    {
+        auto bitmap = this->bitmap();
+        for (dword i = 0; i < capacityInAllocations(); ++i) {
+            if (!bitmap.get(i)) {
+                bitmap.set(i, true);
+                --m_free;
+                return pointerToChunk(i);
+            }
+        }
+        return nullptr;
+    }
+
+    void dump() const
+    {
+        printf("ChunkAllocator<%u> @ %p, free: %u\n", chunkSize, m_base, m_free);
+    }
+
+    void free(byte* ptr)
+    {
+        ASSERT(isInAllocator(ptr));
+        auto bitmap = this->bitmap();
+        auto chunkIndex = chunkIndexFromPointer(ptr);
+        ASSERT(bitmap.get(chunkIndex));
+        bitmap.set(chunkIndex, false);
+        ++m_free;
+    }
+
+    bool isInAllocator(byte* ptr)
+    {
+        return ptr >= pointerToChunk(0) && ptr <= addressAfterThisAllocator();
+    }
+
+    dword chunkIndexFromPointer(byte* ptr)
+    {
+        return (ptr - pointerToChunk(0)) / chunkSize;
+    }
+
+    byte* pointerToChunk(dword index)
+    {
+        return m_base + sizeOfAllocationBitmapInBytes() + (index * chunkSize);
+    }
+
+    AllocationBitmap bitmap()
+    {
+        return AllocationBitmap::wrap(m_base, capacityInAllocations());
+    }
+
+    static constexpr dword sizeOfAllocationBitmapInBytes()
+    {
+        return capacityInAllocations() / 8;
+    }
+
+    byte* addressAfterThisAllocator() const
+    {
+        return m_base + sizeOfAllocationBitmapInBytes() + capacityInBytes();
+    }
+
+    dword numberOfFreeChunks() const
+    {
+        return m_free;
+    }
+
+private:
+    byte* m_base { nullptr };
+    dword m_free { capacityInAllocations() };
+};
+
+struct Allocator {
+    void initialize();
+    void initializeIfNeeded();
+    void dump();
+
+    ChunkAllocator<8> alloc8;
+    ChunkAllocator<16> alloc16;
+    ChunkAllocator<4096> alloc4096;
+    ChunkAllocator<16384> alloc16384;
+
+    byte* space;
+    bool initialized { false };
+};
+
+static Allocator allocator;
+
+void Allocator::initializeIfNeeded()
+{
+    if (initialized)
+        return;
+    initialize();
+    initialized = true;
+}
+
+void Allocator::initialize()
+{
+    space = (byte*)mmap((void*)0x20000000, 32 * MB, PROT_WRITE | PROT_READ | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    ASSERT(space != MAP_FAILED);
+    alloc8.initialize(space + 0x10000);
+    alloc16.initialize(alloc8.addressAfterThisAllocator());
+    alloc4096.initialize(alloc16.addressAfterThisAllocator());
+    alloc16384.initialize(alloc4096.addressAfterThisAllocator());
+}
+
+void Allocator::dump()
+{
+    alloc8.dump();
+    alloc16.dump();
+    alloc4096.dump();
+    alloc16384.dump();
+}
+
+void initialize()
+{
+    allocator.initialize();
+}
+
+void dump()
+{
+    allocator.dump();
+}
+
+byte* allocate(dword size)
+{
+    if (!size)
+        return nullptr;
+    allocator.initializeIfNeeded();
+    if (size <= 8) {
+        if (auto* ptr = allocator.alloc8.allocate())
+            return ptr;
+    }
+    if (size <= 16) {
+        if (auto* ptr = allocator.alloc16.allocate())
+            return ptr;
+    }
+    if (size <= 4096) {
+        if (auto* ptr = allocator.alloc4096.allocate())
+            return ptr;
+    }
+    if (size <= 16384) {
+        if (auto* ptr = allocator.alloc16384.allocate())
+            return ptr;
+    }
+    printf("SimpleMalloc: unsupported alloc size: %u\n", size);
+    ASSERT_NOT_REACHED();
+    return nullptr;
+}
+
+byte* allocateZeroed(dword size)
+{
+    auto* ptr = allocate(size);
+    if (!ptr)
+        return nullptr;
+    memset(ptr, 0, size);
+    return ptr;
+}
+
+byte* reallocate(byte* ptr, dword size)
+{
+    // FIXME;
+    ASSERT_NOT_REACHED();
+    return nullptr;
+}
+
+void free(byte* ptr)
+{
+    if (!ptr)
+        return;
+    allocator.initializeIfNeeded();
+    if (allocator.alloc8.isInAllocator(ptr)) {
+        allocator.alloc8.free(ptr);
+        return;
+    }
+    if (allocator.alloc16.isInAllocator(ptr)) {
+        allocator.alloc16.free(ptr);
+        return;
+    }
+    if (allocator.alloc4096.isInAllocator(ptr)) {
+        allocator.alloc4096.free(ptr);
+        return;
+    }
+    if (allocator.alloc16384.isInAllocator(ptr)) {
+        allocator.alloc16384.free(ptr);
+        return;
+    }
+    ASSERT_NOT_REACHED();
+}
+
+}
+
diff --git a/AK/SimpleMalloc.h b/AK/SimpleMalloc.h
new file mode 100644
index 00000000000..3b4457cdffd
--- /dev/null
+++ b/AK/SimpleMalloc.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Types.h"
+
+namespace SimpleMalloc {
+
+void initialize();
+void dump();
+byte* allocate(dword);
+byte* allocateZeroed(dword);
+void free(byte*);
+byte* reallocate(byte*, dword);
+
+}
+
diff --git a/AK/SinglyLinkedList.h b/AK/SinglyLinkedList.h
new file mode 100644
index 00000000000..03021b0ee8d
--- /dev/null
+++ b/AK/SinglyLinkedList.h
@@ -0,0 +1,114 @@
+#pragma once
+
+#include <utility>
+
+namespace AK {
+
+template<typename T>
+class SinglyLinkedList {
+private:
+    struct Node {
+        T value;
+        Node* next { nullptr };
+    };
+
+public:
+    SinglyLinkedList() { }
+    ~SinglyLinkedList() { }
+
+    bool isEmpty() const { return !head(); }
+
+    T& first() { ASSERT(head()); return head()->value; }
+    const T& first() const { ASSERT(head()); return head()->value; }
+    T& last() { ASSERT(head()); return tail()->value; }
+    const T& last() const { ASSERT(head()); return tail()->value; }
+
+    void append(T&& value)
+    {
+        auto* node = new Node;
+        node->value = std::move(value);
+        if (!m_head) {
+            m_head = node;
+            m_tail = node;
+            return;
+        }
+        m_tail->next = node;
+        m_tail = node;
+    }
+
+    bool containsSlow(const T& value) const
+    {
+        for (auto* node = m_head; node; node = node->next) {
+            if (node->value == value)
+                return true;
+        }
+        return false;
+    }
+
+    class Iterator {
+    public:
+        bool operator!=(const Iterator& other) { return m_node != other.m_node; }
+        Iterator& operator++() { m_node = m_node->next; return *this; }
+        T& operator*() { return m_node->value; }
+        bool isEnd() const { return !m_node; }
+        static Iterator universalEnd() { return Iterator(nullptr); }
+    private:
+        friend class SinglyLinkedList;
+        explicit Iterator(SinglyLinkedList::Node* node) : m_node(node) { }
+        SinglyLinkedList::Node* m_node;
+    };
+
+    Iterator begin() { return Iterator(m_head); }
+    Iterator end() { return Iterator::universalEnd(); }
+
+    class ConstIterator {
+    public:
+        bool operator!=(const ConstIterator& other) { return m_node != other.m_node; }
+        ConstIterator& operator++() { m_node = m_node->next; return *this; }
+        const T& operator*() const { return m_node->value; }
+        bool isEnd() const { return !m_node; }
+        static ConstIterator universalEnd() { return ConstIterator(nullptr); }
+    private:
+        friend class SinglyLinkedList;
+        explicit ConstIterator(const SinglyLinkedList::Node* node) : m_node(node) { }
+        const SinglyLinkedList::Node* m_node;
+    };
+
+    ConstIterator begin() const { return ConstIterator(m_head); }
+    ConstIterator end() const { return ConstIterator::universalEnd(); }
+
+    ConstIterator find(const T& value) const
+    {
+        for (auto* node = m_head; node; node = node->next) {
+            if (node->value == value)
+                return ConstIterator(node);
+        }
+        return end();
+    }
+
+    Iterator find(const T& value)
+    {
+        for (auto* node = m_head; node; node = node->next) {
+            if (node->value == value)
+                return Iterator(node);
+        }
+        return end();
+    }
+
+private:
+    friend class Iterator;
+
+    Node* head() { return m_head; }
+    const Node* head() const { return m_head; }
+
+    Node* tail() { return m_tail; }
+    const Node* tail() const { return m_tail; }
+
+    Node* m_head { nullptr };
+    Node* m_tail { nullptr };
+};
+
+}
+
+using AK::SinglyLinkedList;
+
diff --git a/AK/StdLib.h b/AK/StdLib.h
new file mode 100644
index 00000000000..c23609451e1
--- /dev/null
+++ b/AK/StdLib.h
@@ -0,0 +1,33 @@
+#pragma once
+
+namespace AK {
+
+template<typename T>
+inline T min(const T& a, const T& b)
+{
+    return a < b ? a : b;
+}
+
+template<typename T>
+inline T max(const T& a, const T& b)
+{
+    return a < b ? b : a;
+}
+
+
+template<typename T>
+static inline T ceilDiv(T a, T b)
+{
+    T result = a / b;
+    if ((a % b) != 0)
+        ++result;
+    return result;
+}
+
+
+}
+
+using AK::min;
+using AK::max;
+using AK::ceilDiv;
+
diff --git a/AK/String.cpp b/AK/String.cpp
new file mode 100644
index 00000000000..7c2a02ca3b7
--- /dev/null
+++ b/AK/String.cpp
@@ -0,0 +1,56 @@
+#include "String.h"
+#include <cstring>
+
+namespace AK {
+
+bool String::operator==(const String& other) const
+{
+    if (!m_impl)
+        return !other.m_impl;
+
+    if (!other.m_impl)
+        return false;
+
+    if (length() != other.length())
+        return false;
+    
+    return !memcmp(characters(), other.characters(), length());
+}
+
+String String::empty()
+{
+    return StringImpl::theEmptyStringImpl();
+}
+
+Vector<String> String::split(const char separator) const
+{
+    if (isEmpty())
+        return { };
+
+    Vector<String> parts;
+
+    auto* characters = this->characters();
+    unsigned startOfPart = 0;
+    unsigned i = 0;
+    for (i = 0; i < length(); ++i) {
+        char ch = characters[i];
+        if (ch == separator) {
+            if (i != startOfPart) {
+                parts.append(String(characters + startOfPart, i - startOfPart));
+            }
+            startOfPart = i + 1;
+        }
+    }
+    if (startOfPart != length())
+        parts.append(String(characters + startOfPart, i - startOfPart));
+    return parts;
+}
+
+ByteBuffer String::toByteBuffer() const
+{
+    if (!m_impl)
+        return nullptr;
+    return ByteBuffer::copy(reinterpret_cast<const byte*>(characters()), length());
+}
+
+}
diff --git a/AK/String.h b/AK/String.h
new file mode 100644
index 00000000000..4fe52ddb3f1
--- /dev/null
+++ b/AK/String.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include "ByteBuffer.h"
+#include "RetainPtr.h"
+#include "StringImpl.h"
+#include "Traits.h"
+#include "Vector.h"
+#include <cstdio>
+
+namespace AK {
+
+class String {
+public:
+    ~String() { }
+
+    String() { }
+    String(const String& other)
+        : m_impl(const_cast<String&>(other).m_impl.copyRef())
+    {
+    }
+
+    String(String&& other)
+        : m_impl(std::move(other.m_impl))
+    {
+    }
+
+    String(const char* cstring)
+        : m_impl(StringImpl::create(cstring))
+    {
+    }
+
+    String(const char* cstring, size_t length)
+        : m_impl(StringImpl::create(cstring, length))
+    {
+    }
+
+    String(const StringImpl& impl)
+        : m_impl(const_cast<StringImpl&>(impl))
+    {
+    }
+
+    String(RetainPtr<StringImpl>&& impl)
+        : m_impl(std::move(impl))
+    {
+    }
+
+    String toLowercase() const
+    {
+        if (!m_impl)
+            return String();
+        return m_impl->toLowercase();
+    }
+
+    String toUppercase() const
+    {
+        if (!m_impl)
+            return String();
+        return m_impl->toUppercase();
+    }
+
+    Vector<String> split(char separator) const;
+
+    bool isEmpty() const { return length() == 0; }
+    unsigned length() const { return m_impl ? m_impl->length() : 0; }
+    const char* characters() const { return m_impl ? m_impl->characters() : nullptr; }
+    char operator[](unsigned i) const { ASSERT(m_impl); return (*m_impl)[i]; }
+
+    bool operator==(const String&) const;
+    bool operator!=(const String& other) const { return !(*this == other); }
+
+    static String empty();
+
+    StringImpl* impl() { return m_impl.ptr(); }
+    const StringImpl* impl() const { return m_impl.ptr(); }
+
+    String& operator=(String&& other)
+    {
+        if (this != &other) {
+            m_impl = std::move(other.m_impl);
+        }
+        return *this;
+    }
+
+    ByteBuffer toByteBuffer() const;
+
+private:
+    RetainPtr<StringImpl> m_impl;
+};
+
+template<>
+struct Traits<String> {
+    static unsigned hash(const String& s) { return s.impl() ? s.impl()->hash() : 0; }
+    static void dump(const String& s) { printf("%s", s.characters()); }
+};
+
+}
+
+using AK::String;
diff --git a/AK/StringBuilder.cpp b/AK/StringBuilder.cpp
new file mode 100644
index 00000000000..77677217da0
--- /dev/null
+++ b/AK/StringBuilder.cpp
@@ -0,0 +1,25 @@
+#include "StringBuilder.h"
+
+namespace AK {
+
+void StringBuilder::append(String&& str)
+{
+    m_strings.append(std::move(str));
+}
+
+void StringBuilder::append(char ch)
+{
+    m_strings.append(StringImpl::create(&ch, 1));
+}
+
+String StringBuilder::build()
+{
+    auto strings = std::move(m_strings);
+    if (strings.isEmpty())
+        return String::empty();
+
+    return String();
+}
+
+}
+
diff --git a/AK/StringBuilder.h b/AK/StringBuilder.h
new file mode 100644
index 00000000000..a468eb0a2ab
--- /dev/null
+++ b/AK/StringBuilder.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "String.h"
+#include "Vector.h"
+
+namespace AK {
+
+class StringBuilder {
+public:
+    StringBuilder() { }
+    ~StringBuilder() { }
+
+    void append(String&&);
+    void append(char);
+
+    String build();
+
+private:
+    Vector<String> m_strings;
+};
+
+}
+
+using AK::StringBuilder;
+
diff --git a/AK/StringImpl.cpp b/AK/StringImpl.cpp
new file mode 100644
index 00000000000..0d7016973ae
--- /dev/null
+++ b/AK/StringImpl.cpp
@@ -0,0 +1,149 @@
+#include "StringImpl.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <new> 
+#include "kmalloc.h"
+
+namespace AK {
+
+StringImpl& StringImpl::theEmptyStringImpl()
+{
+    static StringImpl* s = new StringImpl(ConstructTheEmptyStringImpl);
+    return *s;
+}
+
+StringImpl::~StringImpl()
+{
+}
+
+static inline size_t allocationSizeForStringImpl(unsigned length)
+{
+    return sizeof(StringImpl) + (sizeof(char) * length) + sizeof(char);
+}
+
+RetainPtr<StringImpl> StringImpl::createUninitialized(unsigned length, char*& buffer)
+{
+    if (!length)
+        return theEmptyStringImpl();
+
+    void* slot = kmalloc(allocationSizeForStringImpl(length));
+    if (!slot)
+        return nullptr;
+
+    auto newStringImpl = adopt(*new (slot) StringImpl(ConstructWithInlineBuffer, length));
+    buffer = const_cast<char*>(newStringImpl->m_characters);
+    buffer[length] = '\0';
+    return newStringImpl;
+}
+
+RetainPtr<StringImpl> StringImpl::create(const char* cstring, size_t length)
+{
+    if (!cstring)
+        return nullptr;
+
+    if (!*cstring)
+        return theEmptyStringImpl();
+
+    char* buffer;
+    auto newStringImpl = createUninitialized(length, buffer);
+    memcpy(buffer, cstring, length * sizeof(char));
+
+    return newStringImpl;
+}
+
+RetainPtr<StringImpl> StringImpl::create(const char* cstring)
+{
+    if (!cstring)
+        return nullptr;
+
+    return create(cstring, strlen(cstring));
+}
+
+static inline bool isASCIILowercase(char c)
+{
+    return c >= 'a' && c <= 'z';
+}
+
+static inline bool isASCIIUppercase(char c)
+{
+    return c >= 'A' && c <= 'Z';
+}
+
+static inline char toASCIILowercase(char c)
+{
+    if (isASCIIUppercase(c))
+        return c | 0x20;
+    return c;
+}
+
+static inline char toASCIIUppercase(char c)
+{
+    if (isASCIILowercase(c))
+        return c & ~0x20;
+    return c;
+}
+
+RetainPtr<StringImpl> StringImpl::toLowercase() const
+{
+    if (!m_length)
+        return const_cast<StringImpl*>(this);
+
+    for (unsigned i = 0; i < m_length; ++i) {
+        if (!isASCIILowercase(m_characters[i]))
+            goto slowPath;
+    }
+    return const_cast<StringImpl*>(this);
+
+slowPath:
+    char* buffer;
+    auto lowercased = createUninitialized(m_length, buffer);
+    for (unsigned i = 0; i < m_length; ++i) {
+        buffer[i] = toASCIILowercase(m_characters[i]);
+    }
+
+    return lowercased;
+}
+
+RetainPtr<StringImpl> StringImpl::toUppercase() const
+{
+    if (!m_length)
+        return const_cast<StringImpl*>(this);
+
+    for (unsigned i = 0; i < m_length; ++i) {
+        if (!isASCIIUppercase(m_characters[i]))
+            goto slowPath;
+    }
+    return const_cast<StringImpl*>(this);
+
+slowPath:
+    char* buffer;
+    auto uppercased = createUninitialized(m_length, buffer);
+    for (unsigned i = 0; i < m_length; ++i) {
+        buffer[i] = toASCIIUppercase(m_characters[i]);
+    }
+
+    return uppercased;
+}
+
+void StringImpl::computeHash() const
+{
+    if (!length()) {
+        m_hash = 0;
+    } else {
+        unsigned hash = 0;
+        for (unsigned i = 0; i < m_length; ++i) {
+            hash += m_characters[i];
+            hash += (hash << 10);
+            hash ^= (hash >> 6);
+        }
+        hash += hash << 3;
+        hash ^= hash >> 11;
+        hash += hash << 15;
+        m_hash = hash;
+    }
+    m_hasHash = true;
+}
+
+}
+
diff --git a/AK/StringImpl.h b/AK/StringImpl.h
new file mode 100644
index 00000000000..64c4f87415b
--- /dev/null
+++ b/AK/StringImpl.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "Retainable.h"
+#include "RetainPtr.h"
+
+namespace AK {
+
+class StringImpl : public Retainable<StringImpl> {
+public:
+    static RetainPtr<StringImpl> createUninitialized(unsigned length, char*& buffer);
+    static RetainPtr<StringImpl> create(const char* cstring);
+    static RetainPtr<StringImpl> create(const char* cstring, size_t length);
+    RetainPtr<StringImpl> toLowercase() const;
+    RetainPtr<StringImpl> toUppercase() const;
+
+    static StringImpl& theEmptyStringImpl();
+
+    ~StringImpl();
+
+    unsigned length() const { return m_length; }
+    const char* characters() const { return m_characters; }
+    char operator[](unsigned i) const { ASSERT(i < m_length); return m_characters[i]; }
+
+    unsigned hash() const
+    {
+        if (!m_hasHash)
+            computeHash();
+        return m_hash;
+    }
+
+private:
+    enum ConstructTheEmptyStringImplTag { ConstructTheEmptyStringImpl };
+    explicit StringImpl(ConstructTheEmptyStringImplTag) : m_characters("") { }
+
+    enum ConstructWithInlineBufferTag { ConstructWithInlineBuffer };
+    explicit StringImpl(ConstructWithInlineBufferTag, unsigned length) : m_length(length), m_characters(m_inlineBuffer) { }
+
+    void computeHash() const;
+
+    unsigned m_length { 0 };
+    bool m_ownsBuffer { true };
+    mutable bool m_hasHash { false };
+    const char* m_characters { nullptr };
+    mutable unsigned m_hash { 0 };
+    char m_inlineBuffer[0];
+};
+
+}
+
+using AK::StringImpl;
diff --git a/AK/TemporaryFile.cpp b/AK/TemporaryFile.cpp
new file mode 100644
index 00000000000..9d16ee54eaf
--- /dev/null
+++ b/AK/TemporaryFile.cpp
@@ -0,0 +1,33 @@
+#include "TemporaryFile.h"
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+namespace AK {
+
+TemporaryFile::TemporaryFile()
+{
+    char nameBuffer[] = "/tmp/AKTemporaryFile.XXXXXX";
+    int fd = mkstemp(nameBuffer);
+    if (fd != -1) {
+        m_stream = fdopen(fd, "w+");
+        m_fileName = nameBuffer;
+    }
+}
+
+TemporaryFile::~TemporaryFile()
+{
+    if (isValid()) {
+        unlink(m_fileName.characters());
+        fclose(m_stream);
+    }
+}
+
+void TemporaryFile::sync()
+{
+    if (m_stream)
+        fflush(m_stream);
+}
+
+}
+
diff --git a/AK/TemporaryFile.h b/AK/TemporaryFile.h
new file mode 100644
index 00000000000..bcc88b7652b
--- /dev/null
+++ b/AK/TemporaryFile.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "String.h"
+#include <stdio.h>
+
+namespace AK {
+
+class TemporaryFile {
+public:
+    TemporaryFile();
+    ~TemporaryFile();
+
+    bool isValid() const { return m_stream; }
+    FILE* stream() { return m_stream; }
+    String fileName() const { return m_fileName; }
+    void sync();
+
+private:
+    FILE* m_stream { nullptr };
+    String m_fileName;
+};
+
+}
+
+using AK::TemporaryFile;
+
diff --git a/AK/Traits.h b/AK/Traits.h
new file mode 100644
index 00000000000..22d78292922
--- /dev/null
+++ b/AK/Traits.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdio>
+
+namespace AK {
+
+template<typename T>
+struct Traits 
+{
+};
+
+template<>
+struct Traits<int> {
+    static unsigned hash(int i) { return i; }
+    static void dump(int i) { printf("%d", i); }
+};
+
+template<>
+struct Traits<unsigned> {
+    static unsigned hash(unsigned u) { return u; }
+    static void dump(unsigned u) { printf("%u", u); }
+};
+
+}
+
diff --git a/AK/Types.h b/AK/Types.h
new file mode 100644
index 00000000000..cd0eee2ff46
--- /dev/null
+++ b/AK/Types.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef uint8_t byte;
+typedef uint16_t word;
+typedef uint32_t dword;
+typedef uint64_t qword;
+
+typedef int8_t signed_byte;
+typedef int16_t signed_word;
+typedef int32_t signed_dword;
+typedef int64_t signed_qword;
+
+constexpr unsigned KB = 1024;
+constexpr unsigned MB = KB * KB;
+constexpr unsigned GB = KB * KB * KB;
diff --git a/AK/Vector.h b/AK/Vector.h
new file mode 100644
index 00000000000..2b57c993960
--- /dev/null
+++ b/AK/Vector.h
@@ -0,0 +1,169 @@
+#pragma once
+
+#include "Assertions.h"
+#include "OwnPtr.h"
+#include <new>
+#include <stdlib.h>
+#include <stdio.h>
+#include <algorithm>
+
+namespace AK {
+
+template<typename T> class Vector;
+
+template<typename T>
+class VectorImpl {
+public:
+    ~VectorImpl() { }
+    static OwnPtr<VectorImpl> create(unsigned capacity)
+    {
+        size_t size = sizeof(VectorImpl) + sizeof(T) * capacity;
+        void* slot = kmalloc(size);
+        return OwnPtr<VectorImpl>(new (slot) VectorImpl(capacity));
+    }
+
+    unsigned size() const { return m_size; }
+    unsigned capacity() const { return m_capacity; }
+
+    T& at(unsigned i) { return *slot(i); }
+    const T& at(unsigned i) const { return *slot(i); }
+
+private:
+    friend class Vector<T>;
+
+    VectorImpl(unsigned capacity) : m_capacity(capacity) { }
+
+    T* tail() { return reinterpret_cast<T*>(this + 1); }
+    T* slot(unsigned i) { return &tail()[i]; }
+
+    const T* tail() const { return reinterpret_cast<const T*>(this + 1); }
+    const T* slot(unsigned i) const { return &tail()[i]; }
+
+    unsigned m_size { 0 };
+    unsigned m_capacity;
+};
+
+template<typename T>
+class Vector {
+public:
+    Vector() { }
+    ~Vector() { clear(); }
+
+    Vector(Vector&& other)
+        : m_impl(std::move(other.m_impl))
+    {
+    }
+
+    Vector& operator=(Vector&& other)
+    {
+        if (this != &other)
+            m_impl = std::move(other.m_impl);
+        return *this;
+    }
+
+    void clear()
+    {
+        for (unsigned i = 0; i < size(); ++i) {
+            at(i).~T();
+        }
+        m_impl = nullptr;
+    }
+
+    bool isEmpty() const { return size() == 0; }
+    unsigned size() const { return m_impl ? m_impl->size() : 0; }
+    unsigned capacity() const { return m_impl ? m_impl->capacity() : 0; }
+
+    const T& at(unsigned i) const { return m_impl->at(i); }
+    T& at(unsigned i) { return m_impl->at(i); }
+
+    const T& operator[](unsigned i) const { return at(i); }
+    T& operator[](unsigned i) { return at(i); }
+
+    const T& first() const { return at(0); }
+    T& first() { return at(0); }
+
+    const T& last() const { return at(size() - 1); }
+    T& last() { return at(size() - 1); }
+
+    T takeLast()
+    {
+        ASSERT(!isEmpty());
+        T value = std::move(last());
+        last().~T();
+        --m_impl->m_size;
+        return value;
+    }
+
+    void append(T&& value)
+    {
+        ensureCapacity(size() + 1);
+        new (m_impl->slot(m_impl->m_size)) T(std::move(value));
+        ++m_impl->m_size;
+    }
+
+    void append(const T& value)
+    {
+        ensureCapacity(size() + 1);
+        new (m_impl->slot(m_impl->m_size)) T(value);
+        ++m_impl->m_size;
+    }
+
+    void ensureCapacity(unsigned neededCapacity)
+    {
+        if (capacity() >= neededCapacity)
+            return;
+        size_t newCapacity = paddedCapacity(neededCapacity);
+        auto newImpl = VectorImpl<T>::create(newCapacity);
+        if (m_impl) {
+            newImpl->m_size = m_impl->m_size;
+            for (unsigned i = 0; i < size(); ++i) {
+                new (newImpl->slot(i)) T(std::move(m_impl->at(i)));
+                m_impl->at(i).~T();
+            }
+        }
+        m_impl = std::move(newImpl);
+    }
+
+    class Iterator {
+    public:
+        bool operator!=(const Iterator& other) { return m_index != other.m_index; }
+        Iterator& operator++() { ++m_index; return *this; }
+        T& operator*() { return m_vector[m_index]; }
+    private:
+        friend class Vector;
+        Iterator(Vector& vector, unsigned index) : m_vector(vector), m_index(index) { }
+        Vector& m_vector;
+        unsigned m_index { 0 };
+    };
+
+    Iterator begin() { return Iterator(*this, 0); }
+    Iterator end() { return Iterator(*this, size()); }
+
+    class ConstIterator {
+    public:
+        bool operator!=(const ConstIterator& other) { return m_index != other.m_index; }
+        ConstIterator& operator++() { ++m_index; return *this; }
+        const T& operator*() const { return m_vector[m_index]; }
+    private:
+        friend class Vector;
+        ConstIterator(const Vector& vector, const unsigned index) : m_vector(vector), m_index(index) { }
+        const Vector& m_vector;
+        unsigned m_index { 0 };
+    };
+
+    ConstIterator begin() const { return Iterator(*this, 0); }
+    ConstIterator end() const { return Iterator(*this, size()); }
+
+private:
+    static unsigned paddedCapacity(unsigned capacity)
+    {
+        return std::max(4u, capacity + (capacity / 4) + 4);
+    }
+
+    OwnPtr<VectorImpl<T>> m_impl;
+};
+
+}
+
+using AK::Vector;
+
diff --git a/AK/kmalloc.cpp b/AK/kmalloc.cpp
new file mode 100644
index 00000000000..c9fe5a046e2
--- /dev/null
+++ b/AK/kmalloc.cpp
@@ -0,0 +1,66 @@
+#include <cstdio>
+#include "SimpleMalloc.h"
+#include <new>
+
+extern "C" {
+
+void* kcalloc(dword nmemb, dword size)
+{
+    if (!nmemb || !size)
+        return nullptr;
+    return SimpleMalloc::allocateZeroed(nmemb * size);
+}
+
+void* kmalloc(dword size)
+{
+    if (!size)
+        return nullptr;
+    return SimpleMalloc::allocate(size);
+}
+
+void kfree(void* ptr)
+{
+    if (!ptr)
+        return;
+    SimpleMalloc::free((byte*)ptr);
+}
+
+void* krealloc(void* ptr, dword size)
+{
+    if (!ptr)
+        return ptr;
+    return SimpleMalloc::reallocate((byte*)ptr, size);
+}
+
+}
+
+void* operator new(std::size_t size)
+{
+    return kmalloc(size);
+}
+
+void* operator new[](std::size_t size)
+{
+    return kmalloc(size);
+}
+
+void operator delete(void* ptr)
+{
+    return kfree(ptr);
+}
+
+void operator delete[](void* ptr)
+{
+    return kfree(ptr);
+}
+
+void operator delete(void* ptr, size_t)
+{
+    return kfree(ptr);
+}
+
+void operator delete[](void* ptr, size_t)
+{
+    return kfree(ptr);
+}
+
diff --git a/AK/kmalloc.h b/AK/kmalloc.h
new file mode 100644
index 00000000000..89b455bb70e
--- /dev/null
+++ b/AK/kmalloc.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Types.h"
+
+extern "C" {
+
+void* kcalloc(dword nmemb, dword size);
+void* kmalloc(dword size);
+void kfree(void* ptr);
+void* krealloc(void* ptr, dword size);
+
+}
+
diff --git a/AK/test.cpp b/AK/test.cpp
new file mode 100644
index 00000000000..f57036edf1b
--- /dev/null
+++ b/AK/test.cpp
@@ -0,0 +1,131 @@
+#include "String.h"
+//#include "StringBuilder.h"
+#include "Vector.h"
+#include <stdio.h>
+#include "HashTable.h"
+#include "SinglyLinkedList.h"
+#include "HashMap.h"
+#include "TemporaryFile.h"
+#include "Buffer.h"
+
+int main(int, char**)
+{
+    String empty = "";
+
+    char* buffer;
+    auto test = StringImpl::createUninitialized(3, buffer); 
+    auto hello = String("hello");
+    auto Hello = String("Hello");
+
+    printf("hello: '%s'\n", hello.characters());
+    printf("Hello: '%s'\n", Hello.characters());
+    printf("'Hello'.lower(): '%s'\n", Hello.toLowercase().characters());
+    printf("'hello'.upper(): '%s'\n", Hello.toUppercase().characters());
+
+    Vector<String> strings;
+    strings.append("a");
+    strings.append("b");
+    strings.append("c");
+    strings.append("d");
+    strings.append("e");
+    strings.append("f");
+    strings.append("g");
+
+    auto g = strings.takeLast();
+
+    for (unsigned i = 0; i < strings.size(); ++i) {
+        printf("[%u]: '%s'\n", i, strings[i].characters());
+    }
+
+    printf("snodde sista: '%s'\n", g.characters());
+    printf("kvar:\n");
+
+    for (auto& s : strings) {
+        printf("  > %s\n", s.characters());
+    }
+
+#if 0
+    StringBuilder builder;
+    builder.append("HEJ");
+    builder.append(' ');
+    builder.append("KAJ");
+
+    printf("byggd: '%s'\n", builder.build().characters());
+#endif
+
+#if 1
+    HashTable<int> ints;
+    ints.set(10);
+    ints.set(20);
+    ints.set(30);
+    ints.dump();
+
+    ASSERT(ints.size() == 3);
+    ASSERT(ints.contains(10));
+    ASSERT(ints.contains(20));
+    ASSERT(ints.contains(30));
+    ASSERT(!ints.contains(0));
+    ASSERT(!ints.contains(40));
+
+    HashTable<String> sss;
+    sss.set("foo");
+    sss.set("bar");
+    sss.set("baz");
+    sss.set("bee");
+    ASSERT(sss.size() == 4);
+    sss.dump();
+    ASSERT(sss.contains("foo"));
+    ASSERT(sss.contains("bar"));
+    ASSERT(sss.contains("baz"));
+    ASSERT(sss.contains("bee"));
+    ASSERT(!sss.contains("boo"));
+    ASSERT(!sss.contains(""));
+    ASSERT(!sss.contains(String()));
+
+    printf(">>> iterate Hash:\n");
+    for (auto& s : sss) {
+        printf("+ %s\n", s.characters());
+    }
+    printf("<<<\n");
+#endif
+
+    SinglyLinkedList<int> list;
+    list.append(3);
+    list.append(6);
+    list.append(9);
+    ASSERT(!list.isEmpty());
+    ASSERT(list.first() == 3);
+    ASSERT(list.last() == 9);
+
+    for (int i : list) {
+        printf("Iterated to %d\n", i);
+    }
+
+    HashMap<String, int> map;
+    map.set("lol", 100);
+    map.set("kek", 500);
+    map.set("zoo", 300);
+    ASSERT(map.size() == 3);
+    map.dump();
+    for (auto& it : map) {
+        printf("[%s] := %d\n", it.key.characters(), it.value);
+    }
+
+    auto found = map.find("kek");
+    if (found != map.end()) {
+        printf("found 'kek', key: %s, value: %d\n", (*found).key.characters(), (*found).value);
+    } else {
+        printf("not found\n");
+    }
+
+    auto charbuf = Buffer<char>::createUninitialized(1024);
+    printf("charbuf.size() = %u\n", charbuf->size());
+
+    {
+    Vector<String> problem;
+    for (int i = 0; i < 256; ++i)
+        problem.append("test");
+    }
+
+    return 0;
+}
diff --git a/ELFLoader/.gitignore b/ELFLoader/.gitignore
new file mode 100644
index 00000000000..4484621603a
--- /dev/null
+++ b/ELFLoader/.gitignore
@@ -0,0 +1,3 @@
+run
+*.o
+AK
diff --git a/ELFLoader/ELFImage.cpp b/ELFLoader/ELFImage.cpp
new file mode 100644
index 00000000000..0896ece6291
--- /dev/null
+++ b/ELFLoader/ELFImage.cpp
@@ -0,0 +1,188 @@
+#include "ELFImage.h"
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+
+ELFImage::ELFImage(MappedFile&& file)
+    : m_file(std::move(file))
+{
+    m_isValid = parse();
+}
+
+ELFImage::~ELFImage()
+{
+}
+
+static const char* objectFileTypeToString(Elf32_Half type)
+{
+    switch (type) {
+    case ET_NONE: return "None";
+    case ET_REL: return "Relocatable";
+    case ET_EXEC: return "Executable";
+    case ET_DYN: return "Shared object";
+    case ET_CORE: return "Core";
+    default: return "(?)";
+    }
+}
+
+const char* ELFImage::sectionIndexToString(unsigned index)
+{
+    if (index == SHN_UNDEF)
+        return "Undefined";
+    if (index >= SHN_LORESERVE)
+        return "Reserved";
+    return section(index).name();
+}
+
+unsigned ELFImage::symbolCount() const
+{
+    return section(m_symbolTableSectionIndex).entryCount();
+}
+
+void ELFImage::dump()
+{
+    printf("AK::ELFImage{%p} {\n", this);
+    printf("    isValid: %u\n", isValid());
+
+    if (!isValid()) {
+        printf("}\n");
+        return;
+    }
+
+    printf("    type:    %s\n", objectFileTypeToString(header().e_type));
+    printf("    machine: %u\n", header().e_machine);
+    printf("    entry:   %08x\n", header().e_entry);
+    printf("    shoff:   %u\n", header().e_shoff);
+    printf("    shnum:   %u\n", header().e_shnum);
+    printf(" shstrndx:   %u\n", header().e_shstrndx);
+
+    for (unsigned i = 0; i < header().e_shnum; ++i) {
+        auto& section = this->section(i);
+        printf("    Section %u: {\n", i);
+        printf("        name: %s\n", section.name());
+        printf("        type: %x\n", section.type());
+        printf("      offset: %x\n", section.offset());
+        printf("        size: %u\n", section.size());
+        printf("        \n");
+        printf("    }\n");
+    }
+
+    printf("Symbol count: %u (table is %u)\n", symbolCount(), m_symbolTableSectionIndex);
+    for (unsigned i = 1; i < symbolCount(); ++i) {
+        auto& sym = symbol(i);
+        printf("Symbol @%u:\n", i);
+        printf("    Name: %s\n", sym.name());
+        printf("    In section: %s\n", sectionIndexToString(sym.sectionIndex()));
+        printf("    Value: %08x\n", sym.value());
+        printf("    Size: %u\n", sym.size());
+    }
+
+    printf("}\n");
+}
+
+unsigned ELFImage::sectionCount() const
+{
+    return header().e_shnum;
+}
+
+bool ELFImage::parse()
+{
+    // We only support i386.
+    if (header().e_machine != 3)
+        return false;
+
+    // First locate the string tables.
+    for (unsigned i = 0; i < sectionCount(); ++i) {
+        auto& sh = sectionHeader(i);
+        if (sh.sh_type == SHT_SYMTAB) {
+            ASSERT(!m_symbolTableSectionIndex);
+            m_symbolTableSectionIndex = i;
+        }
+        if (sh.sh_type == SHT_STRTAB && i != header().e_shstrndx) {
+            ASSERT(!m_stringTableSectionIndex);
+            m_stringTableSectionIndex = i;
+        }
+    }
+
+    // Then create a name-to-index map.
+    for (unsigned i = 0; i < sectionCount(); ++i) {
+        auto& section = this->section(i);
+        m_sections.set(section.name(), std::move(i));
+    }
+    return true;
+}
+
+const char* ELFImage::sectionHeaderTableString(unsigned offset) const
+{
+    auto& sh = sectionHeader(header().e_shstrndx);
+    if (sh.sh_type != SHT_STRTAB)
+        return nullptr;
+    return rawData(sh.sh_offset + offset);
+}
+
+const char* ELFImage::tableString(unsigned offset) const
+{
+    auto& sh = sectionHeader(m_stringTableSectionIndex);
+    if (sh.sh_type != SHT_STRTAB)
+        return nullptr;
+    return rawData(sh.sh_offset + offset);
+}
+
+const char* ELFImage::rawData(unsigned offset) const
+{
+    return reinterpret_cast<const char*>(m_file.pointer()) + offset;
+}
+
+const Elf32_Ehdr& ELFImage::header() const
+{
+    return *reinterpret_cast<const Elf32_Ehdr*>(rawData(0));
+}
+
+const Elf32_Shdr& ELFImage::sectionHeader(unsigned index) const
+{
+    ASSERT(index < header().e_shnum);
+    return *reinterpret_cast<const Elf32_Shdr*>(rawData(header().e_shoff + (index * sizeof(Elf32_Shdr))));
+}
+
+const ELFImage::Symbol ELFImage::symbol(unsigned index) const
+{
+    ASSERT(index < symbolCount());
+    auto* rawSyms = reinterpret_cast<const Elf32_Sym*>(rawData(section(m_symbolTableSectionIndex).offset()));
+    return Symbol(*this, index, rawSyms[index]);
+}
+
+const ELFImage::Section ELFImage::section(unsigned index) const
+{
+    ASSERT(index < sectionCount());
+    return Section(*this, index);
+}
+
+const ELFImage::Relocation ELFImage::RelocationSection::relocation(unsigned index) const
+{
+    ASSERT(index < relocationCount());
+    auto* rels = reinterpret_cast<const Elf32_Rel*>(m_image.rawData(offset()));
+    return Relocation(m_image, rels[index]);
+}
+
+const ELFImage::RelocationSection ELFImage::Section::relocations() const
+{
+    // FIXME: This is ugly.
+    char relocationSectionName[128];
+    sprintf(relocationSectionName, ".rel%s", name());
+
+    printf("looking for '%s'\n", relocationSectionName);
+    auto relocationSection = m_image.lookupSection(relocationSectionName);
+    if (relocationSection.type() != SHT_REL)
+        return static_cast<const RelocationSection>(m_image.section(0));
+
+    printf("Found relocations for %s in %s\n", name(), relocationSection.name());
+    return static_cast<const RelocationSection>(relocationSection);
+}
+
+const ELFImage::Section ELFImage::lookupSection(const char* name) const
+{
+    if (auto it = m_sections.find(name); it != m_sections.end())
+        return section((*it).value);
+    return section(0);
+}
+
diff --git a/ELFLoader/ELFImage.h b/ELFLoader/ELFImage.h
new file mode 100644
index 00000000000..32e88ec62be
--- /dev/null
+++ b/ELFLoader/ELFImage.h
@@ -0,0 +1,156 @@
+#pragma once
+
+#include <AK/HashMap.h>
+#include <AK/MappedFile.h>
+#include <AK/OwnPtr.h>
+#include "elf.h"
+
+class ELFImage {
+public:
+    explicit ELFImage(MappedFile&&);
+    ~ELFImage();
+    void dump();
+    bool isValid() const { return m_isValid; }
+    bool parse();
+
+    class Section;
+    class RelocationSection;
+    class Symbol;
+    class Relocation;
+
+    class Symbol {
+    public:
+        Symbol(const ELFImage& image, unsigned index, const Elf32_Sym& sym)
+            : m_image(image)
+            , m_sym(sym)
+            , m_index(index)
+        {
+        }
+
+        ~Symbol() { }
+
+        const char* name() const { return m_image.tableString(m_sym.st_name); }
+        unsigned sectionIndex() const { return m_sym.st_shndx; }
+        unsigned value() const { return m_sym.st_value; }
+        unsigned size() const { return m_sym.st_size; }
+        unsigned index() const { return m_index; }
+        unsigned type() const { return ELF32_ST_TYPE(m_sym.st_info); }
+        const Section section() const { return m_image.section(sectionIndex()); }
+
+    private:
+        const ELFImage& m_image;
+        const Elf32_Sym& m_sym;
+        const unsigned m_index;
+    };
+
+    class Section {
+    public:
+        Section(const ELFImage& image, unsigned sectionIndex)
+            : m_image(image)
+            , m_sectionHeader(image.sectionHeader(sectionIndex))
+            , m_sectionIndex(sectionIndex)
+        {
+        }
+        ~Section() { }
+
+        const char* name() const { return m_image.sectionHeaderTableString(m_sectionHeader.sh_name); }
+        unsigned type() const { return m_sectionHeader.sh_type; }
+        unsigned offset() const { return m_sectionHeader.sh_offset; }
+        unsigned size() const { return m_sectionHeader.sh_size; }
+        unsigned entrySize() const { return m_sectionHeader.sh_entsize; }
+        unsigned entryCount() const { return size() / entrySize(); }
+        const char* rawData() const { return m_image.rawData(m_sectionHeader.sh_offset); }
+        bool isUndefined() const { return m_sectionIndex == SHN_UNDEF; }
+        const RelocationSection relocations() const;
+
+    protected:
+        friend class RelocationSection;
+        const ELFImage& m_image;
+        const Elf32_Shdr& m_sectionHeader;
+        unsigned m_sectionIndex;
+    };
+
+    class RelocationSection : public Section {
+    public:
+        RelocationSection(const Section& section)
+            : Section(section.m_image, section.m_sectionIndex)
+        {
+        }
+        unsigned relocationCount() const { return entryCount(); }
+        const Relocation relocation(unsigned index) const;
+        template<typename F> void forEachRelocation(F) const;
+    };
+
+    class Relocation {
+    public:
+        Relocation(const ELFImage& image, const Elf32_Rel& rel)
+            : m_image(image)
+            , m_rel(rel)
+        {
+        }
+
+        ~Relocation() { }
+
+        unsigned offset() const { return m_rel.r_offset; }
+        unsigned type() const { return ELF32_R_TYPE(m_rel.r_info); }
+        unsigned symbolIndex() const { return ELF32_R_SYM(m_rel.r_info); }
+        const Symbol symbol() const { return m_image.symbol(symbolIndex()); }
+
+    private:
+        const ELFImage& m_image;
+        const Elf32_Rel& m_rel;
+    };
+
+    unsigned symbolCount() const;
+    unsigned sectionCount() const;
+
+    const Symbol symbol(unsigned) const;
+    const Section section(unsigned) const;
+
+    template<typename F> void forEachSectionOfType(unsigned, F) const;
+    template<typename F> void forEachSymbol(F) const;
+
+    // NOTE: Returns section(0) if section with name is not found.
+    // FIXME: I don't love this API.
+    const Section lookupSection(const char* name) const;
+
+private:
+    bool parseHeader();
+    const char* rawData(unsigned offset) const;
+    const Elf32_Ehdr& header() const;
+    const Elf32_Shdr& sectionHeader(unsigned) const;
+    const char* tableString(unsigned offset) const;
+    const char* sectionHeaderTableString(unsigned offset) const;
+    const char* sectionIndexToString(unsigned index);
+
+    MappedFile m_file;
+    HashMap<String, unsigned> m_sections;
+    bool m_isValid { false };
+    unsigned m_symbolTableSectionIndex { 0 };
+    unsigned m_stringTableSectionIndex { 0 };
+};
+
+template<typename F>
+inline void ELFImage::forEachSectionOfType(unsigned type, F func) const
+{
+    for (unsigned i = 0; i < sectionCount(); ++i) {
+        auto& section = this->section(i);
+        if (section.type() == type)
+            func(section);
+    }
+}
+
+template<typename F>
+inline void ELFImage::RelocationSection::forEachRelocation(F func) const
+{
+    for (unsigned i = 0; i < relocationCount(); ++i)
+        func(relocation(i));
+}
+
+template<typename F>
+inline void ELFImage::forEachSymbol(F func) const
+{
+    for (unsigned i = 0; i < symbolCount(); ++i)
+        func(symbol(i));
+}
+
diff --git a/ELFLoader/ELFLoader.cpp b/ELFLoader/ELFLoader.cpp
new file mode 100644
index 00000000000..8f228a7893d
--- /dev/null
+++ b/ELFLoader/ELFLoader.cpp
@@ -0,0 +1,115 @@
+#include "ELFLoader.h"
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+
+ELFLoader::ELFLoader(ExecSpace& execSpace, MappedFile&& file)
+    : m_execSpace(execSpace)
+{
+    m_image = make<ELFImage>(std::move(file));
+}
+
+ELFLoader::~ELFLoader()
+{
+}
+
+bool ELFLoader::load()
+{
+    m_image->dump();
+    if (!m_image->isValid())
+        return false;
+
+    layout();
+    exportSymbols();
+    performRelocations();
+
+    return true;
+}
+
+void ELFLoader::layout()
+{
+    printf("[ELFLoader] Layout\n");
+    m_image->forEachSectionOfType(SHT_PROGBITS, [this] (const ELFImage::Section& section) {
+        printf("[ELFLoader] Allocating progbits section: %s\n", section.name());
+        char* ptr = m_execSpace.allocateArea(section.name(), section.size());
+        memcpy(ptr, section.rawData(), section.size());
+        m_sections.set(section.name(), std::move(ptr));
+    });
+}
+
+void* ELFLoader::lookup(const ELFImage::Symbol& symbol)
+{
+    if (symbol.section().isUndefined())
+        return m_execSpace.symbolPtr(symbol.name());
+    return areaForSection(symbol.section()) + symbol.value();
+}
+
+char* ELFLoader::areaForSection(const ELFImage::Section& section)
+{
+    return areaForSectionName(section.name());
+}
+
+char* ELFLoader::areaForSectionName(const char* name)
+{
+    if (auto it = m_sections.find(name); it != m_sections.end())
+        return (*it).value;
+    ASSERT_NOT_REACHED();
+    return nullptr;
+}
+
+void ELFLoader::performRelocations()
+{
+    printf("[ELFLoader] Performing relocations\n");
+
+    m_image->forEachSectionOfType(SHT_PROGBITS, [this] (const ELFImage::Section& section) {
+        auto& relocations = section.relocations();
+        if (relocations.isUndefined())
+            return;
+        relocations.forEachRelocation([this, section] (const ELFImage::Relocation& relocation) {
+            auto symbol = relocation.symbol();
+            auto& patchPtr = *reinterpret_cast<ptrdiff_t*>(areaForSection(section) + relocation.offset());
+
+            switch (relocation.type()) {
+            case R_386_PC32: {
+                char* targetPtr = (char*)lookup(symbol);
+                ptrdiff_t relativeOffset = (char*)targetPtr - ((char*)&patchPtr + 4);
+                printf("[ELFLoader] Relocate PC32:  offset=%08x, symbol=%u(%s) value=%08x target=%p, offset=%d\n",
+                        relocation.offset(),
+                        symbol.index(),
+                        symbol.name(),
+                        symbol.value(),
+                        targetPtr,
+                        relativeOffset
+                );
+                patchPtr = relativeOffset;
+                break;
+            }
+            case R_386_32: {
+                printf("[ELFLoader] Relocate Abs32: symbol=%u(%s), value=%08x, section=%s\n",
+                    symbol.index(),
+                    symbol.name(),
+                    symbol.value(),
+                    symbol.section().name()
+                );
+                char* targetPtr = areaForSection(symbol.section()) + symbol.value();
+                patchPtr += (ptrdiff_t)targetPtr;
+                break;
+            }
+            default:
+                ASSERT_NOT_REACHED();
+                break;
+            }
+        });
+    });
+}
+
+void ELFLoader::exportSymbols()
+{
+    m_image->forEachSymbol([&] (const ELFImage::Symbol symbol) {
+        printf("symbol: %u, type=%u, name=%s\n", symbol.index(), symbol.type(), symbol.name());
+        if (symbol.type() == STT_FUNC)
+            m_execSpace.addSymbol(symbol.name(), areaForSectionName(".text") + symbol.value(), symbol.size());
+        // FIXME: What about other symbol types?
+    });
+}
+
diff --git a/ELFLoader/ELFLoader.h b/ELFLoader/ELFLoader.h
new file mode 100644
index 00000000000..f62745484ab
--- /dev/null
+++ b/ELFLoader/ELFLoader.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <AK/HashMap.h>
+#include <AK/MappedFile.h>
+#include <AK/OwnPtr.h>
+#include <AK/Vector.h>
+#include "ExecSpace.h"
+#include "ELFImage.h"
+
+class ELFLoader {
+public:
+    ELFLoader(ExecSpace&, MappedFile&&);
+    ~ELFLoader();
+
+    bool load();
+
+private:
+    void layout();
+    void performRelocations();
+    void exportSymbols();
+    void* lookup(const ELFImage::Symbol&);
+    char* areaForSection(const ELFImage::Section&);
+    char* areaForSectionName(const char*);
+
+    ExecSpace& m_execSpace;
+    HashMap<String, char*> m_sections;
+    OwnPtr<ELFImage> m_image;
+};
+
diff --git a/ELFLoader/ExecSpace.cpp b/ELFLoader/ExecSpace.cpp
new file mode 100644
index 00000000000..8239d0c1a5f
--- /dev/null
+++ b/ELFLoader/ExecSpace.cpp
@@ -0,0 +1,80 @@
+#include "ExecSpace.h"
+#include "ELFLoader.h"
+#include <AK/TemporaryFile.h>
+#include <unistd.h>
+
+ExecSpace::ExecSpace()
+{
+    initializeBuiltins();
+}
+
+ExecSpace::~ExecSpace()
+{
+}
+
+void ExecSpace::initializeBuiltins()
+{
+    m_symbols.set("puts", { (char*)puts, 0 });
+}
+
+bool ExecSpace::loadELF(MappedFile&& file)
+{
+    ELFLoader loader(*this, std::move(file));
+    if (!loader.load())
+        return false;
+    printf("[ExecSpace] ELF loaded, symbol map now:\n");
+    for (auto& s : m_symbols) {
+        printf("> %p: %s (%u)\n",
+                s.value.ptr,
+                s.key.characters(),
+                s.value.size);
+    }
+    return true;
+}
+
+static void disassemble(const char* data, size_t length)
+{
+    if (!length)
+        return;
+
+    TemporaryFile temp;
+    if (!temp.isValid()) {
+        fprintf(stderr, "Unable to create temp file for disassembly.\n");
+        return;
+    }
+    fprintf(temp.stream(), "db ");
+    for (unsigned i = 0; i < length; ++i) {
+        fprintf(temp.stream(), "0x%02x, ", (unsigned char)data[i]);
+    }
+    fprintf(temp.stream(), "\n");
+    temp.sync();
+
+    char cmdbuf[128];
+    sprintf(cmdbuf, "nasm -f bin -o /dev/stdout %s | ndisasm -b32 -", temp.fileName().characters());
+    system(cmdbuf);
+}
+
+char* ExecSpace::symbolPtr(const char* name)
+{
+    if (auto it = m_symbols.find(name); it != m_symbols.end()) {
+        printf("[ELFLoader] symbolPtr(%s) dump:\n", name);
+        auto& symbol = (*it).value;
+        disassemble(symbol.ptr, symbol.size);
+        return symbol.ptr;
+    }
+    return nullptr;
+}
+
+
+char* ExecSpace::allocateArea(String&& name, unsigned size)
+{
+    char* ptr = static_cast<char*>(malloc(size));
+    ASSERT(ptr);
+    m_areas.append(make<Area>(std::move(name), ptr, size));
+    return ptr;
+}
+
+void ExecSpace::addSymbol(String&& name, char* ptr, unsigned size)
+{
+    m_symbols.set(std::move(name), { ptr, size });
+}
diff --git a/ELFLoader/ExecSpace.h b/ELFLoader/ExecSpace.h
new file mode 100644
index 00000000000..d627a97f849
--- /dev/null
+++ b/ELFLoader/ExecSpace.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <AK/HashMap.h>
+#include <AK/MappedFile.h>
+#include <AK/OwnPtr.h>
+#include <AK/Vector.h>
+
+class ELFLoader;
+
+class ExecSpace {
+public:
+    struct Area {
+        Area(String&& n, char* m, unsigned s)
+            : name(std::move(n))
+            , memory(m)
+            , size(s)
+        {
+        }
+
+        String name;
+        char* memory { 0 };
+        unsigned size { 0 };
+    };
+
+    struct PtrAndSize {
+        PtrAndSize() { }
+        PtrAndSize(char* p, unsigned s)
+            : ptr(p)
+            , size(s)
+        {
+        }
+
+        char* ptr { nullptr };
+        unsigned size { 0 };
+    };
+
+    ExecSpace();
+    ~ExecSpace();
+
+    bool loadELF(MappedFile&&);
+
+    char* symbolPtr(const char* name);
+
+    char* allocateArea(String&& name, unsigned size);
+    void addSymbol(String&& name, char* ptr, unsigned size);
+
+private:
+    void initializeBuiltins();
+
+    Vector<OwnPtr<Area>> m_areas;
+    HashMap<String, PtrAndSize> m_symbols;
+};
+
diff --git a/ELFLoader/Makefile b/ELFLoader/Makefile
new file mode 100644
index 00000000000..1b868acee5c
--- /dev/null
+++ b/ELFLoader/Makefile
@@ -0,0 +1,38 @@
+PROGRAM = run
+
+AK_OBJS = \
+    ../AK/String.o \
+    ../AK/StringImpl.o \
+    ../AK/MappedFile.o \
+    ../AK/TemporaryFile.o \
+    ../AK/kmalloc.o
+
+CSILLA_OBJS = \
+    ExecSpace.o \
+    ELFImage.o \
+    ELFLoader.o \
+    test.o
+
+TEST_OBJ = \
+    _test.o
+
+TEST_OBJ_CXXFLAGS = -Os -fno-exceptions -fno-rtti -fno-asynchronous-unwind-tables
+
+OBJS = $(AK_OBJS) $(CSILLA_OBJS)
+
+CXXFLAGS = -std=c++17 -Os -W -Wall -I. -I.. -ggdb3
+
+all:	$(PROGRAM) $(TEST_OBJ)
+
+_test.o: _test.cpp
+	$(CXX) $(TEST_OBJ_CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) -o $@ -c $<
+
+clean:
+	rm -f $(OBJS) $(TEST_OBJ) $(PROGRAM)
+
+$(PROGRAM): $(OBJS)
+	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
+
diff --git a/ELFLoader/_test.cpp b/ELFLoader/_test.cpp
new file mode 100644
index 00000000000..2d36eb2a6f5
--- /dev/null
+++ b/ELFLoader/_test.cpp
@@ -0,0 +1,29 @@
+#include <stdio.h>
+
+extern "C" const char hello_string[] = "Hello World!";
+
+extern "C" int foo()
+{
+    volatile int i = 3;
+    i = 4;
+    return i;
+}
+
+extern "C" int bar()
+{
+    return foo();
+}
+
+extern "C" int baz()
+{
+    return bar();
+}
+
+extern "C" int EntryPoint()
+{
+    puts(hello_string);
+    printf("abc!\n");
+    printf("def!\n");
+    return 10 + baz();
+}
+
diff --git a/ELFLoader/elf.h b/ELFLoader/elf.h
new file mode 100644
index 00000000000..c541774d985
--- /dev/null
+++ b/ELFLoader/elf.h
@@ -0,0 +1,2645 @@
+/* This file defines standard ELF types, structures, and macros.
+   Copyright (C) 1995-2003,2004,2005,2006,2007 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _ELF_H
+#define	_ELF_H 1
+
+#include <features.h>
+
+__BEGIN_DECLS
+
+/* Standard ELF types.  */
+
+#include <stdint.h>
+
+/* Type for a 16-bit quantity.  */
+typedef uint16_t Elf32_Half;
+typedef uint16_t Elf64_Half;
+
+/* Types for signed and unsigned 32-bit quantities.  */
+typedef uint32_t Elf32_Word;
+typedef	int32_t  Elf32_Sword;
+typedef uint32_t Elf64_Word;
+typedef	int32_t  Elf64_Sword;
+
+/* Types for signed and unsigned 64-bit quantities.  */
+typedef uint64_t Elf32_Xword;
+typedef	int64_t  Elf32_Sxword;
+typedef uint64_t Elf64_Xword;
+typedef	int64_t  Elf64_Sxword;
+
+/* Type of addresses.  */
+typedef uint32_t Elf32_Addr;
+typedef uint64_t Elf64_Addr;
+
+/* Type of file offsets.  */
+typedef uint32_t Elf32_Off;
+typedef uint64_t Elf64_Off;
+
+/* Type for section indices, which are 16-bit quantities.  */
+typedef uint16_t Elf32_Section;
+typedef uint16_t Elf64_Section;
+
+/* Type for version symbol information.  */
+typedef Elf32_Half Elf32_Versym;
+typedef Elf64_Half Elf64_Versym;
+
+
+/* The ELF file header.  This appears at the start of every ELF file.  */
+
+#define EI_NIDENT (16)
+
+typedef struct
+{
+  unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
+  Elf32_Half	e_type;			/* Object file type */
+  Elf32_Half	e_machine;		/* Architecture */
+  Elf32_Word	e_version;		/* Object file version */
+  Elf32_Addr	e_entry;		/* Entry point virtual address */
+  Elf32_Off	e_phoff;		/* Program header table file offset */
+  Elf32_Off	e_shoff;		/* Section header table file offset */
+  Elf32_Word	e_flags;		/* Processor-specific flags */
+  Elf32_Half	e_ehsize;		/* ELF header size in bytes */
+  Elf32_Half	e_phentsize;		/* Program header table entry size */
+  Elf32_Half	e_phnum;		/* Program header table entry count */
+  Elf32_Half	e_shentsize;		/* Section header table entry size */
+  Elf32_Half	e_shnum;		/* Section header table entry count */
+  Elf32_Half	e_shstrndx;		/* Section header string table index */
+} Elf32_Ehdr;
+
+typedef struct
+{
+  unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
+  Elf64_Half	e_type;			/* Object file type */
+  Elf64_Half	e_machine;		/* Architecture */
+  Elf64_Word	e_version;		/* Object file version */
+  Elf64_Addr	e_entry;		/* Entry point virtual address */
+  Elf64_Off	e_phoff;		/* Program header table file offset */
+  Elf64_Off	e_shoff;		/* Section header table file offset */
+  Elf64_Word	e_flags;		/* Processor-specific flags */
+  Elf64_Half	e_ehsize;		/* ELF header size in bytes */
+  Elf64_Half	e_phentsize;		/* Program header table entry size */
+  Elf64_Half	e_phnum;		/* Program header table entry count */
+  Elf64_Half	e_shentsize;		/* Section header table entry size */
+  Elf64_Half	e_shnum;		/* Section header table entry count */
+  Elf64_Half	e_shstrndx;		/* Section header string table index */
+} Elf64_Ehdr;
+
+/* Fields in the e_ident array.  The EI_* macros are indices into the
+   array.  The macros under each EI_* macro are the values the byte
+   may have.  */
+
+#define EI_MAG0		0		/* File identification byte 0 index */
+#define ELFMAG0		0x7f		/* Magic number byte 0 */
+
+#define EI_MAG1		1		/* File identification byte 1 index */
+#define ELFMAG1		'E'		/* Magic number byte 1 */
+
+#define EI_MAG2		2		/* File identification byte 2 index */
+#define ELFMAG2		'L'		/* Magic number byte 2 */
+
+#define EI_MAG3		3		/* File identification byte 3 index */
+#define ELFMAG3		'F'		/* Magic number byte 3 */
+
+/* Conglomeration of the identification bytes, for easy testing as a word.  */
+#define	ELFMAG		"\177ELF"
+#define	SELFMAG		4
+
+#define EI_CLASS	4		/* File class byte index */
+#define ELFCLASSNONE	0		/* Invalid class */
+#define ELFCLASS32	1		/* 32-bit objects */
+#define ELFCLASS64	2		/* 64-bit objects */
+#define ELFCLASSNUM	3
+
+#define EI_DATA		5		/* Data encoding byte index */
+#define ELFDATANONE	0		/* Invalid data encoding */
+#define ELFDATA2LSB	1		/* 2's complement, little endian */
+#define ELFDATA2MSB	2		/* 2's complement, big endian */
+#define ELFDATANUM	3
+
+#define EI_VERSION	6		/* File version byte index */
+					/* Value must be EV_CURRENT */
+
+#define EI_OSABI	7		/* OS ABI identification */
+#define ELFOSABI_NONE		0	/* UNIX System V ABI */
+#define ELFOSABI_SYSV		0	/* Alias.  */
+#define ELFOSABI_HPUX		1	/* HP-UX */
+#define ELFOSABI_NETBSD		2	/* NetBSD.  */
+#define ELFOSABI_LINUX		3	/* Linux.  */
+#define ELFOSABI_SOLARIS	6	/* Sun Solaris.  */
+#define ELFOSABI_AIX		7	/* IBM AIX.  */
+#define ELFOSABI_IRIX		8	/* SGI Irix.  */
+#define ELFOSABI_FREEBSD	9	/* FreeBSD.  */
+#define ELFOSABI_TRU64		10	/* Compaq TRU64 UNIX.  */
+#define ELFOSABI_MODESTO	11	/* Novell Modesto.  */
+#define ELFOSABI_OPENBSD	12	/* OpenBSD.  */
+#define ELFOSABI_ARM		97	/* ARM */
+#define ELFOSABI_STANDALONE	255	/* Standalone (embedded) application */
+
+#define EI_ABIVERSION	8		/* ABI version */
+
+#define EI_PAD		9		/* Byte index of padding bytes */
+
+/* Legal values for e_type (object file type).  */
+
+#define ET_NONE		0		/* No file type */
+#define ET_REL		1		/* Relocatable file */
+#define ET_EXEC		2		/* Executable file */
+#define ET_DYN		3		/* Shared object file */
+#define ET_CORE		4		/* Core file */
+#define	ET_NUM		5		/* Number of defined types */
+#define ET_LOOS		0xfe00		/* OS-specific range start */
+#define ET_HIOS		0xfeff		/* OS-specific range end */
+#define ET_LOPROC	0xff00		/* Processor-specific range start */
+#define ET_HIPROC	0xffff		/* Processor-specific range end */
+
+/* Legal values for e_machine (architecture).  */
+
+#define EM_NONE		 0		/* No machine */
+#define EM_M32		 1		/* AT&T WE 32100 */
+#define EM_SPARC	 2		/* SUN SPARC */
+#define EM_386		 3		/* Intel 80386 */
+#define EM_68K		 4		/* Motorola m68k family */
+#define EM_88K		 5		/* Motorola m88k family */
+#define EM_860		 7		/* Intel 80860 */
+#define EM_MIPS		 8		/* MIPS R3000 big-endian */
+#define EM_S370		 9		/* IBM System/370 */
+#define EM_MIPS_RS3_LE	10		/* MIPS R3000 little-endian */
+
+#define EM_PARISC	15		/* HPPA */
+#define EM_VPP500	17		/* Fujitsu VPP500 */
+#define EM_SPARC32PLUS	18		/* Sun's "v8plus" */
+#define EM_960		19		/* Intel 80960 */
+#define EM_PPC		20		/* PowerPC */
+#define EM_PPC64	21		/* PowerPC 64-bit */
+#define EM_S390		22		/* IBM S390 */
+
+#define EM_V800		36		/* NEC V800 series */
+#define EM_FR20		37		/* Fujitsu FR20 */
+#define EM_RH32		38		/* TRW RH-32 */
+#define EM_RCE		39		/* Motorola RCE */
+#define EM_ARM		40		/* ARM */
+#define EM_FAKE_ALPHA	41		/* Digital Alpha */
+#define EM_SH		42		/* Hitachi SH */
+#define EM_SPARCV9	43		/* SPARC v9 64-bit */
+#define EM_TRICORE	44		/* Siemens Tricore */
+#define EM_ARC		45		/* Argonaut RISC Core */
+#define EM_H8_300	46		/* Hitachi H8/300 */
+#define EM_H8_300H	47		/* Hitachi H8/300H */
+#define EM_H8S		48		/* Hitachi H8S */
+#define EM_H8_500	49		/* Hitachi H8/500 */
+#define EM_IA_64	50		/* Intel Merced */
+#define EM_MIPS_X	51		/* Stanford MIPS-X */
+#define EM_COLDFIRE	52		/* Motorola Coldfire */
+#define EM_68HC12	53		/* Motorola M68HC12 */
+#define EM_MMA		54		/* Fujitsu MMA Multimedia Accelerator*/
+#define EM_PCP		55		/* Siemens PCP */
+#define EM_NCPU		56		/* Sony nCPU embeeded RISC */
+#define EM_NDR1		57		/* Denso NDR1 microprocessor */
+#define EM_STARCORE	58		/* Motorola Start*Core processor */
+#define EM_ME16		59		/* Toyota ME16 processor */
+#define EM_ST100	60		/* STMicroelectronic ST100 processor */
+#define EM_TINYJ	61		/* Advanced Logic Corp. Tinyj emb.fam*/
+#define EM_X86_64	62		/* AMD x86-64 architecture */
+#define EM_PDSP		63		/* Sony DSP Processor */
+
+#define EM_FX66		66		/* Siemens FX66 microcontroller */
+#define EM_ST9PLUS	67		/* STMicroelectronics ST9+ 8/16 mc */
+#define EM_ST7		68		/* STmicroelectronics ST7 8 bit mc */
+#define EM_68HC16	69		/* Motorola MC68HC16 microcontroller */
+#define EM_68HC11	70		/* Motorola MC68HC11 microcontroller */
+#define EM_68HC08	71		/* Motorola MC68HC08 microcontroller */
+#define EM_68HC05	72		/* Motorola MC68HC05 microcontroller */
+#define EM_SVX		73		/* Silicon Graphics SVx */
+#define EM_ST19		74		/* STMicroelectronics ST19 8 bit mc */
+#define EM_VAX		75		/* Digital VAX */
+#define EM_CRIS		76		/* Axis Communications 32-bit embedded processor */
+#define EM_JAVELIN	77		/* Infineon Technologies 32-bit embedded processor */
+#define EM_FIREPATH	78		/* Element 14 64-bit DSP Processor */
+#define EM_ZSP		79		/* LSI Logic 16-bit DSP Processor */
+#define EM_MMIX		80		/* Donald Knuth's educational 64-bit processor */
+#define EM_HUANY	81		/* Harvard University machine-independent object files */
+#define EM_PRISM	82		/* SiTera Prism */
+#define EM_AVR		83		/* Atmel AVR 8-bit microcontroller */
+#define EM_FR30		84		/* Fujitsu FR30 */
+#define EM_D10V		85		/* Mitsubishi D10V */
+#define EM_D30V		86		/* Mitsubishi D30V */
+#define EM_V850		87		/* NEC v850 */
+#define EM_M32R		88		/* Mitsubishi M32R */
+#define EM_MN10300	89		/* Matsushita MN10300 */
+#define EM_MN10200	90		/* Matsushita MN10200 */
+#define EM_PJ		91		/* picoJava */
+#define EM_OPENRISC	92		/* OpenRISC 32-bit embedded processor */
+#define EM_ARC_A5	93		/* ARC Cores Tangent-A5 */
+#define EM_XTENSA	94		/* Tensilica Xtensa Architecture */
+#define EM_NUM		95
+
+/* If it is necessary to assign new unofficial EM_* values, please
+   pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the
+   chances of collision with official or non-GNU unofficial values.  */
+
+#define EM_ALPHA	0x9026
+
+/* Legal values for e_version (version).  */
+
+#define EV_NONE		0		/* Invalid ELF version */
+#define EV_CURRENT	1		/* Current version */
+#define EV_NUM		2
+
+/* Section header.  */
+
+typedef struct
+{
+  Elf32_Word	sh_name;		/* Section name (string tbl index) */
+  Elf32_Word	sh_type;		/* Section type */
+  Elf32_Word	sh_flags;		/* Section flags */
+  Elf32_Addr	sh_addr;		/* Section virtual addr at execution */
+  Elf32_Off	sh_offset;		/* Section file offset */
+  Elf32_Word	sh_size;		/* Section size in bytes */
+  Elf32_Word	sh_link;		/* Link to another section */
+  Elf32_Word	sh_info;		/* Additional section information */
+  Elf32_Word	sh_addralign;		/* Section alignment */
+  Elf32_Word	sh_entsize;		/* Entry size if section holds table */
+} Elf32_Shdr;
+
+typedef struct
+{
+  Elf64_Word	sh_name;		/* Section name (string tbl index) */
+  Elf64_Word	sh_type;		/* Section type */
+  Elf64_Xword	sh_flags;		/* Section flags */
+  Elf64_Addr	sh_addr;		/* Section virtual addr at execution */
+  Elf64_Off	sh_offset;		/* Section file offset */
+  Elf64_Xword	sh_size;		/* Section size in bytes */
+  Elf64_Word	sh_link;		/* Link to another section */
+  Elf64_Word	sh_info;		/* Additional section information */
+  Elf64_Xword	sh_addralign;		/* Section alignment */
+  Elf64_Xword	sh_entsize;		/* Entry size if section holds table */
+} Elf64_Shdr;
+
+/* Special section indices.  */
+
+#define SHN_UNDEF	0		/* Undefined section */
+#define SHN_LORESERVE	0xff00		/* Start of reserved indices */
+#define SHN_LOPROC	0xff00		/* Start of processor-specific */
+#define SHN_BEFORE	0xff00		/* Order section before all others
+					   (Solaris).  */
+#define SHN_AFTER	0xff01		/* Order section after all others
+					   (Solaris).  */
+#define SHN_HIPROC	0xff1f		/* End of processor-specific */
+#define SHN_LOOS	0xff20		/* Start of OS-specific */
+#define SHN_HIOS	0xff3f		/* End of OS-specific */
+#define SHN_ABS		0xfff1		/* Associated symbol is absolute */
+#define SHN_COMMON	0xfff2		/* Associated symbol is common */
+#define SHN_XINDEX	0xffff		/* Index is in extra table.  */
+#define SHN_HIRESERVE	0xffff		/* End of reserved indices */
+
+/* Legal values for sh_type (section type).  */
+
+#define SHT_NULL	  0		/* Section header table entry unused */
+#define SHT_PROGBITS	  1		/* Program data */
+#define SHT_SYMTAB	  2		/* Symbol table */
+#define SHT_STRTAB	  3		/* String table */
+#define SHT_RELA	  4		/* Relocation entries with addends */
+#define SHT_HASH	  5		/* Symbol hash table */
+#define SHT_DYNAMIC	  6		/* Dynamic linking information */
+#define SHT_NOTE	  7		/* Notes */
+#define SHT_NOBITS	  8		/* Program space with no data (bss) */
+#define SHT_REL		  9		/* Relocation entries, no addends */
+#define SHT_SHLIB	  10		/* Reserved */
+#define SHT_DYNSYM	  11		/* Dynamic linker symbol table */
+#define SHT_INIT_ARRAY	  14		/* Array of constructors */
+#define SHT_FINI_ARRAY	  15		/* Array of destructors */
+#define SHT_PREINIT_ARRAY 16		/* Array of pre-constructors */
+#define SHT_GROUP	  17		/* Section group */
+#define SHT_SYMTAB_SHNDX  18		/* Extended section indeces */
+#define	SHT_NUM		  19		/* Number of defined types.  */
+#define SHT_LOOS	  0x60000000	/* Start OS-specific.  */
+#define SHT_GNU_HASH	  0x6ffffff6	/* GNU-style hash table.  */
+#define SHT_GNU_LIBLIST	  0x6ffffff7	/* Prelink library list */
+#define SHT_CHECKSUM	  0x6ffffff8	/* Checksum for DSO content.  */
+#define SHT_LOSUNW	  0x6ffffffa	/* Sun-specific low bound.  */
+#define SHT_SUNW_move	  0x6ffffffa
+#define SHT_SUNW_COMDAT   0x6ffffffb
+#define SHT_SUNW_syminfo  0x6ffffffc
+#define SHT_GNU_verdef	  0x6ffffffd	/* Version definition section.  */
+#define SHT_GNU_verneed	  0x6ffffffe	/* Version needs section.  */
+#define SHT_GNU_versym	  0x6fffffff	/* Version symbol table.  */
+#define SHT_HISUNW	  0x6fffffff	/* Sun-specific high bound.  */
+#define SHT_HIOS	  0x6fffffff	/* End OS-specific type */
+#define SHT_LOPROC	  0x70000000	/* Start of processor-specific */
+#define SHT_HIPROC	  0x7fffffff	/* End of processor-specific */
+#define SHT_LOUSER	  0x80000000	/* Start of application-specific */
+#define SHT_HIUSER	  0x8fffffff	/* End of application-specific */
+
+/* Legal values for sh_flags (section flags).  */
+
+#define SHF_WRITE	     (1 << 0)	/* Writable */
+#define SHF_ALLOC	     (1 << 1)	/* Occupies memory during execution */
+#define SHF_EXECINSTR	     (1 << 2)	/* Executable */
+#define SHF_MERGE	     (1 << 4)	/* Might be merged */
+#define SHF_STRINGS	     (1 << 5)	/* Contains nul-terminated strings */
+#define SHF_INFO_LINK	     (1 << 6)	/* `sh_info' contains SHT index */
+#define SHF_LINK_ORDER	     (1 << 7)	/* Preserve order after combining */
+#define SHF_OS_NONCONFORMING (1 << 8)	/* Non-standard OS specific handling
+					   required */
+#define SHF_GROUP	     (1 << 9)	/* Section is member of a group.  */
+#define SHF_TLS		     (1 << 10)	/* Section hold thread-local data.  */
+#define SHF_MASKOS	     0x0ff00000	/* OS-specific.  */
+#define SHF_MASKPROC	     0xf0000000	/* Processor-specific */
+#define SHF_ORDERED	     (1 << 30)	/* Special ordering requirement
+					   (Solaris).  */
+#define SHF_EXCLUDE	     (1 << 31)	/* Section is excluded unless
+					   referenced or allocated (Solaris).*/
+
+/* Section group handling.  */
+#define GRP_COMDAT	0x1		/* Mark group as COMDAT.  */
+
+/* Symbol table entry.  */
+
+typedef struct
+{
+  Elf32_Word	st_name;		/* Symbol name (string tbl index) */
+  Elf32_Addr	st_value;		/* Symbol value */
+  Elf32_Word	st_size;		/* Symbol size */
+  unsigned char	st_info;		/* Symbol type and binding */
+  unsigned char	st_other;		/* Symbol visibility */
+  Elf32_Section	st_shndx;		/* Section index */
+} Elf32_Sym;
+
+typedef struct
+{
+  Elf64_Word	st_name;		/* Symbol name (string tbl index) */
+  unsigned char	st_info;		/* Symbol type and binding */
+  unsigned char st_other;		/* Symbol visibility */
+  Elf64_Section	st_shndx;		/* Section index */
+  Elf64_Addr	st_value;		/* Symbol value */
+  Elf64_Xword	st_size;		/* Symbol size */
+} Elf64_Sym;
+
+/* The syminfo section if available contains additional information about
+   every dynamic symbol.  */
+
+typedef struct
+{
+  Elf32_Half si_boundto;		/* Direct bindings, symbol bound to */
+  Elf32_Half si_flags;			/* Per symbol flags */
+} Elf32_Syminfo;
+
+typedef struct
+{
+  Elf64_Half si_boundto;		/* Direct bindings, symbol bound to */
+  Elf64_Half si_flags;			/* Per symbol flags */
+} Elf64_Syminfo;
+
+/* Possible values for si_boundto.  */
+#define SYMINFO_BT_SELF		0xffff	/* Symbol bound to self */
+#define SYMINFO_BT_PARENT	0xfffe	/* Symbol bound to parent */
+#define SYMINFO_BT_LOWRESERVE	0xff00	/* Beginning of reserved entries */
+
+/* Possible bitmasks for si_flags.  */
+#define SYMINFO_FLG_DIRECT	0x0001	/* Direct bound symbol */
+#define SYMINFO_FLG_PASSTHRU	0x0002	/* Pass-thru symbol for translator */
+#define SYMINFO_FLG_COPY	0x0004	/* Symbol is a copy-reloc */
+#define SYMINFO_FLG_LAZYLOAD	0x0008	/* Symbol bound to object to be lazy
+					   loaded */
+/* Syminfo version values.  */
+#define SYMINFO_NONE		0
+#define SYMINFO_CURRENT		1
+#define SYMINFO_NUM		2
+
+
+/* How to extract and insert information held in the st_info field.  */
+
+#define ELF32_ST_BIND(val)		(((unsigned char) (val)) >> 4)
+#define ELF32_ST_TYPE(val)		((val) & 0xf)
+#define ELF32_ST_INFO(bind, type)	(((bind) << 4) + ((type) & 0xf))
+
+/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field.  */
+#define ELF64_ST_BIND(val)		ELF32_ST_BIND (val)
+#define ELF64_ST_TYPE(val)		ELF32_ST_TYPE (val)
+#define ELF64_ST_INFO(bind, type)	ELF32_ST_INFO ((bind), (type))
+
+/* Legal values for ST_BIND subfield of st_info (symbol binding).  */
+
+#define STB_LOCAL	0		/* Local symbol */
+#define STB_GLOBAL	1		/* Global symbol */
+#define STB_WEAK	2		/* Weak symbol */
+#define	STB_NUM		3		/* Number of defined types.  */
+#define STB_LOOS	10		/* Start of OS-specific */
+#define STB_HIOS	12		/* End of OS-specific */
+#define STB_LOPROC	13		/* Start of processor-specific */
+#define STB_HIPROC	15		/* End of processor-specific */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
+
+#define STT_NOTYPE	0		/* Symbol type is unspecified */
+#define STT_OBJECT	1		/* Symbol is a data object */
+#define STT_FUNC	2		/* Symbol is a code object */
+#define STT_SECTION	3		/* Symbol associated with a section */
+#define STT_FILE	4		/* Symbol's name is file name */
+#define STT_COMMON	5		/* Symbol is a common data object */
+#define STT_TLS		6		/* Symbol is thread-local data object*/
+#define	STT_NUM		7		/* Number of defined types.  */
+#define STT_LOOS	10		/* Start of OS-specific */
+#define STT_HIOS	12		/* End of OS-specific */
+#define STT_LOPROC	13		/* Start of processor-specific */
+#define STT_HIPROC	15		/* End of processor-specific */
+
+
+/* Symbol table indices are found in the hash buckets and chain table
+   of a symbol hash table section.  This special index value indicates
+   the end of a chain, meaning no further symbols are found in that bucket.  */
+
+#define STN_UNDEF	0		/* End of a chain.  */
+
+
+/* How to extract and insert information held in the st_other field.  */
+
+#define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
+
+/* For ELF64 the definitions are the same.  */
+#define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
+
+/* Symbol visibility specification encoded in the st_other field.  */
+#define STV_DEFAULT	0		/* Default symbol visibility rules */
+#define STV_INTERNAL	1		/* Processor specific hidden class */
+#define STV_HIDDEN	2		/* Sym unavailable in other modules */
+#define STV_PROTECTED	3		/* Not preemptible, not exported */
+
+
+/* Relocation table entry without addend (in section of type SHT_REL).  */
+
+typedef struct
+{
+  Elf32_Addr	r_offset;		/* Address */
+  Elf32_Word	r_info;			/* Relocation type and symbol index */
+} Elf32_Rel;
+
+/* I have seen two different definitions of the Elf64_Rel and
+   Elf64_Rela structures, so we'll leave them out until Novell (or
+   whoever) gets their act together.  */
+/* The following, at least, is used on Sparc v9, MIPS, and Alpha.  */
+
+typedef struct
+{
+  Elf64_Addr	r_offset;		/* Address */
+  Elf64_Xword	r_info;			/* Relocation type and symbol index */
+} Elf64_Rel;
+
+/* Relocation table entry with addend (in section of type SHT_RELA).  */
+
+typedef struct
+{
+  Elf32_Addr	r_offset;		/* Address */
+  Elf32_Word	r_info;			/* Relocation type and symbol index */
+  Elf32_Sword	r_addend;		/* Addend */
+} Elf32_Rela;
+
+typedef struct
+{
+  Elf64_Addr	r_offset;		/* Address */
+  Elf64_Xword	r_info;			/* Relocation type and symbol index */
+  Elf64_Sxword	r_addend;		/* Addend */
+} Elf64_Rela;
+
+/* How to extract and insert information held in the r_info field.  */
+
+#define ELF32_R_SYM(val)		((val) >> 8)
+#define ELF32_R_TYPE(val)		((val) & 0xff)
+#define ELF32_R_INFO(sym, type)		(((sym) << 8) + ((type) & 0xff))
+
+#define ELF64_R_SYM(i)			((i) >> 32)
+#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
+#define ELF64_R_INFO(sym,type)		((((Elf64_Xword) (sym)) << 32) + (type))
+
+/* Program segment header.  */
+
+typedef struct
+{
+  Elf32_Word	p_type;			/* Segment type */
+  Elf32_Off	p_offset;		/* Segment file offset */
+  Elf32_Addr	p_vaddr;		/* Segment virtual address */
+  Elf32_Addr	p_paddr;		/* Segment physical address */
+  Elf32_Word	p_filesz;		/* Segment size in file */
+  Elf32_Word	p_memsz;		/* Segment size in memory */
+  Elf32_Word	p_flags;		/* Segment flags */
+  Elf32_Word	p_align;		/* Segment alignment */
+} Elf32_Phdr;
+
+typedef struct
+{
+  Elf64_Word	p_type;			/* Segment type */
+  Elf64_Word	p_flags;		/* Segment flags */
+  Elf64_Off	p_offset;		/* Segment file offset */
+  Elf64_Addr	p_vaddr;		/* Segment virtual address */
+  Elf64_Addr	p_paddr;		/* Segment physical address */
+  Elf64_Xword	p_filesz;		/* Segment size in file */
+  Elf64_Xword	p_memsz;		/* Segment size in memory */
+  Elf64_Xword	p_align;		/* Segment alignment */
+} Elf64_Phdr;
+
+/* Legal values for p_type (segment type).  */
+
+#define	PT_NULL		0		/* Program header table entry unused */
+#define PT_LOAD		1		/* Loadable program segment */
+#define PT_DYNAMIC	2		/* Dynamic linking information */
+#define PT_INTERP	3		/* Program interpreter */
+#define PT_NOTE		4		/* Auxiliary information */
+#define PT_SHLIB	5		/* Reserved */
+#define PT_PHDR		6		/* Entry for header table itself */
+#define PT_TLS		7		/* Thread-local storage segment */
+#define	PT_NUM		8		/* Number of defined types */
+#define PT_LOOS		0x60000000	/* Start of OS-specific */
+#define PT_GNU_EH_FRAME	0x6474e550	/* GCC .eh_frame_hdr segment */
+#define PT_GNU_STACK	0x6474e551	/* Indicates stack executability */
+#define PT_GNU_RELRO	0x6474e552	/* Read-only after relocation */
+#define PT_LOSUNW	0x6ffffffa
+#define PT_SUNWBSS	0x6ffffffa	/* Sun Specific segment */
+#define PT_SUNWSTACK	0x6ffffffb	/* Stack segment */
+#define PT_HISUNW	0x6fffffff
+#define PT_HIOS		0x6fffffff	/* End of OS-specific */
+#define PT_LOPROC	0x70000000	/* Start of processor-specific */
+#define PT_HIPROC	0x7fffffff	/* End of processor-specific */
+
+/* Legal values for p_flags (segment flags).  */
+
+#define PF_X		(1 << 0)	/* Segment is executable */
+#define PF_W		(1 << 1)	/* Segment is writable */
+#define PF_R		(1 << 2)	/* Segment is readable */
+#define PF_MASKOS	0x0ff00000	/* OS-specific */
+#define PF_MASKPROC	0xf0000000	/* Processor-specific */
+
+/* Legal values for note segment descriptor types for core files. */
+
+#define NT_PRSTATUS	1		/* Contains copy of prstatus struct */
+#define NT_FPREGSET	2		/* Contains copy of fpregset struct */
+#define NT_PRPSINFO	3		/* Contains copy of prpsinfo struct */
+#define NT_PRXREG	4		/* Contains copy of prxregset struct */
+#define NT_TASKSTRUCT	4		/* Contains copy of task structure */
+#define NT_PLATFORM	5		/* String from sysinfo(SI_PLATFORM) */
+#define NT_AUXV		6		/* Contains copy of auxv array */
+#define NT_GWINDOWS	7		/* Contains copy of gwindows struct */
+#define NT_ASRS		8		/* Contains copy of asrset struct */
+#define NT_PSTATUS	10		/* Contains copy of pstatus struct */
+#define NT_PSINFO	13		/* Contains copy of psinfo struct */
+#define NT_PRCRED	14		/* Contains copy of prcred struct */
+#define NT_UTSNAME	15		/* Contains copy of utsname struct */
+#define NT_LWPSTATUS	16		/* Contains copy of lwpstatus struct */
+#define NT_LWPSINFO	17		/* Contains copy of lwpinfo struct */
+#define NT_PRFPXREG	20		/* Contains copy of fprxregset struct */
+#define NT_PRXFPREG	0x46e62b7f	/* Contains copy of user_fxsr_struct */
+
+/* Legal values for the note segment descriptor types for object files.  */
+
+#define NT_VERSION	1		/* Contains a version string.  */
+
+
+/* Dynamic section entry.  */
+
+typedef struct
+{
+  Elf32_Sword	d_tag;			/* Dynamic entry type */
+  union
+    {
+      Elf32_Word d_val;			/* Integer value */
+      Elf32_Addr d_ptr;			/* Address value */
+    } d_un;
+} Elf32_Dyn;
+
+typedef struct
+{
+  Elf64_Sxword	d_tag;			/* Dynamic entry type */
+  union
+    {
+      Elf64_Xword d_val;		/* Integer value */
+      Elf64_Addr d_ptr;			/* Address value */
+    } d_un;
+} Elf64_Dyn;
+
+/* Legal values for d_tag (dynamic entry type).  */
+
+#define DT_NULL		0		/* Marks end of dynamic section */
+#define DT_NEEDED	1		/* Name of needed library */
+#define DT_PLTRELSZ	2		/* Size in bytes of PLT relocs */
+#define DT_PLTGOT	3		/* Processor defined value */
+#define DT_HASH		4		/* Address of symbol hash table */
+#define DT_STRTAB	5		/* Address of string table */
+#define DT_SYMTAB	6		/* Address of symbol table */
+#define DT_RELA		7		/* Address of Rela relocs */
+#define DT_RELASZ	8		/* Total size of Rela relocs */
+#define DT_RELAENT	9		/* Size of one Rela reloc */
+#define DT_STRSZ	10		/* Size of string table */
+#define DT_SYMENT	11		/* Size of one symbol table entry */
+#define DT_INIT		12		/* Address of init function */
+#define DT_FINI		13		/* Address of termination function */
+#define DT_SONAME	14		/* Name of shared object */
+#define DT_RPATH	15		/* Library search path (deprecated) */
+#define DT_SYMBOLIC	16		/* Start symbol search here */
+#define DT_REL		17		/* Address of Rel relocs */
+#define DT_RELSZ	18		/* Total size of Rel relocs */
+#define DT_RELENT	19		/* Size of one Rel reloc */
+#define DT_PLTREL	20		/* Type of reloc in PLT */
+#define DT_DEBUG	21		/* For debugging; unspecified */
+#define DT_TEXTREL	22		/* Reloc might modify .text */
+#define DT_JMPREL	23		/* Address of PLT relocs */
+#define	DT_BIND_NOW	24		/* Process relocations of object */
+#define	DT_INIT_ARRAY	25		/* Array with addresses of init fct */
+#define	DT_FINI_ARRAY	26		/* Array with addresses of fini fct */
+#define	DT_INIT_ARRAYSZ	27		/* Size in bytes of DT_INIT_ARRAY */
+#define	DT_FINI_ARRAYSZ	28		/* Size in bytes of DT_FINI_ARRAY */
+#define DT_RUNPATH	29		/* Library search path */
+#define DT_FLAGS	30		/* Flags for the object being loaded */
+#define DT_ENCODING	32		/* Start of encoded range */
+#define DT_PREINIT_ARRAY 32		/* Array with addresses of preinit fct*/
+#define DT_PREINIT_ARRAYSZ 33		/* size in bytes of DT_PREINIT_ARRAY */
+#define	DT_NUM		34		/* Number used */
+#define DT_LOOS		0x6000000d	/* Start of OS-specific */
+#define DT_HIOS		0x6ffff000	/* End of OS-specific */
+#define DT_LOPROC	0x70000000	/* Start of processor-specific */
+#define DT_HIPROC	0x7fffffff	/* End of processor-specific */
+#define	DT_PROCNUM	DT_MIPS_NUM	/* Most used by any processor */
+
+/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
+   Dyn.d_un.d_val field of the Elf*_Dyn structure.  This follows Sun's
+   approach.  */
+#define DT_VALRNGLO	0x6ffffd00
+#define DT_GNU_PRELINKED 0x6ffffdf5	/* Prelinking timestamp */
+#define DT_GNU_CONFLICTSZ 0x6ffffdf6	/* Size of conflict section */
+#define DT_GNU_LIBLISTSZ 0x6ffffdf7	/* Size of library list */
+#define DT_CHECKSUM	0x6ffffdf8
+#define DT_PLTPADSZ	0x6ffffdf9
+#define DT_MOVEENT	0x6ffffdfa
+#define DT_MOVESZ	0x6ffffdfb
+#define DT_FEATURE_1	0x6ffffdfc	/* Feature selection (DTF_*).  */
+#define DT_POSFLAG_1	0x6ffffdfd	/* Flags for DT_* entries, effecting
+					   the following DT_* entry.  */
+#define DT_SYMINSZ	0x6ffffdfe	/* Size of syminfo table (in bytes) */
+#define DT_SYMINENT	0x6ffffdff	/* Entry size of syminfo */
+#define DT_VALRNGHI	0x6ffffdff
+#define DT_VALTAGIDX(tag)	(DT_VALRNGHI - (tag))	/* Reverse order! */
+#define DT_VALNUM 12
+
+/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
+   Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
+
+   If any adjustment is made to the ELF object after it has been
+   built these entries will need to be adjusted.  */
+#define DT_ADDRRNGLO	0x6ffffe00
+#define DT_GNU_HASH	0x6ffffef5	/* GNU-style hash table.  */
+#define DT_TLSDESC_PLT	0x6ffffef6
+#define DT_TLSDESC_GOT	0x6ffffef7
+#define DT_GNU_CONFLICT	0x6ffffef8	/* Start of conflict section */
+#define DT_GNU_LIBLIST	0x6ffffef9	/* Library list */
+#define DT_CONFIG	0x6ffffefa	/* Configuration information.  */
+#define DT_DEPAUDIT	0x6ffffefb	/* Dependency auditing.  */
+#define DT_AUDIT	0x6ffffefc	/* Object auditing.  */
+#define	DT_PLTPAD	0x6ffffefd	/* PLT padding.  */
+#define	DT_MOVETAB	0x6ffffefe	/* Move table.  */
+#define DT_SYMINFO	0x6ffffeff	/* Syminfo table.  */
+#define DT_ADDRRNGHI	0x6ffffeff
+#define DT_ADDRTAGIDX(tag)	(DT_ADDRRNGHI - (tag))	/* Reverse order! */
+#define DT_ADDRNUM 11
+
+/* The versioning entry types.  The next are defined as part of the
+   GNU extension.  */
+#define DT_VERSYM	0x6ffffff0
+
+#define DT_RELACOUNT	0x6ffffff9
+#define DT_RELCOUNT	0x6ffffffa
+
+/* These were chosen by Sun.  */
+#define DT_FLAGS_1	0x6ffffffb	/* State flags, see DF_1_* below.  */
+#define	DT_VERDEF	0x6ffffffc	/* Address of version definition
+					   table */
+#define	DT_VERDEFNUM	0x6ffffffd	/* Number of version definitions */
+#define	DT_VERNEED	0x6ffffffe	/* Address of table with needed
+					   versions */
+#define	DT_VERNEEDNUM	0x6fffffff	/* Number of needed versions */
+#define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))	/* Reverse order! */
+#define DT_VERSIONTAGNUM 16
+
+/* Sun added these machine-independent extensions in the "processor-specific"
+   range.  Be compatible.  */
+#define DT_AUXILIARY    0x7ffffffd      /* Shared object to load before self */
+#define DT_FILTER       0x7fffffff      /* Shared object to get values from */
+#define DT_EXTRATAGIDX(tag)	((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
+#define DT_EXTRANUM	3
+
+/* Values of `d_un.d_val' in the DT_FLAGS entry.  */
+#define DF_ORIGIN	0x00000001	/* Object may use DF_ORIGIN */
+#define DF_SYMBOLIC	0x00000002	/* Symbol resolutions starts here */
+#define DF_TEXTREL	0x00000004	/* Object contains text relocations */
+#define DF_BIND_NOW	0x00000008	/* No lazy binding for this object */
+#define DF_STATIC_TLS	0x00000010	/* Module uses the static TLS model */
+
+/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
+   entry in the dynamic section.  */
+#define DF_1_NOW	0x00000001	/* Set RTLD_NOW for this object.  */
+#define DF_1_GLOBAL	0x00000002	/* Set RTLD_GLOBAL for this object.  */
+#define DF_1_GROUP	0x00000004	/* Set RTLD_GROUP for this object.  */
+#define DF_1_NODELETE	0x00000008	/* Set RTLD_NODELETE for this object.*/
+#define DF_1_LOADFLTR	0x00000010	/* Trigger filtee loading at runtime.*/
+#define DF_1_INITFIRST	0x00000020	/* Set RTLD_INITFIRST for this object*/
+#define DF_1_NOOPEN	0x00000040	/* Set RTLD_NOOPEN for this object.  */
+#define DF_1_ORIGIN	0x00000080	/* $ORIGIN must be handled.  */
+#define DF_1_DIRECT	0x00000100	/* Direct binding enabled.  */
+#define DF_1_TRANS	0x00000200
+#define DF_1_INTERPOSE	0x00000400	/* Object is used to interpose.  */
+#define DF_1_NODEFLIB	0x00000800	/* Ignore default lib search path.  */
+#define DF_1_NODUMP	0x00001000	/* Object can't be dldump'ed.  */
+#define DF_1_CONFALT	0x00002000	/* Configuration alternative created.*/
+#define DF_1_ENDFILTEE	0x00004000	/* Filtee terminates filters search. */
+#define	DF_1_DISPRELDNE	0x00008000	/* Disp reloc applied at build time. */
+#define	DF_1_DISPRELPND	0x00010000	/* Disp reloc applied at run-time.  */
+
+/* Flags for the feature selection in DT_FEATURE_1.  */
+#define DTF_1_PARINIT	0x00000001
+#define DTF_1_CONFEXP	0x00000002
+
+/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry.  */
+#define DF_P1_LAZYLOAD	0x00000001	/* Lazyload following object.  */
+#define DF_P1_GROUPPERM	0x00000002	/* Symbols from next object are not
+					   generally available.  */
+
+/* Version definition sections.  */
+
+typedef struct
+{
+  Elf32_Half	vd_version;		/* Version revision */
+  Elf32_Half	vd_flags;		/* Version information */
+  Elf32_Half	vd_ndx;			/* Version Index */
+  Elf32_Half	vd_cnt;			/* Number of associated aux entries */
+  Elf32_Word	vd_hash;		/* Version name hash value */
+  Elf32_Word	vd_aux;			/* Offset in bytes to verdaux array */
+  Elf32_Word	vd_next;		/* Offset in bytes to next verdef
+					   entry */
+} Elf32_Verdef;
+
+typedef struct
+{
+  Elf64_Half	vd_version;		/* Version revision */
+  Elf64_Half	vd_flags;		/* Version information */
+  Elf64_Half	vd_ndx;			/* Version Index */
+  Elf64_Half	vd_cnt;			/* Number of associated aux entries */
+  Elf64_Word	vd_hash;		/* Version name hash value */
+  Elf64_Word	vd_aux;			/* Offset in bytes to verdaux array */
+  Elf64_Word	vd_next;		/* Offset in bytes to next verdef
+					   entry */
+} Elf64_Verdef;
+
+
+/* Legal values for vd_version (version revision).  */
+#define VER_DEF_NONE	0		/* No version */
+#define VER_DEF_CURRENT	1		/* Current version */
+#define VER_DEF_NUM	2		/* Given version number */
+
+/* Legal values for vd_flags (version information flags).  */
+#define VER_FLG_BASE	0x1		/* Version definition of file itself */
+#define VER_FLG_WEAK	0x2		/* Weak version identifier */
+
+/* Versym symbol index values.  */
+#define	VER_NDX_LOCAL		0	/* Symbol is local.  */
+#define	VER_NDX_GLOBAL		1	/* Symbol is global.  */
+#define	VER_NDX_LORESERVE	0xff00	/* Beginning of reserved entries.  */
+#define	VER_NDX_ELIMINATE	0xff01	/* Symbol is to be eliminated.  */
+
+/* Auxialiary version information.  */
+
+typedef struct
+{
+  Elf32_Word	vda_name;		/* Version or dependency names */
+  Elf32_Word	vda_next;		/* Offset in bytes to next verdaux
+					   entry */
+} Elf32_Verdaux;
+
+typedef struct
+{
+  Elf64_Word	vda_name;		/* Version or dependency names */
+  Elf64_Word	vda_next;		/* Offset in bytes to next verdaux
+					   entry */
+} Elf64_Verdaux;
+
+
+/* Version dependency section.  */
+
+typedef struct
+{
+  Elf32_Half	vn_version;		/* Version of structure */
+  Elf32_Half	vn_cnt;			/* Number of associated aux entries */
+  Elf32_Word	vn_file;		/* Offset of filename for this
+					   dependency */
+  Elf32_Word	vn_aux;			/* Offset in bytes to vernaux array */
+  Elf32_Word	vn_next;		/* Offset in bytes to next verneed
+					   entry */
+} Elf32_Verneed;
+
+typedef struct
+{
+  Elf64_Half	vn_version;		/* Version of structure */
+  Elf64_Half	vn_cnt;			/* Number of associated aux entries */
+  Elf64_Word	vn_file;		/* Offset of filename for this
+					   dependency */
+  Elf64_Word	vn_aux;			/* Offset in bytes to vernaux array */
+  Elf64_Word	vn_next;		/* Offset in bytes to next verneed
+					   entry */
+} Elf64_Verneed;
+
+
+/* Legal values for vn_version (version revision).  */
+#define VER_NEED_NONE	 0		/* No version */
+#define VER_NEED_CURRENT 1		/* Current version */
+#define VER_NEED_NUM	 2		/* Given version number */
+
+/* Auxiliary needed version information.  */
+
+typedef struct
+{
+  Elf32_Word	vna_hash;		/* Hash value of dependency name */
+  Elf32_Half	vna_flags;		/* Dependency specific information */
+  Elf32_Half	vna_other;		/* Unused */
+  Elf32_Word	vna_name;		/* Dependency name string offset */
+  Elf32_Word	vna_next;		/* Offset in bytes to next vernaux
+					   entry */
+} Elf32_Vernaux;
+
+typedef struct
+{
+  Elf64_Word	vna_hash;		/* Hash value of dependency name */
+  Elf64_Half	vna_flags;		/* Dependency specific information */
+  Elf64_Half	vna_other;		/* Unused */
+  Elf64_Word	vna_name;		/* Dependency name string offset */
+  Elf64_Word	vna_next;		/* Offset in bytes to next vernaux
+					   entry */
+} Elf64_Vernaux;
+
+
+/* Legal values for vna_flags.  */
+#define VER_FLG_WEAK	0x2		/* Weak version identifier */
+
+
+/* Auxiliary vector.  */
+
+/* This vector is normally only used by the program interpreter.  The
+   usual definition in an ABI supplement uses the name auxv_t.  The
+   vector is not usually defined in a standard <elf.h> file, but it
+   can't hurt.  We rename it to avoid conflicts.  The sizes of these
+   types are an arrangement between the exec server and the program
+   interpreter, so we don't fully specify them here.  */
+
+typedef struct
+{
+  uint32_t a_type;		/* Entry type */
+  union
+    {
+      uint32_t a_val;		/* Integer value */
+      /* We use to have pointer elements added here.  We cannot do that,
+	 though, since it does not work when using 32-bit definitions
+	 on 64-bit platforms and vice versa.  */
+    } a_un;
+} Elf32_auxv_t;
+
+typedef struct
+{
+  uint64_t a_type;		/* Entry type */
+  union
+    {
+      uint64_t a_val;		/* Integer value */
+      /* We use to have pointer elements added here.  We cannot do that,
+	 though, since it does not work when using 32-bit definitions
+	 on 64-bit platforms and vice versa.  */
+    } a_un;
+} Elf64_auxv_t;
+
+/* Legal values for a_type (entry type).  */
+
+#define AT_NULL		0		/* End of vector */
+#define AT_IGNORE	1		/* Entry should be ignored */
+#define AT_EXECFD	2		/* File descriptor of program */
+#define AT_PHDR		3		/* Program headers for program */
+#define AT_PHENT	4		/* Size of program header entry */
+#define AT_PHNUM	5		/* Number of program headers */
+#define AT_PAGESZ	6		/* System page size */
+#define AT_BASE		7		/* Base address of interpreter */
+#define AT_FLAGS	8		/* Flags */
+#define AT_ENTRY	9		/* Entry point of program */
+#define AT_NOTELF	10		/* Program is not ELF */
+#define AT_UID		11		/* Real uid */
+#define AT_EUID		12		/* Effective uid */
+#define AT_GID		13		/* Real gid */
+#define AT_EGID		14		/* Effective gid */
+#define AT_CLKTCK	17		/* Frequency of times() */
+
+/* Some more special a_type values describing the hardware.  */
+#define AT_PLATFORM	15		/* String identifying platform.  */
+#define AT_HWCAP	16		/* Machine dependent hints about
+					   processor capabilities.  */
+
+/* This entry gives some information about the FPU initialization
+   performed by the kernel.  */
+#define AT_FPUCW	18		/* Used FPU control word.  */
+
+/* Cache block sizes.  */
+#define AT_DCACHEBSIZE	19		/* Data cache block size.  */
+#define AT_ICACHEBSIZE	20		/* Instruction cache block size.  */
+#define AT_UCACHEBSIZE	21		/* Unified cache block size.  */
+
+/* A special ignored value for PPC, used by the kernel to control the
+   interpretation of the AUXV. Must be > 16.  */
+#define AT_IGNOREPPC	22		/* Entry should be ignored.  */
+
+#define	AT_SECURE	23		/* Boolean, was exec setuid-like?  */
+
+/* Pointer to the global system page used for system calls and other
+   nice things.  */
+#define AT_SYSINFO	32
+#define AT_SYSINFO_EHDR	33
+
+/* Shapes of the caches.  Bits 0-3 contains associativity; bits 4-7 contains
+   log2 of line size; mask those to get cache size.  */
+#define AT_L1I_CACHESHAPE	34
+#define AT_L1D_CACHESHAPE	35
+#define AT_L2_CACHESHAPE	36
+#define AT_L3_CACHESHAPE	37
+
+/* Note section contents.  Each entry in the note section begins with
+   a header of a fixed form.  */
+
+typedef struct
+{
+  Elf32_Word n_namesz;			/* Length of the note's name.  */
+  Elf32_Word n_descsz;			/* Length of the note's descriptor.  */
+  Elf32_Word n_type;			/* Type of the note.  */
+} Elf32_Nhdr;
+
+typedef struct
+{
+  Elf64_Word n_namesz;			/* Length of the note's name.  */
+  Elf64_Word n_descsz;			/* Length of the note's descriptor.  */
+  Elf64_Word n_type;			/* Type of the note.  */
+} Elf64_Nhdr;
+
+/* Known names of notes.  */
+
+/* Solaris entries in the note section have this name.  */
+#define ELF_NOTE_SOLARIS	"SUNW Solaris"
+
+/* Note entries for GNU systems have this name.  */
+#define ELF_NOTE_GNU		"GNU"
+
+
+/* Defined types of notes for Solaris.  */
+
+/* Value of descriptor (one word) is desired pagesize for the binary.  */
+#define ELF_NOTE_PAGESIZE_HINT	1
+
+
+/* Defined note types for GNU systems.  */
+
+/* ABI information.  The descriptor consists of words:
+   word 0: OS descriptor
+   word 1: major version of the ABI
+   word 2: minor version of the ABI
+   word 3: subminor version of the ABI
+*/
+#define NT_GNU_ABI_TAG	1
+#define ELF_NOTE_ABI	NT_GNU_ABI_TAG /* Old name.  */
+
+/* Known OSes.  These values can appear in word 0 of an
+   NT_GNU_ABI_TAG note section entry.  */
+#define ELF_NOTE_OS_LINUX	0
+#define ELF_NOTE_OS_GNU		1
+#define ELF_NOTE_OS_SOLARIS2	2
+#define ELF_NOTE_OS_FREEBSD	3
+
+/* Synthetic hwcap information.  The descriptor begins with two words:
+   word 0: number of entries
+   word 1: bitmask of enabled entries
+   Then follow variable-length entries, one byte followed by a
+   '\0'-terminated hwcap name string.  The byte gives the bit
+   number to test if enabled, (1U << bit) & bitmask.  */
+#define NT_GNU_HWCAP	2
+
+/* Build ID bits as generated by ld --build-id.
+   The descriptor consists of any nonzero number of bytes.  */
+#define NT_GNU_BUILD_ID	3
+
+
+/* Move records.  */
+typedef struct
+{
+  Elf32_Xword m_value;		/* Symbol value.  */
+  Elf32_Word m_info;		/* Size and index.  */
+  Elf32_Word m_poffset;		/* Symbol offset.  */
+  Elf32_Half m_repeat;		/* Repeat count.  */
+  Elf32_Half m_stride;		/* Stride info.  */
+} Elf32_Move;
+
+typedef struct
+{
+  Elf64_Xword m_value;		/* Symbol value.  */
+  Elf64_Xword m_info;		/* Size and index.  */
+  Elf64_Xword m_poffset;	/* Symbol offset.  */
+  Elf64_Half m_repeat;		/* Repeat count.  */
+  Elf64_Half m_stride;		/* Stride info.  */
+} Elf64_Move;
+
+/* Macro to construct move records.  */
+#define ELF32_M_SYM(info)	((info) >> 8)
+#define ELF32_M_SIZE(info)	((unsigned char) (info))
+#define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))
+
+#define ELF64_M_SYM(info)	ELF32_M_SYM (info)
+#define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
+#define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)
+
+
+/* Motorola 68k specific definitions.  */
+
+/* Values for Elf32_Ehdr.e_flags.  */
+#define EF_CPU32	0x00810000
+
+/* m68k relocs.  */
+
+#define R_68K_NONE	0		/* No reloc */
+#define R_68K_32	1		/* Direct 32 bit  */
+#define R_68K_16	2		/* Direct 16 bit  */
+#define R_68K_8		3		/* Direct 8 bit  */
+#define R_68K_PC32	4		/* PC relative 32 bit */
+#define R_68K_PC16	5		/* PC relative 16 bit */
+#define R_68K_PC8	6		/* PC relative 8 bit */
+#define R_68K_GOT32	7		/* 32 bit PC relative GOT entry */
+#define R_68K_GOT16	8		/* 16 bit PC relative GOT entry */
+#define R_68K_GOT8	9		/* 8 bit PC relative GOT entry */
+#define R_68K_GOT32O	10		/* 32 bit GOT offset */
+#define R_68K_GOT16O	11		/* 16 bit GOT offset */
+#define R_68K_GOT8O	12		/* 8 bit GOT offset */
+#define R_68K_PLT32	13		/* 32 bit PC relative PLT address */
+#define R_68K_PLT16	14		/* 16 bit PC relative PLT address */
+#define R_68K_PLT8	15		/* 8 bit PC relative PLT address */
+#define R_68K_PLT32O	16		/* 32 bit PLT offset */
+#define R_68K_PLT16O	17		/* 16 bit PLT offset */
+#define R_68K_PLT8O	18		/* 8 bit PLT offset */
+#define R_68K_COPY	19		/* Copy symbol at runtime */
+#define R_68K_GLOB_DAT	20		/* Create GOT entry */
+#define R_68K_JMP_SLOT	21		/* Create PLT entry */
+#define R_68K_RELATIVE	22		/* Adjust by program base */
+/* Keep this the last entry.  */
+#define R_68K_NUM	23
+
+/* Intel 80386 specific definitions.  */
+
+/* i386 relocs.  */
+
+#define R_386_NONE	   0		/* No reloc */
+#define R_386_32	   1		/* Direct 32 bit  */
+#define R_386_PC32	   2		/* PC relative 32 bit */
+#define R_386_GOT32	   3		/* 32 bit GOT entry */
+#define R_386_PLT32	   4		/* 32 bit PLT address */
+#define R_386_COPY	   5		/* Copy symbol at runtime */
+#define R_386_GLOB_DAT	   6		/* Create GOT entry */
+#define R_386_JMP_SLOT	   7		/* Create PLT entry */
+#define R_386_RELATIVE	   8		/* Adjust by program base */
+#define R_386_GOTOFF	   9		/* 32 bit offset to GOT */
+#define R_386_GOTPC	   10		/* 32 bit PC relative offset to GOT */
+#define R_386_32PLT	   11
+#define R_386_TLS_TPOFF	   14		/* Offset in static TLS block */
+#define R_386_TLS_IE	   15		/* Address of GOT entry for static TLS
+					   block offset */
+#define R_386_TLS_GOTIE	   16		/* GOT entry for static TLS block
+					   offset */
+#define R_386_TLS_LE	   17		/* Offset relative to static TLS
+					   block */
+#define R_386_TLS_GD	   18		/* Direct 32 bit for GNU version of
+					   general dynamic thread local data */
+#define R_386_TLS_LDM	   19		/* Direct 32 bit for GNU version of
+					   local dynamic thread local data
+					   in LE code */
+#define R_386_16	   20
+#define R_386_PC16	   21
+#define R_386_8		   22
+#define R_386_PC8	   23
+#define R_386_TLS_GD_32	   24		/* Direct 32 bit for general dynamic
+					   thread local data */
+#define R_386_TLS_GD_PUSH  25		/* Tag for pushl in GD TLS code */
+#define R_386_TLS_GD_CALL  26		/* Relocation for call to
+					   __tls_get_addr() */
+#define R_386_TLS_GD_POP   27		/* Tag for popl in GD TLS code */
+#define R_386_TLS_LDM_32   28		/* Direct 32 bit for local dynamic
+					   thread local data in LE code */
+#define R_386_TLS_LDM_PUSH 29		/* Tag for pushl in LDM TLS code */
+#define R_386_TLS_LDM_CALL 30		/* Relocation for call to
+					   __tls_get_addr() in LDM code */
+#define R_386_TLS_LDM_POP  31		/* Tag for popl in LDM TLS code */
+#define R_386_TLS_LDO_32   32		/* Offset relative to TLS block */
+#define R_386_TLS_IE_32	   33		/* GOT entry for negated static TLS
+					   block offset */
+#define R_386_TLS_LE_32	   34		/* Negated offset relative to static
+					   TLS block */
+#define R_386_TLS_DTPMOD32 35		/* ID of module containing symbol */
+#define R_386_TLS_DTPOFF32 36		/* Offset in TLS block */
+#define R_386_TLS_TPOFF32  37		/* Negated offset in static TLS block */
+/* Keep this the last entry.  */
+#define R_386_NUM	   38
+
+/* SUN SPARC specific definitions.  */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
+
+#define STT_SPARC_REGISTER	13	/* Global register reserved to app. */
+
+/* Values for Elf64_Ehdr.e_flags.  */
+
+#define EF_SPARCV9_MM		3
+#define EF_SPARCV9_TSO		0
+#define EF_SPARCV9_PSO		1
+#define EF_SPARCV9_RMO		2
+#define EF_SPARC_LEDATA		0x800000 /* little endian data */
+#define EF_SPARC_EXT_MASK	0xFFFF00
+#define EF_SPARC_32PLUS		0x000100 /* generic V8+ features */
+#define EF_SPARC_SUN_US1	0x000200 /* Sun UltraSPARC1 extensions */
+#define EF_SPARC_HAL_R1		0x000400 /* HAL R1 extensions */
+#define EF_SPARC_SUN_US3	0x000800 /* Sun UltraSPARCIII extensions */
+
+/* SPARC relocs.  */
+
+#define R_SPARC_NONE		0	/* No reloc */
+#define R_SPARC_8		1	/* Direct 8 bit */
+#define R_SPARC_16		2	/* Direct 16 bit */
+#define R_SPARC_32		3	/* Direct 32 bit */
+#define R_SPARC_DISP8		4	/* PC relative 8 bit */
+#define R_SPARC_DISP16		5	/* PC relative 16 bit */
+#define R_SPARC_DISP32		6	/* PC relative 32 bit */
+#define R_SPARC_WDISP30		7	/* PC relative 30 bit shifted */
+#define R_SPARC_WDISP22		8	/* PC relative 22 bit shifted */
+#define R_SPARC_HI22		9	/* High 22 bit */
+#define R_SPARC_22		10	/* Direct 22 bit */
+#define R_SPARC_13		11	/* Direct 13 bit */
+#define R_SPARC_LO10		12	/* Truncated 10 bit */
+#define R_SPARC_GOT10		13	/* Truncated 10 bit GOT entry */
+#define R_SPARC_GOT13		14	/* 13 bit GOT entry */
+#define R_SPARC_GOT22		15	/* 22 bit GOT entry shifted */
+#define R_SPARC_PC10		16	/* PC relative 10 bit truncated */
+#define R_SPARC_PC22		17	/* PC relative 22 bit shifted */
+#define R_SPARC_WPLT30		18	/* 30 bit PC relative PLT address */
+#define R_SPARC_COPY		19	/* Copy symbol at runtime */
+#define R_SPARC_GLOB_DAT	20	/* Create GOT entry */
+#define R_SPARC_JMP_SLOT	21	/* Create PLT entry */
+#define R_SPARC_RELATIVE	22	/* Adjust by program base */
+#define R_SPARC_UA32		23	/* Direct 32 bit unaligned */
+
+/* Additional Sparc64 relocs.  */
+
+#define R_SPARC_PLT32		24	/* Direct 32 bit ref to PLT entry */
+#define R_SPARC_HIPLT22		25	/* High 22 bit PLT entry */
+#define R_SPARC_LOPLT10		26	/* Truncated 10 bit PLT entry */
+#define R_SPARC_PCPLT32		27	/* PC rel 32 bit ref to PLT entry */
+#define R_SPARC_PCPLT22		28	/* PC rel high 22 bit PLT entry */
+#define R_SPARC_PCPLT10		29	/* PC rel trunc 10 bit PLT entry */
+#define R_SPARC_10		30	/* Direct 10 bit */
+#define R_SPARC_11		31	/* Direct 11 bit */
+#define R_SPARC_64		32	/* Direct 64 bit */
+#define R_SPARC_OLO10		33	/* 10bit with secondary 13bit addend */
+#define R_SPARC_HH22		34	/* Top 22 bits of direct 64 bit */
+#define R_SPARC_HM10		35	/* High middle 10 bits of ... */
+#define R_SPARC_LM22		36	/* Low middle 22 bits of ... */
+#define R_SPARC_PC_HH22		37	/* Top 22 bits of pc rel 64 bit */
+#define R_SPARC_PC_HM10		38	/* High middle 10 bit of ... */
+#define R_SPARC_PC_LM22		39	/* Low miggle 22 bits of ... */
+#define R_SPARC_WDISP16		40	/* PC relative 16 bit shifted */
+#define R_SPARC_WDISP19		41	/* PC relative 19 bit shifted */
+#define R_SPARC_7		43	/* Direct 7 bit */
+#define R_SPARC_5		44	/* Direct 5 bit */
+#define R_SPARC_6		45	/* Direct 6 bit */
+#define R_SPARC_DISP64		46	/* PC relative 64 bit */
+#define R_SPARC_PLT64		47	/* Direct 64 bit ref to PLT entry */
+#define R_SPARC_HIX22		48	/* High 22 bit complemented */
+#define R_SPARC_LOX10		49	/* Truncated 11 bit complemented */
+#define R_SPARC_H44		50	/* Direct high 12 of 44 bit */
+#define R_SPARC_M44		51	/* Direct mid 22 of 44 bit */
+#define R_SPARC_L44		52	/* Direct low 10 of 44 bit */
+#define R_SPARC_REGISTER	53	/* Global register usage */
+#define R_SPARC_UA64		54	/* Direct 64 bit unaligned */
+#define R_SPARC_UA16		55	/* Direct 16 bit unaligned */
+#define R_SPARC_TLS_GD_HI22	56
+#define R_SPARC_TLS_GD_LO10	57
+#define R_SPARC_TLS_GD_ADD	58
+#define R_SPARC_TLS_GD_CALL	59
+#define R_SPARC_TLS_LDM_HI22	60
+#define R_SPARC_TLS_LDM_LO10	61
+#define R_SPARC_TLS_LDM_ADD	62
+#define R_SPARC_TLS_LDM_CALL	63
+#define R_SPARC_TLS_LDO_HIX22	64
+#define R_SPARC_TLS_LDO_LOX10	65
+#define R_SPARC_TLS_LDO_ADD	66
+#define R_SPARC_TLS_IE_HI22	67
+#define R_SPARC_TLS_IE_LO10	68
+#define R_SPARC_TLS_IE_LD	69
+#define R_SPARC_TLS_IE_LDX	70
+#define R_SPARC_TLS_IE_ADD	71
+#define R_SPARC_TLS_LE_HIX22	72
+#define R_SPARC_TLS_LE_LOX10	73
+#define R_SPARC_TLS_DTPMOD32	74
+#define R_SPARC_TLS_DTPMOD64	75
+#define R_SPARC_TLS_DTPOFF32	76
+#define R_SPARC_TLS_DTPOFF64	77
+#define R_SPARC_TLS_TPOFF32	78
+#define R_SPARC_TLS_TPOFF64	79
+/* Keep this the last entry.  */
+#define R_SPARC_NUM		80
+
+/* For Sparc64, legal values for d_tag of Elf64_Dyn.  */
+
+#define DT_SPARC_REGISTER 0x70000001
+#define DT_SPARC_NUM	2
+
+/* Bits present in AT_HWCAP on SPARC.  */
+
+#define HWCAP_SPARC_FLUSH	1	/* The CPU supports flush insn.  */
+#define HWCAP_SPARC_STBAR	2
+#define HWCAP_SPARC_SWAP	4
+#define HWCAP_SPARC_MULDIV	8
+#define HWCAP_SPARC_V9		16	/* The CPU is v9, so v8plus is ok.  */
+#define HWCAP_SPARC_ULTRA3	32
+#define HWCAP_SPARC_BLKINIT	64	/* Sun4v with block-init/load-twin.  */
+
+/* MIPS R3000 specific definitions.  */
+
+/* Legal values for e_flags field of Elf32_Ehdr.  */
+
+#define EF_MIPS_NOREORDER   1		/* A .noreorder directive was used */
+#define EF_MIPS_PIC	    2		/* Contains PIC code */
+#define EF_MIPS_CPIC	    4		/* Uses PIC calling sequence */
+#define EF_MIPS_XGOT	    8
+#define EF_MIPS_64BIT_WHIRL 16
+#define EF_MIPS_ABI2	    32
+#define EF_MIPS_ABI_ON32    64
+#define EF_MIPS_ARCH	    0xf0000000	/* MIPS architecture level */
+
+/* Legal values for MIPS architecture level.  */
+
+#define EF_MIPS_ARCH_1	    0x00000000	/* -mips1 code.  */
+#define EF_MIPS_ARCH_2	    0x10000000	/* -mips2 code.  */
+#define EF_MIPS_ARCH_3	    0x20000000	/* -mips3 code.  */
+#define EF_MIPS_ARCH_4	    0x30000000	/* -mips4 code.  */
+#define EF_MIPS_ARCH_5	    0x40000000	/* -mips5 code.  */
+#define EF_MIPS_ARCH_32	    0x60000000	/* MIPS32 code.  */
+#define EF_MIPS_ARCH_64	    0x70000000	/* MIPS64 code.  */
+
+/* The following are non-official names and should not be used.  */
+
+#define E_MIPS_ARCH_1	  0x00000000	/* -mips1 code.  */
+#define E_MIPS_ARCH_2	  0x10000000	/* -mips2 code.  */
+#define E_MIPS_ARCH_3	  0x20000000	/* -mips3 code.  */
+#define E_MIPS_ARCH_4	  0x30000000	/* -mips4 code.  */
+#define E_MIPS_ARCH_5	  0x40000000	/* -mips5 code.  */
+#define E_MIPS_ARCH_32	  0x60000000	/* MIPS32 code.  */
+#define E_MIPS_ARCH_64	  0x70000000	/* MIPS64 code.  */
+
+/* Special section indices.  */
+
+#define SHN_MIPS_ACOMMON    0xff00	/* Allocated common symbols */
+#define SHN_MIPS_TEXT	    0xff01	/* Allocated test symbols.  */
+#define SHN_MIPS_DATA	    0xff02	/* Allocated data symbols.  */
+#define SHN_MIPS_SCOMMON    0xff03	/* Small common symbols */
+#define SHN_MIPS_SUNDEFINED 0xff04	/* Small undefined symbols */
+
+/* Legal values for sh_type field of Elf32_Shdr.  */
+
+#define SHT_MIPS_LIBLIST       0x70000000 /* Shared objects used in link */
+#define SHT_MIPS_MSYM	       0x70000001
+#define SHT_MIPS_CONFLICT      0x70000002 /* Conflicting symbols */
+#define SHT_MIPS_GPTAB	       0x70000003 /* Global data area sizes */
+#define SHT_MIPS_UCODE	       0x70000004 /* Reserved for SGI/MIPS compilers */
+#define SHT_MIPS_DEBUG	       0x70000005 /* MIPS ECOFF debugging information*/
+#define SHT_MIPS_REGINFO       0x70000006 /* Register usage information */
+#define SHT_MIPS_PACKAGE       0x70000007
+#define SHT_MIPS_PACKSYM       0x70000008
+#define SHT_MIPS_RELD	       0x70000009
+#define SHT_MIPS_IFACE         0x7000000b
+#define SHT_MIPS_CONTENT       0x7000000c
+#define SHT_MIPS_OPTIONS       0x7000000d /* Miscellaneous options.  */
+#define SHT_MIPS_SHDR	       0x70000010
+#define SHT_MIPS_FDESC	       0x70000011
+#define SHT_MIPS_EXTSYM	       0x70000012
+#define SHT_MIPS_DENSE	       0x70000013
+#define SHT_MIPS_PDESC	       0x70000014
+#define SHT_MIPS_LOCSYM	       0x70000015
+#define SHT_MIPS_AUXSYM	       0x70000016
+#define SHT_MIPS_OPTSYM	       0x70000017
+#define SHT_MIPS_LOCSTR	       0x70000018
+#define SHT_MIPS_LINE	       0x70000019
+#define SHT_MIPS_RFDESC	       0x7000001a
+#define SHT_MIPS_DELTASYM      0x7000001b
+#define SHT_MIPS_DELTAINST     0x7000001c
+#define SHT_MIPS_DELTACLASS    0x7000001d
+#define SHT_MIPS_DWARF         0x7000001e /* DWARF debugging information.  */
+#define SHT_MIPS_DELTADECL     0x7000001f
+#define SHT_MIPS_SYMBOL_LIB    0x70000020
+#define SHT_MIPS_EVENTS	       0x70000021 /* Event section.  */
+#define SHT_MIPS_TRANSLATE     0x70000022
+#define SHT_MIPS_PIXIE	       0x70000023
+#define SHT_MIPS_XLATE	       0x70000024
+#define SHT_MIPS_XLATE_DEBUG   0x70000025
+#define SHT_MIPS_WHIRL	       0x70000026
+#define SHT_MIPS_EH_REGION     0x70000027
+#define SHT_MIPS_XLATE_OLD     0x70000028
+#define SHT_MIPS_PDR_EXCEPTION 0x70000029
+
+/* Legal values for sh_flags field of Elf32_Shdr.  */
+
+#define SHF_MIPS_GPREL	 0x10000000	/* Must be part of global data area */
+#define SHF_MIPS_MERGE	 0x20000000
+#define SHF_MIPS_ADDR	 0x40000000
+#define SHF_MIPS_STRINGS 0x80000000
+#define SHF_MIPS_NOSTRIP 0x08000000
+#define SHF_MIPS_LOCAL	 0x04000000
+#define SHF_MIPS_NAMES	 0x02000000
+#define SHF_MIPS_NODUPE	 0x01000000
+
+
+/* Symbol tables.  */
+
+/* MIPS specific values for `st_other'.  */
+#define STO_MIPS_DEFAULT		0x0
+#define STO_MIPS_INTERNAL		0x1
+#define STO_MIPS_HIDDEN			0x2
+#define STO_MIPS_PROTECTED		0x3
+#define STO_MIPS_SC_ALIGN_UNUSED	0xff
+
+/* MIPS specific values for `st_info'.  */
+#define STB_MIPS_SPLIT_COMMON		13
+
+/* Entries found in sections of type SHT_MIPS_GPTAB.  */
+
+typedef union
+{
+  struct
+    {
+      Elf32_Word gt_current_g_value;	/* -G value used for compilation */
+      Elf32_Word gt_unused;		/* Not used */
+    } gt_header;			/* First entry in section */
+  struct
+    {
+      Elf32_Word gt_g_value;		/* If this value were used for -G */
+      Elf32_Word gt_bytes;		/* This many bytes would be used */
+    } gt_entry;				/* Subsequent entries in section */
+} Elf32_gptab;
+
+/* Entry found in sections of type SHT_MIPS_REGINFO.  */
+
+typedef struct
+{
+  Elf32_Word	ri_gprmask;		/* General registers used */
+  Elf32_Word	ri_cprmask[4];		/* Coprocessor registers used */
+  Elf32_Sword	ri_gp_value;		/* $gp register value */
+} Elf32_RegInfo;
+
+/* Entries found in sections of type SHT_MIPS_OPTIONS.  */
+
+typedef struct
+{
+  unsigned char kind;		/* Determines interpretation of the
+				   variable part of descriptor.  */
+  unsigned char size;		/* Size of descriptor, including header.  */
+  Elf32_Section section;	/* Section header index of section affected,
+				   0 for global options.  */
+  Elf32_Word info;		/* Kind-specific information.  */
+} Elf_Options;
+
+/* Values for `kind' field in Elf_Options.  */
+
+#define ODK_NULL	0	/* Undefined.  */
+#define ODK_REGINFO	1	/* Register usage information.  */
+#define ODK_EXCEPTIONS	2	/* Exception processing options.  */
+#define ODK_PAD		3	/* Section padding options.  */
+#define ODK_HWPATCH	4	/* Hardware workarounds performed */
+#define ODK_FILL	5	/* record the fill value used by the linker. */
+#define ODK_TAGS	6	/* reserve space for desktop tools to write. */
+#define ODK_HWAND	7	/* HW workarounds.  'AND' bits when merging. */
+#define ODK_HWOR	8	/* HW workarounds.  'OR' bits when merging.  */
+
+/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries.  */
+
+#define OEX_FPU_MIN	0x1f	/* FPE's which MUST be enabled.  */
+#define OEX_FPU_MAX	0x1f00	/* FPE's which MAY be enabled.  */
+#define OEX_PAGE0	0x10000	/* page zero must be mapped.  */
+#define OEX_SMM		0x20000	/* Force sequential memory mode?  */
+#define OEX_FPDBUG	0x40000	/* Force floating point debug mode?  */
+#define OEX_PRECISEFP	OEX_FPDBUG
+#define OEX_DISMISS	0x80000	/* Dismiss invalid address faults?  */
+
+#define OEX_FPU_INVAL	0x10
+#define OEX_FPU_DIV0	0x08
+#define OEX_FPU_OFLO	0x04
+#define OEX_FPU_UFLO	0x02
+#define OEX_FPU_INEX	0x01
+
+/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry.  */
+
+#define OHW_R4KEOP	0x1	/* R4000 end-of-page patch.  */
+#define OHW_R8KPFETCH	0x2	/* may need R8000 prefetch patch.  */
+#define OHW_R5KEOP	0x4	/* R5000 end-of-page patch.  */
+#define OHW_R5KCVTL	0x8	/* R5000 cvt.[ds].l bug.  clean=1.  */
+
+#define OPAD_PREFIX	0x1
+#define OPAD_POSTFIX	0x2
+#define OPAD_SYMBOL	0x4
+
+/* Entry found in `.options' section.  */
+
+typedef struct
+{
+  Elf32_Word hwp_flags1;	/* Extra flags.  */
+  Elf32_Word hwp_flags2;	/* Extra flags.  */
+} Elf_Options_Hw;
+
+/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries.  */
+
+#define OHWA0_R4KEOP_CHECKED	0x00000001
+#define OHWA1_R4KEOP_CLEAN	0x00000002
+
+/* MIPS relocs.  */
+
+#define R_MIPS_NONE		0	/* No reloc */
+#define R_MIPS_16		1	/* Direct 16 bit */
+#define R_MIPS_32		2	/* Direct 32 bit */
+#define R_MIPS_REL32		3	/* PC relative 32 bit */
+#define R_MIPS_26		4	/* Direct 26 bit shifted */
+#define R_MIPS_HI16		5	/* High 16 bit */
+#define R_MIPS_LO16		6	/* Low 16 bit */
+#define R_MIPS_GPREL16		7	/* GP relative 16 bit */
+#define R_MIPS_LITERAL		8	/* 16 bit literal entry */
+#define R_MIPS_GOT16		9	/* 16 bit GOT entry */
+#define R_MIPS_PC16		10	/* PC relative 16 bit */
+#define R_MIPS_CALL16		11	/* 16 bit GOT entry for function */
+#define R_MIPS_GPREL32		12	/* GP relative 32 bit */
+
+#define R_MIPS_SHIFT5		16
+#define R_MIPS_SHIFT6		17
+#define R_MIPS_64		18
+#define R_MIPS_GOT_DISP		19
+#define R_MIPS_GOT_PAGE		20
+#define R_MIPS_GOT_OFST		21
+#define R_MIPS_GOT_HI16		22
+#define R_MIPS_GOT_LO16		23
+#define R_MIPS_SUB		24
+#define R_MIPS_INSERT_A		25
+#define R_MIPS_INSERT_B		26
+#define R_MIPS_DELETE		27
+#define R_MIPS_HIGHER		28
+#define R_MIPS_HIGHEST		29
+#define R_MIPS_CALL_HI16	30
+#define R_MIPS_CALL_LO16	31
+#define R_MIPS_SCN_DISP		32
+#define R_MIPS_REL16		33
+#define R_MIPS_ADD_IMMEDIATE	34
+#define R_MIPS_PJUMP		35
+#define R_MIPS_RELGOT		36
+#define R_MIPS_JALR		37
+#define R_MIPS_TLS_DTPMOD32	38	/* Module number 32 bit */
+#define R_MIPS_TLS_DTPREL32	39	/* Module-relative offset 32 bit */
+#define R_MIPS_TLS_DTPMOD64	40	/* Module number 64 bit */
+#define R_MIPS_TLS_DTPREL64	41	/* Module-relative offset 64 bit */
+#define R_MIPS_TLS_GD		42	/* 16 bit GOT offset for GD */
+#define R_MIPS_TLS_LDM		43	/* 16 bit GOT offset for LDM */
+#define R_MIPS_TLS_DTPREL_HI16	44	/* Module-relative offset, high 16 bits */
+#define R_MIPS_TLS_DTPREL_LO16	45	/* Module-relative offset, low 16 bits */
+#define R_MIPS_TLS_GOTTPREL	46	/* 16 bit GOT offset for IE */
+#define R_MIPS_TLS_TPREL32	47	/* TP-relative offset, 32 bit */
+#define R_MIPS_TLS_TPREL64	48	/* TP-relative offset, 64 bit */
+#define R_MIPS_TLS_TPREL_HI16	49	/* TP-relative offset, high 16 bits */
+#define R_MIPS_TLS_TPREL_LO16	50	/* TP-relative offset, low 16 bits */
+#define R_MIPS_GLOB_DAT		51
+/* Keep this the last entry.  */
+#define R_MIPS_NUM		52
+
+/* Legal values for p_type field of Elf32_Phdr.  */
+
+#define PT_MIPS_REGINFO	0x70000000	/* Register usage information */
+#define PT_MIPS_RTPROC  0x70000001	/* Runtime procedure table. */
+#define PT_MIPS_OPTIONS 0x70000002
+
+/* Special program header types.  */
+
+#define PF_MIPS_LOCAL	0x10000000
+
+/* Legal values for d_tag field of Elf32_Dyn.  */
+
+#define DT_MIPS_RLD_VERSION  0x70000001	/* Runtime linker interface version */
+#define DT_MIPS_TIME_STAMP   0x70000002	/* Timestamp */
+#define DT_MIPS_ICHECKSUM    0x70000003	/* Checksum */
+#define DT_MIPS_IVERSION     0x70000004	/* Version string (string tbl index) */
+#define DT_MIPS_FLAGS	     0x70000005	/* Flags */
+#define DT_MIPS_BASE_ADDRESS 0x70000006	/* Base address */
+#define DT_MIPS_MSYM	     0x70000007
+#define DT_MIPS_CONFLICT     0x70000008	/* Address of CONFLICT section */
+#define DT_MIPS_LIBLIST	     0x70000009	/* Address of LIBLIST section */
+#define DT_MIPS_LOCAL_GOTNO  0x7000000a	/* Number of local GOT entries */
+#define DT_MIPS_CONFLICTNO   0x7000000b	/* Number of CONFLICT entries */
+#define DT_MIPS_LIBLISTNO    0x70000010	/* Number of LIBLIST entries */
+#define DT_MIPS_SYMTABNO     0x70000011	/* Number of DYNSYM entries */
+#define DT_MIPS_UNREFEXTNO   0x70000012	/* First external DYNSYM */
+#define DT_MIPS_GOTSYM	     0x70000013	/* First GOT entry in DYNSYM */
+#define DT_MIPS_HIPAGENO     0x70000014	/* Number of GOT page table entries */
+#define DT_MIPS_RLD_MAP	     0x70000016	/* Address of run time loader map.  */
+#define DT_MIPS_DELTA_CLASS  0x70000017	/* Delta C++ class definition.  */
+#define DT_MIPS_DELTA_CLASS_NO    0x70000018 /* Number of entries in
+						DT_MIPS_DELTA_CLASS.  */
+#define DT_MIPS_DELTA_INSTANCE    0x70000019 /* Delta C++ class instances.  */
+#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in
+						DT_MIPS_DELTA_INSTANCE.  */
+#define DT_MIPS_DELTA_RELOC  0x7000001b /* Delta relocations.  */
+#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in
+					     DT_MIPS_DELTA_RELOC.  */
+#define DT_MIPS_DELTA_SYM    0x7000001d /* Delta symbols that Delta
+					   relocations refer to.  */
+#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in
+					   DT_MIPS_DELTA_SYM.  */
+#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the
+					     class declaration.  */
+#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in
+						DT_MIPS_DELTA_CLASSSYM.  */
+#define DT_MIPS_CXX_FLAGS    0x70000022 /* Flags indicating for C++ flavor.  */
+#define DT_MIPS_PIXIE_INIT   0x70000023
+#define DT_MIPS_SYMBOL_LIB   0x70000024
+#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
+#define DT_MIPS_LOCAL_GOTIDX 0x70000026
+#define DT_MIPS_HIDDEN_GOTIDX 0x70000027
+#define DT_MIPS_PROTECTED_GOTIDX 0x70000028
+#define DT_MIPS_OPTIONS	     0x70000029 /* Address of .options.  */
+#define DT_MIPS_INTERFACE    0x7000002a /* Address of .interface.  */
+#define DT_MIPS_DYNSTR_ALIGN 0x7000002b
+#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */
+#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve
+						    function stored in GOT.  */
+#define DT_MIPS_PERF_SUFFIX  0x7000002e /* Default suffix of dso to be added
+					   by rld on dlopen() calls.  */
+#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */
+#define DT_MIPS_GP_VALUE     0x70000030 /* GP value for aux GOTs.  */
+#define DT_MIPS_AUX_DYNAMIC  0x70000031 /* Address of aux .dynamic.  */
+#define DT_MIPS_NUM	     0x32
+
+/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry.  */
+
+#define RHF_NONE		   0		/* No flags */
+#define RHF_QUICKSTART		   (1 << 0)	/* Use quickstart */
+#define RHF_NOTPOT		   (1 << 1)	/* Hash size not power of 2 */
+#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2)	/* Ignore LD_LIBRARY_PATH */
+#define RHF_NO_MOVE		   (1 << 3)
+#define RHF_SGI_ONLY		   (1 << 4)
+#define RHF_GUARANTEE_INIT	   (1 << 5)
+#define RHF_DELTA_C_PLUS_PLUS	   (1 << 6)
+#define RHF_GUARANTEE_START_INIT   (1 << 7)
+#define RHF_PIXIE		   (1 << 8)
+#define RHF_DEFAULT_DELAY_LOAD	   (1 << 9)
+#define RHF_REQUICKSTART	   (1 << 10)
+#define RHF_REQUICKSTARTED	   (1 << 11)
+#define RHF_CORD		   (1 << 12)
+#define RHF_NO_UNRES_UNDEF	   (1 << 13)
+#define RHF_RLD_ORDER_SAFE	   (1 << 14)
+
+/* Entries found in sections of type SHT_MIPS_LIBLIST.  */
+
+typedef struct
+{
+  Elf32_Word l_name;		/* Name (string table index) */
+  Elf32_Word l_time_stamp;	/* Timestamp */
+  Elf32_Word l_checksum;	/* Checksum */
+  Elf32_Word l_version;		/* Interface version */
+  Elf32_Word l_flags;		/* Flags */
+} Elf32_Lib;
+
+typedef struct
+{
+  Elf64_Word l_name;		/* Name (string table index) */
+  Elf64_Word l_time_stamp;	/* Timestamp */
+  Elf64_Word l_checksum;	/* Checksum */
+  Elf64_Word l_version;		/* Interface version */
+  Elf64_Word l_flags;		/* Flags */
+} Elf64_Lib;
+
+
+/* Legal values for l_flags.  */
+
+#define LL_NONE		  0
+#define LL_EXACT_MATCH	  (1 << 0)	/* Require exact match */
+#define LL_IGNORE_INT_VER (1 << 1)	/* Ignore interface version */
+#define LL_REQUIRE_MINOR  (1 << 2)
+#define LL_EXPORTS	  (1 << 3)
+#define LL_DELAY_LOAD	  (1 << 4)
+#define LL_DELTA	  (1 << 5)
+
+/* Entries found in sections of type SHT_MIPS_CONFLICT.  */
+
+typedef Elf32_Addr Elf32_Conflict;
+
+
+/* HPPA specific definitions.  */
+
+/* Legal values for e_flags field of Elf32_Ehdr.  */
+
+#define EF_PARISC_TRAPNIL	0x00010000 /* Trap nil pointer dereference.  */
+#define EF_PARISC_EXT		0x00020000 /* Program uses arch. extensions. */
+#define EF_PARISC_LSB		0x00040000 /* Program expects little endian. */
+#define EF_PARISC_WIDE		0x00080000 /* Program expects wide mode.  */
+#define EF_PARISC_NO_KABP	0x00100000 /* No kernel assisted branch
+					      prediction.  */
+#define EF_PARISC_LAZYSWAP	0x00400000 /* Allow lazy swapping.  */
+#define EF_PARISC_ARCH		0x0000ffff /* Architecture version.  */
+
+/* Defined values for `e_flags & EF_PARISC_ARCH' are:  */
+
+#define EFA_PARISC_1_0		    0x020b /* PA-RISC 1.0 big-endian.  */
+#define EFA_PARISC_1_1		    0x0210 /* PA-RISC 1.1 big-endian.  */
+#define EFA_PARISC_2_0		    0x0214 /* PA-RISC 2.0 big-endian.  */
+
+/* Additional section indeces.  */
+
+#define SHN_PARISC_ANSI_COMMON	0xff00	   /* Section for tenatively declared
+					      symbols in ANSI C.  */
+#define SHN_PARISC_HUGE_COMMON	0xff01	   /* Common blocks in huge model.  */
+
+/* Legal values for sh_type field of Elf32_Shdr.  */
+
+#define SHT_PARISC_EXT		0x70000000 /* Contains product specific ext. */
+#define SHT_PARISC_UNWIND	0x70000001 /* Unwind information.  */
+#define SHT_PARISC_DOC		0x70000002 /* Debug info for optimized code. */
+
+/* Legal values for sh_flags field of Elf32_Shdr.  */
+
+#define SHF_PARISC_SHORT	0x20000000 /* Section with short addressing. */
+#define SHF_PARISC_HUGE		0x40000000 /* Section far from gp.  */
+#define SHF_PARISC_SBP		0x80000000 /* Static branch prediction code. */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
+
+#define STT_PARISC_MILLICODE	13	/* Millicode function entry point.  */
+
+#define STT_HP_OPAQUE		(STT_LOOS + 0x1)
+#define STT_HP_STUB		(STT_LOOS + 0x2)
+
+/* HPPA relocs.  */
+
+#define R_PARISC_NONE		0	/* No reloc.  */
+#define R_PARISC_DIR32		1	/* Direct 32-bit reference.  */
+#define R_PARISC_DIR21L		2	/* Left 21 bits of eff. address.  */
+#define R_PARISC_DIR17R		3	/* Right 17 bits of eff. address.  */
+#define R_PARISC_DIR17F		4	/* 17 bits of eff. address.  */
+#define R_PARISC_DIR14R		6	/* Right 14 bits of eff. address.  */
+#define R_PARISC_PCREL32	9	/* 32-bit rel. address.  */
+#define R_PARISC_PCREL21L	10	/* Left 21 bits of rel. address.  */
+#define R_PARISC_PCREL17R	11	/* Right 17 bits of rel. address.  */
+#define R_PARISC_PCREL17F	12	/* 17 bits of rel. address.  */
+#define R_PARISC_PCREL14R	14	/* Right 14 bits of rel. address.  */
+#define R_PARISC_DPREL21L	18	/* Left 21 bits of rel. address.  */
+#define R_PARISC_DPREL14R	22	/* Right 14 bits of rel. address.  */
+#define R_PARISC_GPREL21L	26	/* GP-relative, left 21 bits.  */
+#define R_PARISC_GPREL14R	30	/* GP-relative, right 14 bits.  */
+#define R_PARISC_LTOFF21L	34	/* LT-relative, left 21 bits.  */
+#define R_PARISC_LTOFF14R	38	/* LT-relative, right 14 bits.  */
+#define R_PARISC_SECREL32	41	/* 32 bits section rel. address.  */
+#define R_PARISC_SEGBASE	48	/* No relocation, set segment base.  */
+#define R_PARISC_SEGREL32	49	/* 32 bits segment rel. address.  */
+#define R_PARISC_PLTOFF21L	50	/* PLT rel. address, left 21 bits.  */
+#define R_PARISC_PLTOFF14R	54	/* PLT rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF_FPTR32	57	/* 32 bits LT-rel. function pointer. */
+#define R_PARISC_LTOFF_FPTR21L	58	/* LT-rel. fct ptr, left 21 bits. */
+#define R_PARISC_LTOFF_FPTR14R	62	/* LT-rel. fct ptr, right 14 bits. */
+#define R_PARISC_FPTR64		64	/* 64 bits function address.  */
+#define R_PARISC_PLABEL32	65	/* 32 bits function address.  */
+#define R_PARISC_PLABEL21L	66	/* Left 21 bits of fdesc address.  */
+#define R_PARISC_PLABEL14R	70	/* Right 14 bits of fdesc address.  */
+#define R_PARISC_PCREL64	72	/* 64 bits PC-rel. address.  */
+#define R_PARISC_PCREL22F	74	/* 22 bits PC-rel. address.  */
+#define R_PARISC_PCREL14WR	75	/* PC-rel. address, right 14 bits.  */
+#define R_PARISC_PCREL14DR	76	/* PC rel. address, right 14 bits.  */
+#define R_PARISC_PCREL16F	77	/* 16 bits PC-rel. address.  */
+#define R_PARISC_PCREL16WF	78	/* 16 bits PC-rel. address.  */
+#define R_PARISC_PCREL16DF	79	/* 16 bits PC-rel. address.  */
+#define R_PARISC_DIR64		80	/* 64 bits of eff. address.  */
+#define R_PARISC_DIR14WR	83	/* 14 bits of eff. address.  */
+#define R_PARISC_DIR14DR	84	/* 14 bits of eff. address.  */
+#define R_PARISC_DIR16F		85	/* 16 bits of eff. address.  */
+#define R_PARISC_DIR16WF	86	/* 16 bits of eff. address.  */
+#define R_PARISC_DIR16DF	87	/* 16 bits of eff. address.  */
+#define R_PARISC_GPREL64	88	/* 64 bits of GP-rel. address.  */
+#define R_PARISC_GPREL14WR	91	/* GP-rel. address, right 14 bits.  */
+#define R_PARISC_GPREL14DR	92	/* GP-rel. address, right 14 bits.  */
+#define R_PARISC_GPREL16F	93	/* 16 bits GP-rel. address.  */
+#define R_PARISC_GPREL16WF	94	/* 16 bits GP-rel. address.  */
+#define R_PARISC_GPREL16DF	95	/* 16 bits GP-rel. address.  */
+#define R_PARISC_LTOFF64	96	/* 64 bits LT-rel. address.  */
+#define R_PARISC_LTOFF14WR	99	/* LT-rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF14DR	100	/* LT-rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF16F	101	/* 16 bits LT-rel. address.  */
+#define R_PARISC_LTOFF16WF	102	/* 16 bits LT-rel. address.  */
+#define R_PARISC_LTOFF16DF	103	/* 16 bits LT-rel. address.  */
+#define R_PARISC_SECREL64	104	/* 64 bits section rel. address.  */
+#define R_PARISC_SEGREL64	112	/* 64 bits segment rel. address.  */
+#define R_PARISC_PLTOFF14WR	115	/* PLT-rel. address, right 14 bits.  */
+#define R_PARISC_PLTOFF14DR	116	/* PLT-rel. address, right 14 bits.  */
+#define R_PARISC_PLTOFF16F	117	/* 16 bits LT-rel. address.  */
+#define R_PARISC_PLTOFF16WF	118	/* 16 bits PLT-rel. address.  */
+#define R_PARISC_PLTOFF16DF	119	/* 16 bits PLT-rel. address.  */
+#define R_PARISC_LTOFF_FPTR64	120	/* 64 bits LT-rel. function ptr.  */
+#define R_PARISC_LTOFF_FPTR14WR	123	/* LT-rel. fct. ptr., right 14 bits. */
+#define R_PARISC_LTOFF_FPTR14DR	124	/* LT-rel. fct. ptr., right 14 bits. */
+#define R_PARISC_LTOFF_FPTR16F	125	/* 16 bits LT-rel. function ptr.  */
+#define R_PARISC_LTOFF_FPTR16WF	126	/* 16 bits LT-rel. function ptr.  */
+#define R_PARISC_LTOFF_FPTR16DF	127	/* 16 bits LT-rel. function ptr.  */
+#define R_PARISC_LORESERVE	128
+#define R_PARISC_COPY		128	/* Copy relocation.  */
+#define R_PARISC_IPLT		129	/* Dynamic reloc, imported PLT */
+#define R_PARISC_EPLT		130	/* Dynamic reloc, exported PLT */
+#define R_PARISC_TPREL32	153	/* 32 bits TP-rel. address.  */
+#define R_PARISC_TPREL21L	154	/* TP-rel. address, left 21 bits.  */
+#define R_PARISC_TPREL14R	158	/* TP-rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF_TP21L	162	/* LT-TP-rel. address, left 21 bits. */
+#define R_PARISC_LTOFF_TP14R	166	/* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP14F	167	/* 14 bits LT-TP-rel. address.  */
+#define R_PARISC_TPREL64	216	/* 64 bits TP-rel. address.  */
+#define R_PARISC_TPREL14WR	219	/* TP-rel. address, right 14 bits.  */
+#define R_PARISC_TPREL14DR	220	/* TP-rel. address, right 14 bits.  */
+#define R_PARISC_TPREL16F	221	/* 16 bits TP-rel. address.  */
+#define R_PARISC_TPREL16WF	222	/* 16 bits TP-rel. address.  */
+#define R_PARISC_TPREL16DF	223	/* 16 bits TP-rel. address.  */
+#define R_PARISC_LTOFF_TP64	224	/* 64 bits LT-TP-rel. address.  */
+#define R_PARISC_LTOFF_TP14WR	227	/* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP14DR	228	/* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP16F	229	/* 16 bits LT-TP-rel. address.  */
+#define R_PARISC_LTOFF_TP16WF	230	/* 16 bits LT-TP-rel. address.  */
+#define R_PARISC_LTOFF_TP16DF	231	/* 16 bits LT-TP-rel. address.  */
+#define R_PARISC_GNU_VTENTRY	232
+#define R_PARISC_GNU_VTINHERIT	233
+#define R_PARISC_TLS_GD21L	234	/* GD 21-bit left.  */
+#define R_PARISC_TLS_GD14R	235	/* GD 14-bit right.  */
+#define R_PARISC_TLS_GDCALL	236	/* GD call to __t_g_a.  */
+#define R_PARISC_TLS_LDM21L	237	/* LD module 21-bit left.  */
+#define R_PARISC_TLS_LDM14R	238	/* LD module 14-bit right.  */
+#define R_PARISC_TLS_LDMCALL	239	/* LD module call to __t_g_a.  */
+#define R_PARISC_TLS_LDO21L	240	/* LD offset 21-bit left.  */
+#define R_PARISC_TLS_LDO14R	241	/* LD offset 14-bit right.  */
+#define R_PARISC_TLS_DTPMOD32	242	/* DTP module 32-bit.  */
+#define R_PARISC_TLS_DTPMOD64	243	/* DTP module 64-bit.  */
+#define R_PARISC_TLS_DTPOFF32	244	/* DTP offset 32-bit.  */
+#define R_PARISC_TLS_DTPOFF64	245	/* DTP offset 32-bit.  */
+#define R_PARISC_TLS_LE21L	R_PARISC_TPREL21L
+#define R_PARISC_TLS_LE14R	R_PARISC_TPREL14R
+#define R_PARISC_TLS_IE21L	R_PARISC_LTOFF_TP21L
+#define R_PARISC_TLS_IE14R	R_PARISC_LTOFF_TP14R
+#define R_PARISC_TLS_TPREL32	R_PARISC_TPREL32
+#define R_PARISC_TLS_TPREL64	R_PARISC_TPREL64
+#define R_PARISC_HIRESERVE	255
+
+/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr.  */
+
+#define PT_HP_TLS		(PT_LOOS + 0x0)
+#define PT_HP_CORE_NONE		(PT_LOOS + 0x1)
+#define PT_HP_CORE_VERSION	(PT_LOOS + 0x2)
+#define PT_HP_CORE_KERNEL	(PT_LOOS + 0x3)
+#define PT_HP_CORE_COMM		(PT_LOOS + 0x4)
+#define PT_HP_CORE_PROC		(PT_LOOS + 0x5)
+#define PT_HP_CORE_LOADABLE	(PT_LOOS + 0x6)
+#define PT_HP_CORE_STACK	(PT_LOOS + 0x7)
+#define PT_HP_CORE_SHM		(PT_LOOS + 0x8)
+#define PT_HP_CORE_MMF		(PT_LOOS + 0x9)
+#define PT_HP_PARALLEL		(PT_LOOS + 0x10)
+#define PT_HP_FASTBIND		(PT_LOOS + 0x11)
+#define PT_HP_OPT_ANNOT		(PT_LOOS + 0x12)
+#define PT_HP_HSL_ANNOT		(PT_LOOS + 0x13)
+#define PT_HP_STACK		(PT_LOOS + 0x14)
+
+#define PT_PARISC_ARCHEXT	0x70000000
+#define PT_PARISC_UNWIND	0x70000001
+
+/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr.  */
+
+#define PF_PARISC_SBP		0x08000000
+
+#define PF_HP_PAGE_SIZE		0x00100000
+#define PF_HP_FAR_SHARED	0x00200000
+#define PF_HP_NEAR_SHARED	0x00400000
+#define PF_HP_CODE		0x01000000
+#define PF_HP_MODIFY		0x02000000
+#define PF_HP_LAZYSWAP		0x04000000
+#define PF_HP_SBP		0x08000000
+
+
+/* Alpha specific definitions.  */
+
+/* Legal values for e_flags field of Elf64_Ehdr.  */
+
+#define EF_ALPHA_32BIT		1	/* All addresses must be < 2GB.  */
+#define EF_ALPHA_CANRELAX	2	/* Relocations for relaxing exist.  */
+
+/* Legal values for sh_type field of Elf64_Shdr.  */
+
+/* These two are primerily concerned with ECOFF debugging info.  */
+#define SHT_ALPHA_DEBUG		0x70000001
+#define SHT_ALPHA_REGINFO	0x70000002
+
+/* Legal values for sh_flags field of Elf64_Shdr.  */
+
+#define SHF_ALPHA_GPREL		0x10000000
+
+/* Legal values for st_other field of Elf64_Sym.  */
+#define STO_ALPHA_NOPV		0x80	/* No PV required.  */
+#define STO_ALPHA_STD_GPLOAD	0x88	/* PV only used for initial ldgp.  */
+
+/* Alpha relocs.  */
+
+#define R_ALPHA_NONE		0	/* No reloc */
+#define R_ALPHA_REFLONG		1	/* Direct 32 bit */
+#define R_ALPHA_REFQUAD		2	/* Direct 64 bit */
+#define R_ALPHA_GPREL32		3	/* GP relative 32 bit */
+#define R_ALPHA_LITERAL		4	/* GP relative 16 bit w/optimization */
+#define R_ALPHA_LITUSE		5	/* Optimization hint for LITERAL */
+#define R_ALPHA_GPDISP		6	/* Add displacement to GP */
+#define R_ALPHA_BRADDR		7	/* PC+4 relative 23 bit shifted */
+#define R_ALPHA_HINT		8	/* PC+4 relative 16 bit shifted */
+#define R_ALPHA_SREL16		9	/* PC relative 16 bit */
+#define R_ALPHA_SREL32		10	/* PC relative 32 bit */
+#define R_ALPHA_SREL64		11	/* PC relative 64 bit */
+#define R_ALPHA_GPRELHIGH	17	/* GP relative 32 bit, high 16 bits */
+#define R_ALPHA_GPRELLOW	18	/* GP relative 32 bit, low 16 bits */
+#define R_ALPHA_GPREL16		19	/* GP relative 16 bit */
+#define R_ALPHA_COPY		24	/* Copy symbol at runtime */
+#define R_ALPHA_GLOB_DAT	25	/* Create GOT entry */
+#define R_ALPHA_JMP_SLOT	26	/* Create PLT entry */
+#define R_ALPHA_RELATIVE	27	/* Adjust by program base */
+#define R_ALPHA_TLS_GD_HI	28
+#define R_ALPHA_TLSGD		29
+#define R_ALPHA_TLS_LDM		30
+#define R_ALPHA_DTPMOD64	31
+#define R_ALPHA_GOTDTPREL	32
+#define R_ALPHA_DTPREL64	33
+#define R_ALPHA_DTPRELHI	34
+#define R_ALPHA_DTPRELLO	35
+#define R_ALPHA_DTPREL16	36
+#define R_ALPHA_GOTTPREL	37
+#define R_ALPHA_TPREL64		38
+#define R_ALPHA_TPRELHI		39
+#define R_ALPHA_TPRELLO		40
+#define R_ALPHA_TPREL16		41
+/* Keep this the last entry.  */
+#define R_ALPHA_NUM		46
+
+/* Magic values of the LITUSE relocation addend.  */
+#define LITUSE_ALPHA_ADDR	0
+#define LITUSE_ALPHA_BASE	1
+#define LITUSE_ALPHA_BYTOFF	2
+#define LITUSE_ALPHA_JSR	3
+#define LITUSE_ALPHA_TLS_GD	4
+#define LITUSE_ALPHA_TLS_LDM	5
+
+/* Legal values for d_tag of Elf64_Dyn.  */
+#define DT_ALPHA_PLTRO		(DT_LOPROC + 0)
+#define DT_ALPHA_NUM		1
+
+/* PowerPC specific declarations */
+
+/* Values for Elf32/64_Ehdr.e_flags.  */
+#define EF_PPC_EMB		0x80000000	/* PowerPC embedded flag */
+
+/* Cygnus local bits below */
+#define EF_PPC_RELOCATABLE	0x00010000	/* PowerPC -mrelocatable flag*/
+#define EF_PPC_RELOCATABLE_LIB	0x00008000	/* PowerPC -mrelocatable-lib
+						   flag */
+
+/* PowerPC relocations defined by the ABIs */
+#define R_PPC_NONE		0
+#define R_PPC_ADDR32		1	/* 32bit absolute address */
+#define R_PPC_ADDR24		2	/* 26bit address, 2 bits ignored.  */
+#define R_PPC_ADDR16		3	/* 16bit absolute address */
+#define R_PPC_ADDR16_LO		4	/* lower 16bit of absolute address */
+#define R_PPC_ADDR16_HI		5	/* high 16bit of absolute address */
+#define R_PPC_ADDR16_HA		6	/* adjusted high 16bit */
+#define R_PPC_ADDR14		7	/* 16bit address, 2 bits ignored */
+#define R_PPC_ADDR14_BRTAKEN	8
+#define R_PPC_ADDR14_BRNTAKEN	9
+#define R_PPC_REL24		10	/* PC relative 26 bit */
+#define R_PPC_REL14		11	/* PC relative 16 bit */
+#define R_PPC_REL14_BRTAKEN	12
+#define R_PPC_REL14_BRNTAKEN	13
+#define R_PPC_GOT16		14
+#define R_PPC_GOT16_LO		15
+#define R_PPC_GOT16_HI		16
+#define R_PPC_GOT16_HA		17
+#define R_PPC_PLTREL24		18
+#define R_PPC_COPY		19
+#define R_PPC_GLOB_DAT		20
+#define R_PPC_JMP_SLOT		21
+#define R_PPC_RELATIVE		22
+#define R_PPC_LOCAL24PC		23
+#define R_PPC_UADDR32		24
+#define R_PPC_UADDR16		25
+#define R_PPC_REL32		26
+#define R_PPC_PLT32		27
+#define R_PPC_PLTREL32		28
+#define R_PPC_PLT16_LO		29
+#define R_PPC_PLT16_HI		30
+#define R_PPC_PLT16_HA		31
+#define R_PPC_SDAREL16		32
+#define R_PPC_SECTOFF		33
+#define R_PPC_SECTOFF_LO	34
+#define R_PPC_SECTOFF_HI	35
+#define R_PPC_SECTOFF_HA	36
+
+/* PowerPC relocations defined for the TLS access ABI.  */
+#define R_PPC_TLS		67 /* none	(sym+add)@tls */
+#define R_PPC_DTPMOD32		68 /* word32	(sym+add)@dtpmod */
+#define R_PPC_TPREL16		69 /* half16*	(sym+add)@tprel */
+#define R_PPC_TPREL16_LO	70 /* half16	(sym+add)@tprel@l */
+#define R_PPC_TPREL16_HI	71 /* half16	(sym+add)@tprel@h */
+#define R_PPC_TPREL16_HA	72 /* half16	(sym+add)@tprel@ha */
+#define R_PPC_TPREL32		73 /* word32	(sym+add)@tprel */
+#define R_PPC_DTPREL16		74 /* half16*	(sym+add)@dtprel */
+#define R_PPC_DTPREL16_LO	75 /* half16	(sym+add)@dtprel@l */
+#define R_PPC_DTPREL16_HI	76 /* half16	(sym+add)@dtprel@h */
+#define R_PPC_DTPREL16_HA	77 /* half16	(sym+add)@dtprel@ha */
+#define R_PPC_DTPREL32		78 /* word32	(sym+add)@dtprel */
+#define R_PPC_GOT_TLSGD16	79 /* half16*	(sym+add)@got@tlsgd */
+#define R_PPC_GOT_TLSGD16_LO	80 /* half16	(sym+add)@got@tlsgd@l */
+#define R_PPC_GOT_TLSGD16_HI	81 /* half16	(sym+add)@got@tlsgd@h */
+#define R_PPC_GOT_TLSGD16_HA	82 /* half16	(sym+add)@got@tlsgd@ha */
+#define R_PPC_GOT_TLSLD16	83 /* half16*	(sym+add)@got@tlsld */
+#define R_PPC_GOT_TLSLD16_LO	84 /* half16	(sym+add)@got@tlsld@l */
+#define R_PPC_GOT_TLSLD16_HI	85 /* half16	(sym+add)@got@tlsld@h */
+#define R_PPC_GOT_TLSLD16_HA	86 /* half16	(sym+add)@got@tlsld@ha */
+#define R_PPC_GOT_TPREL16	87 /* half16*	(sym+add)@got@tprel */
+#define R_PPC_GOT_TPREL16_LO	88 /* half16	(sym+add)@got@tprel@l */
+#define R_PPC_GOT_TPREL16_HI	89 /* half16	(sym+add)@got@tprel@h */
+#define R_PPC_GOT_TPREL16_HA	90 /* half16	(sym+add)@got@tprel@ha */
+#define R_PPC_GOT_DTPREL16	91 /* half16*	(sym+add)@got@dtprel */
+#define R_PPC_GOT_DTPREL16_LO	92 /* half16*	(sym+add)@got@dtprel@l */
+#define R_PPC_GOT_DTPREL16_HI	93 /* half16*	(sym+add)@got@dtprel@h */
+#define R_PPC_GOT_DTPREL16_HA	94 /* half16*	(sym+add)@got@dtprel@ha */
+
+/* Keep this the last entry.  */
+#define R_PPC_NUM		95
+
+/* The remaining relocs are from the Embedded ELF ABI, and are not
+   in the SVR4 ELF ABI.  */
+#define R_PPC_EMB_NADDR32	101
+#define R_PPC_EMB_NADDR16	102
+#define R_PPC_EMB_NADDR16_LO	103
+#define R_PPC_EMB_NADDR16_HI	104
+#define R_PPC_EMB_NADDR16_HA	105
+#define R_PPC_EMB_SDAI16	106
+#define R_PPC_EMB_SDA2I16	107
+#define R_PPC_EMB_SDA2REL	108
+#define R_PPC_EMB_SDA21		109	/* 16 bit offset in SDA */
+#define R_PPC_EMB_MRKREF	110
+#define R_PPC_EMB_RELSEC16	111
+#define R_PPC_EMB_RELST_LO	112
+#define R_PPC_EMB_RELST_HI	113
+#define R_PPC_EMB_RELST_HA	114
+#define R_PPC_EMB_BIT_FLD	115
+#define R_PPC_EMB_RELSDA	116	/* 16 bit relative offset in SDA */
+
+/* Diab tool relocations.  */
+#define R_PPC_DIAB_SDA21_LO	180	/* like EMB_SDA21, but lower 16 bit */
+#define R_PPC_DIAB_SDA21_HI	181	/* like EMB_SDA21, but high 16 bit */
+#define R_PPC_DIAB_SDA21_HA	182	/* like EMB_SDA21, adjusted high 16 */
+#define R_PPC_DIAB_RELSDA_LO	183	/* like EMB_RELSDA, but lower 16 bit */
+#define R_PPC_DIAB_RELSDA_HI	184	/* like EMB_RELSDA, but high 16 bit */
+#define R_PPC_DIAB_RELSDA_HA	185	/* like EMB_RELSDA, adjusted high 16 */
+
+/* GNU relocs used in PIC code sequences.  */
+#define R_PPC_REL16		249	/* word32   (sym-.) */
+#define R_PPC_REL16_LO		250	/* half16   (sym-.)@l */
+#define R_PPC_REL16_HI		251	/* half16   (sym-.)@h */
+#define R_PPC_REL16_HA		252	/* half16   (sym-.)@ha */
+
+/* This is a phony reloc to handle any old fashioned TOC16 references
+   that may still be in object files.  */
+#define R_PPC_TOC16		255
+
+/* PowerPC specific values for the Dyn d_tag field.  */
+#define DT_PPC_GOT		(DT_LOPROC + 0)
+#define DT_PPC_NUM		1
+
+/* PowerPC64 relocations defined by the ABIs */
+#define R_PPC64_NONE		R_PPC_NONE
+#define R_PPC64_ADDR32		R_PPC_ADDR32 /* 32bit absolute address */
+#define R_PPC64_ADDR24		R_PPC_ADDR24 /* 26bit address, word aligned */
+#define R_PPC64_ADDR16		R_PPC_ADDR16 /* 16bit absolute address */
+#define R_PPC64_ADDR16_LO	R_PPC_ADDR16_LO	/* lower 16bits of address */
+#define R_PPC64_ADDR16_HI	R_PPC_ADDR16_HI	/* high 16bits of address. */
+#define R_PPC64_ADDR16_HA	R_PPC_ADDR16_HA /* adjusted high 16bits.  */
+#define R_PPC64_ADDR14		R_PPC_ADDR14 /* 16bit address, word aligned */
+#define R_PPC64_ADDR14_BRTAKEN	R_PPC_ADDR14_BRTAKEN
+#define R_PPC64_ADDR14_BRNTAKEN	R_PPC_ADDR14_BRNTAKEN
+#define R_PPC64_REL24		R_PPC_REL24 /* PC-rel. 26 bit, word aligned */
+#define R_PPC64_REL14		R_PPC_REL14 /* PC relative 16 bit */
+#define R_PPC64_REL14_BRTAKEN	R_PPC_REL14_BRTAKEN
+#define R_PPC64_REL14_BRNTAKEN	R_PPC_REL14_BRNTAKEN
+#define R_PPC64_GOT16		R_PPC_GOT16
+#define R_PPC64_GOT16_LO	R_PPC_GOT16_LO
+#define R_PPC64_GOT16_HI	R_PPC_GOT16_HI
+#define R_PPC64_GOT16_HA	R_PPC_GOT16_HA
+
+#define R_PPC64_COPY		R_PPC_COPY
+#define R_PPC64_GLOB_DAT	R_PPC_GLOB_DAT
+#define R_PPC64_JMP_SLOT	R_PPC_JMP_SLOT
+#define R_PPC64_RELATIVE	R_PPC_RELATIVE
+
+#define R_PPC64_UADDR32		R_PPC_UADDR32
+#define R_PPC64_UADDR16		R_PPC_UADDR16
+#define R_PPC64_REL32		R_PPC_REL32
+#define R_PPC64_PLT32		R_PPC_PLT32
+#define R_PPC64_PLTREL32	R_PPC_PLTREL32
+#define R_PPC64_PLT16_LO	R_PPC_PLT16_LO
+#define R_PPC64_PLT16_HI	R_PPC_PLT16_HI
+#define R_PPC64_PLT16_HA	R_PPC_PLT16_HA
+
+#define R_PPC64_SECTOFF		R_PPC_SECTOFF
+#define R_PPC64_SECTOFF_LO	R_PPC_SECTOFF_LO
+#define R_PPC64_SECTOFF_HI	R_PPC_SECTOFF_HI
+#define R_PPC64_SECTOFF_HA	R_PPC_SECTOFF_HA
+#define R_PPC64_ADDR30		37 /* word30 (S + A - P) >> 2 */
+#define R_PPC64_ADDR64		38 /* doubleword64 S + A */
+#define R_PPC64_ADDR16_HIGHER	39 /* half16 #higher(S + A) */
+#define R_PPC64_ADDR16_HIGHERA	40 /* half16 #highera(S + A) */
+#define R_PPC64_ADDR16_HIGHEST	41 /* half16 #highest(S + A) */
+#define R_PPC64_ADDR16_HIGHESTA	42 /* half16 #highesta(S + A) */
+#define R_PPC64_UADDR64		43 /* doubleword64 S + A */
+#define R_PPC64_REL64		44 /* doubleword64 S + A - P */
+#define R_PPC64_PLT64		45 /* doubleword64 L + A */
+#define R_PPC64_PLTREL64	46 /* doubleword64 L + A - P */
+#define R_PPC64_TOC16		47 /* half16* S + A - .TOC */
+#define R_PPC64_TOC16_LO	48 /* half16 #lo(S + A - .TOC.) */
+#define R_PPC64_TOC16_HI	49 /* half16 #hi(S + A - .TOC.) */
+#define R_PPC64_TOC16_HA	50 /* half16 #ha(S + A - .TOC.) */
+#define R_PPC64_TOC		51 /* doubleword64 .TOC */
+#define R_PPC64_PLTGOT16	52 /* half16* M + A */
+#define R_PPC64_PLTGOT16_LO	53 /* half16 #lo(M + A) */
+#define R_PPC64_PLTGOT16_HI	54 /* half16 #hi(M + A) */
+#define R_PPC64_PLTGOT16_HA	55 /* half16 #ha(M + A) */
+
+#define R_PPC64_ADDR16_DS	56 /* half16ds* (S + A) >> 2 */
+#define R_PPC64_ADDR16_LO_DS	57 /* half16ds  #lo(S + A) >> 2 */
+#define R_PPC64_GOT16_DS	58 /* half16ds* (G + A) >> 2 */
+#define R_PPC64_GOT16_LO_DS	59 /* half16ds  #lo(G + A) >> 2 */
+#define R_PPC64_PLT16_LO_DS	60 /* half16ds  #lo(L + A) >> 2 */
+#define R_PPC64_SECTOFF_DS	61 /* half16ds* (R + A) >> 2 */
+#define R_PPC64_SECTOFF_LO_DS	62 /* half16ds  #lo(R + A) >> 2 */
+#define R_PPC64_TOC16_DS	63 /* half16ds* (S + A - .TOC.) >> 2 */
+#define R_PPC64_TOC16_LO_DS	64 /* half16ds  #lo(S + A - .TOC.) >> 2 */
+#define R_PPC64_PLTGOT16_DS	65 /* half16ds* (M + A) >> 2 */
+#define R_PPC64_PLTGOT16_LO_DS	66 /* half16ds  #lo(M + A) >> 2 */
+
+/* PowerPC64 relocations defined for the TLS access ABI.  */
+#define R_PPC64_TLS		67 /* none	(sym+add)@tls */
+#define R_PPC64_DTPMOD64	68 /* doubleword64 (sym+add)@dtpmod */
+#define R_PPC64_TPREL16		69 /* half16*	(sym+add)@tprel */
+#define R_PPC64_TPREL16_LO	70 /* half16	(sym+add)@tprel@l */
+#define R_PPC64_TPREL16_HI	71 /* half16	(sym+add)@tprel@h */
+#define R_PPC64_TPREL16_HA	72 /* half16	(sym+add)@tprel@ha */
+#define R_PPC64_TPREL64		73 /* doubleword64 (sym+add)@tprel */
+#define R_PPC64_DTPREL16	74 /* half16*	(sym+add)@dtprel */
+#define R_PPC64_DTPREL16_LO	75 /* half16	(sym+add)@dtprel@l */
+#define R_PPC64_DTPREL16_HI	76 /* half16	(sym+add)@dtprel@h */
+#define R_PPC64_DTPREL16_HA	77 /* half16	(sym+add)@dtprel@ha */
+#define R_PPC64_DTPREL64	78 /* doubleword64 (sym+add)@dtprel */
+#define R_PPC64_GOT_TLSGD16	79 /* half16*	(sym+add)@got@tlsgd */
+#define R_PPC64_GOT_TLSGD16_LO	80 /* half16	(sym+add)@got@tlsgd@l */
+#define R_PPC64_GOT_TLSGD16_HI	81 /* half16	(sym+add)@got@tlsgd@h */
+#define R_PPC64_GOT_TLSGD16_HA	82 /* half16	(sym+add)@got@tlsgd@ha */
+#define R_PPC64_GOT_TLSLD16	83 /* half16*	(sym+add)@got@tlsld */
+#define R_PPC64_GOT_TLSLD16_LO	84 /* half16	(sym+add)@got@tlsld@l */
+#define R_PPC64_GOT_TLSLD16_HI	85 /* half16	(sym+add)@got@tlsld@h */
+#define R_PPC64_GOT_TLSLD16_HA	86 /* half16	(sym+add)@got@tlsld@ha */
+#define R_PPC64_GOT_TPREL16_DS	87 /* half16ds*	(sym+add)@got@tprel */
+#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */
+#define R_PPC64_GOT_TPREL16_HI	89 /* half16	(sym+add)@got@tprel@h */
+#define R_PPC64_GOT_TPREL16_HA	90 /* half16	(sym+add)@got@tprel@ha */
+#define R_PPC64_GOT_DTPREL16_DS	91 /* half16ds*	(sym+add)@got@dtprel */
+#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */
+#define R_PPC64_GOT_DTPREL16_HI	93 /* half16	(sym+add)@got@dtprel@h */
+#define R_PPC64_GOT_DTPREL16_HA	94 /* half16	(sym+add)@got@dtprel@ha */
+#define R_PPC64_TPREL16_DS	95 /* half16ds*	(sym+add)@tprel */
+#define R_PPC64_TPREL16_LO_DS	96 /* half16ds	(sym+add)@tprel@l */
+#define R_PPC64_TPREL16_HIGHER	97 /* half16	(sym+add)@tprel@higher */
+#define R_PPC64_TPREL16_HIGHERA	98 /* half16	(sym+add)@tprel@highera */
+#define R_PPC64_TPREL16_HIGHEST	99 /* half16	(sym+add)@tprel@highest */
+#define R_PPC64_TPREL16_HIGHESTA 100 /* half16	(sym+add)@tprel@highesta */
+#define R_PPC64_DTPREL16_DS	101 /* half16ds* (sym+add)@dtprel */
+#define R_PPC64_DTPREL16_LO_DS	102 /* half16ds	(sym+add)@dtprel@l */
+#define R_PPC64_DTPREL16_HIGHER	103 /* half16	(sym+add)@dtprel@higher */
+#define R_PPC64_DTPREL16_HIGHERA 104 /* half16	(sym+add)@dtprel@highera */
+#define R_PPC64_DTPREL16_HIGHEST 105 /* half16	(sym+add)@dtprel@highest */
+#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16	(sym+add)@dtprel@highesta */
+
+/* Keep this the last entry.  */
+#define R_PPC64_NUM		107
+
+/* PowerPC64 specific values for the Dyn d_tag field.  */
+#define DT_PPC64_GLINK  (DT_LOPROC + 0)
+#define DT_PPC64_OPD	(DT_LOPROC + 1)
+#define DT_PPC64_OPDSZ	(DT_LOPROC + 2)
+#define DT_PPC64_NUM    3
+
+
+/* ARM specific declarations */
+
+/* Processor specific flags for the ELF header e_flags field.  */
+#define EF_ARM_RELEXEC     0x01
+#define EF_ARM_HASENTRY    0x02
+#define EF_ARM_INTERWORK   0x04
+#define EF_ARM_APCS_26     0x08
+#define EF_ARM_APCS_FLOAT  0x10
+#define EF_ARM_PIC         0x20
+#define EF_ARM_ALIGN8      0x40		/* 8-bit structure alignment is in use */
+#define EF_ARM_NEW_ABI     0x80
+#define EF_ARM_OLD_ABI     0x100
+
+/* Other constants defined in the ARM ELF spec. version B-01.  */
+/* NB. These conflict with values defined above.  */
+#define EF_ARM_SYMSARESORTED	0x04
+#define EF_ARM_DYNSYMSUSESEGIDX 0x08
+#define EF_ARM_MAPSYMSFIRST	0x10
+#define EF_ARM_EABIMASK		0XFF000000
+
+#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK)
+#define EF_ARM_EABI_UNKNOWN  0x00000000
+#define EF_ARM_EABI_VER1     0x01000000
+#define EF_ARM_EABI_VER2     0x02000000
+
+/* Additional symbol types for Thumb */
+#define STT_ARM_TFUNC      0xd
+
+/* ARM-specific values for sh_flags */
+#define SHF_ARM_ENTRYSECT  0x10000000   /* Section contains an entry point */
+#define SHF_ARM_COMDEF     0x80000000   /* Section may be multiply defined
+					   in the input to a link step */
+
+/* ARM-specific program header flags */
+#define PF_ARM_SB          0x10000000   /* Segment contains the location
+					   addressed by the static base */
+
+/* Processor specific values for the Phdr p_type field.  */
+#define PT_ARM_EXIDX	0x70000001	/* .ARM.exidx segment */
+
+/* ARM relocs.  */
+
+#define R_ARM_NONE		0	/* No reloc */
+#define R_ARM_PC24		1	/* PC relative 26 bit branch */
+#define R_ARM_ABS32		2	/* Direct 32 bit  */
+#define R_ARM_REL32		3	/* PC relative 32 bit */
+#define R_ARM_PC13		4
+#define R_ARM_ABS16		5	/* Direct 16 bit */
+#define R_ARM_ABS12		6	/* Direct 12 bit */
+#define R_ARM_THM_ABS5		7
+#define R_ARM_ABS8		8	/* Direct 8 bit */
+#define R_ARM_SBREL32		9
+#define R_ARM_THM_PC22		10
+#define R_ARM_THM_PC8		11
+#define R_ARM_AMP_VCALL9	12
+#define R_ARM_SWI24		13
+#define R_ARM_THM_SWI8		14
+#define R_ARM_XPC25		15
+#define R_ARM_THM_XPC22		16
+#define R_ARM_TLS_DTPMOD32	17	/* ID of module containing symbol */
+#define R_ARM_TLS_DTPOFF32	18	/* Offset in TLS block */
+#define R_ARM_TLS_TPOFF32	19	/* Offset in static TLS block */
+#define R_ARM_COPY		20	/* Copy symbol at runtime */
+#define R_ARM_GLOB_DAT		21	/* Create GOT entry */
+#define R_ARM_JUMP_SLOT		22	/* Create PLT entry */
+#define R_ARM_RELATIVE		23	/* Adjust by program base */
+#define R_ARM_GOTOFF		24	/* 32 bit offset to GOT */
+#define R_ARM_GOTPC		25	/* 32 bit PC relative offset to GOT */
+#define R_ARM_GOT32		26	/* 32 bit GOT entry */
+#define R_ARM_PLT32		27	/* 32 bit PLT address */
+#define R_ARM_ALU_PCREL_7_0	32
+#define R_ARM_ALU_PCREL_15_8	33
+#define R_ARM_ALU_PCREL_23_15	34
+#define R_ARM_LDR_SBREL_11_0	35
+#define R_ARM_ALU_SBREL_19_12	36
+#define R_ARM_ALU_SBREL_27_20	37
+#define R_ARM_GNU_VTENTRY	100
+#define R_ARM_GNU_VTINHERIT	101
+#define R_ARM_THM_PC11		102	/* thumb unconditional branch */
+#define R_ARM_THM_PC9		103	/* thumb conditional branch */
+#define R_ARM_TLS_GD32		104	/* PC-rel 32 bit for global dynamic
+					   thread local data */
+#define R_ARM_TLS_LDM32		105	/* PC-rel 32 bit for local dynamic
+					   thread local data */
+#define R_ARM_TLS_LDO32		106	/* 32 bit offset relative to TLS
+					   block */
+#define R_ARM_TLS_IE32		107	/* PC-rel 32 bit for GOT entry of
+					   static TLS block offset */
+#define R_ARM_TLS_LE32		108	/* 32 bit offset relative to static
+					   TLS block */
+#define R_ARM_RXPC25		249
+#define R_ARM_RSBREL32		250
+#define R_ARM_THM_RPC22		251
+#define R_ARM_RREL32		252
+#define R_ARM_RABS22		253
+#define R_ARM_RPC24		254
+#define R_ARM_RBASE		255
+/* Keep this the last entry.  */
+#define R_ARM_NUM		256
+
+/* IA-64 specific declarations.  */
+
+/* Processor specific flags for the Ehdr e_flags field.  */
+#define EF_IA_64_MASKOS		0x0000000f	/* os-specific flags */
+#define EF_IA_64_ABI64		0x00000010	/* 64-bit ABI */
+#define EF_IA_64_ARCH		0xff000000	/* arch. version mask */
+
+/* Processor specific values for the Phdr p_type field.  */
+#define PT_IA_64_ARCHEXT	(PT_LOPROC + 0)	/* arch extension bits */
+#define PT_IA_64_UNWIND		(PT_LOPROC + 1)	/* ia64 unwind bits */
+#define PT_IA_64_HP_OPT_ANOT	(PT_LOOS + 0x12)
+#define PT_IA_64_HP_HSL_ANOT	(PT_LOOS + 0x13)
+#define PT_IA_64_HP_STACK	(PT_LOOS + 0x14)
+
+/* Processor specific flags for the Phdr p_flags field.  */
+#define PF_IA_64_NORECOV	0x80000000	/* spec insns w/o recovery */
+
+/* Processor specific values for the Shdr sh_type field.  */
+#define SHT_IA_64_EXT		(SHT_LOPROC + 0) /* extension bits */
+#define SHT_IA_64_UNWIND	(SHT_LOPROC + 1) /* unwind bits */
+
+/* Processor specific flags for the Shdr sh_flags field.  */
+#define SHF_IA_64_SHORT		0x10000000	/* section near gp */
+#define SHF_IA_64_NORECOV	0x20000000	/* spec insns w/o recovery */
+
+/* Processor specific values for the Dyn d_tag field.  */
+#define DT_IA_64_PLT_RESERVE	(DT_LOPROC + 0)
+#define DT_IA_64_NUM		1
+
+/* IA-64 relocations.  */
+#define R_IA64_NONE		0x00	/* none */
+#define R_IA64_IMM14		0x21	/* symbol + addend, add imm14 */
+#define R_IA64_IMM22		0x22	/* symbol + addend, add imm22 */
+#define R_IA64_IMM64		0x23	/* symbol + addend, mov imm64 */
+#define R_IA64_DIR32MSB		0x24	/* symbol + addend, data4 MSB */
+#define R_IA64_DIR32LSB		0x25	/* symbol + addend, data4 LSB */
+#define R_IA64_DIR64MSB		0x26	/* symbol + addend, data8 MSB */
+#define R_IA64_DIR64LSB		0x27	/* symbol + addend, data8 LSB */
+#define R_IA64_GPREL22		0x2a	/* @gprel(sym + add), add imm22 */
+#define R_IA64_GPREL64I		0x2b	/* @gprel(sym + add), mov imm64 */
+#define R_IA64_GPREL32MSB	0x2c	/* @gprel(sym + add), data4 MSB */
+#define R_IA64_GPREL32LSB	0x2d	/* @gprel(sym + add), data4 LSB */
+#define R_IA64_GPREL64MSB	0x2e	/* @gprel(sym + add), data8 MSB */
+#define R_IA64_GPREL64LSB	0x2f	/* @gprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF22		0x32	/* @ltoff(sym + add), add imm22 */
+#define R_IA64_LTOFF64I		0x33	/* @ltoff(sym + add), mov imm64 */
+#define R_IA64_PLTOFF22		0x3a	/* @pltoff(sym + add), add imm22 */
+#define R_IA64_PLTOFF64I	0x3b	/* @pltoff(sym + add), mov imm64 */
+#define R_IA64_PLTOFF64MSB	0x3e	/* @pltoff(sym + add), data8 MSB */
+#define R_IA64_PLTOFF64LSB	0x3f	/* @pltoff(sym + add), data8 LSB */
+#define R_IA64_FPTR64I		0x43	/* @fptr(sym + add), mov imm64 */
+#define R_IA64_FPTR32MSB	0x44	/* @fptr(sym + add), data4 MSB */
+#define R_IA64_FPTR32LSB	0x45	/* @fptr(sym + add), data4 LSB */
+#define R_IA64_FPTR64MSB	0x46	/* @fptr(sym + add), data8 MSB */
+#define R_IA64_FPTR64LSB	0x47	/* @fptr(sym + add), data8 LSB */
+#define R_IA64_PCREL60B		0x48	/* @pcrel(sym + add), brl */
+#define R_IA64_PCREL21B		0x49	/* @pcrel(sym + add), ptb, call */
+#define R_IA64_PCREL21M		0x4a	/* @pcrel(sym + add), chk.s */
+#define R_IA64_PCREL21F		0x4b	/* @pcrel(sym + add), fchkf */
+#define R_IA64_PCREL32MSB	0x4c	/* @pcrel(sym + add), data4 MSB */
+#define R_IA64_PCREL32LSB	0x4d	/* @pcrel(sym + add), data4 LSB */
+#define R_IA64_PCREL64MSB	0x4e	/* @pcrel(sym + add), data8 MSB */
+#define R_IA64_PCREL64LSB	0x4f	/* @pcrel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_FPTR22	0x52	/* @ltoff(@fptr(s+a)), imm22 */
+#define R_IA64_LTOFF_FPTR64I	0x53	/* @ltoff(@fptr(s+a)), imm64 */
+#define R_IA64_LTOFF_FPTR32MSB	0x54	/* @ltoff(@fptr(s+a)), data4 MSB */
+#define R_IA64_LTOFF_FPTR32LSB	0x55	/* @ltoff(@fptr(s+a)), data4 LSB */
+#define R_IA64_LTOFF_FPTR64MSB	0x56	/* @ltoff(@fptr(s+a)), data8 MSB */
+#define R_IA64_LTOFF_FPTR64LSB	0x57	/* @ltoff(@fptr(s+a)), data8 LSB */
+#define R_IA64_SEGREL32MSB	0x5c	/* @segrel(sym + add), data4 MSB */
+#define R_IA64_SEGREL32LSB	0x5d	/* @segrel(sym + add), data4 LSB */
+#define R_IA64_SEGREL64MSB	0x5e	/* @segrel(sym + add), data8 MSB */
+#define R_IA64_SEGREL64LSB	0x5f	/* @segrel(sym + add), data8 LSB */
+#define R_IA64_SECREL32MSB	0x64	/* @secrel(sym + add), data4 MSB */
+#define R_IA64_SECREL32LSB	0x65	/* @secrel(sym + add), data4 LSB */
+#define R_IA64_SECREL64MSB	0x66	/* @secrel(sym + add), data8 MSB */
+#define R_IA64_SECREL64LSB	0x67	/* @secrel(sym + add), data8 LSB */
+#define R_IA64_REL32MSB		0x6c	/* data 4 + REL */
+#define R_IA64_REL32LSB		0x6d	/* data 4 + REL */
+#define R_IA64_REL64MSB		0x6e	/* data 8 + REL */
+#define R_IA64_REL64LSB		0x6f	/* data 8 + REL */
+#define R_IA64_LTV32MSB		0x74	/* symbol + addend, data4 MSB */
+#define R_IA64_LTV32LSB		0x75	/* symbol + addend, data4 LSB */
+#define R_IA64_LTV64MSB		0x76	/* symbol + addend, data8 MSB */
+#define R_IA64_LTV64LSB		0x77	/* symbol + addend, data8 LSB */
+#define R_IA64_PCREL21BI	0x79	/* @pcrel(sym + add), 21bit inst */
+#define R_IA64_PCREL22		0x7a	/* @pcrel(sym + add), 22bit inst */
+#define R_IA64_PCREL64I		0x7b	/* @pcrel(sym + add), 64bit inst */
+#define R_IA64_IPLTMSB		0x80	/* dynamic reloc, imported PLT, MSB */
+#define R_IA64_IPLTLSB		0x81	/* dynamic reloc, imported PLT, LSB */
+#define R_IA64_COPY		0x84	/* copy relocation */
+#define R_IA64_SUB		0x85	/* Addend and symbol difference */
+#define R_IA64_LTOFF22X		0x86	/* LTOFF22, relaxable.  */
+#define R_IA64_LDXMOV		0x87	/* Use of LTOFF22X.  */
+#define R_IA64_TPREL14		0x91	/* @tprel(sym + add), imm14 */
+#define R_IA64_TPREL22		0x92	/* @tprel(sym + add), imm22 */
+#define R_IA64_TPREL64I		0x93	/* @tprel(sym + add), imm64 */
+#define R_IA64_TPREL64MSB	0x96	/* @tprel(sym + add), data8 MSB */
+#define R_IA64_TPREL64LSB	0x97	/* @tprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_TPREL22	0x9a	/* @ltoff(@tprel(s+a)), imm2 */
+#define R_IA64_DTPMOD64MSB	0xa6	/* @dtpmod(sym + add), data8 MSB */
+#define R_IA64_DTPMOD64LSB	0xa7	/* @dtpmod(sym + add), data8 LSB */
+#define R_IA64_LTOFF_DTPMOD22	0xaa	/* @ltoff(@dtpmod(sym + add)), imm22 */
+#define R_IA64_DTPREL14		0xb1	/* @dtprel(sym + add), imm14 */
+#define R_IA64_DTPREL22		0xb2	/* @dtprel(sym + add), imm22 */
+#define R_IA64_DTPREL64I	0xb3	/* @dtprel(sym + add), imm64 */
+#define R_IA64_DTPREL32MSB	0xb4	/* @dtprel(sym + add), data4 MSB */
+#define R_IA64_DTPREL32LSB	0xb5	/* @dtprel(sym + add), data4 LSB */
+#define R_IA64_DTPREL64MSB	0xb6	/* @dtprel(sym + add), data8 MSB */
+#define R_IA64_DTPREL64LSB	0xb7	/* @dtprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_DTPREL22	0xba	/* @ltoff(@dtprel(s+a)), imm22 */
+
+/* SH specific declarations */
+
+/* SH relocs.  */
+#define	R_SH_NONE		0
+#define	R_SH_DIR32		1
+#define	R_SH_REL32		2
+#define	R_SH_DIR8WPN		3
+#define	R_SH_IND12W		4
+#define	R_SH_DIR8WPL		5
+#define	R_SH_DIR8WPZ		6
+#define	R_SH_DIR8BP		7
+#define	R_SH_DIR8W		8
+#define	R_SH_DIR8L		9
+#define	R_SH_SWITCH16		25
+#define	R_SH_SWITCH32		26
+#define	R_SH_USES		27
+#define	R_SH_COUNT		28
+#define	R_SH_ALIGN		29
+#define	R_SH_CODE		30
+#define	R_SH_DATA		31
+#define	R_SH_LABEL		32
+#define	R_SH_SWITCH8		33
+#define	R_SH_GNU_VTINHERIT	34
+#define	R_SH_GNU_VTENTRY	35
+#define	R_SH_TLS_GD_32		144
+#define	R_SH_TLS_LD_32		145
+#define	R_SH_TLS_LDO_32		146
+#define	R_SH_TLS_IE_32		147
+#define	R_SH_TLS_LE_32		148
+#define	R_SH_TLS_DTPMOD32	149
+#define	R_SH_TLS_DTPOFF32	150
+#define	R_SH_TLS_TPOFF32	151
+#define	R_SH_GOT32		160
+#define	R_SH_PLT32		161
+#define	R_SH_COPY		162
+#define	R_SH_GLOB_DAT		163
+#define	R_SH_JMP_SLOT		164
+#define	R_SH_RELATIVE		165
+#define	R_SH_GOTOFF		166
+#define	R_SH_GOTPC		167
+/* Keep this the last entry.  */
+#define	R_SH_NUM		256
+
+/* Additional s390 relocs */
+
+#define R_390_NONE		0	/* No reloc.  */
+#define R_390_8			1	/* Direct 8 bit.  */
+#define R_390_12		2	/* Direct 12 bit.  */
+#define R_390_16		3	/* Direct 16 bit.  */
+#define R_390_32		4	/* Direct 32 bit.  */
+#define R_390_PC32		5	/* PC relative 32 bit.	*/
+#define R_390_GOT12		6	/* 12 bit GOT offset.  */
+#define R_390_GOT32		7	/* 32 bit GOT offset.  */
+#define R_390_PLT32		8	/* 32 bit PC relative PLT address.  */
+#define R_390_COPY		9	/* Copy symbol at runtime.  */
+#define R_390_GLOB_DAT		10	/* Create GOT entry.  */
+#define R_390_JMP_SLOT		11	/* Create PLT entry.  */
+#define R_390_RELATIVE		12	/* Adjust by program base.  */
+#define R_390_GOTOFF32		13	/* 32 bit offset to GOT.	 */
+#define R_390_GOTPC		14	/* 32 bit PC relative offset to GOT.  */
+#define R_390_GOT16		15	/* 16 bit GOT offset.  */
+#define R_390_PC16		16	/* PC relative 16 bit.	*/
+#define R_390_PC16DBL		17	/* PC relative 16 bit shifted by 1.  */
+#define R_390_PLT16DBL		18	/* 16 bit PC rel. PLT shifted by 1.  */
+#define R_390_PC32DBL		19	/* PC relative 32 bit shifted by 1.  */
+#define R_390_PLT32DBL		20	/* 32 bit PC rel. PLT shifted by 1.  */
+#define R_390_GOTPCDBL		21	/* 32 bit PC rel. GOT shifted by 1.  */
+#define R_390_64		22	/* Direct 64 bit.  */
+#define R_390_PC64		23	/* PC relative 64 bit.	*/
+#define R_390_GOT64		24	/* 64 bit GOT offset.  */
+#define R_390_PLT64		25	/* 64 bit PC relative PLT address.  */
+#define R_390_GOTENT		26	/* 32 bit PC rel. to GOT entry >> 1. */
+#define R_390_GOTOFF16		27	/* 16 bit offset to GOT. */
+#define R_390_GOTOFF64		28	/* 64 bit offset to GOT. */
+#define R_390_GOTPLT12		29	/* 12 bit offset to jump slot.	*/
+#define R_390_GOTPLT16		30	/* 16 bit offset to jump slot.	*/
+#define R_390_GOTPLT32		31	/* 32 bit offset to jump slot.	*/
+#define R_390_GOTPLT64		32	/* 64 bit offset to jump slot.	*/
+#define R_390_GOTPLTENT		33	/* 32 bit rel. offset to jump slot.  */
+#define R_390_PLTOFF16		34	/* 16 bit offset from GOT to PLT. */
+#define R_390_PLTOFF32		35	/* 32 bit offset from GOT to PLT. */
+#define R_390_PLTOFF64		36	/* 16 bit offset from GOT to PLT. */
+#define R_390_TLS_LOAD		37	/* Tag for load insn in TLS code.  */
+#define R_390_TLS_GDCALL	38	/* Tag for function call in general
+					   dynamic TLS code. */
+#define R_390_TLS_LDCALL	39	/* Tag for function call in local
+					   dynamic TLS code. */
+#define R_390_TLS_GD32		40	/* Direct 32 bit for general dynamic
+					   thread local data.  */
+#define R_390_TLS_GD64		41	/* Direct 64 bit for general dynamic
+					  thread local data.  */
+#define R_390_TLS_GOTIE12	42	/* 12 bit GOT offset for static TLS
+					   block offset.  */
+#define R_390_TLS_GOTIE32	43	/* 32 bit GOT offset for static TLS
+					   block offset.  */
+#define R_390_TLS_GOTIE64	44	/* 64 bit GOT offset for static TLS
+					   block offset. */
+#define R_390_TLS_LDM32		45	/* Direct 32 bit for local dynamic
+					   thread local data in LE code.  */
+#define R_390_TLS_LDM64		46	/* Direct 64 bit for local dynamic
+					   thread local data in LE code.  */
+#define R_390_TLS_IE32		47	/* 32 bit address of GOT entry for
+					   negated static TLS block offset.  */
+#define R_390_TLS_IE64		48	/* 64 bit address of GOT entry for
+					   negated static TLS block offset.  */
+#define R_390_TLS_IEENT		49	/* 32 bit rel. offset to GOT entry for
+					   negated static TLS block offset.  */
+#define R_390_TLS_LE32		50	/* 32 bit negated offset relative to
+					   static TLS block.  */
+#define R_390_TLS_LE64		51	/* 64 bit negated offset relative to
+					   static TLS block.  */
+#define R_390_TLS_LDO32		52	/* 32 bit offset relative to TLS
+					   block.  */
+#define R_390_TLS_LDO64		53	/* 64 bit offset relative to TLS
+					   block.  */
+#define R_390_TLS_DTPMOD	54	/* ID of module containing symbol.  */
+#define R_390_TLS_DTPOFF	55	/* Offset in TLS block.	 */
+#define R_390_TLS_TPOFF		56	/* Negated offset in static TLS
+					   block.  */
+#define R_390_20		57	/* Direct 20 bit.  */
+#define R_390_GOT20		58	/* 20 bit GOT offset.  */
+#define R_390_GOTPLT20		59	/* 20 bit offset to jump slot.  */
+#define R_390_TLS_GOTIE20	60	/* 20 bit GOT offset for static TLS
+					   block offset.  */
+/* Keep this the last entry.  */
+#define R_390_NUM		61
+
+
+/* CRIS relocations.  */
+#define R_CRIS_NONE		0
+#define R_CRIS_8		1
+#define R_CRIS_16		2
+#define R_CRIS_32		3
+#define R_CRIS_8_PCREL		4
+#define R_CRIS_16_PCREL		5
+#define R_CRIS_32_PCREL		6
+#define R_CRIS_GNU_VTINHERIT	7
+#define R_CRIS_GNU_VTENTRY	8
+#define R_CRIS_COPY		9
+#define R_CRIS_GLOB_DAT		10
+#define R_CRIS_JUMP_SLOT	11
+#define R_CRIS_RELATIVE		12
+#define R_CRIS_16_GOT		13
+#define R_CRIS_32_GOT		14
+#define R_CRIS_16_GOTPLT	15
+#define R_CRIS_32_GOTPLT	16
+#define R_CRIS_32_GOTREL	17
+#define R_CRIS_32_PLT_GOTREL	18
+#define R_CRIS_32_PLT_PCREL	19
+
+#define R_CRIS_NUM		20
+
+
+/* AMD x86-64 relocations.  */
+#define R_X86_64_NONE		0	/* No reloc */
+#define R_X86_64_64		1	/* Direct 64 bit  */
+#define R_X86_64_PC32		2	/* PC relative 32 bit signed */
+#define R_X86_64_GOT32		3	/* 32 bit GOT entry */
+#define R_X86_64_PLT32		4	/* 32 bit PLT address */
+#define R_X86_64_COPY		5	/* Copy symbol at runtime */
+#define R_X86_64_GLOB_DAT	6	/* Create GOT entry */
+#define R_X86_64_JUMP_SLOT	7	/* Create PLT entry */
+#define R_X86_64_RELATIVE	8	/* Adjust by program base */
+#define R_X86_64_GOTPCREL	9	/* 32 bit signed PC relative
+					   offset to GOT */
+#define R_X86_64_32		10	/* Direct 32 bit zero extended */
+#define R_X86_64_32S		11	/* Direct 32 bit sign extended */
+#define R_X86_64_16		12	/* Direct 16 bit zero extended */
+#define R_X86_64_PC16		13	/* 16 bit sign extended pc relative */
+#define R_X86_64_8		14	/* Direct 8 bit sign extended  */
+#define R_X86_64_PC8		15	/* 8 bit sign extended pc relative */
+#define R_X86_64_DTPMOD64	16	/* ID of module containing symbol */
+#define R_X86_64_DTPOFF64	17	/* Offset in module's TLS block */
+#define R_X86_64_TPOFF64	18	/* Offset in initial TLS block */
+#define R_X86_64_TLSGD		19	/* 32 bit signed PC relative offset
+					   to two GOT entries for GD symbol */
+#define R_X86_64_TLSLD		20	/* 32 bit signed PC relative offset
+					   to two GOT entries for LD symbol */
+#define R_X86_64_DTPOFF32	21	/* Offset in TLS block */
+#define R_X86_64_GOTTPOFF	22	/* 32 bit signed PC relative offset
+					   to GOT entry for IE symbol */
+#define R_X86_64_TPOFF32	23	/* Offset in initial TLS block */
+
+#define R_X86_64_NUM		24
+
+
+/* AM33 relocations.  */
+#define R_MN10300_NONE		0	/* No reloc.  */
+#define R_MN10300_32		1	/* Direct 32 bit.  */
+#define R_MN10300_16		2	/* Direct 16 bit.  */
+#define R_MN10300_8		3	/* Direct 8 bit.  */
+#define R_MN10300_PCREL32	4	/* PC-relative 32-bit.  */
+#define R_MN10300_PCREL16	5	/* PC-relative 16-bit signed.  */
+#define R_MN10300_PCREL8	6	/* PC-relative 8-bit signed.  */
+#define R_MN10300_GNU_VTINHERIT	7	/* Ancient C++ vtable garbage... */
+#define R_MN10300_GNU_VTENTRY	8	/* ... collection annotation.  */
+#define R_MN10300_24		9	/* Direct 24 bit.  */
+#define R_MN10300_GOTPC32	10	/* 32-bit PCrel offset to GOT.  */
+#define R_MN10300_GOTPC16	11	/* 16-bit PCrel offset to GOT.  */
+#define R_MN10300_GOTOFF32	12	/* 32-bit offset from GOT.  */
+#define R_MN10300_GOTOFF24	13	/* 24-bit offset from GOT.  */
+#define R_MN10300_GOTOFF16	14	/* 16-bit offset from GOT.  */
+#define R_MN10300_PLT32		15	/* 32-bit PCrel to PLT entry.  */
+#define R_MN10300_PLT16		16	/* 16-bit PCrel to PLT entry.  */
+#define R_MN10300_GOT32		17	/* 32-bit offset to GOT entry.  */
+#define R_MN10300_GOT24		18	/* 24-bit offset to GOT entry.  */
+#define R_MN10300_GOT16		19	/* 16-bit offset to GOT entry.  */
+#define R_MN10300_COPY		20	/* Copy symbol at runtime.  */
+#define R_MN10300_GLOB_DAT	21	/* Create GOT entry.  */
+#define R_MN10300_JMP_SLOT	22	/* Create PLT entry.  */
+#define R_MN10300_RELATIVE	23	/* Adjust by program base.  */
+
+#define R_MN10300_NUM		24
+
+
+/* M32R relocs.  */
+#define R_M32R_NONE		0	/* No reloc. */
+#define R_M32R_16		1	/* Direct 16 bit. */
+#define R_M32R_32		2	/* Direct 32 bit. */
+#define R_M32R_24		3	/* Direct 24 bit. */
+#define R_M32R_10_PCREL		4	/* PC relative 10 bit shifted. */
+#define R_M32R_18_PCREL		5	/* PC relative 18 bit shifted. */
+#define R_M32R_26_PCREL		6	/* PC relative 26 bit shifted. */
+#define R_M32R_HI16_ULO		7	/* High 16 bit with unsigned low. */
+#define R_M32R_HI16_SLO		8	/* High 16 bit with signed low. */
+#define R_M32R_LO16		9	/* Low 16 bit. */
+#define R_M32R_SDA16		10	/* 16 bit offset in SDA. */
+#define R_M32R_GNU_VTINHERIT	11
+#define R_M32R_GNU_VTENTRY	12
+/* M32R relocs use SHT_RELA.  */
+#define R_M32R_16_RELA		33	/* Direct 16 bit. */
+#define R_M32R_32_RELA		34	/* Direct 32 bit. */
+#define R_M32R_24_RELA		35	/* Direct 24 bit. */
+#define R_M32R_10_PCREL_RELA	36	/* PC relative 10 bit shifted. */
+#define R_M32R_18_PCREL_RELA	37	/* PC relative 18 bit shifted. */
+#define R_M32R_26_PCREL_RELA	38	/* PC relative 26 bit shifted. */
+#define R_M32R_HI16_ULO_RELA	39	/* High 16 bit with unsigned low */
+#define R_M32R_HI16_SLO_RELA	40	/* High 16 bit with signed low */
+#define R_M32R_LO16_RELA	41	/* Low 16 bit */
+#define R_M32R_SDA16_RELA	42	/* 16 bit offset in SDA */
+#define R_M32R_RELA_GNU_VTINHERIT	43
+#define R_M32R_RELA_GNU_VTENTRY	44
+#define R_M32R_REL32		45	/* PC relative 32 bit.  */
+
+#define R_M32R_GOT24		48	/* 24 bit GOT entry */
+#define R_M32R_26_PLTREL	49	/* 26 bit PC relative to PLT shifted */
+#define R_M32R_COPY		50	/* Copy symbol at runtime */
+#define R_M32R_GLOB_DAT		51	/* Create GOT entry */
+#define R_M32R_JMP_SLOT		52	/* Create PLT entry */
+#define R_M32R_RELATIVE		53	/* Adjust by program base */
+#define R_M32R_GOTOFF		54	/* 24 bit offset to GOT */
+#define R_M32R_GOTPC24		55	/* 24 bit PC relative offset to GOT */
+#define R_M32R_GOT16_HI_ULO	56	/* High 16 bit GOT entry with unsigned
+					   low */
+#define R_M32R_GOT16_HI_SLO	57	/* High 16 bit GOT entry with signed
+					   low */
+#define R_M32R_GOT16_LO		58	/* Low 16 bit GOT entry */
+#define R_M32R_GOTPC_HI_ULO	59	/* High 16 bit PC relative offset to
+					   GOT with unsigned low */
+#define R_M32R_GOTPC_HI_SLO	60	/* High 16 bit PC relative offset to
+					   GOT with signed low */
+#define R_M32R_GOTPC_LO		61	/* Low 16 bit PC relative offset to
+					   GOT */
+#define R_M32R_GOTOFF_HI_ULO	62	/* High 16 bit offset to GOT
+					   with unsigned low */
+#define R_M32R_GOTOFF_HI_SLO	63	/* High 16 bit offset to GOT
+					   with signed low */
+#define R_M32R_GOTOFF_LO	64	/* Low 16 bit offset to GOT */
+#define R_M32R_NUM		256	/* Keep this the last entry. */
+
+
+__END_DECLS
+
+#endif	/* elf.h */
diff --git a/ELFLoader/test.cpp b/ELFLoader/test.cpp
new file mode 100644
index 00000000000..2e66cb172ea
--- /dev/null
+++ b/ELFLoader/test.cpp
@@ -0,0 +1,24 @@
+#include "ExecSpace.h"
+#include <cstdio>
+
+typedef int (*MainFunctionPtr)(void);
+
+int main(int, char**)
+{
+    MappedFile f("_test.o");
+    if (!f.isValid()) {
+        fprintf(stderr, "Failed to map file :(\n");
+        return 1;
+    }
+
+    ExecSpace space;
+    space.loadELF(std::move(f));
+
+    auto func = reinterpret_cast<MainFunctionPtr>(space.symbolPtr("EntryPoint"));
+    printf("func: %p\n", func);
+
+    int z = func();
+    printf("func() returned %d\n", z);
+
+    return 0;
+}
diff --git a/VirtualFileSystem/.gitignore b/VirtualFileSystem/.gitignore
new file mode 100644
index 00000000000..5588753b2b6
--- /dev/null
+++ b/VirtualFileSystem/.gitignore
@@ -0,0 +1,4 @@
+test
+*.o
+*.swp
+AK
diff --git a/VirtualFileSystem/BlockDevice.cpp b/VirtualFileSystem/BlockDevice.cpp
new file mode 100644
index 00000000000..3c53e8c426a
--- /dev/null
+++ b/VirtualFileSystem/BlockDevice.cpp
@@ -0,0 +1,9 @@
+#include "BlockDevice.h"
+
+BlockDevice::BlockDevice()
+{
+}
+
+BlockDevice::~BlockDevice()
+{
+}
diff --git a/VirtualFileSystem/BlockDevice.h b/VirtualFileSystem/BlockDevice.h
new file mode 100644
index 00000000000..e295ee801e8
--- /dev/null
+++ b/VirtualFileSystem/BlockDevice.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <AK/Retainable.h>
+#include <AK/Types.h>
+
+class BlockDevice : public Retainable<BlockDevice> {
+public:
+    virtual ~BlockDevice();
+
+    virtual unsigned blockSize() const = 0;
+    virtual bool readBlock(unsigned index, byte*) const = 0;
+    virtual bool writeBlock(unsigned index, const byte*) = 0;
+    virtual const char* className() const = 0;
+    virtual bool read(qword offset, unsigned length, byte*) const = 0;
+    virtual bool write(qword offset, unsigned length, const byte*) = 0;
+
+protected:
+    BlockDevice();
+};
+
diff --git a/VirtualFileSystem/DeviceBackedFileSystem.cpp b/VirtualFileSystem/DeviceBackedFileSystem.cpp
new file mode 100644
index 00000000000..5fc6b199b6e
--- /dev/null
+++ b/VirtualFileSystem/DeviceBackedFileSystem.cpp
@@ -0,0 +1,78 @@
+#include "DeviceBackedFileSystem.h"
+
+//#define DBFS_DEBUG
+
+DeviceBackedFileSystem::DeviceBackedFileSystem(RetainPtr<BlockDevice>&& device)
+    : m_device(std::move(device))
+{
+    ASSERT(m_device);
+}
+
+DeviceBackedFileSystem::~DeviceBackedFileSystem()
+{
+}
+
+bool DeviceBackedFileSystem::writeBlock(unsigned index, const ByteBuffer& data)
+{
+    ASSERT(data.size() == blockSize());
+#ifdef DBFS_DEBUG
+    printf("DeviceBackedFileSystem::writeBlock %u\n", index);
+#endif
+    qword baseOffset = static_cast<qword>(index) * static_cast<qword>(blockSize());
+    return device().write(baseOffset, blockSize(), data.pointer());
+}
+
+bool DeviceBackedFileSystem::writeBlocks(unsigned index, unsigned count, const ByteBuffer& data)
+{
+#ifdef DBFS_DEBUG
+    printf("DeviceBackedFileSystem::writeBlocks %u x%u\n", index, count);
+#endif
+    qword baseOffset = static_cast<qword>(index) * static_cast<qword>(blockSize());
+    return device().write(baseOffset, count * blockSize(), data.pointer());
+}
+
+ByteBuffer DeviceBackedFileSystem::readBlock(unsigned index) const
+{
+#ifdef DBFS_DEBUG
+    printf("DeviceBackedFileSystem::readBlock %u\n", index);
+#endif
+    auto buffer = ByteBuffer::createUninitialized(blockSize());
+    qword baseOffset = static_cast<qword>(index) * static_cast<qword>(blockSize());
+    auto* bufferPointer = buffer.pointer();
+    device().read(baseOffset, blockSize(), bufferPointer);
+    ASSERT(buffer.size() == blockSize());
+    return buffer;
+}
+
+ByteBuffer DeviceBackedFileSystem::readBlocks(unsigned index, unsigned count) const
+{
+    if (!count)
+        return nullptr;
+    if (count == 1)
+        return readBlock(index);
+    auto blocks = ByteBuffer::createUninitialized(count * blockSize());
+    byte* out = blocks.pointer();
+
+    for (unsigned i = 0; i < count; ++i) {
+        auto block = readBlock(index + i);
+        if (!block)
+            return nullptr;
+        memcpy(out, block.pointer(), block.size());
+        out += blockSize();
+    }
+
+    return blocks;
+}
+
+void DeviceBackedFileSystem::setBlockSize(unsigned blockSize)
+{
+    if (blockSize == m_blockSize)
+        return;
+    m_blockSize = blockSize;
+    invalidateCaches();
+}
+
+void DeviceBackedFileSystem::invalidateCaches()
+{
+    // FIXME: Implement block cache.
+}
diff --git a/VirtualFileSystem/DeviceBackedFileSystem.h b/VirtualFileSystem/DeviceBackedFileSystem.h
new file mode 100644
index 00000000000..739f3c468db
--- /dev/null
+++ b/VirtualFileSystem/DeviceBackedFileSystem.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "FileSystem.h"
+#include <AK/ByteBuffer.h>
+
+class DeviceBackedFileSystem : public FileSystem {
+public:
+    virtual ~DeviceBackedFileSystem() override;
+
+    BlockDevice& device() { return *m_device; }
+    const BlockDevice& device() const { return *m_device; }
+
+    unsigned blockSize() const { return m_blockSize; }
+
+protected:
+    explicit DeviceBackedFileSystem(RetainPtr<BlockDevice>&&);
+
+    void setBlockSize(unsigned);
+    void invalidateCaches();
+
+    ByteBuffer readBlock(unsigned index) const;
+    ByteBuffer readBlocks(unsigned index, unsigned count) const;
+
+    bool writeBlock(unsigned index, const ByteBuffer&);
+    bool writeBlocks(unsigned index, unsigned count, const ByteBuffer&);
+
+private:
+    unsigned m_blockSize { 0 };
+    RetainPtr<BlockDevice> m_device;
+};
diff --git a/VirtualFileSystem/Ext2FileSystem.cpp b/VirtualFileSystem/Ext2FileSystem.cpp
new file mode 100644
index 00000000000..b84084a7425
--- /dev/null
+++ b/VirtualFileSystem/Ext2FileSystem.cpp
@@ -0,0 +1,746 @@
+#include "Ext2FileSystem.h"
+#include "ext2_fs.h"
+#include <AK/Bitmap.h>
+#include <AK/StdLib.h>
+#include <cstdio>
+#include <cstring>
+#include "kmalloc.h"
+
+//#define EXT2_DEBUG
+
+RetainPtr<Ext2FileSystem> Ext2FileSystem::create(RetainPtr<BlockDevice> device)
+{
+    return adopt(*new Ext2FileSystem(std::move(device)));
+}
+
+Ext2FileSystem::Ext2FileSystem(RetainPtr<BlockDevice> device)
+    : DeviceBackedFileSystem(std::move(device))
+{
+}
+
+Ext2FileSystem::~Ext2FileSystem()
+{
+}
+
+ByteBuffer Ext2FileSystem::readSuperBlock() const
+{
+    auto buffer = ByteBuffer::createUninitialized(1024);
+    device().readBlock(2, buffer.pointer());
+    device().readBlock(3, buffer.offsetPointer(512));
+    return buffer;
+}
+
+bool Ext2FileSystem::writeSuperBlock(const ext2_super_block& sb)
+{
+    const byte* raw = (const byte*)&sb;
+    bool success;
+    success = device().writeBlock(2, raw);
+    ASSERT(success);
+    success = device().writeBlock(3, raw + 512);
+    ASSERT(success);
+    // FIXME: This is an ugly way to refresh the superblock cache. :-|
+    superBlock();
+    return true;
+}
+
+unsigned Ext2FileSystem::firstBlockOfGroup(unsigned groupIndex) const
+{
+    return superBlock().s_first_data_block + (groupIndex * superBlock().s_blocks_per_group);
+}
+
+const ext2_super_block& Ext2FileSystem::superBlock() const
+{
+    if (!m_cachedSuperBlock)
+        m_cachedSuperBlock = readSuperBlock();
+    return *reinterpret_cast<ext2_super_block*>(m_cachedSuperBlock.pointer());
+}
+
+const ext2_group_desc& Ext2FileSystem::blockGroupDescriptor(unsigned groupIndex) const
+{
+    // FIXME: Should this fail gracefully somehow?
+    ASSERT(groupIndex <= m_blockGroupCount);
+
+    if (!m_cachedBlockGroupDescriptorTable) {
+        unsigned blocksToRead = ceilDiv(m_blockGroupCount * sizeof(ext2_group_desc), blockSize());
+        printf("[ext2fs] block group count: %u, blocks-to-read: %u\n", m_blockGroupCount, blocksToRead);
+        unsigned firstBlockOfBGDT = blockSize() == 1024 ? 2 : 1;
+        printf("[ext2fs] first block of BGDT: %u\n", firstBlockOfBGDT);
+        m_cachedBlockGroupDescriptorTable = readBlocks(firstBlockOfBGDT, blocksToRead);
+    }
+    return reinterpret_cast<ext2_group_desc*>(m_cachedBlockGroupDescriptorTable.pointer())[groupIndex - 1];
+}
+
+bool Ext2FileSystem::initialize()
+{
+    auto& superBlock = this->superBlock();
+    printf("[ext2fs] super block magic: %04x (super block size: %u)\n", superBlock.s_magic, sizeof(ext2_super_block));
+    if (superBlock.s_magic != EXT2_SUPER_MAGIC)
+        return false;
+
+    printf("[ext2fs] %u inodes, %u blocks\n", superBlock.s_inodes_count, superBlock.s_blocks_count);
+    printf("[ext2fs] block size = %u\n", EXT2_BLOCK_SIZE(&superBlock));
+    printf("[ext2fs] first data block = %u\n", superBlock.s_first_data_block);
+    printf("[ext2fs] inodes per block = %u\n", inodesPerBlock());
+    printf("[ext2fs] inodes per group = %u\n", inodesPerGroup());
+    printf("[ext2fs] free inodes = %u\n", superBlock.s_free_inodes_count);
+
+    printf("[ext2fs] desc per block = %u\n", EXT2_DESC_PER_BLOCK(&superBlock));
+    printf("[ext2fs] desc size = %u\n", EXT2_DESC_SIZE(&superBlock));
+
+    setBlockSize(EXT2_BLOCK_SIZE(&superBlock));
+
+    m_blockGroupCount = ceilDiv(superBlock.s_blocks_count, superBlock.s_blocks_per_group);
+
+    if (m_blockGroupCount == 0) {
+        printf("[ext2fs] no block groups :(\n");
+        return false;
+    }
+
+    for (unsigned i = 1; i <= m_blockGroupCount; ++i) {
+        auto& group = blockGroupDescriptor(i);
+        printf("[ext2fs] group[%u] { block_bitmap: %u, inode_bitmap: %u, inode_table: %u }\n",
+            i,
+            group.bg_block_bitmap,
+            group.bg_inode_bitmap,
+            group.bg_inode_table);
+    }
+
+    return true;
+}
+
+const char* Ext2FileSystem::className() const
+{
+    return "ext2fs";
+}
+
+InodeIdentifier Ext2FileSystem::rootInode() const
+{
+    return { id(), EXT2_ROOT_INO };
+}
+
+#ifdef EXT2_DEBUG
+static void dumpExt2Inode(const ext2_inode& inode)
+{
+    printf("Dump of ext2_inode:\n");
+    printf("  i_size: %u\n", inode.i_size);
+    printf("  i_mode: %u\n", inode.i_mode);
+    printf("  i_blocks: %u\n", inode.i_blocks);
+    printf("  i_uid: %u\n", inode.i_uid);
+    printf("  i_gid: %u\n", inode.i_gid);
+}
+#endif
+
+ByteBuffer Ext2FileSystem::readBlockContainingInode(unsigned inode, unsigned& blockIndex, unsigned& offset) const
+{
+    auto& superBlock = this->superBlock();
+
+    if (inode != EXT2_ROOT_INO && inode < EXT2_FIRST_INO(&superBlock))
+        return { };
+
+    if (inode > superBlock.s_inodes_count)
+        return { };
+
+    auto& bgd = blockGroupDescriptor(groupIndexFromInode(inode));
+
+    offset = ((inode - 1) % inodesPerGroup()) * inodeSize();
+    blockIndex = bgd.bg_inode_table + (offset >> EXT2_BLOCK_SIZE_BITS(&superBlock));
+    offset &= blockSize() - 1;
+
+    return readBlock(blockIndex);
+}
+
+OwnPtr<ext2_inode> Ext2FileSystem::lookupExt2Inode(unsigned inode) const
+{
+    unsigned blockIndex;
+    unsigned offset;
+    auto block = readBlockContainingInode(inode, blockIndex, offset);
+
+    if (!block)
+        return nullptr;
+
+    auto* e2inode = reinterpret_cast<ext2_inode*>(kmalloc(inodeSize()));
+    memcpy(e2inode, reinterpret_cast<ext2_inode*>(block.offsetPointer(offset)), inodeSize());
+#ifdef EXT2_DEBUG
+    dumpExt2Inode(*e2inode);
+#endif
+
+    return OwnPtr<ext2_inode>(e2inode);
+}
+
+InodeMetadata Ext2FileSystem::inodeMetadata(InodeIdentifier inode) const
+{
+    ASSERT(inode.fileSystemID() == id());
+
+    auto e2inode = lookupExt2Inode(inode.index());
+    if (!e2inode)
+        return InodeMetadata();
+
+    InodeMetadata metadata;
+    metadata.inode = inode;
+    metadata.size = e2inode->i_size;
+    metadata.mode = e2inode->i_mode;
+    metadata.uid = e2inode->i_uid;
+    metadata.gid = e2inode->i_gid;
+    metadata.linkCount = e2inode->i_links_count;
+    metadata.atime = e2inode->i_atime;
+    metadata.ctime = e2inode->i_ctime;
+    metadata.mtime = e2inode->i_mtime;
+    metadata.dtime = e2inode->i_dtime;
+    return metadata;
+}
+
+Vector<unsigned> Ext2FileSystem::blockListForInode(const ext2_inode& e2inode) const
+{
+    unsigned entriesPerBlock = EXT2_ADDR_PER_BLOCK(&superBlock());
+
+    // NOTE: i_blocks is number of 512-byte blocks, not number of fs-blocks.
+    unsigned blockCount = e2inode.i_blocks / (blockSize() / 512);
+    unsigned blocksRemaining = blockCount;
+    Vector<unsigned> list;
+    list.ensureCapacity(blocksRemaining);
+
+    unsigned directCount = min(blockCount, (unsigned)EXT2_NDIR_BLOCKS);
+    for (unsigned i = 0; i < directCount; ++i) {
+        list.append(e2inode.i_block[i]);
+        --blocksRemaining;
+    }
+
+    if (!blocksRemaining)
+        return list;
+
+    auto processBlockArray = [&] (unsigned arrayBlockIndex, std::function<void(unsigned)> callback) {
+        auto arrayBlock = readBlock(arrayBlockIndex);
+        ASSERT(arrayBlock);
+        auto* array = reinterpret_cast<const __u32*>(arrayBlock.pointer());
+        unsigned count = min(blocksRemaining, entriesPerBlock);
+        for (unsigned i = 0; i < count; ++i) {
+            if (!array[i]) {
+                blocksRemaining = 0;
+                return;
+            }
+            callback(array[i]);
+            --blocksRemaining;
+        }
+    };
+
+    processBlockArray(e2inode.i_block[EXT2_IND_BLOCK], [&] (unsigned entry) {
+        list.append(entry);
+    });
+
+    if (!blocksRemaining)
+        return list;
+
+    processBlockArray(e2inode.i_block[EXT2_DIND_BLOCK], [&] (unsigned entry) {
+        processBlockArray(entry, [&] (unsigned entry) {
+            list.append(entry);
+        });
+    });
+
+    if (!blocksRemaining)
+        return list;
+
+    processBlockArray(e2inode.i_block[EXT2_TIND_BLOCK], [&] (unsigned entry) {
+        processBlockArray(entry, [&] (unsigned entry) {
+            processBlockArray(entry, [&] (unsigned entry) {
+                list.append(entry);
+            });
+        });
+    });
+
+    return list;
+}
+
+ByteBuffer Ext2FileSystem::readInode(InodeIdentifier inode) const
+{
+    ASSERT(inode.fileSystemID() == id());
+
+    auto e2inode = lookupExt2Inode(inode.index());
+    if (!e2inode) {
+        printf("[ext2fs] readInode: metadata lookup for inode %u failed\n", inode.index());
+        return nullptr;
+    }
+
+    // Symbolic links shorter than 60 characters are store inline inside the i_block array.
+    // This avoids wasting an entire block on short links. (Most links are short.)
+    static const unsigned maxInlineSymlinkLength = 60;
+    if (isSymbolicLink(e2inode->i_mode) && e2inode->i_size < maxInlineSymlinkLength) {
+        auto inlineSymlink = ByteBuffer::createUninitialized(e2inode->i_size);
+        memcpy(inlineSymlink.pointer(), e2inode->i_block, e2inode->i_size);
+        return inlineSymlink;
+    }
+
+    auto list = blockListForInode(*e2inode);
+    if (list.isEmpty()) {
+        printf("[ext2fs] readInode: empty block list for inode %u\n", inode.index());
+        return nullptr;
+    }
+
+    auto contents = ByteBuffer::createUninitialized(list.size() * blockSize());
+    auto* out = contents.pointer();
+
+    for (unsigned i = 0; i < list.size(); ++i) {
+        auto block = readBlock(list[i]);
+        if (!block) {
+            printf("[ext2fs] readInode: readBlock(%u) failed\n", list[i]);
+            return nullptr;
+        }
+        memcpy(out, block.pointer(), block.size());
+        out += blockSize();
+    }
+
+#ifdef EXT2_DEBUG
+    printf("trim from %u to %u\n", contents.size(), e2inode->i_size);
+#endif
+    contents.trim(e2inode->i_size);
+    return contents;
+}
+
+bool Ext2FileSystem::writeInode(InodeIdentifier inode, const ByteBuffer& data)
+{
+    ASSERT(inode.fileSystemID() == id());
+
+    auto e2inode = lookupExt2Inode(inode.index());
+    if (!e2inode) {
+        printf("[ext2fs] writeInode: metadata lookup for inode %u failed\n", inode.index());
+        return false;
+    }
+
+    // FIXME: Support writing to symlink inodes.
+    ASSERT(!isSymbolicLink(e2inode->i_mode));
+
+    unsigned blocksNeededBefore = ceilDiv(e2inode->i_size, blockSize());
+    unsigned blocksNeededAfter = ceilDiv(data.size(), blockSize());
+
+    // FIXME: Support growing or shrinking the block list.
+    ASSERT(blocksNeededBefore == blocksNeededAfter);
+
+    auto list = blockListForInode(*e2inode);
+    if (list.isEmpty()) {
+        printf("[ext2fs] writeInode: empty block list for inode %u\n", inode.index());
+        return false;
+    }
+
+    for (unsigned i = 0; i < list.size(); ++i) {
+        auto section = data.slice(i * blockSize(), blockSize());
+        printf("section = %p (%u)\n", section.pointer(), section.size());
+        bool success = writeBlock(list[i], section);
+        ASSERT(success);
+    }
+
+    return true;
+}
+
+bool Ext2FileSystem::enumerateDirectoryInode(InodeIdentifier inode, std::function<bool(const DirectoryEntry&)> callback) const
+{
+    ASSERT(inode.fileSystemID() == id());
+    ASSERT(isDirectoryInode(inode.index()));
+
+#ifdef EXT2_DEBUG
+    printf("[ext2fs] Enumerating directory contents of inode %u:\n", inode.index());
+#endif
+
+    auto buffer = readInode(inode);
+    ASSERT(buffer);
+    auto* entry = reinterpret_cast<ext2_dir_entry_2*>(buffer.pointer());
+
+    char namebuf[EXT2_NAME_LEN + 1];
+
+    while (entry < buffer.endPointer()) {
+        if (entry->inode != 0) {
+            memcpy(namebuf, entry->name, entry->name_len);
+            namebuf[entry->name_len] = 0;
+#ifdef EXT2_DEBUG
+            printf("inode: %u, name_len: %u, rec_len: %u, name: %s\n", entry->inode, entry->name_len, entry->rec_len, namebuf);
+#endif
+            if (!callback({ namebuf, { id(), entry->inode }, entry->file_type }))
+                break;
+        }
+        entry = (ext2_dir_entry_2*)((char*)entry + entry->rec_len);
+    }
+    return true;
+}
+
+bool Ext2FileSystem::addInodeToDirectory(unsigned directoryInode, unsigned inode, const String& name)
+{
+    auto e2inodeForDirectory = lookupExt2Inode(directoryInode);
+    ASSERT(e2inodeForDirectory);
+    ASSERT(isDirectory(e2inodeForDirectory->i_mode));
+
+//#ifdef EXT2_DEBUG
+    printf("[ext2fs] Adding inode %u with name '%s' to directory %u\n", inode, name.characters(), directoryInode);
+//#endif
+
+    Vector<DirectoryEntry> entries;
+    bool nameAlreadyExists = false;
+    enumerateDirectoryInode({ id(), directoryInode }, [&] (const DirectoryEntry& entry) {
+        if (entry.name == name) {
+            nameAlreadyExists = true;
+            return false;
+        }
+        entries.append(entry);
+        return true;
+    });
+    if (nameAlreadyExists) {
+        printf("[ext2fs] Name '%s' already exists in directory inode %u\n", name.characters(), directoryInode);
+        return false;
+    }
+
+    entries.append({ name, { id(), inode } });
+
+    return writeDirectoryInode(directoryInode, std::move(entries));
+}
+
+class BufferStream {
+public:
+    explicit BufferStream(ByteBuffer& buffer)
+        : m_buffer(buffer)
+    {
+    }
+
+    void operator<<(byte value)
+    {
+        m_buffer[m_offset++] = value & 0xffu;
+    }
+
+    void operator<<(word value)
+    {
+        m_buffer[m_offset++] = value & 0xffu;
+        m_buffer[m_offset++] = (byte)(value >> 8) & 0xffu;
+    }
+
+    void operator<<(dword value)
+    {
+        m_buffer[m_offset++] = value & 0xffu;
+        m_buffer[m_offset++] = (byte)(value >> 8) & 0xffu;
+        m_buffer[m_offset++] = (byte)(value >> 16) & 0xffu;
+        m_buffer[m_offset++] = (byte)(value >> 24) & 0xffu;
+    }
+
+    void operator<<(const String& value)
+    {
+        for (unsigned i = 0; i < value.length(); ++i)
+            m_buffer[m_offset++] = value[i];
+    }
+
+    void fillToEnd(byte ch)
+    {
+        while (m_offset < m_buffer.size())
+            m_buffer[m_offset++] = ch;
+    }
+
+private:
+    ByteBuffer& m_buffer;
+    size_t m_offset { 0 };
+};
+
+bool Ext2FileSystem::writeDirectoryInode(unsigned directoryInode, Vector<DirectoryEntry>&& entries)
+{
+    printf("[ext2fs] New directory inode %u contents to write:\n", directoryInode);
+
+    unsigned directorySize = 0;
+    for (auto& entry : entries) {
+        printf("  - %08u %s\n", entry.inode.index(), entry.name.characters());
+        directorySize += EXT2_DIR_REC_LEN(entry.name.length());
+    }
+
+    unsigned blocksNeeded = ceilDiv(directorySize, blockSize());
+    unsigned occupiedSize = blocksNeeded * blockSize();
+
+    printf("[ext2fs] directory size: %u (occupied: %u)\n", directorySize, occupiedSize);
+
+    auto directoryData = ByteBuffer::createUninitialized(occupiedSize);
+
+    BufferStream stream(directoryData);
+    for (unsigned i = 0; i < entries.size(); ++i) {
+        auto& entry = entries[i];
+
+        unsigned recordLength = EXT2_DIR_REC_LEN(entry.name.length());
+        if (i == entries.size() - 1)
+            recordLength += occupiedSize - directorySize;
+
+        printf("* inode: %u", entry.inode.index());
+        printf(", name_len: %u", word(entry.name.length()));
+        printf(", rec_len: %u", word(recordLength));
+        printf(", name: %s\n", entry.name.characters());
+
+        stream << dword(entry.inode.index());
+        stream << word(recordLength);
+        stream << byte(entry.name.length());
+        stream << byte(entry.fileType);
+        stream << entry.name;
+
+        unsigned padding = recordLength - entry.name.length() - 8;
+        printf("  *** pad %u bytes\n", padding);
+        for (unsigned j = 0; j < padding; ++j) {
+            stream << byte(0);
+        }
+    }
+
+    stream.fillToEnd(0);
+
+#if 0
+    printf("data to write (%u):\n", directoryData.size());
+    for (unsigned i = 0; i < directoryData.size(); ++i) {
+        printf("%02x ", directoryData[i]);
+        if ((i + 1) % 8 == 0)
+            printf(" ");
+        if ((i + 1) % 16 == 0)
+            printf("\n");
+    }
+    printf("\n");
+#endif
+
+    writeInode({ id(), directoryInode }, directoryData);
+
+    return true;
+}
+
+unsigned Ext2FileSystem::inodesPerBlock() const
+{
+    return EXT2_INODES_PER_BLOCK(&superBlock());
+}
+
+unsigned Ext2FileSystem::inodesPerGroup() const
+{
+    return EXT2_INODES_PER_GROUP(&superBlock());
+}
+
+unsigned Ext2FileSystem::inodeSize() const
+{
+    return EXT2_INODE_SIZE(&superBlock());
+
+}
+unsigned Ext2FileSystem::blocksPerGroup() const
+{
+    return EXT2_BLOCKS_PER_GROUP(&superBlock());
+}
+
+void Ext2FileSystem::dumpBlockBitmap(unsigned groupIndex) const
+{
+    ASSERT(groupIndex <= m_blockGroupCount);
+    auto& bgd = blockGroupDescriptor(groupIndex);
+
+    unsigned blocksInGroup = min(blocksPerGroup(), superBlock().s_blocks_count);
+    unsigned blockCount = ceilDiv(blocksInGroup, 8u);
+
+    auto bitmapBlocks = readBlocks(bgd.bg_block_bitmap, blockCount);
+    ASSERT(bitmapBlocks);
+
+    printf("[ext2fs] group[%u] block bitmap (bitmap occupies %u blocks):\n", groupIndex, blockCount);
+
+    auto bitmap = Bitmap::wrap(bitmapBlocks.pointer(), blocksInGroup);
+    for (unsigned i = 0; i < blocksInGroup; ++i) {
+        printf("%c", bitmap.get(i) ? '1' : '0');
+    }
+    printf("\n");
+}
+
+void Ext2FileSystem::dumpInodeBitmap(unsigned groupIndex) const
+{
+    traverseInodeBitmap(groupIndex, [] (unsigned, const Bitmap& bitmap) {
+        for (unsigned i = 0; i < bitmap.size(); ++i)
+            printf("%c", bitmap.get(i) ? '1' : '0');
+        return true;
+    });
+}
+
+template<typename F>
+void Ext2FileSystem::traverseInodeBitmap(unsigned groupIndex, F callback) const
+{
+    ASSERT(groupIndex <= m_blockGroupCount);
+    auto& bgd = blockGroupDescriptor(groupIndex);
+
+    unsigned inodesInGroup = min(inodesPerGroup(), superBlock().s_inodes_count);
+    unsigned blockCount = ceilDiv(inodesInGroup, 8u);
+
+    for (unsigned i = 0; i < blockCount; ++i) {
+        auto block = readBlock(bgd.bg_inode_bitmap + i);
+        ASSERT(block);
+        bool shouldContinue = callback(i * (blockSize() / 8), Bitmap::wrap(block.pointer(), inodesInGroup));
+        if (!shouldContinue)
+            break;
+    }
+}
+
+bool Ext2FileSystem::setModificationTime(InodeIdentifier inode, dword timestamp)
+{
+    ASSERT(inode.fileSystemID() == id());
+
+    auto e2inode = lookupExt2Inode(inode.index());
+    if (!e2inode)
+        return false;
+
+    printf("changing inode %u mtime from %u to %u\n", inode.index(), e2inode->i_mtime, timestamp);
+    e2inode->i_mtime = timestamp;
+
+    return writeExt2Inode(inode.index(), *e2inode);
+}
+
+bool Ext2FileSystem::writeExt2Inode(unsigned inode, const ext2_inode& e2inode)
+{
+    unsigned blockIndex;
+    unsigned offset;
+    auto block = readBlockContainingInode(inode, blockIndex, offset);
+    if (!block)
+        return false;
+    memcpy(reinterpret_cast<ext2_inode*>(block.offsetPointer(offset)), &e2inode, inodeSize());
+    writeBlock(blockIndex, block);
+    return true;
+}
+
+bool Ext2FileSystem::isDirectoryInode(unsigned inode) const
+{
+    if (auto e2inode = lookupExt2Inode(inode))
+        return isDirectory(e2inode->i_mode);
+    return false;
+}
+
+unsigned Ext2FileSystem::allocateInode(unsigned preferredGroup, unsigned expectedSize)
+{
+    printf("[ext2fs] allocateInode(preferredGroup: %u, expectedSize: %u)\n", preferredGroup, expectedSize);
+
+    unsigned neededBlocks = ceilDiv(expectedSize, blockSize());
+
+    printf("[ext2fs] minimum needed blocks: %u\n", neededBlocks);
+
+    unsigned groupIndex = 0;
+
+    auto isSuitableGroup = [this, neededBlocks] (unsigned groupIndex) {
+        auto& bgd = blockGroupDescriptor(groupIndex);
+        return bgd.bg_free_inodes_count && bgd.bg_free_blocks_count >= neededBlocks;
+    };
+
+    if (preferredGroup && isSuitableGroup(preferredGroup)) {
+        groupIndex = preferredGroup;
+    } else {
+        for (unsigned i = 1; i <= m_blockGroupCount; ++i) {
+            if (isSuitableGroup(i))
+                groupIndex = i;
+        }
+    }
+
+    if (!groupIndex) {
+        printf("[ext2fs] allocateInode: no suitable group found for new inode with %u blocks needed :(\n", neededBlocks);
+        return 0;
+    }
+
+    printf("[ext2fs] allocateInode: found suitable group [%u] for new inode with %u blocks needed :^)\n", groupIndex, neededBlocks);
+
+    unsigned firstFreeInodeInGroup = 0;
+    traverseInodeBitmap(groupIndex, [&firstFreeInodeInGroup] (unsigned firstInodeInBitmap, const Bitmap& bitmap) {
+        for (unsigned i = 0; i < bitmap.size(); ++i) {
+            if (!bitmap.get(i)) {
+                firstFreeInodeInGroup = firstInodeInBitmap + i;
+                return false;
+            }
+        }
+        return true;
+    });
+
+    if (!firstFreeInodeInGroup) {
+        printf("[ext2fs] firstFreeInodeInGroup returned no inode, despite bgd claiming there are inodes :(\n");
+        return 0;
+    }
+
+    unsigned inode = firstFreeInodeInGroup;
+    printf("[ext2fs] found suitable inode %u\n", inode);
+
+    // FIXME: allocate blocks if needed!
+
+    return inode;
+}
+
+unsigned Ext2FileSystem::groupIndexFromInode(unsigned inode) const
+{
+    if (!inode)
+        return 0;
+    return (inode - 1) / inodesPerGroup() + 1;
+}
+
+bool Ext2FileSystem::setInodeAllocationState(unsigned inode, bool newState)
+{
+    auto& bgd = blockGroupDescriptor(groupIndexFromInode(inode));
+
+    // Update inode bitmap
+    unsigned inodesPerBitmapBlock = blockSize() * 8;
+    unsigned bitmapBlockIndex = (inode - 1) / inodesPerBitmapBlock;
+    unsigned bitIndex = (inode - 1) % inodesPerBitmapBlock;
+    auto block = readBlock(bgd.bg_inode_bitmap + bitmapBlockIndex);
+    ASSERT(block);
+    auto bitmap = Bitmap::wrap(block.pointer(), block.size());
+    bool currentState = bitmap.get(bitIndex);
+    printf("[ext2fs] setInodeAllocationState(%u) %u -> %u\n", inode, currentState, newState);
+
+    if (currentState == newState)
+        return true;
+
+    bitmap.set(bitIndex, newState);
+    writeBlock(bgd.bg_inode_bitmap + bitmapBlockIndex, block);
+
+    // Update superblock
+    auto& sb = *reinterpret_cast<ext2_super_block*>(m_cachedSuperBlock.pointer());
+    printf("[ext2fs] superblock free inode count %u -> %u\n", sb.s_free_inodes_count, sb.s_free_inodes_count - 1);
+    if (newState)
+        --sb.s_free_inodes_count;
+    else
+        ++sb.s_free_inodes_count;
+    writeSuperBlock(sb);
+
+    // Update BGD
+    auto& mutableBGD = const_cast<ext2_group_desc&>(bgd);
+    if (newState)
+        --mutableBGD.bg_free_inodes_count;
+    else
+        ++mutableBGD.bg_free_inodes_count;
+    printf("[ext2fs] group free inode count %u -> %u\n", bgd.bg_free_inodes_count, bgd.bg_free_inodes_count - 1);
+
+    unsigned blocksToWrite = ceilDiv(m_blockGroupCount * sizeof(ext2_group_desc), blockSize());
+    unsigned firstBlockOfBGDT = blockSize() == 1024 ? 2 : 1;
+    writeBlocks(firstBlockOfBGDT, blocksToWrite, m_cachedBlockGroupDescriptorTable);
+    
+    return true;
+}
+
+InodeIdentifier Ext2FileSystem::createInode(InodeIdentifier parentInode, const String& name, word mode)
+{
+    ASSERT(parentInode.fileSystemID() == id());
+    ASSERT(isDirectoryInode(parentInode.index()));
+
+//#ifdef EXT2_DEBUG
+    printf("[ext2fs] Adding inode '%s' (mode %o) to parent directory %u:\n", name.characters(), mode, parentInode.index());
+//#endif
+
+    // NOTE: This doesn't commit the inode allocation just yet!
+    auto inode = allocateInode(0, 0);
+
+    // Try adding it to the directory first, in case the name is already in use.
+    bool success = addInodeToDirectory(parentInode.index(), inode, name);
+    if (!success) {
+        printf("[ext2fs] failed to add inode to directory :(\n");
+        return { };
+    }
+
+    // Looks like we're good, time to update the inode bitmap and group+global inode counters.
+    success = setInodeAllocationState(inode, true);
+    ASSERT(success);
+
+    auto timestamp = time(nullptr);
+    auto e2inode = make<ext2_inode>();
+    memset(e2inode.ptr(), 0, sizeof(ext2_inode));
+    e2inode->i_mode = mode;
+    e2inode->i_uid = 0;
+    e2inode->i_size = 0;
+    e2inode->i_atime = timestamp;
+    e2inode->i_ctime = timestamp;
+    e2inode->i_mtime = timestamp;
+    e2inode->i_dtime = 0;
+    e2inode->i_gid = 0;
+    e2inode->i_links_count = 2;
+    e2inode->i_blocks = 0;
+    e2inode->i_flags = 0;
+    success = writeExt2Inode(inode, *e2inode);
+    ASSERT(success);
+
+    return { id(), inode };
+}
+
diff --git a/VirtualFileSystem/Ext2FileSystem.h b/VirtualFileSystem/Ext2FileSystem.h
new file mode 100644
index 00000000000..97c7ae23ee3
--- /dev/null
+++ b/VirtualFileSystem/Ext2FileSystem.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include "DeviceBackedFileSystem.h"
+#include <AK/Buffer.h>
+#include <AK/OwnPtr.h>
+
+struct ext2_group_desc;
+struct ext2_inode;
+struct ext2_super_block;
+
+class Ext2FileSystem final : public DeviceBackedFileSystem {
+public:
+    static RetainPtr<Ext2FileSystem> create(RetainPtr<BlockDevice>);
+    virtual ~Ext2FileSystem() override;
+
+private:
+    explicit Ext2FileSystem(RetainPtr<BlockDevice>);
+
+    const ext2_super_block& superBlock() const;
+    const ext2_group_desc& blockGroupDescriptor(unsigned groupIndex) const;
+    unsigned firstBlockOfGroup(unsigned groupIndex) const;
+    unsigned inodesPerBlock() const;
+    unsigned inodesPerGroup() const;
+    unsigned blocksPerGroup() const;
+    unsigned inodeSize() const;
+
+    OwnPtr<ext2_inode> lookupExt2Inode(unsigned) const;
+    bool writeExt2Inode(unsigned, const ext2_inode&);
+    ByteBuffer readBlockContainingInode(unsigned inode, unsigned& blockIndex, unsigned& offset) const;
+
+    ByteBuffer readSuperBlock() const;
+    bool writeSuperBlock(const ext2_super_block&);
+
+    virtual bool initialize() override;
+    virtual const char* className() const override;
+    virtual InodeIdentifier rootInode() const override;
+    virtual ByteBuffer readInode(InodeIdentifier) const override;
+    virtual bool writeInode(InodeIdentifier, const ByteBuffer&) override;
+    virtual bool enumerateDirectoryInode(InodeIdentifier, std::function<bool(const DirectoryEntry&)>) const override;
+    virtual InodeMetadata inodeMetadata(InodeIdentifier) const override;
+    virtual bool setModificationTime(InodeIdentifier, dword timestamp) override;
+    virtual InodeIdentifier createInode(InodeIdentifier parentInode, const String& name, word mode) override;
+
+    bool isDirectoryInode(unsigned) const;
+    unsigned allocateInode(unsigned preferredGroup, unsigned expectedSize);
+    unsigned groupIndexFromInode(unsigned) const;
+
+    Vector<unsigned> blockListForInode(const ext2_inode&) const;
+
+    void dumpBlockBitmap(unsigned groupIndex) const;
+    void dumpInodeBitmap(unsigned groupIndex) const;
+
+    template<typename F>
+    void traverseInodeBitmap(unsigned groupIndex, F) const;
+
+    bool addInodeToDirectory(unsigned directoryInode, unsigned inode, const String& name);
+    bool writeDirectoryInode(unsigned directoryInode, Vector<DirectoryEntry>&&);
+    bool setInodeAllocationState(unsigned inode, bool);
+
+    unsigned m_blockGroupCount { 0 };
+
+    mutable ByteBuffer m_cachedSuperBlock;
+    mutable ByteBuffer m_cachedBlockGroupDescriptorTable;
+};
+
diff --git a/VirtualFileSystem/FileBackedBlockDevice.cpp b/VirtualFileSystem/FileBackedBlockDevice.cpp
new file mode 100644
index 00000000000..ddf8bdb543f
--- /dev/null
+++ b/VirtualFileSystem/FileBackedBlockDevice.cpp
@@ -0,0 +1,82 @@
+#define _FILE_OFFSET_BITS 64
+
+#include "FileBackedBlockDevice.h"
+#include <cstring>
+#include <sys/stat.h>
+
+//#define FBBD_DEBUG
+#define IGNORE_FILE_LENGTH // Useful for e.g /dev/hda2
+
+RetainPtr<FileBackedBlockDevice> FileBackedBlockDevice::create(String&& imagePath, unsigned blockSize)
+{
+    return adopt(*new FileBackedBlockDevice(std::move(imagePath), blockSize));
+}
+
+FileBackedBlockDevice::FileBackedBlockDevice(String&& imagePath, unsigned blockSize)
+    : m_imagePath(std::move(imagePath))
+    , m_blockSize(blockSize)
+{
+    struct stat st;
+    int result = stat(m_imagePath.characters(), &st);
+    ASSERT(result != -1);
+    m_fileLength = st.st_size;
+    m_file = fopen(m_imagePath.characters(), "r+");
+}
+
+FileBackedBlockDevice::~FileBackedBlockDevice()
+{
+}
+
+unsigned FileBackedBlockDevice::blockSize() const
+{
+    return m_blockSize;
+}
+
+bool FileBackedBlockDevice::readBlock(unsigned index, byte* out) const
+{
+    qword offset = index * m_blockSize;
+    return read(offset, blockSize(), out);
+}
+
+bool FileBackedBlockDevice::writeBlock(unsigned index, const byte* data)
+{
+    qword offset = index * m_blockSize;
+    return write(offset, blockSize(), data);
+}
+
+bool FileBackedBlockDevice::read(qword offset, unsigned length, byte* out) const
+{
+#ifndef IGNORE_FILE_LENGTH
+    if (offset + length >= m_fileLength)
+        return false;
+#endif
+#ifdef FBBD_DEBUG
+    printf("[FileBackedBlockDevice] Read device @ offset %llx, length %u\n", offset, length);
+#endif
+    fseeko(m_file, offset, SEEK_SET);
+    unsigned nread = fread(out, sizeof(byte), length, m_file);
+    ASSERT(nread == length);
+    return true;
+}
+
+bool FileBackedBlockDevice::write(qword offset, unsigned length, const byte* data)
+{
+#ifndef IGNORE_FILE_LENGTH
+    if (offset + length >= m_fileLength)
+        return false;
+#endif
+#ifdef FBBD_DEBUG
+    printf("[FileBackedBlockDevice] Write device @ offset %llx, length %u\n", offset, length);
+#endif
+    fseeko(m_file, offset, SEEK_SET);
+    // size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
+    unsigned nwritten = fwrite(data, sizeof(byte), length, m_file);
+    ASSERT(nwritten == length);
+    return true;
+}
+
+const char* FileBackedBlockDevice::className() const
+{
+    return "FileBackedBlockDevice";
+}
+
diff --git a/VirtualFileSystem/FileBackedBlockDevice.h b/VirtualFileSystem/FileBackedBlockDevice.h
new file mode 100644
index 00000000000..dd1d81083f6
--- /dev/null
+++ b/VirtualFileSystem/FileBackedBlockDevice.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "BlockDevice.h"
+#include <AK/RetainPtr.h>
+#include <AK/String.h>
+#include <AK/Types.h>
+#include <stdio.h>
+
+class FileBackedBlockDevice final : public BlockDevice {
+public:
+    static RetainPtr<FileBackedBlockDevice> create(String&& imagePath, unsigned blockSize);
+    virtual ~FileBackedBlockDevice() override;
+
+    bool isValid() const { return m_file; }
+
+    virtual unsigned blockSize() const override;
+    virtual bool readBlock(unsigned index, byte* out) const override;
+    virtual bool writeBlock(unsigned index, const byte*) override;
+    virtual bool read(qword offset, unsigned length, byte* out) const override;
+    virtual bool write(qword offset, unsigned length, const byte* data) override;
+
+private:
+    virtual const char* className() const override;
+
+    FileBackedBlockDevice(String&& imagePath, unsigned blockSize);
+
+    String m_imagePath;
+    FILE* m_file { nullptr };
+    qword m_fileLength { 0 };
+    unsigned m_blockSize { 0 };
+};
+
diff --git a/VirtualFileSystem/FileHandle.cpp b/VirtualFileSystem/FileHandle.cpp
new file mode 100644
index 00000000000..46760d9471a
--- /dev/null
+++ b/VirtualFileSystem/FileHandle.cpp
@@ -0,0 +1,17 @@
+#include "FileHandle.h"
+#include "FileSystem.h"
+
+FileHandle::FileHandle(RetainPtr<VirtualFileSystem::Node>&& vnode)
+    : m_vnode(std::move(vnode))
+{
+}
+
+FileHandle::~FileHandle()
+{
+}
+
+ByteBuffer FileHandle::read() const
+{
+    return m_vnode->fileSystem()->readInode(m_vnode->inode);
+}
+
diff --git a/VirtualFileSystem/FileHandle.h b/VirtualFileSystem/FileHandle.h
new file mode 100644
index 00000000000..b51c14b62a5
--- /dev/null
+++ b/VirtualFileSystem/FileHandle.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "VirtualFileSystem.h"
+#include <AK/ByteBuffer.h>
+
+class FileHandle {
+public:
+    explicit FileHandle(RetainPtr<VirtualFileSystem::Node>&&);
+    ~FileHandle();
+
+    ByteBuffer read() const;
+
+private:
+    friend class VirtualFileSystem;
+
+    RetainPtr<VirtualFileSystem::Node> m_vnode;
+};
+
diff --git a/VirtualFileSystem/FileSystem.cpp b/VirtualFileSystem/FileSystem.cpp
new file mode 100644
index 00000000000..4deada69727
--- /dev/null
+++ b/VirtualFileSystem/FileSystem.cpp
@@ -0,0 +1,45 @@
+#include <AK/Assertions.h>
+#include <AK/HashMap.h>
+#include "FileSystem.h"
+
+static dword s_lastFileSystemID = 0;
+
+static HashMap<dword, FileSystem*>& fileSystems()
+{
+    static auto* map = new HashMap<dword, FileSystem*>();
+    return *map;
+}
+
+FileSystem::FileSystem()
+    : m_id(++s_lastFileSystemID)
+{
+    fileSystems().set(m_id, this);
+}
+
+FileSystem::~FileSystem()
+{
+    // FIXME: Needs HashMap::remove()!
+    //fileSystems().remove(m_id);
+}
+
+FileSystem* FileSystem::fromID(dword id)
+{
+    auto it = fileSystems().find(id);
+    if (it != fileSystems().end())
+        return (*it).value;
+    return nullptr;
+}
+
+InodeIdentifier FileSystem::childOfDirectoryInodeWithName(InodeIdentifier inode, const String& name)
+{
+    InodeIdentifier foundInode;
+    enumerateDirectoryInode(inode, [&] (const DirectoryEntry& entry) {
+        if (entry.name == name) {
+            foundInode = entry.inode;
+            return false;
+        }
+        return true;
+    });
+    return foundInode;
+}
+
diff --git a/VirtualFileSystem/FileSystem.h b/VirtualFileSystem/FileSystem.h
new file mode 100644
index 00000000000..9c9548d7882
--- /dev/null
+++ b/VirtualFileSystem/FileSystem.h
@@ -0,0 +1,81 @@
+#pragma once
+
+#include "BlockDevice.h"
+#include "InodeIdentifier.h"
+#include "InodeMetadata.h"
+#include <AK/ByteBuffer.h>
+#include <AK/HashMap.h>
+#include <AK/OwnPtr.h>
+#include <AK/Retainable.h>
+#include <AK/RetainPtr.h>
+#include <AK/String.h>
+#include <functional>
+
+static const dword mepoch = 476763780;
+
+class FileSystem : public Retainable<FileSystem> {
+public:
+    virtual ~FileSystem();
+
+    dword id() const { return m_id; }
+    static FileSystem* fromID(dword);
+
+    virtual bool initialize() = 0;
+    virtual const char* className() const = 0;
+    virtual InodeIdentifier rootInode() const = 0;
+    virtual ByteBuffer readInode(InodeIdentifier) const = 0;
+    virtual bool writeInode(InodeIdentifier, const ByteBuffer&) = 0;
+    virtual InodeMetadata inodeMetadata(InodeIdentifier) const = 0;
+
+    struct DirectoryEntry {
+        String name;
+        InodeIdentifier inode;
+        byte fileType { 0 };
+    };
+    virtual bool enumerateDirectoryInode(InodeIdentifier, std::function<bool(const DirectoryEntry&)>) const = 0;
+
+    virtual bool setModificationTime(InodeIdentifier, dword timestamp) = 0;
+    virtual InodeIdentifier createInode(InodeIdentifier parentInode, const String& name, word mode) = 0;
+
+    InodeIdentifier childOfDirectoryInodeWithName(InodeIdentifier, const String& name);
+
+protected:
+    FileSystem();
+
+private:
+    dword m_id { 0 };
+};
+
+inline FileSystem* InodeIdentifier::fileSystem()
+{
+    return FileSystem::fromID(m_fileSystemID);
+}
+
+inline const FileSystem* InodeIdentifier::fileSystem() const
+{
+    return FileSystem::fromID(m_fileSystemID);
+}
+
+inline InodeMetadata InodeIdentifier::metadata() const
+{
+    if (!isValid())
+        return InodeMetadata();
+    return fileSystem()->inodeMetadata(*this);
+}
+
+inline bool InodeIdentifier::isRootInode() const
+{
+    return (*this) == fileSystem()->rootInode();
+}
+
+namespace AK {
+
+template<>
+struct Traits<InodeIdentifier> {
+    // FIXME: This is a shitty hash.
+    static unsigned hash(const InodeIdentifier& inode) { return Traits<unsigned>::hash(inode.fileSystemID()) + Traits<unsigned>::hash(inode.index()); }
+    static void dump(const InodeIdentifier& inode) { printf("%02u:%08u", inode.fileSystemID(), inode.index()); }
+};
+
+}
+
diff --git a/VirtualFileSystem/InodeIdentifier.cpp b/VirtualFileSystem/InodeIdentifier.cpp
new file mode 100644
index 00000000000..787f039f1ff
--- /dev/null
+++ b/VirtualFileSystem/InodeIdentifier.cpp
@@ -0,0 +1,9 @@
+#include "InodeIdentifier.h"
+#include "FileSystem.h"
+
+ByteBuffer InodeIdentifier::readEntireFile() const
+{
+    if (!fileSystem())
+        return { };
+    return fileSystem()->readInode(*this);
+}
diff --git a/VirtualFileSystem/InodeIdentifier.h b/VirtualFileSystem/InodeIdentifier.h
new file mode 100644
index 00000000000..865b07f8384
--- /dev/null
+++ b/VirtualFileSystem/InodeIdentifier.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <AK/ByteBuffer.h>
+#include <AK/Types.h>
+
+class FileSystem;
+struct InodeMetadata;
+
+class InodeIdentifier {
+public:
+    InodeIdentifier() { }
+    InodeIdentifier(dword fileSystemID, dword inode)
+        : m_fileSystemID(fileSystemID)
+        , m_index(inode)
+    {
+    }
+
+    bool isValid() const { return m_fileSystemID != 0 && m_index != 0; }
+
+    dword fileSystemID() const { return m_fileSystemID; }
+    dword index() const { return m_index; }
+
+    FileSystem* fileSystem();
+    const FileSystem* fileSystem() const;
+
+    bool operator==(const InodeIdentifier& other) const
+    {
+        return m_fileSystemID == other.m_fileSystemID && m_index == other.m_index;
+    }
+
+    InodeMetadata metadata() const;
+    bool isRootInode() const;
+
+    ByteBuffer readEntireFile() const;
+
+private:
+    dword m_fileSystemID { 0 };
+    dword m_index { 0 };
+};
+
diff --git a/VirtualFileSystem/InodeMetadata.h b/VirtualFileSystem/InodeMetadata.h
new file mode 100644
index 00000000000..4bbf95483af
--- /dev/null
+++ b/VirtualFileSystem/InodeMetadata.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "InodeIdentifier.h"
+
+inline bool isDirectory(word mode) { return (mode & 0170000) == 0040000; }
+inline bool isCharacterDevice(word mode) { return (mode & 0170000) == 0020000; }
+inline bool isBlockDevice(word mode) { return (mode & 0170000) == 0060000; }
+inline bool isRegularFile(word mode) { return (mode & 0170000) == 0100000; }
+inline bool isFIFO(word mode) { return (mode & 0170000) == 0010000; }
+inline bool isSymbolicLink(word mode) { return (mode & 0170000) == 0120000; }
+inline bool isSocket(word mode) { return (mode & 0170000) == 0140000; }
+inline bool isSticky(word mode) { return mode & 01000; }
+inline bool isSetUID(word mode) { return mode & 04000; }
+inline bool isSetGID(word mode) { return mode & 02000; }
+
+struct InodeMetadata {
+    bool isValid() const { return inode.isValid(); }
+
+    bool isDirectory() const { return ::isDirectory(mode); }
+    bool isCharacterDevice() const { return ::isCharacterDevice(mode); }
+    bool isBlockDevice() const { return ::isBlockDevice(mode); }
+    bool isRegularFile() const { return ::isRegularFile(mode); }
+    bool isFIFO() const { return ::isFIFO(mode); }
+    bool isSymbolicLink() const { return ::isSymbolicLink(mode); }
+    bool isSocket() const { return ::isSocket(mode); }
+    bool isSticky() const { return ::isSticky(mode); }
+    bool isSetUID() const { return ::isSetUID(mode); }
+    bool isSetGID() const { return ::isSetGID(mode); }
+
+    InodeIdentifier inode;
+    dword size { 0 };
+    word mode { 0 };
+    dword uid { 0 };
+    dword gid { 0 };
+    dword linkCount { 0 };
+    time_t atime { 0 };
+    time_t ctime { 0 };
+    time_t mtime { 0 };
+    time_t dtime { 0 };
+};
+
+
diff --git a/VirtualFileSystem/Makefile b/VirtualFileSystem/Makefile
new file mode 100644
index 00000000000..dab96e0a2c8
--- /dev/null
+++ b/VirtualFileSystem/Makefile
@@ -0,0 +1,39 @@
+PROGRAM = test
+
+AK_OBJS = \
+    ../AK/String.o \
+    ../AK/StringImpl.o \
+    ../AK/MappedFile.o \
+    ../AK/TemporaryFile.o \
+    ../AK/SimpleMalloc.o \
+    ../AK/kmalloc.o
+
+VFS_OBJS = \
+    BlockDevice.o \
+    FileBackedBlockDevice.o \
+    FileSystem.o \
+    Ext2FileSystem.o \
+    VirtualFileSystem.o \
+    FileHandle.o \
+    DeviceBackedFileSystem.o \
+    SyntheticFileSystem.o \
+    InodeIdentifier.o \
+    test.o
+
+OBJS = $(AK_OBJS) $(VFS_OBJS)
+
+CXXFLAGS = -std=c++17 -Os -W -Wall -Wextra -Wconversion -I. -I.. -ggdb3 -Wno-class-memaccess
+
+#test.o: BlockDevice.h FileBackedBlockDevice.h FileSystem.h Ext2FileSystem.h VirtualFileSystem.h FileHandle.h
+
+all:	$(PROGRAM)
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) -o $@ -c $<
+
+clean:
+	rm -f $(OBJS) $(PROGRAM)
+
+$(PROGRAM): $(OBJS)
+	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
+
diff --git a/VirtualFileSystem/SyntheticFileSystem.cpp b/VirtualFileSystem/SyntheticFileSystem.cpp
new file mode 100644
index 00000000000..2d12eae04b1
--- /dev/null
+++ b/VirtualFileSystem/SyntheticFileSystem.cpp
@@ -0,0 +1,123 @@
+#include "SyntheticFileSystem.h"
+
+RetainPtr<SyntheticFileSystem> SyntheticFileSystem::create()
+{
+    return adopt(*new SyntheticFileSystem);
+}
+
+SyntheticFileSystem::SyntheticFileSystem()
+{
+}
+
+SyntheticFileSystem::~SyntheticFileSystem()
+{
+}
+
+bool SyntheticFileSystem::initialize()
+{
+    // Add a File for the root directory.
+    // FIXME: This needs work.
+    auto rootDir = make<File>();
+    rootDir->metadata.inode = { id(), 1 };
+    rootDir->metadata.mode = 0040555;
+    rootDir->metadata.uid = 0;
+    rootDir->metadata.gid = 0;
+    rootDir->metadata.size = 0;
+    rootDir->metadata.mtime = mepoch;
+    m_files.append(std::move(rootDir));
+
+    addFile(createTextFile("file", "I'm a synthetic file!\n"));
+    addFile(createTextFile("message", "Hey! This isn't my bottle!\n"));
+    return true;
+}
+
+auto SyntheticFileSystem::createTextFile(String&& name, String&& text) -> OwnPtr<File>
+{
+    auto file = make<File>();
+    file->data = text.toByteBuffer();
+    file->name = std::move(name);
+    file->metadata.size = file->data.size();
+    file->metadata.uid = 100;
+    file->metadata.gid = 200;
+    file->metadata.mode = 0100644;
+    file->metadata.mtime = mepoch;
+    return file;
+}
+
+void SyntheticFileSystem::addFile(OwnPtr<File>&& file)
+{
+    ASSERT(file);
+    file->metadata.inode = { id(), m_files.size() + 1 };
+    m_files.append(std::move(file));
+}
+
+const char* SyntheticFileSystem::className() const
+{
+    return "synthfs";
+}
+
+InodeIdentifier SyntheticFileSystem::rootInode() const
+{
+    return { id(), 1 };
+}
+
+ByteBuffer SyntheticFileSystem::readInode(InodeIdentifier inode) const
+{
+    ASSERT(inode.fileSystemID() == id());
+#ifdef SYNTHFS_DEBUG
+    printf("[synthfs] readInode %u\n", inode.index());
+#endif
+    ASSERT(inode.index() != 1);
+    ASSERT(inode.index() <= m_files.size());
+    return m_files[inode.index() - 1]->data;
+}
+
+bool SyntheticFileSystem::enumerateDirectoryInode(InodeIdentifier inode, std::function<bool(const DirectoryEntry&)> callback) const
+{
+    ASSERT(inode.fileSystemID() == id());
+#ifdef SYNTHFS_DEBUG
+    printf("[synthfs] enumerateDirectoryInode %u\n", inode.index());
+#endif
+    if (inode.index() != 1)
+        return false;
+
+    callback({ ".", m_files[0]->metadata.inode });
+    callback({ "..", m_files[0]->metadata.inode });
+
+    for (unsigned i = 1; i < m_files.size(); ++i)
+        callback({ m_files[i]->name, m_files[i]->metadata.inode });
+    return true;
+}
+
+InodeMetadata SyntheticFileSystem::inodeMetadata(InodeIdentifier inode) const
+{
+    ASSERT(inode.fileSystemID() == id());
+#ifdef SYNTHFS_DEBUG
+    printf("[synthfs] inodeMetadata(%u)\n", inode.index);
+#endif
+    if (inode.index() == 0 || inode.index() > m_files.size())
+        return InodeMetadata();
+    return m_files[inode.index() - 1]->metadata;
+}
+
+bool SyntheticFileSystem::setModificationTime(InodeIdentifier, dword timestamp)
+{
+    (void) timestamp;
+    printf("FIXME: Implement SyntheticFileSystem::setModificationTime().\n");
+    return false;
+}
+
+InodeIdentifier SyntheticFileSystem::createInode(InodeIdentifier parentInode, const String& name, word mode)
+{
+    (void) parentInode;
+    (void) name;
+    (void) mode;
+    printf("FIXME: Implement SyntheticFileSystem::createDirectoryInode().\n");
+    return { };
+}
+
+bool SyntheticFileSystem::writeInode(InodeIdentifier, const ByteBuffer&)
+{
+    printf("FIXME: Implement SyntheticFileSystem::writeInode().\n");
+    return false;
+}
diff --git a/VirtualFileSystem/SyntheticFileSystem.h b/VirtualFileSystem/SyntheticFileSystem.h
new file mode 100644
index 00000000000..76f7075de06
--- /dev/null
+++ b/VirtualFileSystem/SyntheticFileSystem.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "FileSystem.h"
+#include <AK/HashMap.h>
+
+class SyntheticFileSystem final : public FileSystem {
+public:
+    virtual ~SyntheticFileSystem() override;
+    static RetainPtr<SyntheticFileSystem> create();
+
+    virtual bool initialize() override;
+    virtual const char* className() const override;
+    virtual InodeIdentifier rootInode() const override;
+    virtual ByteBuffer readInode(InodeIdentifier) const override;
+    virtual bool writeInode(InodeIdentifier, const ByteBuffer&) override;
+    virtual bool enumerateDirectoryInode(InodeIdentifier, std::function<bool(const DirectoryEntry&)>) const override;
+    virtual InodeMetadata inodeMetadata(InodeIdentifier) const override;
+    virtual bool setModificationTime(InodeIdentifier, dword timestamp) override;
+    virtual InodeIdentifier createInode(InodeIdentifier parentInode, const String& name, word mode) override;
+
+private:
+    SyntheticFileSystem();
+
+    struct File {
+        String name;
+        InodeMetadata metadata;
+        ByteBuffer data;
+    };
+
+    OwnPtr<File> createTextFile(String&& name, String&& text);
+    void addFile(OwnPtr<File>&&);
+
+    Vector<OwnPtr<File>> m_files;
+};
+
diff --git a/VirtualFileSystem/VirtualFileSystem.cpp b/VirtualFileSystem/VirtualFileSystem.cpp
new file mode 100644
index 00000000000..288c93e3df3
--- /dev/null
+++ b/VirtualFileSystem/VirtualFileSystem.cpp
@@ -0,0 +1,408 @@
+#include "VirtualFileSystem.h"
+#include "FileHandle.h"
+#include "FileSystem.h"
+#include <cstdio>
+#include <cstdlib>
+#include "kmalloc.h"
+
+//#define VFS_DEBUG
+
+VirtualFileSystem::VirtualFileSystem()
+{
+    m_maxNodeCount = 16;
+    m_nodes = reinterpret_cast<Node*>(kmalloc(sizeof(Node) * maxNodeCount()));
+    memset(m_nodes, 0, sizeof(Node) * maxNodeCount());
+
+    for (unsigned i = 0; i < m_maxNodeCount; ++i)
+        m_nodeFreeList.append(&m_nodes[i]);
+}
+
+VirtualFileSystem::~VirtualFileSystem()
+{
+    printf("[VFS] ~VirtualFileSystem with %u nodes allocated\n", allocatedNodeCount());
+}
+
+auto VirtualFileSystem::makeNode(InodeIdentifier inode) -> RetainPtr<Node>
+{
+    auto metadata = inode.metadata();
+    if (!metadata.isValid())
+        return nullptr;
+
+    auto vnode = allocateNode();
+    ASSERT(vnode);
+
+    FileSystem* fileSystem = inode.fileSystem();
+    fileSystem->retain();
+
+    vnode->inode = inode;
+
+#ifdef VFS_DEBUG
+    printf("makeNode: inode=%u, size=%u, mode=%o, uid=%u, gid=%u\n", inode.index(), metadata.size, metadata.mode, metadata.uid, metadata.gid);
+#endif
+
+    m_inode2vnode.set(inode, vnode.ptr());
+    return vnode;
+}
+
+auto VirtualFileSystem::getOrCreateNode(InodeIdentifier inode) -> RetainPtr<Node>
+{
+    auto it = m_inode2vnode.find(inode);
+    if (it != m_inode2vnode.end())
+        return (*it).value;
+    return makeNode(inode);
+}
+
+bool VirtualFileSystem::mount(RetainPtr<FileSystem>&& fileSystem, const String& path)
+{
+    ASSERT(fileSystem);
+
+    auto inode = resolvePath(path);
+    if (!inode.isValid()) {
+        printf("[VFS] mount can't resolve mount point '%s'\n", path.characters());
+        return false;
+    }
+
+    printf("mounting %s{%p} at %s (inode: %u)\n", fileSystem->className(), fileSystem.ptr(), path.characters(), inode.index());
+    // FIXME: check that this is not already a mount point
+    auto mount = make<Mount>(inode, std::move(fileSystem));
+    m_mounts.append(std::move(mount));
+    return true;
+}
+
+bool VirtualFileSystem::mountRoot(RetainPtr<FileSystem>&& fileSystem)
+{
+    if (m_rootNode) {
+        printf("[VFS] mountRoot can't mount another root\n");
+        return false;
+    }
+
+    auto mount = make<Mount>(InodeIdentifier(), std::move(fileSystem));
+
+    auto node = makeNode(mount->guest());
+    if (!node->inUse()) {
+        printf("[VFS] root inode for / is not in use :(\n");
+        return false;
+    }
+    if (!node->inode.metadata().isDirectory()) {
+        printf("[VFS] root inode for / is not in use :(\n");
+        return false;
+    }
+
+    m_rootNode = std::move(node);
+
+    printf("[VFS] mountRoot mounted %s{%p}\n",
+        m_rootNode->fileSystem()->className(),
+        m_rootNode->fileSystem());
+
+    m_mounts.append(std::move(mount));
+    return true;
+}
+
+auto VirtualFileSystem::allocateNode() -> RetainPtr<Node>
+{
+    if (m_nodeFreeList.isEmpty()) {
+        printf("[VFS] allocateNode has no nodes left\n");
+        return nullptr;
+    }
+    auto* node = m_nodeFreeList.takeLast();
+    ASSERT(node->retainCount == 0);
+    node->retainCount = 1;
+    node->vfs = this;
+    return adopt(*node);
+}
+
+void VirtualFileSystem::freeNode(Node* node)
+{
+    ASSERT(node);
+    ASSERT(node->inUse());
+    node->inode.fileSystem()->release();
+    node->inode = InodeIdentifier();
+    m_nodeFreeList.append(std::move(node));
+    // FIXME: Need HashMap::remove.
+    //m_inode2vnode.remove(node);
+}
+
+bool VirtualFileSystem::isDirectory(const String& path)
+{
+    auto inode = resolvePath(path);
+    if (!inode.isValid())
+        return false;
+
+    return inode.metadata().isDirectory();
+}
+
+auto VirtualFileSystem::findMountForHost(InodeIdentifier inode) -> Mount*
+{
+    for (auto& mount : m_mounts) {
+        if (mount->host() == inode)
+            return mount.ptr();
+    }
+    return nullptr;
+}
+
+auto VirtualFileSystem::findMountForGuest(InodeIdentifier inode) -> Mount*
+{
+    for (auto& mount : m_mounts) {
+        if (mount->guest() == inode)
+            return mount.ptr();
+    }
+    return nullptr;
+}
+
+bool VirtualFileSystem::isRoot(InodeIdentifier inode) const
+{
+    return inode == m_rootNode->inode;
+}
+
+template<typename F>
+void VirtualFileSystem::enumerateDirectoryInode(InodeIdentifier directoryInode, F func)
+{
+    if (!directoryInode.isValid())
+        return;
+
+    directoryInode.fileSystem()->enumerateDirectoryInode(directoryInode, [&] (const FileSystem::DirectoryEntry& entry) {
+        InodeIdentifier resolvedInode;
+        if (auto mount = findMountForHost(entry.inode))
+            resolvedInode = mount->guest();
+        else
+            resolvedInode = entry.inode;
+
+        if (directoryInode.isRootInode() && !isRoot(directoryInode) && entry.name == "..") {
+            auto mount = findMountForGuest(entry.inode);
+            ASSERT(mount);
+            resolvedInode = mount->host();
+        }
+        func({ entry.name, resolvedInode });
+        return true;
+    });
+}
+
+void VirtualFileSystem::listDirectory(const String& path)
+{
+    auto directoryInode = resolvePath(path);
+    if (!directoryInode.isValid())
+        return;
+
+    printf("[VFS] ls %s -> %s %02u:%08u\n", path.characters(), directoryInode.fileSystem()->className(), directoryInode.fileSystemID(), directoryInode.index());
+    enumerateDirectoryInode(directoryInode, [&] (const FileSystem::DirectoryEntry& entry) {
+        const char* nameColorBegin = "";
+        const char* nameColorEnd = "";
+        auto metadata = entry.inode.metadata();
+        ASSERT(metadata.isValid());
+        if (metadata.isDirectory()) {
+            nameColorBegin = "\033[34;1m";
+            nameColorEnd = "\033[0m";
+        } else if (metadata.isSymbolicLink()) {
+            nameColorBegin = "\033[36;1m";
+            nameColorEnd = "\033[0m";
+        }
+        if (metadata.isSticky()) {
+            nameColorBegin = "\033[42;30m";
+            nameColorEnd = "\033[0m";
+        }
+        printf("%02u:%08u ",
+            metadata.inode.fileSystemID(),
+            metadata.inode.index());
+
+        if (metadata.isDirectory())
+            printf("d");
+        else if (metadata.isSymbolicLink())
+            printf("l");
+        else if (metadata.isBlockDevice())
+            printf("b");
+        else if (metadata.isCharacterDevice())
+            printf("c");
+        else if (metadata.isSocket())
+            printf("s");
+        else if (metadata.isFIFO())
+            printf("f");
+        else if (metadata.isRegularFile())
+            printf("-");
+        else
+            printf("?");
+
+        printf("%c%c%c%c%c%c%c%c",
+            metadata.mode & 00400 ? 'r' : '-',
+            metadata.mode & 00200 ? 'w' : '-',
+            metadata.mode & 00100 ? 'x' : '-',
+            metadata.mode & 00040 ? 'r' : '-',
+            metadata.mode & 00020 ? 'w' : '-',
+            metadata.mode & 00010 ? 'x' : '-',
+            metadata.mode & 00004 ? 'r' : '-',
+            metadata.mode & 00002 ? 'w' : '-'
+        );
+
+        if (metadata.isSticky())
+            printf("t");
+        else
+            printf("%c", metadata.mode & 00001 ? 'x' : '-');
+
+        printf("%12u ", metadata.size);
+
+        printf("\033[30;1m");
+        auto tm = *localtime(&metadata.mtime);
+        printf("%04u-%02u-%02u %02u:%02u:%02u ",
+                tm.tm_year + 1900,
+                tm.tm_mon + 1,
+                tm.tm_mday,
+                tm.tm_hour,
+                tm.tm_min,
+                tm.tm_sec);
+        printf("\033[0m");
+
+        printf("%s%s%s",
+            nameColorBegin,
+            entry.name.characters(),
+            nameColorEnd);
+
+        if (metadata.isDirectory()) {
+            printf("/");
+        } else if (metadata.isSymbolicLink()) {
+            auto symlinkContents = directoryInode.fileSystem()->readInode(metadata.inode);
+            printf(" -> %s", String((const char*)symlinkContents.pointer(), symlinkContents.size()).characters());
+        }
+        printf("\n");
+        return true;
+    });
+}
+
+void VirtualFileSystem::listDirectoryRecursively(const String& path)
+{
+    auto directory = resolvePath(path);
+    if (!directory.isValid())
+        return;
+
+    printf("%s\n", path.characters());
+
+    enumerateDirectoryInode(directory, [&] (const FileSystem::DirectoryEntry& entry) {
+        auto metadata = entry.inode.metadata();
+        if (metadata.isDirectory()) {
+            if (entry.name != "." && entry.name != "..") {
+                char buf[4096];
+                sprintf(buf, "%s/%s", path.characters(), entry.name.characters());
+                listDirectoryRecursively(buf);
+            }
+        } else {
+            printf("%s/%s\n", path.characters(), entry.name.characters());
+        }
+    });
+}
+
+bool VirtualFileSystem::touch(const String& path)
+{
+    auto inode = resolvePath(path);
+    if (!inode.isValid())
+        return false;
+    return inode.fileSystem()->setModificationTime(inode, time(nullptr));
+}
+
+OwnPtr<FileHandle> VirtualFileSystem::open(const String& path)
+{
+    auto inode = resolvePath(path);
+    if (!inode.isValid())
+        return nullptr;
+    auto vnode = getOrCreateNode(inode);
+    if (!vnode)
+        return nullptr;
+    return make<FileHandle>(std::move(vnode));
+}
+
+OwnPtr<FileHandle> VirtualFileSystem::create(const String& path)
+{
+    // FIXME: Do the real thing, not just this fake thing!
+    m_rootNode->fileSystem()->createInode(m_rootNode->fileSystem()->rootInode(), "empty", 0100644);
+    return nullptr;
+}
+
+InodeIdentifier VirtualFileSystem::resolveSymbolicLink(const String& basePath, InodeIdentifier symlinkInode)
+{
+    auto symlinkContents = symlinkInode.readEntireFile();
+    if (!symlinkContents)
+        return { };
+    char buf[4096];
+    sprintf(buf, "/%s/%s", basePath.characters(), String((const char*)symlinkContents.pointer(), symlinkContents.size()).characters());
+    return resolvePath(buf);
+}
+
+InodeIdentifier VirtualFileSystem::resolvePath(const String& path)
+{
+    auto parts = path.split('/');
+    InodeIdentifier inode = m_rootNode->inode;
+
+    for (unsigned i = 0; i < parts.size(); ++i) {
+        auto& part = parts[i];
+        auto metadata = inode.metadata();
+        if (!metadata.isValid()) {
+#ifdef VFS_DEBUG
+            printf("invalid metadata\n");
+#endif
+            return InodeIdentifier();
+        }
+        if (!metadata.isDirectory()) {
+#ifdef VFS_DEBUG
+            printf("not directory\n");
+#endif
+            return InodeIdentifier();
+        }
+        inode = inode.fileSystem()->childOfDirectoryInodeWithName(inode, part);
+        if (!inode.isValid()) {
+#ifdef VFS_DEBUG
+            printf("bad child\n");
+#endif
+            return InodeIdentifier();
+        }
+#ifdef VFS_DEBUG
+        printf("<%s> %02u:%08u\n", part.characters(), inode.fileSystemID(), inode.index());
+#endif
+        if (auto mount = findMountForHost(inode)) {
+#ifdef VFS_DEBUG
+            printf("  -- is host\n");
+#endif
+            inode = mount->guest();
+        }
+        if (inode.isRootInode() && !isRoot(inode) && part == "..") {
+#ifdef VFS_DEBUG
+            printf("  -- is guest\n");
+#endif
+            auto mount = findMountForGuest(inode);
+            inode = mount->host();
+            inode = inode.fileSystem()->childOfDirectoryInodeWithName(inode, "..");
+        }
+        metadata = inode.metadata();
+        if (metadata.isSymbolicLink()) {
+            char buf[4096] = "";
+            char* p = buf;
+            for (unsigned j = 0; j < i; ++j) {
+                p += sprintf(p, "/%s", parts[j].characters());
+            }
+            inode = resolveSymbolicLink(buf, inode);
+            if (!inode.isValid()) {
+                printf("Symbolic link resolution failed :(\n");
+                return { };
+            }
+        }
+    }
+
+    return inode;
+}
+
+void VirtualFileSystem::Node::retain()
+{
+    ++retainCount;
+}
+
+void VirtualFileSystem::Node::release()
+{
+    ASSERT(retainCount);
+    if (--retainCount == 0) {
+        vfs->freeNode(this);
+    }
+}
+
+VirtualFileSystem::Mount::Mount(InodeIdentifier host, RetainPtr<FileSystem>&& guestFileSystem)
+    : m_host(host)
+    , m_guest(guestFileSystem->rootInode())
+    , m_fileSystem(std::move(guestFileSystem))
+{
+}
+
diff --git a/VirtualFileSystem/VirtualFileSystem.h b/VirtualFileSystem/VirtualFileSystem.h
new file mode 100644
index 00000000000..82a30e5513a
--- /dev/null
+++ b/VirtualFileSystem/VirtualFileSystem.h
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <AK/HashMap.h>
+#include <AK/OwnPtr.h>
+#include <AK/RetainPtr.h>
+#include <AK/String.h>
+#include <AK/Vector.h>
+#include "InodeIdentifier.h"
+
+class FileHandle;
+class FileSystem;
+
+class VirtualFileSystem {
+public:
+    struct Node {
+        InodeIdentifier inode;
+
+        bool inUse() const { return inode.isValid(); }
+
+        void retain();
+        void release();
+
+        FileSystem* fileSystem() { return inode.fileSystem(); }
+        const FileSystem* fileSystem() const { return inode.fileSystem(); }
+
+    private:
+        friend class VirtualFileSystem;
+        VirtualFileSystem* vfs { nullptr };
+        unsigned retainCount { 0 };
+    };
+
+    VirtualFileSystem();
+    ~VirtualFileSystem();
+
+    bool isDirectory(const String& path);
+    void listDirectory(const String& path);
+    void listDirectoryRecursively(const String& path);
+
+    unsigned maxNodeCount() const { return m_maxNodeCount; }
+    unsigned allocatedNodeCount() const { return m_maxNodeCount - m_nodeFreeList.size(); }
+
+    Node* root() { return m_rootNode.ptr(); }
+    const Node* root() const { return m_rootNode.ptr(); }
+
+    bool mountRoot(RetainPtr<FileSystem>&&);
+    bool mount(RetainPtr<FileSystem>&&, const String& path);
+
+    OwnPtr<FileHandle> open(const String& path);
+    OwnPtr<FileHandle> create(const String& path);
+
+    bool isRoot(InodeIdentifier) const;
+
+    bool touch(const String&path);
+
+private:
+    template<typename F> void enumerateDirectoryInode(InodeIdentifier, F func);
+    InodeIdentifier resolvePath(const String& path);
+    InodeIdentifier resolveSymbolicLink(const String& basePath, InodeIdentifier symlinkInode);
+
+    RetainPtr<Node> allocateNode();
+    void freeNode(Node*);
+
+    RetainPtr<Node> makeNode(InodeIdentifier);
+    RetainPtr<Node> getOrCreateNode(InodeIdentifier);
+
+    class Mount {
+    public:
+        Mount(InodeIdentifier host, RetainPtr<FileSystem>&&);
+
+        InodeIdentifier host() const { return m_host; }
+        InodeIdentifier guest() const { return m_guest; }
+
+    private:
+        InodeIdentifier m_host;
+        InodeIdentifier m_guest;
+        RetainPtr<FileSystem> m_fileSystem;
+    };
+
+    Mount* findMountForHost(InodeIdentifier);
+    Mount* findMountForGuest(InodeIdentifier);
+
+    HashMap<InodeIdentifier, Node*> m_inode2vnode;
+
+    Vector<OwnPtr<Mount>> m_mounts;
+
+    unsigned m_maxNodeCount { 0 };
+    Node* m_nodes { nullptr };
+
+    Vector<Node*> m_nodeFreeList;
+
+    RetainPtr<Node> m_rootNode;
+};
+
diff --git a/VirtualFileSystem/ext2_fs.h b/VirtualFileSystem/ext2_fs.h
new file mode 100644
index 00000000000..4f0856acf1d
--- /dev/null
+++ b/VirtualFileSystem/ext2_fs.h
@@ -0,0 +1,750 @@
+/*
+ *  linux/include/linux/ext2_fs.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_EXT2_FS_H
+#define _LINUX_EXT2_FS_H
+
+#include "ext2_types.h"		/* Changed from linux/types.h */
+
+/*
+ * The second extended filesystem constants/structures
+ */
+
+/*
+ * Define EXT2FS_DEBUG to produce debug messages
+ */
+#undef EXT2FS_DEBUG
+
+/*
+ * Define EXT2_PREALLOCATE to preallocate data blocks for expanding files
+ */
+#define EXT2_PREALLOCATE
+#define EXT2_DEFAULT_PREALLOC_BLOCKS	8
+
+/*
+ * The second extended file system version
+ */
+#define EXT2FS_DATE		"95/08/09"
+#define EXT2FS_VERSION		"0.5b"
+
+/*
+ * Special inode numbers
+ */
+#define EXT2_BAD_INO		 1	/* Bad blocks inode */
+#define EXT2_ROOT_INO		 2	/* Root inode */
+#define EXT2_ACL_IDX_INO	 3	/* ACL inode */
+#define EXT2_ACL_DATA_INO	 4	/* ACL inode */
+#define EXT2_BOOT_LOADER_INO	 5	/* Boot loader inode */
+#define EXT2_UNDEL_DIR_INO	 6	/* Undelete directory inode */
+#define EXT2_RESIZE_INO		 7	/* Reserved group descriptors inode */
+#define EXT2_JOURNAL_INO	 8	/* Journal inode */
+
+/* First non-reserved inode for old ext2 filesystems */
+#define EXT2_GOOD_OLD_FIRST_INO	11
+
+/*
+ * The second extended file system magic number
+ */
+#define EXT2_SUPER_MAGIC	0xEF53
+
+#ifdef __KERNEL__
+#define EXT2_SB(sb)	(&((sb)->u.ext2_sb))
+#else
+/* Assume that user mode programs are passing in an ext2fs superblock, not
+ * a kernel struct super_block.  This will allow us to call the feature-test
+ * macros from user land. */
+#define EXT2_SB(sb)	(sb)
+#endif
+
+/*
+ * Maximal count of links to a file
+ */
+#define EXT2_LINK_MAX		65000
+
+/*
+ * Macro-instructions used to manage several block sizes
+ */
+#define EXT2_MIN_BLOCK_LOG_SIZE		10	/* 1024 */
+#define EXT2_MAX_BLOCK_LOG_SIZE		16	/* 65536 */
+#define EXT2_MIN_BLOCK_SIZE	(1 << EXT2_MIN_BLOCK_LOG_SIZE)
+#define EXT2_MAX_BLOCK_SIZE	(1 << EXT2_MAX_BLOCK_LOG_SIZE)
+#ifdef __KERNEL__
+#define EXT2_BLOCK_SIZE(s)	((s)->s_blocksize)
+#define EXT2_BLOCK_SIZE_BITS(s)	((s)->s_blocksize_bits)
+#define EXT2_ADDR_PER_BLOCK_BITS(s)	(EXT2_SB(s)->addr_per_block_bits)
+#define EXT2_INODE_SIZE(s)	(EXT2_SB(s)->s_inode_size)
+#define EXT2_FIRST_INO(s)	(EXT2_SB(s)->s_first_ino)
+#else
+#define EXT2_BLOCK_SIZE(s)	(EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
+#define EXT2_BLOCK_SIZE_BITS(s)	((s)->s_log_block_size + 10)
+#define EXT2_INODE_SIZE(s)	(((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
+				 EXT2_GOOD_OLD_INODE_SIZE : (s)->s_inode_size)
+#define EXT2_FIRST_INO(s)	(((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
+				 EXT2_GOOD_OLD_FIRST_INO : (s)->s_first_ino)
+#endif
+#define EXT2_ADDR_PER_BLOCK(s)	(EXT2_BLOCK_SIZE(s) / sizeof(__u32))
+
+/*
+ * Macro-instructions used to manage fragments
+ */
+#define EXT2_MIN_FRAG_SIZE		EXT2_MIN_BLOCK_SIZE
+#define EXT2_MAX_FRAG_SIZE		EXT2_MAX_BLOCK_SIZE
+#define EXT2_MIN_FRAG_LOG_SIZE		EXT2_MIN_BLOCK_LOG_SIZE
+#ifdef __KERNEL__
+# define EXT2_FRAG_SIZE(s)		(EXT2_SB(s)->s_frag_size)
+# define EXT2_FRAGS_PER_BLOCK(s)	(EXT2_SB(s)->s_frags_per_block)
+#else
+# define EXT2_FRAG_SIZE(s)		(EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
+# define EXT2_FRAGS_PER_BLOCK(s)	(EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
+#endif
+
+/*
+ * ACL structures
+ */
+struct ext2_acl_header	/* Header of Access Control Lists */
+{
+	__u32	aclh_size;
+	__u32	aclh_file_count;
+	__u32	aclh_acle_count;
+	__u32	aclh_first_acle;
+};
+
+struct ext2_acl_entry	/* Access Control List Entry */
+{
+	__u32	acle_size;
+	__u16	acle_perms;	/* Access permissions */
+	__u16	acle_type;	/* Type of entry */
+	__u16	acle_tag;	/* User or group identity */
+	__u16	acle_pad1;
+	__u32	acle_next;	/* Pointer on next entry for the */
+					/* same inode or on next free entry */
+};
+
+/*
+ * Structure of a blocks group descriptor
+ */
+struct ext2_group_desc
+{
+	__u32	bg_block_bitmap;	/* Blocks bitmap block */
+	__u32	bg_inode_bitmap;	/* Inodes bitmap block */
+	__u32	bg_inode_table;		/* Inodes table block */
+	__u16	bg_free_blocks_count;	/* Free blocks count */
+	__u16	bg_free_inodes_count;	/* Free inodes count */
+	__u16	bg_used_dirs_count;	/* Directories count */
+	__u16	bg_flags;
+	__u32	bg_reserved[2];
+	__u16	bg_itable_unused;	/* Unused inodes count */
+	__u16	bg_checksum;		/* crc16(s_uuid+grouo_num+group_desc)*/
+};
+
+struct ext4_group_desc
+{
+	__u32	bg_block_bitmap;	/* Blocks bitmap block */
+	__u32	bg_inode_bitmap;	/* Inodes bitmap block */
+	__u32	bg_inode_table;		/* Inodes table block */
+	__u16	bg_free_blocks_count;	/* Free blocks count */
+	__u16	bg_free_inodes_count;	/* Free inodes count */
+	__u16	bg_used_dirs_count;	/* Directories count */
+	__u16	bg_flags;
+	__u32	bg_reserved[2];
+	__u16	bg_itable_unused;	/* Unused inodes count */
+	__u16	bg_checksum;		/* crc16(s_uuid+grouo_num+group_desc)*/
+	__u32	bg_block_bitmap_hi;	/* Blocks bitmap block MSB */
+	__u32	bg_inode_bitmap_hi;	/* Inodes bitmap block MSB */
+	__u32	bg_inode_table_hi;	/* Inodes table block MSB */
+	__u16	bg_free_blocks_count_hi;/* Free blocks count MSB */
+	__u16	bg_free_inodes_count_hi;/* Free inodes count MSB */
+	__u16	bg_used_dirs_count_hi;	/* Directories count MSB */
+	__u16   bg_pad;
+	__u32	bg_reserved2[3];
+};
+
+#define EXT2_BG_INODE_UNINIT	0x0001 /* Inode table/bitmap not initialized */
+#define EXT2_BG_BLOCK_UNINIT	0x0002 /* Block bitmap not initialized */
+#define EXT2_BG_INODE_ZEROED	0x0004 /* On-disk itable initialized to zero */
+
+/*
+ * Data structures used by the directory indexing feature
+ *
+ * Note: all of the multibyte integer fields are little endian.
+ */
+
+/*
+ * Note: dx_root_info is laid out so that if it should somehow get
+ * overlaid by a dirent the two low bits of the hash version will be
+ * zero.  Therefore, the hash version mod 4 should never be 0.
+ * Sincerely, the paranoia department.
+ */
+struct ext2_dx_root_info {
+	__u32 reserved_zero;
+	__u8 hash_version; /* 0 now, 1 at release */
+	__u8 info_length; /* 8 */
+	__u8 indirect_levels;
+	__u8 unused_flags;
+};
+
+#define EXT2_HASH_LEGACY		0
+#define EXT2_HASH_HALF_MD4		1
+#define EXT2_HASH_TEA			2
+#define EXT2_HASH_LEGACY_UNSIGNED	3 /* reserved for userspace lib */
+#define EXT2_HASH_HALF_MD4_UNSIGNED	4 /* reserved for userspace lib */
+#define EXT2_HASH_TEA_UNSIGNED		5 /* reserved for userspace lib */
+
+#define EXT2_HASH_FLAG_INCOMPAT	0x1
+
+struct ext2_dx_entry {
+	__u32 hash;
+	__u32 block;
+};
+
+struct ext2_dx_countlimit {
+	__u16 limit;
+	__u16 count;
+};
+
+
+/*
+ * Macro-instructions used to manage group descriptors
+ */
+#define EXT2_MIN_DESC_SIZE             32
+#define EXT2_MIN_DESC_SIZE_64BIT       64
+#define EXT2_MAX_DESC_SIZE             EXT2_MIN_BLOCK_SIZE
+#define EXT2_DESC_SIZE(s)                                                \
+       ((EXT2_SB(s)->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) ? \
+	(s)->s_desc_size : EXT2_MIN_DESC_SIZE)
+
+#define EXT2_BLOCKS_PER_GROUP(s)	(EXT2_SB(s)->s_blocks_per_group)
+#define EXT2_INODES_PER_GROUP(s)	(EXT2_SB(s)->s_inodes_per_group)
+#define EXT2_INODES_PER_BLOCK(s)	(EXT2_BLOCK_SIZE(s)/EXT2_INODE_SIZE(s))
+/* limits imposed by 16-bit value gd_free_{blocks,inode}_count */
+#define EXT2_MAX_BLOCKS_PER_GROUP(s)	((1 << 16) - 8)
+#define EXT2_MAX_INODES_PER_GROUP(s)	((1 << 16) - EXT2_INODES_PER_BLOCK(s))
+#ifdef __KERNEL__
+#define EXT2_DESC_PER_BLOCK(s)		(EXT2_SB(s)->s_desc_per_block)
+#define EXT2_DESC_PER_BLOCK_BITS(s)	(EXT2_SB(s)->s_desc_per_block_bits)
+#else
+#define EXT2_DESC_PER_BLOCK(s)		(EXT2_BLOCK_SIZE(s) / EXT2_DESC_SIZE(s))
+#endif
+
+/*
+ * Constants relative to the data blocks
+ */
+#define EXT2_NDIR_BLOCKS		12
+#define EXT2_IND_BLOCK			EXT2_NDIR_BLOCKS
+#define EXT2_DIND_BLOCK			(EXT2_IND_BLOCK + 1)
+#define EXT2_TIND_BLOCK			(EXT2_DIND_BLOCK + 1)
+#define EXT2_N_BLOCKS			(EXT2_TIND_BLOCK + 1)
+
+/*
+ * Inode flags
+ */
+#define EXT2_SECRM_FL			0x00000001 /* Secure deletion */
+#define EXT2_UNRM_FL			0x00000002 /* Undelete */
+#define EXT2_COMPR_FL			0x00000004 /* Compress file */
+#define EXT2_SYNC_FL			0x00000008 /* Synchronous updates */
+#define EXT2_IMMUTABLE_FL		0x00000010 /* Immutable file */
+#define EXT2_APPEND_FL			0x00000020 /* writes to file may only append */
+#define EXT2_NODUMP_FL			0x00000040 /* do not dump file */
+#define EXT2_NOATIME_FL			0x00000080 /* do not update atime */
+/* Reserved for compression usage... */
+#define EXT2_DIRTY_FL			0x00000100
+#define EXT2_COMPRBLK_FL		0x00000200 /* One or more compressed clusters */
+#define EXT2_NOCOMPR_FL			0x00000400 /* Access raw compressed data */
+#define EXT2_ECOMPR_FL			0x00000800 /* Compression error */
+/* End compression flags --- maybe not all used */
+#define EXT2_BTREE_FL			0x00001000 /* btree format dir */
+#define EXT2_INDEX_FL			0x00001000 /* hash-indexed directory */
+#define EXT2_IMAGIC_FL			0x00002000
+#define EXT3_JOURNAL_DATA_FL		0x00004000 /* file data should be journaled */
+#define EXT2_NOTAIL_FL			0x00008000 /* file tail should not be merged */
+#define EXT2_DIRSYNC_FL 		0x00010000 /* Synchronous directory modifications */
+#define EXT2_TOPDIR_FL			0x00020000 /* Top of directory hierarchies*/
+#define EXT4_HUGE_FILE_FL               0x00040000 /* Set to each huge file */
+#define EXT4_EXTENTS_FL 		0x00080000 /* Inode uses extents */
+#define EXT2_RESERVED_FL		0x80000000 /* reserved for ext2 lib */
+
+#define EXT2_FL_USER_VISIBLE		0x000BDFFF /* User visible flags */
+#define EXT2_FL_USER_MODIFIABLE		0x000080FF /* User modifiable flags */
+
+/*
+ * ioctl commands
+ */
+
+/* Used for online resize */
+struct ext2_new_group_input {
+	__u32 group;		/* Group number for this data */
+	__u32 block_bitmap;	/* Absolute block number of block bitmap */
+	__u32 inode_bitmap;	/* Absolute block number of inode bitmap */
+	__u32 inode_table;	/* Absolute block number of inode table start */
+	__u32 blocks_count;	/* Total number of blocks in this group */
+	__u16 reserved_blocks;	/* Number of reserved blocks in this group */
+	__u16 unused;		/* Number of reserved GDT blocks in group */
+};
+
+struct ext4_new_group_input {
+	__u32 group;		/* Group number for this data */
+	__u64 block_bitmap;	/* Absolute block number of block bitmap */
+	__u64 inode_bitmap;	/* Absolute block number of inode bitmap */
+	__u64 inode_table;	/* Absolute block number of inode table start */
+	__u32 blocks_count;	/* Total number of blocks in this group */
+	__u16 reserved_blocks;	/* Number of reserved blocks in this group */
+	__u16 unused;
+};
+
+#ifdef __GNU__			/* Needed for the Hurd */
+#define _IOT_ext2_new_group_input _IOT (_IOTS(__u32), 5, _IOTS(__u16), 2, 0, 0)
+#endif
+
+#define EXT2_IOC_GETFLAGS		_IOR('f', 1, long)
+#define EXT2_IOC_SETFLAGS		_IOW('f', 2, long)
+#define EXT2_IOC_GETVERSION		_IOR('v', 1, long)
+#define EXT2_IOC_SETVERSION		_IOW('v', 2, long)
+#define EXT2_IOC_GETVERSION_NEW		_IOR('f', 3, long)
+#define EXT2_IOC_SETVERSION_NEW		_IOW('f', 4, long)
+#define EXT2_IOC_GROUP_EXTEND		_IOW('f', 7, unsigned long)
+#define EXT2_IOC_GROUP_ADD		_IOW('f', 8,struct ext2_new_group_input)
+#define EXT4_IOC_GROUP_ADD		_IOW('f', 8,struct ext4_new_group_input)
+
+/*
+ * Structure of an inode on the disk
+ */
+struct ext2_inode {
+	__u16	i_mode;		/* File mode */
+	__u16	i_uid;		/* Low 16 bits of Owner Uid */
+	__u32	i_size;		/* Size in bytes */
+	__u32	i_atime;	/* Access time */
+	__u32	i_ctime;	/* Inode change time */
+	__u32	i_mtime;	/* Modification time */
+	__u32	i_dtime;	/* Deletion Time */
+	__u16	i_gid;		/* Low 16 bits of Group Id */
+	__u16	i_links_count;	/* Links count */
+	__u32	i_blocks;	/* Blocks count */
+	__u32	i_flags;	/* File flags */
+	union {
+		struct {
+			__u32	l_i_version; /* was l_i_reserved1 */
+		} linux1;
+		struct {
+			__u32  h_i_translator;
+		} hurd1;
+	} osd1;				/* OS dependent 1 */
+	__u32	i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
+	__u32	i_generation;	/* File version (for NFS) */
+	__u32	i_file_acl;	/* File ACL */
+	__u32	i_dir_acl;	/* Directory ACL */
+	__u32	i_faddr;	/* Fragment address */
+	union {
+		struct {
+			__u16	l_i_blocks_hi;
+			__u16	l_i_file_acl_high;
+			__u16	l_i_uid_high;	/* these 2 fields    */
+			__u16	l_i_gid_high;	/* were reserved2[0] */
+			__u32	l_i_reserved2;
+		} linux2;
+		struct {
+			__u8	h_i_frag;	/* Fragment number */
+			__u8	h_i_fsize;	/* Fragment size */
+			__u16	h_i_mode_high;
+			__u16	h_i_uid_high;
+			__u16	h_i_gid_high;
+			__u32	h_i_author;
+		} hurd2;
+	} osd2;				/* OS dependent 2 */
+};
+
+/*
+ * Permanent part of an large inode on the disk
+ */
+struct ext2_inode_large {
+	__u16	i_mode;		/* File mode */
+	__u16	i_uid;		/* Low 16 bits of Owner Uid */
+	__u32	i_size;		/* Size in bytes */
+	__u32	i_atime;	/* Access time */
+	__u32	i_ctime;	/* Inode Change time */
+	__u32	i_mtime;	/* Modification time */
+	__u32	i_dtime;	/* Deletion Time */
+	__u16	i_gid;		/* Low 16 bits of Group Id */
+	__u16	i_links_count;	/* Links count */
+	__u32	i_blocks;	/* Blocks count */
+	__u32	i_flags;	/* File flags */
+	union {
+		struct {
+			__u32	l_i_version; /* was l_i_reserved1 */
+		} linux1;
+		struct {
+			__u32  h_i_translator;
+		} hurd1;
+	} osd1;				/* OS dependent 1 */
+	__u32	i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
+	__u32	i_generation;	/* File version (for NFS) */
+	__u32	i_file_acl;	/* File ACL */
+	__u32	i_dir_acl;	/* Directory ACL */
+	__u32	i_faddr;	/* Fragment address */
+	union {
+		struct {
+			__u16	l_i_blocks_hi;
+			__u16	l_i_file_acl_high;
+			__u16	l_i_uid_high;	/* these 2 fields    */
+			__u16	l_i_gid_high;	/* were reserved2[0] */
+			__u32	l_i_reserved2;
+		} linux2;
+		struct {
+			__u8	h_i_frag;	/* Fragment number */
+			__u8	h_i_fsize;	/* Fragment size */
+			__u16	h_i_mode_high;
+			__u16	h_i_uid_high;
+			__u16	h_i_gid_high;
+			__u32	h_i_author;
+		} hurd2;
+	} osd2;				/* OS dependent 2 */
+	__u16	i_extra_isize;
+	__u16	i_pad1;
+	__u32	i_ctime_extra;	/* extra Change time (nsec << 2 | epoch) */
+	__u32	i_mtime_extra;	/* extra Modification time (nsec << 2 | epoch) */
+	__u32	i_atime_extra;	/* extra Access time (nsec << 2 | epoch) */
+	__u32	i_crtime;	/* File creation time */
+	__u32	i_crtime_extra;	/* extra File creation time (nsec << 2 | epoch)*/
+	__u32	i_version_hi;	/* high 32 bits for 64-bit version */
+};
+
+#define i_size_high	i_dir_acl
+
+#if defined(__KERNEL__) || defined(__linux__)
+#define i_reserved1	osd1.linux1.l_i_reserved1
+#define i_frag		osd2.linux2.l_i_frag
+#define i_fsize		osd2.linux2.l_i_fsize
+#define i_uid_low	i_uid
+#define i_gid_low	i_gid
+#define i_uid_high	osd2.linux2.l_i_uid_high
+#define i_gid_high	osd2.linux2.l_i_gid_high
+#define i_reserved2	osd2.linux2.l_i_reserved2
+#else
+#if defined(__GNU__)
+
+#define i_translator	osd1.hurd1.h_i_translator
+#define i_frag		osd2.hurd2.h_i_frag;
+#define i_fsize		osd2.hurd2.h_i_fsize;
+#define i_uid_high	osd2.hurd2.h_i_uid_high
+#define i_gid_high	osd2.hurd2.h_i_gid_high
+#define i_author	osd2.hurd2.h_i_author
+
+#endif  /* __GNU__ */
+#endif	/* defined(__KERNEL__) || defined(__linux__) */
+
+#define inode_uid(inode)	((inode).i_uid | (inode).osd2.linux2.l_i_uid_high << 16)
+#define inode_gid(inode)	((inode).i_gid | (inode).osd2.linux2.l_i_gid_high << 16)
+#define ext2fs_set_i_uid_high(inode,x) ((inode).osd2.linux2.l_i_uid_high = (x))
+#define ext2fs_set_i_gid_high(inode,x) ((inode).osd2.linux2.l_i_gid_high = (x))
+
+/*
+ * File system states
+ */
+#define EXT2_VALID_FS			0x0001	/* Unmounted cleanly */
+#define EXT2_ERROR_FS			0x0002	/* Errors detected */
+#define EXT3_ORPHAN_FS			0x0004	/* Orphans being recovered */
+
+/*
+ * Misc. filesystem flags
+ */
+#define EXT2_FLAGS_SIGNED_HASH		0x0001  /* Signed dirhash in use */
+#define EXT2_FLAGS_UNSIGNED_HASH	0x0002  /* Unsigned dirhash in use */
+#define EXT2_FLAGS_TEST_FILESYS		0x0004	/* OK for use on development code */
+
+/*
+ * Mount flags
+ */
+#define EXT2_MOUNT_CHECK		0x0001	/* Do mount-time checks */
+#define EXT2_MOUNT_GRPID		0x0004	/* Create files with directory's group */
+#define EXT2_MOUNT_DEBUG		0x0008	/* Some debugging messages */
+#define EXT2_MOUNT_ERRORS_CONT		0x0010	/* Continue on errors */
+#define EXT2_MOUNT_ERRORS_RO		0x0020	/* Remount fs ro on errors */
+#define EXT2_MOUNT_ERRORS_PANIC		0x0040	/* Panic on errors */
+#define EXT2_MOUNT_MINIX_DF		0x0080	/* Mimics the Minix statfs */
+#define EXT2_MOUNT_NO_UID32		0x0200  /* Disable 32-bit UIDs */
+
+#define clear_opt(o, opt)		o &= ~EXT2_MOUNT_##opt
+#define set_opt(o, opt)			o |= EXT2_MOUNT_##opt
+#define test_opt(sb, opt)		(EXT2_SB(sb)->s_mount_opt & \
+					 EXT2_MOUNT_##opt)
+/*
+ * Maximal mount counts between two filesystem checks
+ */
+#define EXT2_DFL_MAX_MNT_COUNT		20	/* Allow 20 mounts */
+#define EXT2_DFL_CHECKINTERVAL		0	/* Don't use interval check */
+
+/*
+ * Behaviour when detecting errors
+ */
+#define EXT2_ERRORS_CONTINUE		1	/* Continue execution */
+#define EXT2_ERRORS_RO			2	/* Remount fs read-only */
+#define EXT2_ERRORS_PANIC		3	/* Panic */
+#define EXT2_ERRORS_DEFAULT		EXT2_ERRORS_CONTINUE
+
+/*
+ * Structure of the super block
+ */
+struct ext2_super_block {
+	__u32	s_inodes_count;		/* Inodes count */
+	__u32	s_blocks_count;		/* Blocks count */
+	__u32	s_r_blocks_count;	/* Reserved blocks count */
+	__u32	s_free_blocks_count;	/* Free blocks count */
+	__u32	s_free_inodes_count;	/* Free inodes count */
+	__u32	s_first_data_block;	/* First Data Block */
+	__u32	s_log_block_size;	/* Block size */
+	__s32	s_log_frag_size;	/* Fragment size */
+	__u32	s_blocks_per_group;	/* # Blocks per group */
+	__u32	s_frags_per_group;	/* # Fragments per group */
+	__u32	s_inodes_per_group;	/* # Inodes per group */
+	__u32	s_mtime;		/* Mount time */
+	__u32	s_wtime;		/* Write time */
+	__u16	s_mnt_count;		/* Mount count */
+	__s16	s_max_mnt_count;	/* Maximal mount count */
+	__u16	s_magic;		/* Magic signature */
+	__u16	s_state;		/* File system state */
+	__u16	s_errors;		/* Behaviour when detecting errors */
+	__u16	s_minor_rev_level;	/* minor revision level */
+	__u32	s_lastcheck;		/* time of last check */
+	__u32	s_checkinterval;	/* max. time between checks */
+	__u32	s_creator_os;		/* OS */
+	__u32	s_rev_level;		/* Revision level */
+	__u16	s_def_resuid;		/* Default uid for reserved blocks */
+	__u16	s_def_resgid;		/* Default gid for reserved blocks */
+	/*
+	 * These fields are for EXT2_DYNAMIC_REV superblocks only.
+	 *
+	 * Note: the difference between the compatible feature set and
+	 * the incompatible feature set is that if there is a bit set
+	 * in the incompatible feature set that the kernel doesn't
+	 * know about, it should refuse to mount the filesystem.
+	 *
+	 * e2fsck's requirements are more strict; if it doesn't know
+	 * about a feature in either the compatible or incompatible
+	 * feature set, it must abort and not try to meddle with
+	 * things it doesn't understand...
+	 */
+	__u32	s_first_ino;		/* First non-reserved inode */
+	__u16   s_inode_size;		/* size of inode structure */
+	__u16	s_block_group_nr;	/* block group # of this superblock */
+	__u32	s_feature_compat;	/* compatible feature set */
+	__u32	s_feature_incompat;	/* incompatible feature set */
+	__u32	s_feature_ro_compat;	/* readonly-compatible feature set */
+	__u8	s_uuid[16];		/* 128-bit uuid for volume */
+	char	s_volume_name[16];	/* volume name */
+	char	s_last_mounted[64];	/* directory where last mounted */
+	__u32	s_algorithm_usage_bitmap; /* For compression */
+	/*
+	 * Performance hints.  Directory preallocation should only
+	 * happen if the EXT2_FEATURE_COMPAT_DIR_PREALLOC flag is on.
+	 */
+	__u8	s_prealloc_blocks;	/* Nr of blocks to try to preallocate*/
+	__u8	s_prealloc_dir_blocks;	/* Nr to preallocate for dirs */
+	__u16	s_reserved_gdt_blocks;	/* Per group table for online growth */
+	/*
+	 * Journaling support valid if EXT2_FEATURE_COMPAT_HAS_JOURNAL set.
+	 */
+	__u8	s_journal_uuid[16];	/* uuid of journal superblock */
+	__u32	s_journal_inum;		/* inode number of journal file */
+	__u32	s_journal_dev;		/* device number of journal file */
+	__u32	s_last_orphan;		/* start of list of inodes to delete */
+	__u32	s_hash_seed[4];		/* HTREE hash seed */
+	__u8	s_def_hash_version;	/* Default hash version to use */
+	__u8	s_jnl_backup_type; 	/* Default type of journal backup */
+	__u16	s_desc_size;		/* Group desc. size: INCOMPAT_64BIT */
+	__u32	s_default_mount_opts;
+	__u32	s_first_meta_bg;	/* First metablock group */
+	__u32	s_mkfs_time;		/* When the filesystem was created */
+	__u32	s_jnl_blocks[17]; 	/* Backup of the journal inode */
+	__u32	s_blocks_count_hi;	/* Blocks count high 32bits */
+	__u32	s_r_blocks_count_hi;	/* Reserved blocks count high 32 bits*/
+	__u32	s_free_blocks_hi; 	/* Free blocks count */
+	__u16	s_min_extra_isize;	/* All inodes have at least # bytes */
+	__u16	s_want_extra_isize; 	/* New inodes should reserve # bytes */
+	__u32	s_flags;		/* Miscellaneous flags */
+	__u16   s_raid_stride;		/* RAID stride */
+	__u16   s_mmp_interval;         /* # seconds to wait in MMP checking */
+	__u64   s_mmp_block;            /* Block for multi-mount protection */
+	__u32   s_raid_stripe_width;    /* blocks on all data disks (N*stride)*/
+	__u8	s_log_groups_per_flex;	/* FLEX_BG group size */
+	__u8    s_reserved_char_pad;
+	__u16	s_reserved_pad;		/* Padding to next 32bits */
+	__u32   s_reserved[162];        /* Padding to the end of the block */
+};
+
+/*
+ * Codes for operating systems
+ */
+#define EXT2_OS_LINUX		0
+#define EXT2_OS_HURD		1
+#define EXT2_OBSO_OS_MASIX	2
+#define EXT2_OS_FREEBSD		3
+#define EXT2_OS_LITES		4
+
+/*
+ * Revision levels
+ */
+#define EXT2_GOOD_OLD_REV	0	/* The good old (original) format */
+#define EXT2_DYNAMIC_REV	1	/* V2 format w/ dynamic inode sizes */
+
+#define EXT2_CURRENT_REV	EXT2_GOOD_OLD_REV
+#define EXT2_MAX_SUPP_REV	EXT2_DYNAMIC_REV
+
+#define EXT2_GOOD_OLD_INODE_SIZE 128
+
+/*
+ * Journal inode backup types
+ */
+#define EXT3_JNL_BACKUP_BLOCKS	1
+
+/*
+ * Feature set definitions
+ */
+
+#define EXT2_HAS_COMPAT_FEATURE(sb,mask)			\
+	( EXT2_SB(sb)->s_feature_compat & (mask) )
+#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask)			\
+	( EXT2_SB(sb)->s_feature_ro_compat & (mask) )
+#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask)			\
+	( EXT2_SB(sb)->s_feature_incompat & (mask) )
+
+#define EXT2_FEATURE_COMPAT_DIR_PREALLOC	0x0001
+#define EXT2_FEATURE_COMPAT_IMAGIC_INODES	0x0002
+#define EXT3_FEATURE_COMPAT_HAS_JOURNAL		0x0004
+#define EXT2_FEATURE_COMPAT_EXT_ATTR		0x0008
+#define EXT2_FEATURE_COMPAT_RESIZE_INODE	0x0010
+#define EXT2_FEATURE_COMPAT_DIR_INDEX		0x0020
+#define EXT2_FEATURE_COMPAT_LAZY_BG		0x0040
+
+#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER	0x0001
+#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE	0x0002
+/* #define EXT2_FEATURE_RO_COMPAT_BTREE_DIR	0x0004 not used */
+#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE	0x0008
+#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM		0x0010
+#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK	0x0020
+#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE	0x0040
+
+#define EXT2_FEATURE_INCOMPAT_COMPRESSION	0x0001
+#define EXT2_FEATURE_INCOMPAT_FILETYPE		0x0002
+#define EXT3_FEATURE_INCOMPAT_RECOVER		0x0004 /* Needs recovery */
+#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV	0x0008 /* Journal device */
+#define EXT2_FEATURE_INCOMPAT_META_BG		0x0010
+#define EXT3_FEATURE_INCOMPAT_EXTENTS		0x0040
+#define EXT4_FEATURE_INCOMPAT_64BIT		0x0080
+#define EXT4_FEATURE_INCOMPAT_MMP		0x0100
+#define EXT4_FEATURE_INCOMPAT_FLEX_BG		0x0200
+
+
+#define EXT2_FEATURE_COMPAT_SUPP	0
+#define EXT2_FEATURE_INCOMPAT_SUPP	(EXT2_FEATURE_INCOMPAT_FILETYPE)
+#define EXT2_FEATURE_RO_COMPAT_SUPP	(EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
+					 EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
+					 EXT4_FEATURE_RO_COMPAT_DIR_NLINK| \
+					 EXT2_FEATURE_RO_COMPAT_BTREE_DIR)
+
+/*
+ * Default values for user and/or group using reserved blocks
+ */
+#define EXT2_DEF_RESUID		0
+#define EXT2_DEF_RESGID		0
+
+/*
+ * Default mount options
+ */
+#define EXT2_DEFM_DEBUG		0x0001
+#define EXT2_DEFM_BSDGROUPS	0x0002
+#define EXT2_DEFM_XATTR_USER	0x0004
+#define EXT2_DEFM_ACL		0x0008
+#define EXT2_DEFM_UID16		0x0010
+#define EXT3_DEFM_JMODE		0x0060
+#define EXT3_DEFM_JMODE_DATA	0x0020
+#define EXT3_DEFM_JMODE_ORDERED	0x0040
+#define EXT3_DEFM_JMODE_WBACK	0x0060
+
+/*
+ * Structure of a directory entry
+ */
+#define EXT2_NAME_LEN 255
+
+struct ext2_dir_entry {
+	__u32	inode;			/* Inode number */
+	__u16	rec_len;		/* Directory entry length */
+	__u16	name_len;		/* Name length */
+	char	name[EXT2_NAME_LEN];	/* File name */
+};
+
+/*
+ * The new version of the directory entry.  Since EXT2 structures are
+ * stored in intel byte order, and the name_len field could never be
+ * bigger than 255 chars, it's safe to reclaim the extra byte for the
+ * file_type field.
+ */
+struct ext2_dir_entry_2 {
+	__u32	inode;			/* Inode number */
+	__u16	rec_len;		/* Directory entry length */
+	__u8	name_len;		/* Name length */
+	__u8	file_type;
+	char	name[EXT2_NAME_LEN];	/* File name */
+};
+
+/*
+ * Ext2 directory file types.  Only the low 3 bits are used.  The
+ * other bits are reserved for now.
+ */
+#define EXT2_FT_UNKNOWN		0
+#define EXT2_FT_REG_FILE	1
+#define EXT2_FT_DIR		2
+#define EXT2_FT_CHRDEV		3
+#define EXT2_FT_BLKDEV		4
+#define EXT2_FT_FIFO		5
+#define EXT2_FT_SOCK		6
+#define EXT2_FT_SYMLINK		7
+
+#define EXT2_FT_MAX		8
+
+/*
+ * EXT2_DIR_PAD defines the directory entries boundaries
+ *
+ * NOTE: It must be a multiple of 4
+ */
+#define EXT2_DIR_PAD			4
+#define EXT2_DIR_ROUND			(EXT2_DIR_PAD - 1)
+#define EXT2_DIR_REC_LEN(name_len)	(((name_len) + 8 + EXT2_DIR_ROUND) & \
+					 ~EXT2_DIR_ROUND)
+
+/*
+ * This structure will be used for multiple mount protection. It will be
+ * written into the block number saved in the s_mmp_block field in the
+ * superblock.
+ */
+#define	EXT2_MMP_MAGIC    0x004D4D50 /* ASCII for MMP */
+#define	EXT2_MMP_CLEAN    0xFF4D4D50 /* Value of mmp_seq for clean unmount */
+#define	EXT2_MMP_FSCK_ON  0xE24D4D50 /* Value of mmp_seq when being fscked */
+
+struct mmp_struct {
+	__u32	mmp_magic;
+	__u32	mmp_seq;
+	__u64	mmp_time;
+	char	mmp_nodename[64];
+	char	mmp_bdevname[32];
+	__u16	mmp_interval;
+	__u16	mmp_pad1;
+	__u32	mmp_pad2;
+};
+
+/*
+ * Interval in number of seconds to update the MMP sequence number.
+ */
+#define EXT2_MMP_DEF_INTERVAL	5
+
+#endif	/* _LINUX_EXT2_FS_H */
diff --git a/VirtualFileSystem/ext2_types.h b/VirtualFileSystem/ext2_types.h
new file mode 100644
index 00000000000..27277fa3fe2
--- /dev/null
+++ b/VirtualFileSystem/ext2_types.h
@@ -0,0 +1,145 @@
+/* 
+ * If linux/types.h is already been included, assume it has defined
+ * everything we need.  (cross fingers)  Other header files may have 
+ * also defined the types that we need.
+ */
+#if (!defined(_LINUX_TYPES_H) && !defined(_BLKID_TYPES_H) && \
+	!defined(_EXT2_TYPES_H))
+#define _EXT2_TYPES_H
+
+#define __S8_TYPEDEF __signed__ char
+#define __U8_TYPEDEF unsigned char
+#define __S16_TYPEDEF __signed__ short
+#define __U16_TYPEDEF unsigned short
+#define __S32_TYPEDEF __signed__ int
+#define __U32_TYPEDEF unsigned int
+#define __S64_TYPEDEF __signed__ long long
+#define __U64_TYPEDEF unsigned long long
+
+#ifdef __U8_TYPEDEF
+typedef __U8_TYPEDEF __u8;
+#else
+typedef unsigned char __u8;
+#endif
+
+#ifdef __S8_TYPEDEF
+typedef __S8_TYPEDEF __s8;
+#else
+typedef signed char __s8;
+#endif
+
+#ifdef __U16_TYPEDEF
+typedef __U16_TYPEDEF __u16;
+#else
+#if (4 == 2)
+typedef	unsigned int	__u16;
+#else
+#if (2 == 2)
+typedef	unsigned short	__u16;
+#else
+  ?==error: undefined 16 bit type
+#endif /* SIZEOF_SHORT == 2 */
+#endif /* SIZEOF_INT == 2 */
+#endif /* __U16_TYPEDEF */
+
+#ifdef __S16_TYPEDEF
+typedef __S16_TYPEDEF __s16;
+#else
+#if (4 == 2)
+typedef	int		__s16;
+#else
+#if (2 == 2)
+typedef	short		__s16;
+#else
+  ?==error: undefined 16 bit type
+#endif /* SIZEOF_SHORT == 2 */
+#endif /* SIZEOF_INT == 2 */
+#endif /* __S16_TYPEDEF */
+
+
+#ifdef __U32_TYPEDEF
+typedef __U32_TYPEDEF __u32;
+#else
+#if (4 == 4)
+typedef	unsigned int	__u32;
+#else
+#if (4 == 4)
+typedef	unsigned long	__u32;
+#else
+#if (2 == 4)
+typedef	unsigned short	__u32;
+#else
+ ?== error: undefined 32 bit type
+#endif /* SIZEOF_SHORT == 4 */
+#endif /* SIZEOF_LONG == 4 */
+#endif /* SIZEOF_INT == 4 */
+#endif /* __U32_TYPEDEF */
+
+#ifdef __S32_TYPEDEF
+typedef __S32_TYPEDEF __s32;
+#else
+#if (4 == 4)
+typedef	int		__s32;
+#else
+#if (4 == 4)
+typedef	long		__s32;
+#else
+#if (2 == 4)
+typedef	short		__s32;
+#else
+ ?== error: undefined 32 bit type
+#endif /* SIZEOF_SHORT == 4 */
+#endif /* SIZEOF_LONG == 4 */
+#endif /* SIZEOF_INT == 4 */
+#endif /* __S32_TYPEDEF */
+
+#ifdef __U64_TYPEDEF
+typedef __U64_TYPEDEF __u64;
+#else
+#if (4 == 8)
+typedef unsigned int	__u64;
+#else
+#if (4 == 8)
+typedef unsigned long	__u64;
+#else
+#if (8 == 8)
+typedef unsigned long long	__u64;
+#endif /* SIZEOF_LONG_LONG == 8 */
+#endif /* SIZEOF_LONG == 8 */
+#endif /* SIZEOF_INT == 8 */
+#endif /* __U64_TYPEDEF */
+
+#ifdef __S64_TYPEDEF
+typedef __S64_TYPEDEF __s64;
+#else
+#if (4 == 8)
+typedef int		__s64;
+#else
+#if (4 == 8)
+typedef long		__s64;
+#else
+#if (8 == 8)
+#if defined(__GNUC__)
+typedef __signed__ long long 	__s64;
+#else
+typedef signed long long 	__s64;
+#endif /* __GNUC__ */
+#endif /* SIZEOF_LONG_LONG == 8 */
+#endif /* SIZEOF_LONG == 8 */
+#endif /* SIZEOF_INT == 8 */
+#endif /* __S64_TYPEDEF */
+
+#undef __S8_TYPEDEF
+#undef __U8_TYPEDEF
+#undef __S16_TYPEDEF
+#undef __U16_TYPEDEF
+#undef __S32_TYPEDEF
+#undef __U32_TYPEDEF
+#undef __S64_TYPEDEF
+#undef __U64_TYPEDEF
+
+#endif /* _*_TYPES_H */
+
+/* These defines are needed for the public ext2fs.h header file */
+#define HAVE_SYS_TYPES_H 1
+#undef WORDS_BIGENDIAN
diff --git a/VirtualFileSystem/small.fs b/VirtualFileSystem/small.fs
new file mode 100644
index 00000000000..8a073edadbb
Binary files /dev/null and b/VirtualFileSystem/small.fs differ
diff --git a/VirtualFileSystem/test.cpp b/VirtualFileSystem/test.cpp
new file mode 100644
index 00000000000..f47067fa190
--- /dev/null
+++ b/VirtualFileSystem/test.cpp
@@ -0,0 +1,158 @@
+#include "Ext2FileSystem.h"
+#include "FileBackedBlockDevice.h"
+#include "VirtualFileSystem.h"
+#include "FileHandle.h"
+#include "SyntheticFileSystem.h"
+#include <cstring>
+#include <AK/SimpleMalloc.h>
+#include <AK/kmalloc.h>
+
+static RetainPtr<FileSystem> makeFileSystem(const char* imagePath);
+
+int main(int c, char** v)
+{
+    const char* filename = "small.fs";
+    if (c >= 2)
+        filename = v[1];
+
+    VirtualFileSystem vfs;
+
+    if (!vfs.mountRoot(makeFileSystem(filename))) {
+        printf("Failed to mount root :(\n");
+        return 1;
+    }
+
+    auto newFile = vfs.create("/empty");
+    printf("vfs.create: %p\n", newFile.ptr());
+    //return 0;
+
+    if (!strcmp(v[0], "./vcat")) {
+        auto handle = vfs.open(v[2]);
+        if (!handle) {
+            printf("failed to open %s inside fs image\n", v[2]);
+            return 1;
+        }
+        auto contents = handle->read();
+
+        FILE* fout = fopen(v[3], "w");
+        if (!fout) {
+            printf("failed to open %s for output\n", v[3]);
+            return 1;
+        }
+        fwrite(contents.pointer(), sizeof(char), contents.size(), fout);
+        fclose(fout);
+        return 0;
+    }
+
+    auto synthfs = SyntheticFileSystem::create();
+    bool success = static_cast<FileSystem&>(*synthfs).initialize();
+    printf("synth->initialize(): returned %u\n", success);
+
+    vfs.mount(std::move(synthfs), "/syn");
+
+    vfs.listDirectory("/");
+    printf("list /syn:\n");
+    vfs.listDirectory("/syn");
+
+#if 0
+    auto handle = vfs.open("/home/andreas/../../home/./andreas/./file2");
+    printf("handle = %p\n", handle.ptr());
+    ASSERT(handle);
+
+    auto contents = handle->read();
+    ASSERT(contents);
+
+    printf("contents: '%s'\n", contents->pointer());
+#endif
+
+    String currentDirectory = "/";
+
+    while (true) {
+        char cmdbuf[256];
+        printf("::>");
+        fflush(stdout);
+        fgets(cmdbuf, sizeof(cmdbuf), stdin);
+
+        if (cmdbuf[strlen(cmdbuf) - 1] == '\n')
+            cmdbuf[strlen(cmdbuf) - 1] = '\0';
+
+        String command = cmdbuf;
+        auto parts = command.split(' ');
+
+        if (parts.isEmpty())
+            continue;
+
+        String cmd = parts[0];
+
+        if (cmd == "q")
+            break;
+
+        if (cmd == "pwd") {
+            printf("%s\n", currentDirectory.characters());
+            continue;
+        }
+
+        if (cmd == "ls") {
+            vfs.listDirectory(currentDirectory);
+            continue;
+        }
+
+        if (cmd == "lr") {
+            vfs.listDirectoryRecursively(currentDirectory);
+            continue;
+        }
+
+        if (cmd == "cd" && parts.size() > 1) {
+            char buf[1024];
+            sprintf(buf, "%s/%s", currentDirectory.characters(), parts[1].characters());
+            if (vfs.isDirectory(buf)) {
+                currentDirectory = buf;
+            } else {
+                printf("No such directory: %s\n", buf);
+            }
+            continue;
+        }
+
+        if (cmd == "mt" && parts.size() > 1) {
+            char buf[1024];
+            sprintf(buf, "%s/%s", currentDirectory.characters(), parts[1].characters());
+            vfs.touch(buf);
+            continue;
+        }
+
+
+        if (cmd == "cat" && parts.size() > 1) {
+            char pathbuf[1024];
+            sprintf(pathbuf, "%s/%s", currentDirectory.characters(), parts[1].characters());
+            auto handle = vfs.open(pathbuf);
+            if (!handle) {
+                printf("failed to open %s\n", pathbuf);
+                continue;
+            }
+            auto contents = handle->read();
+            fwrite(contents.pointer(), sizeof(char), contents.size(), stdout);
+            continue;
+        }
+
+        if (cmd == "ma") {
+            SimpleMalloc::dump();
+            continue;
+        }
+    }
+
+    return 0;
+}
+
+RetainPtr<FileSystem> makeFileSystem(const char* imagePath)
+{
+    auto fsImage = FileBackedBlockDevice::create(imagePath, 512);
+    if (!fsImage->isValid()) {
+        fprintf(stderr, "Failed to open fs image file '%s'\n", imagePath);
+        exit(1);
+    }
+    auto ext2 = Ext2FileSystem::create(std::move(fsImage));
+
+    bool success = static_cast<FileSystem&>(*ext2).initialize();
+    printf("ext2->initialize(): returned %u\n", success);
+    return ext2;
+}