AVDVirglRenderer: Host-side 3D for cuttlefish

Initial implementation of libvirglrenderer for the cuttlefish AVD.

This replaces the host renderer part of the Virgil3D project. Control
messages are replaced with the goldfish-opengl protocol. QEMU needs to
be built with support for libvirglrenderer, then this library can either
replace the system copy of libvirglrenderer, or be LD_PRELOADed.

Code from the goldfish emulator has been extensively reused. The
protocol decoders are identical to those used by the external/qemu
emu-master-dev project. Additionally, the OpenGLESDispatch library
was taken and repurposed to allow an alternative EGL/GLES implementation
to be loaded and utilized by AVDVirglRenderer.

- OpenGL ES 1.1 and OpenGL ES 3.1 are supported.
- OpenGL ES 3.2 support is not planned.
- Vulkan support is not planned.

Bug: 77276633
Change-Id: I981102308113577bccb514d1d7c515a999e6b059

69 files changed, 5783 insertions, 2786 deletions

diff --git a/android/emulation/DmaMap.cpp b/android/emulation/DmaMap.cpp
deleted file mode 100644
index fb04803a0..000000000
--- a/android/emulation/DmaMap.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright 2016 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "android/emulation/DmaMap.h"
-
-#include "android/base/containers/Lookup.h"
-#include "android/base/memory/LazyInstance.h"
-
-#include <type_traits>
-#include <inttypes.h>
-#include <stdio.h>
-
-#define DEBUG 0
-
-#if DEBUG >= 1
-#define D(fmt,...) fprintf(stderr, "DmaMap: %s: " fmt "\n", __func__, ##__VA_ARGS__);
-#else
-#define D(...) (void)0
-#endif
-
-#if DEBUG >= 2
-#define DD(fmt,...) fprintf(stderr, "DmaMap: %s: " fmt "\n", __func__, ##__VA_ARGS__);
-#else
-#define DD(...) (void)0
-#endif
-
-#define E(fmt,...) fprintf(stderr, "DmaMap: ERROR: %s: " fmt "\n", __func__, ##__VA_ARGS__);
-
-namespace android {
-
-static DmaMap* sInstance = nullptr;
-
-DmaMap* DmaMap::get() {
-    return sInstance;
-}
-
-DmaMap* DmaMap::set(DmaMap* dmaMap) {
-    DmaMap* result = sInstance;
-    sInstance = dmaMap;
-    return result;
-}
-
-void DmaMap::addBuffer(void* hwpipe,
-                       uint64_t guest_paddr,
-                       uint64_t bufferSize) {
-    D("guest paddr 0x%llx bufferSize %llu",
-      (unsigned long long)guest_paddr,
-      (unsigned long long)bufferSize);
-    DmaBufferInfo info;
-    info.hwpipe = hwpipe;
-    info.guestAddr = guest_paddr; // guest address
-    info.bufferSize = bufferSize; // size of buffer
-    info.currHostAddr = kNullopt; // no current host address
-    android::base::AutoWriteLock lock(mLock);
-    createMappingLocked(&info);
-    mDmaBuffers[guest_paddr] = info;
-}
-
-void DmaMap::removeBuffer(uint64_t guest_paddr) {
-    D("guest paddr 0x%llx", (unsigned long long)guest_paddr);
-    android::base::AutoWriteLock lock(mLock);
-    if (auto info = android::base::find(mDmaBuffers, guest_paddr)) {
-        removeMappingLocked(info);
-        mDmaBuffers.erase(guest_paddr);
-    } else {
-        E("guest addr 0x%llx not alloced!",
-          (unsigned long long)guest_paddr);
-    }
-}
-
-void* DmaMap::getHostAddr(uint64_t guest_paddr) {
-    DD("guest paddr 0x%llx", (unsigned long long)guest_paddr);
-    android::base::AutoReadLock rlock(mLock);
-    if (auto info = android::base::find(mDmaBuffers, guest_paddr)) {
-        if (info->currHostAddr) {
-            DD("guest paddr 0x%llx -> host 0x%llx valid",
-              (unsigned long long)guest_paddr,
-              (unsigned long long)(*info->currHostAddr));
-            return *(info->currHostAddr);
-        } else {
-            rlock.unlockRead();
-            android::base::AutoWriteLock wlock(mLock);
-            createMappingLocked(info);
-            D("guest paddr 0x%llx -> host 0x%llx valid (new)",
-              (unsigned long long)guest_paddr,
-              (unsigned long long)*(info->currHostAddr));
-            return *(info->currHostAddr);
-        }
-    } else {
-        E("guest paddr 0x%llx not alloced!",
-          (unsigned long long)guest_paddr);
-        return 0;
-    }
-}
-
-void DmaMap::invalidateHostMappings() {
-    android::base::AutoWriteLock lock(mLock);
-    for (auto& it : mDmaBuffers) {
-        removeMappingLocked(&it.second);
-    }
-}
-
-void DmaMap::resetHostMappings() {
-    android::base::AutoWriteLock lock(mLock);
-    for (auto& it : mDmaBuffers) {
-        removeMappingLocked(&it.second);
-    }
-    mDmaBuffers.clear();
-}
-
-void* DmaMap::getPipeInstance(uint64_t guest_paddr) {
-    android::base::AutoReadLock lock(mLock);
-    if (auto info = android::base::find(mDmaBuffers, guest_paddr)) {
-        return info->hwpipe;
-    } else {
-        E("guest paddr 0x%llx not alloced!",
-          (unsigned long long)guest_paddr);
-        return nullptr;
-    }
-}
-
-void DmaMap::createMappingLocked(DmaBufferInfo* info) {
-    info->currHostAddr = doMap(info->guestAddr, info->bufferSize);
-}
-
-void DmaMap::removeMappingLocked(DmaBufferInfo* info ) {
-    if (info->currHostAddr) {
-        doUnmap(*(info->currHostAddr), info->bufferSize);
-        info->currHostAddr = kNullopt;
-        D("guest addr 0x%llx host mapping 0x%llx removed.",
-          (unsigned long long)info->guestAddr,
-          (unsigned long long)info->currHostAddr);
-    } else {
-        D("guest addr 0x%llx has no host mapping. don't remove.",
-          (unsigned long long)info->guestAddr);
-    }
-}
-
-}  // namespace android
-
-
diff --git a/android/emulation/DmaMap.h b/android/emulation/DmaMap.h
deleted file mode 100644
index 754549fac..000000000
--- a/android/emulation/DmaMap.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2016 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "android/base/Compiler.h"
-#include "android/base/Optional.h"
-#include "android/base/synchronization/Lock.h"
-
-#include <unordered_map>
-#include <inttypes.h>
-
-using android::base::Optional;
-using android::base::kNullopt;
-
-namespace android {
-
-struct DmaBufferInfo {
-    void* hwpipe = nullptr;
-    uint64_t guestAddr = 0;
-    uint64_t bufferSize = 0;
-    Optional<void*> currHostAddr = kNullopt;
-};
-
-class DmaMap {
-public:
-    // Constructor.
-    DmaMap() = default;
-
-    // Destructor.
-    virtual ~DmaMap() = default;
-
-    void addBuffer(void* hwpipe, uint64_t addr, uint64_t bufferSize);
-    void removeBuffer(uint64_t addr);
-    void* getHostAddr(uint64_t addr);
-    void invalidateHostMappings();
-    void resetHostMappings();
-    void* getPipeInstance(uint64_t addr);
-
-    // get() / set are NOT thread-safe,
-    // but we don't expect multiple threads to call this
-    // concurrently at init time, and the worst that can happen is to leak
-    // a single instance. (c.f. VmLock)
-    static DmaMap* get();
-    static DmaMap* set(DmaMap* dmaMap);
-protected:
-
-    virtual void createMappingLocked(DmaBufferInfo* info);
-    virtual void removeMappingLocked(DmaBufferInfo* info);
-
-    // These are meant to be replaced by a real implementation
-    // in subclasses.
-    virtual void* doMap(uint64_t addr, uint64_t bufferSize) = 0;
-    virtual void doUnmap(void* mapped, uint64_t bufferSize) = 0;
-
-    std::unordered_map<uint64_t, DmaBufferInfo> mDmaBuffers;
-    android::base::ReadWriteLock mLock;
-    DISALLOW_COPY_ASSIGN_AND_MOVE(DmaMap);
-};
-
-} // namespace android
diff --git a/android/emulation/DmaMap_unittest.cpp b/android/emulation/DmaMap_unittest.cpp
deleted file mode 100644
index d5e23b8d9..000000000
--- a/android/emulation/DmaMap_unittest.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2016 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "android/emulation/DmaMap.h"
-#include "android/emulation/testing/TestDmaMap.h"
-
-#include <gtest/gtest.h>
-
-using android::base::Optional;
-using android::base::kNullopt;
-
-namespace android {
-
-
-TEST(DmaMap, Default) {
-    // No default impl of DmaMap should exist on startup.
-    DmaMap* dmaMap = DmaMap::get();
-    ASSERT_FALSE(dmaMap);
-}
-
-TEST(DmaMap, CustomDmaMap) {
-    TestDmaMap myMap;
-    const DmaMapState& currState = myMap.dumpState();
-    EXPECT_EQ(currState.size(), 0);
-}
-
-TEST(DmaMap, SingleMapAdd) {
-    TestDmaMap myMap;
-    myMap.addBuffer(nullptr, 1, 2);
-    const DmaMapState& currState = myMap.dumpState();
-    const auto& it = currState.find(1);
-    EXPECT_TRUE(it != currState.end());
-    const DmaBufferInfo& info = it->second;
-    EXPECT_EQ(info.guestAddr, 1);
-    EXPECT_EQ(info.bufferSize, 2);
-    EXPECT_TRUE(info.currHostAddr);
-}
-
-TEST(DmaMap, SingleMapAddRemove) {
-    TestDmaMap myMap;
-    const DmaMapState& currState = myMap.dumpState();
-    myMap.addBuffer(nullptr, 1, 2);
-    const auto& it = currState.find(1);
-    EXPECT_TRUE(it != currState.end());
-    myMap.removeBuffer(1);
-    const auto& it2 = currState.find(1);
-    EXPECT_TRUE(it2 == currState.end());
-}
-
-TEST(DmaMap, SingleMapAddMulti) {
-    TestDmaMap myMap;
-    myMap.addBuffer(nullptr, 1, 2);
-    myMap.addBuffer(nullptr, 1, 3);
-    const DmaMapState& currState = myMap.dumpState();
-    const DmaBufferInfo& info = currState.find(1)->second;
-    EXPECT_EQ(info.guestAddr, 1);
-    EXPECT_EQ(info.bufferSize, 3);
-}
-
-TEST(DmaMap, MultiMap) {
-    TestDmaMap myMap;
-    myMap.addBuffer(nullptr, 1, 2);
-    myMap.addBuffer(nullptr, 3, 4);
-    const DmaMapState& currState = myMap.dumpState();
-    const auto& it1 = currState.find(1);
-    const auto& it3 = currState.find(3);
-    EXPECT_TRUE(it1 != currState.end());
-    EXPECT_TRUE(it3 != currState.end());
-    const DmaBufferInfo& info1 = it1->second;
-    const DmaBufferInfo& info3 = it3->second;
-    EXPECT_EQ(info1.guestAddr, 1);
-    EXPECT_EQ(info1.bufferSize, 2);
-    EXPECT_TRUE(info1.currHostAddr);
-    EXPECT_EQ(info3.guestAddr, 3);
-    EXPECT_EQ(info3.bufferSize, 4);
-    EXPECT_TRUE(info3.currHostAddr);
-    myMap.removeBuffer(1);
-    myMap.removeBuffer(3);
-    const auto& it1_notfound = currState.find(1);
-    const auto& it3_notfound = currState.find(3);
-    EXPECT_TRUE(it1_notfound == currState.end());
-    EXPECT_TRUE(it3_notfound == currState.end());
-}
-
-TEST(DmaMap, SingleMapHostRead) {
-    TestDmaMap myMap;
-    myMap.addBuffer(nullptr, 1, 2);
-    myMap.getHostAddr(1);
-
-    const DmaMapState& currState = myMap.dumpState();
-    const auto& it = currState.find(1);
-    const DmaBufferInfo& info = it->second;
-    EXPECT_EQ(info.guestAddr, 1);
-    EXPECT_EQ(info.bufferSize, 2);
-    EXPECT_TRUE(info.currHostAddr);
-
-    myMap.getHostAddr(1);
-    EXPECT_TRUE(currState.find(1)->second.currHostAddr);
-    myMap.getHostAddr(1);
-    EXPECT_TRUE(currState.find(1)->second.currHostAddr);
-}
-
-TEST(DmaMap, SingleMapHostReadInvalidate) {
-    TestDmaMap myMap;
-    myMap.addBuffer(nullptr, 1, 2);
-    myMap.getHostAddr(1);
-    myMap.invalidateHostMappings();
-    const DmaMapState& currState = myMap.dumpState();
-    const auto& it = currState.find(1);
-    const DmaBufferInfo& info = it->second;
-    EXPECT_EQ(info.guestAddr, 1);
-    EXPECT_EQ(info.bufferSize, 2);
-    EXPECT_FALSE(info.currHostAddr);
-}
-
-TEST(DmaMap, MultiMapHostReadInvalidate) {
-    TestDmaMap myMap;
-    const DmaMapState& currState = myMap.dumpState();
-    myMap.addBuffer(nullptr, 1, 2);
-    myMap.addBuffer(nullptr, 3, 4);
-    myMap.addBuffer(nullptr, 5, 6);
-    myMap.getHostAddr(1);
-    myMap.getHostAddr(3);
-    EXPECT_TRUE(currState.find(1)->second.currHostAddr);
-    EXPECT_TRUE(currState.find(3)->second.currHostAddr);
-    EXPECT_TRUE(currState.find(5)->second.currHostAddr);
-    myMap.invalidateHostMappings();
-    EXPECT_FALSE(currState.find(1)->second.currHostAddr);
-    EXPECT_FALSE(currState.find(3)->second.currHostAddr);
-    EXPECT_FALSE(currState.find(5)->second.currHostAddr);
-}
-
-TEST(DmaMap, MultiMapHostReadInvalidateRemap) {
-    TestDmaMap myMap;
-    const DmaMapState& currState = myMap.dumpState();
-    myMap.addBuffer(nullptr, 1, 2);
-    myMap.addBuffer(nullptr, 3, 4);
-    myMap.addBuffer(nullptr, 5, 6);
-    myMap.getHostAddr(1);
-    myMap.getHostAddr(3);
-    EXPECT_TRUE(currState.find(1)->second.currHostAddr);
-    EXPECT_TRUE(currState.find(3)->second.currHostAddr);
-    EXPECT_TRUE(currState.find(5)->second.currHostAddr);
-    myMap.invalidateHostMappings();
-    myMap.getHostAddr(3);
-    myMap.getHostAddr(5);
-    EXPECT_FALSE(currState.find(1)->second.currHostAddr);
-    EXPECT_TRUE(currState.find(3)->second.currHostAddr);
-    EXPECT_TRUE(currState.find(5)->second.currHostAddr);
-}
-
-TEST(DmaMap, ErrorCaseMapNonExistent) {
-    TestDmaMap myMap;
-    myMap.getHostAddr(1);
-}
-
-TEST(DmaMap, ErrorCaseRemoveNonExistent) {
-    TestDmaMap myMap;
-    myMap.removeBuffer(1);
-}
-
-} // namespace android
diff --git a/android/emulation/GoldfishDma.cpp b/android/emulation/GoldfishDma.cpp
deleted file mode 100644
index 1e5bf9f0a..000000000
--- a/android/emulation/GoldfishDma.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "android/base/memory/LazyInstance.h"
-
-#include "android/emulation/GoldfishDma.h"
-#include "android/emulation/DmaMap.h"
-
-#include "android/emulation/android_pipe_host.h"
-#include "android/utils/assert.h"
-#include "android/utils/debug.h"
-#include "android/utils/system.h"
-
-static void android_goldfish_dma_add_buffer(void* pipe, uint64_t guest_paddr, uint64_t sz) {
-    android::DmaMap::get()->addBuffer(pipe, guest_paddr, sz);
-}
-
-static void android_goldfish_dma_remove_buffer(uint64_t guest_paddr) {
-    android::DmaMap::get()->removeBuffer(guest_paddr);
-}
-
-static void* android_goldfish_dma_get_host_addr(uint64_t guest_paddr) {
-    return android::DmaMap::get()->getHostAddr(guest_paddr);
-}
-
-static void android_goldfish_dma_invalidate_host_mappings() {
-    android::DmaMap::get()->invalidateHostMappings();
-}
-
-static void android_goldfish_dma_unlock(uint64_t guest_paddr) {
-    void* hwpipe = android::DmaMap::get()->getPipeInstance(guest_paddr);
-    android_pipe_host_signal_wake(hwpipe, PIPE_WAKE_UNLOCK_DMA);
-}
-
-static void android_goldfish_dma_reset_host_mappings() {
-    android::DmaMap::get()->resetHostMappings();
-}
-
-GoldfishDmaOps android_goldfish_dma_ops = {
-    .add_buffer = android_goldfish_dma_add_buffer,
-    .remove_buffer = android_goldfish_dma_remove_buffer,
-    .get_host_addr = android_goldfish_dma_get_host_addr,
-    .invalidate_host_mappings = android_goldfish_dma_invalidate_host_mappings,
-    .unlock = android_goldfish_dma_unlock,
-    .reset_host_mappings = android_goldfish_dma_reset_host_mappings,
-};
diff --git a/android/emulation/GoldfishDma.h b/android/emulation/GoldfishDma.h
deleted file mode 100644
index d28e5b7bf..000000000
--- a/android/emulation/GoldfishDma.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Copyright (C) 2016 The Android Open Source Project
-**
-** This software is licensed under the terms of the GNU General Public
-** License version 2, as published by the Free Software Foundation, and
-** may be copied, distributed, and modified under those terms.
-**
-** This program 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 General Public License for more details.
-*/
-
-#pragma once
-
-#include <inttypes.h>
-
-static const uint32_t kDmaBufSizeMB = 32;
-// GOLDFISH DMA
-//
-// Goldfish DMA is an extension to the pipe device
-// and is designed to facilitate high-speed RAM->RAM
-// transfers from guest to host.
-//
-// See docs/GOLDFISH-VIRTUAL-HARDWARE.txt and
-//     docs/ANDROID-QEMU-PIPE.txt
-//
-// for more details.
-// Host / virtual device interface:
-typedef struct {
-// add_buffer():
-// Tell us that there is a physically-contiguous buffer in the guest
-// starting at |guest_paddr|. This should be used upon allocation
-// of the DMA buffer in the ugest.
-void (*add_buffer)(void* pipe, uint64_t guest_paddr, uint64_t sz);
-// remove_buffer():
-// Tell us that we don't care about tracking this buffer anymore.
-// This should usually be used when the DMA buffer has been freed
-// in the ugest.
-void (*remove_buffer)(uint64_t guest_paddr);
-// get_host_addr():
-// Obtain a pointer to guest physical memory that is usable as
-// as host void*.
-void* (*get_host_addr)(uint64_t guest_paddr);
-// invalidate_host_mappings():
-// Sometimes (say, on snapshot save/load) we may need to re-map
-// the guest DMA buffers so to regain access to them.
-// This function tells our map of DMA buffers to remap the buffers
-// next time they are used.
-void (*invalidate_host_mappings)(void);
-// unlock():
-// Unlocks the buffer at |guest_paddr| to signal the guest
-// that we are done writing it.
-void (*unlock)(uint64_t guest_paddr);
-// reset_host_mappings();
-// Not only invalidates the mappings, but also removes them from the record.
-void (*reset_host_mappings)(void);
-} GoldfishDmaOps;
-
-extern GoldfishDmaOps android_goldfish_dma_ops;
diff --git a/android/emulation/testing/TestDmaMap.h b/android/emulation/testing/TestDmaMap.h
deleted file mode 100644
index c71fe9dea..000000000
--- a/android/emulation/testing/TestDmaMap.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2016 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "android/emulation/DmaMap.h"
-
-#include <unordered_map>
-#include <vector>
-
-namespace android {
-
-typedef std::unordered_map<uint64_t, DmaBufferInfo> DmaMapState;
-
-class TestDmaMap : public DmaMap {
-public:
-    TestDmaMap() : mOldDmaMap(DmaMap::set(this)), mInstalled(true) {}
-
-    ~TestDmaMap() { release(); }
-
-    void release() {
-        if (mInstalled) {
-            // NOTE: A value of nullptr for mOldDmaMap is valid.
-            DmaMap::set(mOldDmaMap);
-            mInstalled = false;
-        }
-    }
-
-    const DmaMapState& dumpState() {
-        return mDmaBuffers;
-    }
-
-    virtual void* doMap(uint64_t addr, uint64_t buffer) { return nullptr; }
-    virtual void doUnmap(void* mapped, uint64_t buffer) { }
-
-    DmaMap* mOldDmaMap = nullptr;
-    bool mInstalled = false;
-};
-
-} // namespace android
diff --git a/host/commands/gen-entries.py b/host/commands/gen-entries.py
index a122ef7e3..fbfdb4daf 100755
--- a/host/commands/gen-entries.py
+++ b/host/commands/gen-entries.py
@@ -61,7 +61,7 @@ def banner_command(argv):
 
     # Remove path from first parameter
     argv = argv[:]
-    argv[0] = "android/scripts/gen-entries.py"
+    argv[0] = "host/commands/gen-entries.py"
     return ' '.join(argv)
 
 def parse_entries_file(lines):
@@ -151,165 +151,6 @@ def gen_functions_header(entries, prefix_name, verbatim, filename, with_args):
     print ""
     print "#endif  // %s_FUNCTIONS_H" % prefix_name
 
-
-
-# The purpose of gen_translator()
-# is to quickly generate implementations on the host Translator,
-# which processes commands that just got onto the renderthread off goldfish pipe
-# and are fed to system OpenGL.
-
-def gen_translator(entries):
-    # Definitions for custom implementation bodies go in
-    # android/scripts/gles3translatorgen/gles30_custom.py
-    # android/scripts/gles3translatorgen/gles31_custom.py
-    from gles3translatorgen import gles30_custom
-    from gles3translatorgen import gles31_custom
-
-    translator_custom_share_processing = { }
-    for (k, v) in gles30_custom.custom_share_processing.items():
-        translator_custom_share_processing[k] = v
-    for (k, v) in gles31_custom.custom_share_processing.items():
-        translator_custom_share_processing[k] = v
-
-    translator_custom_pre = { }
-    for (k, v) in gles30_custom.custom_preprocesses.items():
-        translator_custom_pre[k] = v
-    for (k, v) in gles31_custom.custom_preprocesses.items():
-        translator_custom_pre[k] = v
-
-    translator_custom_post = { }
-    for (k, v) in gles30_custom.custom_postprocesses.items():
-        translator_custom_post[k] = v
-    for (k, v) in gles31_custom.custom_postprocesses.items():
-        translator_custom_post[k] = v
-
-    translator_no_passthrough = {}
-    for (k, v) in gles30_custom.no_passthrough.items():
-        translator_no_passthrough[k] = v
-    for (k, v) in gles31_custom.no_passthrough.items():
-        translator_no_passthrough[k] = v
-
-    translator_needexternc = {
-            "glGetStringi": 1,
-            "glUniform4ui": 1,
-            "glGetUniformIndices": 1,
-            "glTransformFeedbackVaryings": 1,
-            "glCreateShaderProgramv": 1,
-            "glProgramUniform2ui": 1,
-            "glProgramUniform3ui": 1,
-            "glProgramUniform4ui": 1,
-            "glBindVertexBuffer": 1,
-    };
-    translator_nocontext_fail_codes = {
-            "glClientWaitSync" : "GL_WAIT_FAILED",
-    };
-    def needExternC(entry):
-        if translator_needexternc.has_key(entry.func_name):
-            return "extern \"C\" "
-        else:
-            return ""
-    def get_fail_code(entry):
-        if translator_nocontext_fail_codes.has_key(entry.func_name):
-            return translator_nocontext_fail_codes[entry.func_name];
-        else:
-            return "0"
-    def gen_cxt_getter(entry):
-        if (entry.return_type == "void"):
-            print "    GET_CTX_V2();"
-        else:
-            print "    GET_CTX_V2_RET(%s);" % get_fail_code(entry)
-
-    def gen_validations_custom_impl(entry):
-        isGen = entry.func_name.startswith("glGen")
-        isDelete = entry.func_name.startswith("glDelete")
-        isBufferOp = "Buffer" in entry.func_name
-
-        hasTargetArg = "target" in entry.varnames
-        hasProgramArg = "program" in entry.varnames
-
-        def mySetError(condition, glerr):
-            if entry.return_type == "void":
-                return "SET_ERROR_IF(%s,%s)" % (condition, glerr);
-            else:
-                return "RET_AND_SET_ERROR_IF(%s,%s,%s)" % (condition, glerr, get_fail_code(entry));
-
-        if (isGen or isDelete) and ("n" in entry.varnames):
-            print "    %s;" % mySetError("n < 0", "GL_INVALID_VALUE");
-        if (isBufferOp and hasTargetArg):
-            print "    %s;" % mySetError("!GLESv2Validate::bufferTarget(ctx, target)", "GL_INVALID_ENUM");
-        if translator_custom_pre.has_key(entry.func_name):
-            print translator_custom_pre[entry.func_name],
-
-    def gen_call_ret(entry):
-        globalNameTypes = {
-                ("GLuint", "program") : "NamedObjectType::SHADER_OR_PROGRAM",
-                ("GLuint", "texture") : "NamedObjectType::TEXTURE",
-                ("GLuint", "buffer") : "NamedObjectType::VERTEXBUFFER",
-                ("GLuint", "sampler") : "NamedObjectType::SAMPLER",
-                ("GLuint", "query") : "NamedObjectType::QUERY",
-        }
-        globalNames = {
-                ("GLuint", "program") : "globalProgramName",
-                ("GLuint", "texture") : "globalTextureName",
-                ("GLuint", "buffer") : "globalBufferName",
-                ("GLuint", "sampler") : "globalSampler",
-                ("GLuint", "query") : "globalQuery",
-        }
-
-        needsShareGroup = False
-        for v in zip(entry.vartypes, entry.varnames):
-            if v in globalNameTypes.keys():
-                needsShareGroup = True
-
-        if needsShareGroup:
-            print "    if (ctx->shareGroup().get()) {"
-            for key in zip(entry.vartypes, entry.varnames):
-                vartype, varname = key
-                if globalNames.has_key(key):
-                    print "        const GLuint %s = ctx->shareGroup()->getGlobalName(%s, %s);" % (globalNames[key], globalNameTypes[key], varname)
-
-        globalCall = ", ".join(map(lambda k: globalNames.get(k, k[1]), zip(entry.vartypes, entry.varnames)))
-
-        if needsShareGroup and translator_custom_share_processing.has_key(entry.func_name):
-            print translator_custom_share_processing[entry.func_name],
-
-        if (entry.return_type == "void"):
-            if (needsShareGroup):
-                print "   ",
-
-            if not translator_no_passthrough.has_key(entry.func_name):
-                print "    ctx->dispatcher().%s(%s);" % (entry.func_name, globalCall)
-
-            if needsShareGroup:
-                print "    }"
-            if translator_custom_post.has_key(entry.func_name):
-                print translator_custom_post[entry.func_name];
-        else:
-            if (needsShareGroup):
-                print "   ",
-            if not translator_no_passthrough.has_key(entry.func_name):
-                print "    %s %s = ctx->dispatcher().%s(%s);" % (entry.return_type, entry.func_name + "RET", entry.func_name, globalCall)
-            else:
-                print "    %s %s = %s" % (entry.return_type, entry_func_name + "RET", get_fail_code(entry))
-
-            if translator_custom_post.has_key(entry.func_name):
-                print translator_custom_post[entry.func_name];
-
-            print "    return %s;" % (entry.func_name + "RET");
-            if needsShareGroup:
-                print "    } else return %s;" % (get_fail_code(entry))
-
-    print "// Auto-generated with: %s" % banner_command(sys.argv)
-    print "// This file is best left unedited."
-    print "// Try to make changes through gen_translator in gen-entries.py,"
-    print "// and/or parcel out custom functionality in separate code."
-    for entry in entries:
-        print "%sGL_APICALL %s GL_APIENTRY %s(%s) {" % (needExternC(entry), entry.return_type, entry.func_name, entry.parameters)
-        gen_cxt_getter(entry);
-        gen_validations_custom_impl(entry);
-        gen_call_ret(entry);
-        print "}\n"
-
 def gen_dll_wrapper(entries, prefix_name, verbatim, filename):
     """Generate a C source file that contains functions that act as wrappers
        for entry points located in another shared library. This allows the
@@ -423,8 +264,6 @@ def parse_file(filename, lines, mode):
         gen_windows_def_file(entries)
     elif mode == 'sym':
         gen_unix_sym_file(entries)
-    elif mode == 'translator_passthrough':
-        gen_translator(entries)
     elif mode == 'wrapper':
         gen_dll_wrapper(entries, prefix_name, verbatim, filename)
     elif mode == 'symbols':
@@ -439,7 +278,7 @@ def parse_file(filename, lines, mode):
 
 # List of valid --mode option values.
 mode_list = [
-    'def', 'sym', 'translator_passthrough', 'wrapper', 'symbols', '_symbols', 'functions', 'funcargs'
+    'def', 'sym', 'wrapper', 'symbols', '_symbols', 'functions', 'funcargs'
 ]
 
 # Argument parsing.
diff --git a/host/libs/Android.bp b/host/libs/Android.bp
new file mode 100644
index 000000000..99a3ff0cd
--- /dev/null
+++ b/host/libs/Android.bp
@@ -0,0 +1,24 @@
+//
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+subdirs = [
+    "adb_connection_maintainer",
+    "config",
+    "ivserver",
+    "monitor",
+    "usbip",
+    "virglrenderer",
+    "vm_manager",
+]
diff --git a/host/libs/virglrenderer/.clang-format b/host/libs/virglrenderer/.clang-format
new file mode 100644
index 000000000..4b8411883
--- /dev/null
+++ b/host/libs/virglrenderer/.clang-format
@@ -0,0 +1,17 @@
+BasedOnStyle: Google
+AccessModifierOffset: -2
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ColumnLimit: 100
+CommentPragmas: NOLINT:.*
+Cpp11BracedListStyle: false
+DerivePointerAlignment: false
+IndentWidth: 4
+PointerAlignment: Left
+TabWidth: 4
+UseTab: Never
+PenaltyExcessCharacter: 32
diff --git a/host/libs/virglrenderer/.gitignore b/host/libs/virglrenderer/.gitignore
new file mode 100644
index 000000000..562939a07
--- /dev/null
+++ b/host/libs/virglrenderer/.gitignore
@@ -0,0 +1,3 @@
+renderControl_dec/renderControl_server_context.cpp
+GLESv1_dec/gles1_server_context.cpp
+GLESv3_dec/gles3_server_context.cpp
diff --git a/host/libs/virglrenderer/AVDVirglRenderer.cpp b/host/libs/virglrenderer/AVDVirglRenderer.cpp
new file mode 100644
index 000000000..a089489f8
--- /dev/null
+++ b/host/libs/virglrenderer/AVDVirglRenderer.cpp
@@ -0,0 +1,1092 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#undef NDEBUG
+
+extern "C" {
+#include <linux/virtio_gpu.h>
+#include <virgl/virglrenderer.h>
+#include <virgl_hw.h>
+}
+
+#include <sys/uio.h>
+
+#include <dlfcn.h>
+#include <algorithm>
+#include <cassert>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <deque>
+#include <map>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+#include <GLES3/gl31.h>
+#include <GLES3/gl3ext.h>
+
+#include <drm/drm_fourcc.h>
+
+#include <OpenGLESDispatch/EGLDispatch.h>
+#include <OpenGLESDispatch/GLESv1Dispatch.h>
+#include <OpenGLESDispatch/GLESv3Dispatch.h>
+
+#include "OpenglRender/IOStream.h"
+
+#include "Context.h"
+#include "EglConfig.h"
+#include "EglContext.h"
+#include "EglSurface.h"
+#include "EglSync.h"
+#include "Resource.h"
+
+#include <VirtioGpuCmd.h>
+
+// for debug only
+#include <sys/syscall.h>
+#include <unistd.h>
+#define gettid() (int)syscall(__NR_gettid)
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 0x1000
+#endif
+
+#define MAX_CMDRESPBUF_SIZE (10 * PAGE_SIZE)
+
+#define ALIGN(A, B) (((A) + (B)-1) / (B) * (B))
+
+// Enable passing scanout buffers as texture names to sdl2 backend
+#define QEMU_HARDWARE_GL_INTEROP
+
+#ifdef QEMU_HARDWARE_GL_INTEROP
+typedef GLenum (*PFNGLGETERROR)(void);
+typedef void (*PFNGLBINDTEXTURE)(GLenum target, GLuint texture);
+typedef void (*PFNGLGENTEXTURES)(GLsizei n, GLuint* textures);
+typedef void (*PFNGLTEXPARAMETERI)(GLenum target, GLenum pname, GLint param);
+typedef void (*PFNGLPIXELSTOREI)(GLenum pname, GLint param);
+typedef void (*PFNGLTEXIMAGE2D)(GLenum target, GLint level, GLint internalformat, GLsizei width,
+                                GLsizei height, GLint border, GLenum format, GLenum type,
+                                const void* pixels);
+static PFNGLBINDTEXTURE g_glBindTexture;
+static PFNGLGENTEXTURES g_glGenTextures;
+static PFNGLTEXPARAMETERI g_glTexParameteri;
+static PFNGLPIXELSTOREI g_glPixelStorei;
+static PFNGLTEXIMAGE2D g_glTexImage2D;
+static virgl_renderer_gl_context g_ctx0_alt;
+#endif
+
+// Global state
+std::map<uint32_t, EglContext*> EglContext::map;
+std::map<uint32_t, EglSurface*> EglSurface::map;
+std::map<uint32_t, EglImage*> EglImage::map;
+std::map<uint32_t, Resource*> Resource::map;
+std::map<uint64_t, EglSync*> EglSync::map;
+std::map<uint32_t, Context*> Context::map;
+std::vector<EglConfig*> EglConfig::vec;
+static virgl_renderer_callbacks* g_cb;
+const EGLint EglConfig::kAttribs[];
+uint32_t EglContext::nextId = 1U;
+uint32_t EglSurface::nextId = 1U;
+uint32_t EglImage::nextId = 1U;
+uint64_t EglSync::nextId = 1U;
+static void* g_cookie;
+
+// Fence queue, must be thread safe
+static std::mutex g_fence_deque_mutex;
+static std::deque<int> g_fence_deque;
+
+// Other GPU context and state
+static EGLSurface g_ctx0_surface;
+static EGLContext g_ctx0_es1;
+static EGLContext g_ctx0_es2;
+static EGLDisplay g_dpy;
+
+// Last context receiving a command. Allows us to find the context a fence is
+// being created for. Works around the poorly designed virgl interface.
+static Context* g_last_submit_cmd_ctx;
+
+#ifdef OPENGL_DEBUG_PRINTOUT
+
+#include "emugl/common/logging.h"
+
+// For logging from the protocol decoders
+
+void default_logger(const char* fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+    vprintf(fmt, ap);
+    va_end(ap);
+}
+
+emugl_logger_t emugl_cxt_logger = default_logger;
+
+#endif
+
+static void dump_global_state(void) {
+    printf("AVDVIRGLRENDERER GLOBAL STATE\n\n");
+
+    printf("Resources:\n");
+    for (auto const& it : Resource::map) {
+        Resource const* res = it.second;
+
+        printf(
+            "  Resource %u: %ux%u 0x%x %p (%zub) t=%u b=%u d=%u a=%u l=%u "
+            "n=%u f=%u\n",
+            res->args.handle, res->args.width, res->args.height, res->args.format,
+            res->iov ? res->iov[0].iov_base : nullptr, res->iov ? res->iov[0].iov_len : 0,
+            res->args.target, res->args.bind, res->args.depth, res->args.array_size,
+            res->args.last_level, res->args.nr_samples, res->args.flags);
+
+        for (auto const& it : res->context_map) {
+            Context const* ctx = it.second;
+
+            printf("    Context %u, pid=%d, tid=%d\n", ctx->handle, ctx->pid, ctx->tid);
+        }
+    }
+
+    printf("Contexts:\n");
+    for (auto const& it : Context::map) {
+        Context const* ctx = it.second;
+
+        printf("  Context %u: %s pid=%u tid=%u\n", ctx->handle, ctx->name.c_str(), ctx->pid,
+               ctx->tid);
+
+        for (auto const& it : ctx->resource_map) {
+            Resource const* res = it.second;
+
+            printf("    Resource %u\n", res->args.handle);
+        }
+    }
+}
+
+static int sync_linear_to_iovec(Resource* res, uint64_t offset, const virgl_box* box) {
+    uint32_t bpp;
+    switch (res->args.format) {
+        case VIRGL_FORMAT_R8_UNORM:
+            bpp = 1U;
+            break;
+        case VIRGL_FORMAT_B5G6R5_UNORM:
+            bpp = 2U;
+            break;
+        default:
+            bpp = 4U;
+            break;
+    }
+
+    if (box->x > res->args.width || box->y > res->args.height)
+        return 0;
+    if (box->w == 0U || box->h == 0U)
+        return 0;
+    uint32_t w = std::min(box->w, res->args.width - box->x);
+    uint32_t h = std::min(box->h, res->args.height - box->y);
+    uint32_t stride = ALIGN(res->args.width * bpp, 16U);
+    offset += box->y * stride + box->x * bpp;
+    size_t length = (h - 1U) * stride + w * bpp;
+    if (offset + length > res->linearSize)
+        return EINVAL;
+
+    if (res->num_iovs > 1) {
+        const char* linear = static_cast<const char*>(res->linear);
+        for (uint32_t i = 0, iovOffset = 0U; length && i < res->num_iovs; i++) {
+            if (iovOffset + res->iov[i].iov_len > offset) {
+                char* iov_base = static_cast<char*>(res->iov[i].iov_base);
+                size_t copyLength = std::min(length, res->iov[i].iov_len);
+                memcpy(iov_base + offset - iovOffset, linear, copyLength);
+                linear += copyLength;
+                offset += copyLength;
+                length -= copyLength;
+            }
+            iovOffset += res->iov[i].iov_len;
+        }
+    }
+
+    return 0;
+}
+
+static int sync_iovec_to_linear(Resource* res, uint64_t offset, const virgl_box* box) {
+    uint32_t bpp;
+    switch (res->args.format) {
+        case VIRGL_FORMAT_R8_UNORM:
+            bpp = 1U;
+            break;
+        case VIRGL_FORMAT_B5G6R5_UNORM:
+            bpp = 2U;
+            break;
+        default:
+            bpp = 4U;
+            break;
+    }
+
+    if (box->x > res->args.width || box->y > res->args.height)
+        return 0;
+    if (box->w == 0U || box->h == 0U)
+        return 0;
+    uint32_t w = std::min(box->w, res->args.width - box->x);
+    uint32_t h = std::min(box->h, res->args.height - box->y);
+    uint32_t stride = ALIGN(res->args.width * bpp, 16U);
+    offset += box->y * stride + box->x * bpp;
+    size_t length = (h - 1U) * stride + w * bpp;
+    if (offset + length > res->linearSize)
+        return EINVAL;
+
+    if (res->num_iovs > 1) {
+        char* linear = static_cast<char*>(res->linear);
+        for (uint32_t i = 0, iovOffset = 0U; length && i < res->num_iovs; i++) {
+            if (iovOffset + res->iov[i].iov_len > offset) {
+                const char* iov_base = static_cast<const char*>(res->iov[i].iov_base);
+                size_t copyLength = std::min(length, res->iov[i].iov_len);
+                memcpy(linear, iov_base + offset - iovOffset, copyLength);
+                linear += copyLength;
+                offset += copyLength;
+                length -= copyLength;
+            }
+            iovOffset += res->iov[i].iov_len;
+        }
+    }
+
+    return 0;
+}
+
+// The below API was defined by virglrenderer 'master', but does not seem to
+// be used by QEMU, so just ignore it for now..
+//
+// virgl_renderer_get_rect
+// virgl_renderer_get_fd_for_texture
+// virgl_renderer_cleanup
+// virgl_renderer_reset
+// virgl_renderer_get_poll_fd
+
+int virgl_renderer_init(void* cookie, int flags, virgl_renderer_callbacks* cb) {
+    if (!cookie || !cb)
+        return EINVAL;
+
+    if (flags != 0)
+        return ENOSYS;
+
+    if (cb->version != 1)
+        return ENOSYS;
+
+#ifdef QEMU_HARDWARE_GL_INTEROP
+    // FIXME: If we just use "libGL.so" here, mesa's interception library returns
+    //        stub dlsyms that do nothing at runtime, even after binding..
+    void* handle = dlopen(
+        "/usr/lib/x86_64-linux-gnu/nvidia/"
+        "current/libGL.so.384.111",
+        RTLD_NOW);
+    assert(handle != nullptr);
+    g_glBindTexture = (PFNGLBINDTEXTURE)dlsym(handle, "glBindTexture");
+    assert(g_glBindTexture != nullptr);
+    g_glGenTextures = (PFNGLGENTEXTURES)dlsym(handle, "glGenTextures");
+    assert(g_glGenTextures != nullptr);
+    g_glTexParameteri = (PFNGLTEXPARAMETERI)dlsym(handle, "glTexParameteri");
+    assert(g_glTexParameteri != nullptr);
+    g_glPixelStorei = (PFNGLPIXELSTOREI)dlsym(handle, "glPixelStorei");
+    assert(g_glPixelStorei != nullptr);
+    g_glTexImage2D = (PFNGLTEXIMAGE2D)dlsym(handle, "glTexImage2D");
+    assert(g_glTexImage2D != nullptr);
+#endif
+
+    if (!egl_dispatch_init())
+        return ENOENT;
+
+    if (!gles1_dispatch_init())
+        return ENOENT;
+
+    if (!gles3_dispatch_init())
+        return ENOENT;
+
+    g_dpy = s_egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if (g_dpy == EGL_NO_DISPLAY) {
+        printf("Failed to open default EGL display\n");
+        return ENOENT;
+    }
+
+    if (!s_egl.eglInitialize(g_dpy, nullptr, nullptr)) {
+        printf("Failed to initialize EGL display\n");
+        g_dpy = EGL_NO_DISPLAY;
+        return ENOENT;
+    }
+
+    EGLint nConfigs;
+    if (!s_egl.eglGetConfigs(g_dpy, nullptr, 0, &nConfigs)) {
+        printf("Failed to retrieve number of EGL configs\n");
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+        return ENOENT;
+    }
+
+    EGLConfig configs[nConfigs];
+    if (!s_egl.eglGetConfigs(g_dpy, configs, nConfigs, &nConfigs)) {
+        printf("Failed to retrieve EGL configs\n");
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+        return ENOENT;
+    }
+    for (EGLint c = 0; c < nConfigs; c++) {
+        EGLint configId;
+        if (!s_egl.eglGetConfigAttrib(g_dpy, configs[c], EGL_CONFIG_ID, &configId)) {
+            printf("Failed to retrieve EGL config ID\n");
+            s_egl.eglTerminate(g_dpy);
+            g_dpy = EGL_NO_DISPLAY;
+            return ENOENT;
+        }
+        EglConfig* config =
+            new (std::nothrow) EglConfig(g_dpy, configs[c], s_egl.eglGetConfigAttrib);
+        if (!config)
+            return ENOMEM;
+    }
+
+    // clang-format off
+    EGLint const attrib_list[] = {
+        EGL_CONFORMANT,   EGL_OPENGL_ES_BIT | EGL_OPENGL_ES3_BIT_KHR,
+        EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+        EGL_NONE,
+     };
+    // clang-format on
+    EGLint num_config = 0;
+    EGLConfig config;
+    if (!s_egl.eglChooseConfig(g_dpy, attrib_list, &config, 1, &num_config) || num_config != 1) {
+        printf("Failed to select ES1 & ES3 capable EGL config\n");
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+        return ENOENT;
+    }
+
+    // clang-format off
+    EGLint const pbuffer_attrib_list[] = {
+        EGL_WIDTH,  1,
+        EGL_HEIGHT, 1,
+        EGL_NONE
+    };
+    // clang-format on
+    g_ctx0_surface = s_egl.eglCreatePbufferSurface(g_dpy, config, pbuffer_attrib_list);
+    if (!g_ctx0_surface) {
+        printf("Failed to create pbuffer surface for context 0\n");
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+        return ENOENT;
+    }
+
+    // clang-format off
+    EGLint const es1_attrib_list[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 1,
+        EGL_NONE
+    };
+    // clang-format on
+    g_ctx0_es1 = s_egl.eglCreateContext(g_dpy, config, EGL_NO_CONTEXT, es1_attrib_list);
+    if (g_ctx0_es1 == EGL_NO_CONTEXT) {
+        printf("Failed to create ES1 context 0\n");
+        s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+        return ENOENT;
+    }
+
+    // clang-format off
+    EGLint const es2_attrib_list[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 3, // yes, 3
+        EGL_NONE
+    };
+    // clang-format on
+    g_ctx0_es2 = s_egl.eglCreateContext(g_dpy, config, EGL_NO_CONTEXT, es2_attrib_list);
+    if (g_ctx0_es2 == EGL_NO_CONTEXT) {
+        printf("Failed to create ES2 context 0\n");
+        s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
+        s_egl.eglDestroyContext(g_dpy, g_ctx0_es1);
+        g_ctx0_es1 = EGL_NO_CONTEXT;
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+    }
+
+#ifdef QEMU_HARDWARE_GL_INTEROP
+    // This is the hardware GPU context. In future, this code should probably
+    // be removed and SwiftShader be used for all presentation blits.
+    virgl_renderer_gl_ctx_param ctx_params = {
+        .major_ver = 3,
+        .minor_ver = 0,
+    };
+    g_ctx0_alt = cb->create_gl_context(cookie, 0, &ctx_params);
+    if (!g_ctx0_alt) {
+        printf("Failed to create hardware GL context 0\n");
+        s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
+        s_egl.eglDestroyContext(g_dpy, g_ctx0_es1);
+        g_ctx0_es1 = EGL_NO_CONTEXT;
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+    }
+
+    // Test we can actually make it current; otherwise, bail
+    if (cb->make_current(cookie, 0, g_ctx0_alt)) {
+        printf("Failed to make hardware GL context 0 current\n");
+        cb->destroy_gl_context(cookie, g_ctx0_alt);
+        g_ctx0_alt = nullptr;
+        s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
+        s_egl.eglDestroyContext(g_dpy, g_ctx0_es1);
+        g_ctx0_es1 = EGL_NO_CONTEXT;
+        s_egl.eglTerminate(g_dpy);
+        g_dpy = EGL_NO_DISPLAY;
+    }
+#endif
+
+    EglContext::nextId = 1U;
+    g_cookie = cookie;
+    g_cb = cb;
+    return 0;
+}
+
+void virgl_renderer_poll(void) {
+    std::lock_guard<std::mutex> lk(g_fence_deque_mutex);
+    for (auto fence : g_fence_deque)
+        g_cb->write_fence(g_cookie, fence);
+    g_fence_deque.clear();
+}
+
+void* virgl_renderer_get_cursor_data(uint32_t resource_id, uint32_t* width, uint32_t* height) {
+    if (!width || !height)
+        return nullptr;
+
+    std::map<uint32_t, Resource*>::iterator it;
+    it = Resource::map.find(resource_id);
+    if (it == Resource::map.end())
+        return nullptr;
+
+    Resource* res = it->second;
+    if (res->args.bind != VIRGL_RES_BIND_CURSOR)
+        return nullptr;
+
+    void* pixels = malloc(res->linearSize);
+    memcpy(pixels, res->linear, res->linearSize);
+    *height = res->args.height;
+    *width = res->args.width;
+    return pixels;
+}
+
+// NOTE: This function is called from thread context. Do not touch anything
+// without a mutex to protect it from concurrent access. Everything else in
+// libvirglrenderer is designed to be single-threaded *only*.
+
+// Hack to serialize all calls into EGL or GLES functions due to bugs in
+// swiftshader. This should be removed as soon as possible.
+static std::mutex swiftshader_wa_mutex;
+
+static void process_cmd(Context* ctx, char* buf, size_t bufSize, int fence) {
+    VirtioGpuCmd* cmd_resp = reinterpret_cast<VirtioGpuCmd*>(ctx->cmd_resp->linear);
+
+    IOStream stream(cmd_resp->buf, MAX_CMDRESPBUF_SIZE - sizeof(*cmd_resp));
+
+    {
+        std::lock_guard<std::mutex> lk(swiftshader_wa_mutex);
+        size_t decodedBytes;
+
+        decodedBytes = ctx->render_control.decode(buf, bufSize, &stream, &ctx->checksum_calc);
+        bufSize -= decodedBytes;
+        buf += decodedBytes;
+
+        decodedBytes = ctx->gles1.decode(buf, bufSize, &stream, &ctx->checksum_calc);
+        bufSize -= decodedBytes;
+        buf += decodedBytes;
+
+        decodedBytes = ctx->gles3.decode(buf, bufSize, &stream, &ctx->checksum_calc);
+        bufSize -= decodedBytes;
+        buf += decodedBytes;
+    }
+
+    assert(bufSize == 0);
+
+    cmd_resp->cmdSize += stream.getFlushSize();
+
+    printf("(tid %d) ctx %d: cmd %u, size %zu, fence %d\n", gettid(), ctx->handle, cmd_resp->op,
+           cmd_resp->cmdSize - sizeof(*cmd_resp), fence);
+    if (cmd_resp->cmdSize - sizeof(*cmd_resp) > 0) {
+        printf("(tid %d) ", gettid());
+        for (size_t i = 0; i < cmd_resp->cmdSize - sizeof(*cmd_resp); i++) {
+            printf("%.2x ", (unsigned char)cmd_resp->buf[i]);
+        }
+        printf("\n");
+    }
+
+    virgl_box box = {
+        .w = cmd_resp->cmdSize,
+        .h = 1,
+    };
+    sync_linear_to_iovec(ctx->cmd_resp, 0, &box);
+
+    {
+        std::lock_guard<std::mutex> lk(g_fence_deque_mutex);
+        g_fence_deque.push_back(fence);
+    }
+}
+
+int virgl_renderer_submit_cmd(void* buffer, int ctx_id, int ndw) {
+    VirtioGpuCmd* cmd = static_cast<VirtioGpuCmd*>(buffer);
+    size_t bufSize = sizeof(uint32_t) * ndw;
+
+    if (bufSize < sizeof(*cmd)) {
+        printf("bad buffer size, bufSize=%zu, ctx=%d\n", bufSize, ctx_id);
+        return -1;
+    }
+
+    printf("ctx %d: cmd %u, size %zu\n", ctx_id, cmd->op, cmd->cmdSize - sizeof(*cmd));
+
+    for (size_t i = 0; i < bufSize - sizeof(*cmd); i++) {
+        printf("%.2x ", (unsigned char)cmd->buf[i]);
+    }
+    printf("\n");
+
+    if (cmd->cmdSize < bufSize) {
+        printf("ignoring short command, cmdSize=%u, bufSize=%zu\n", cmd->cmdSize, bufSize);
+        return 0;
+    }
+
+    if (cmd->cmdSize > bufSize) {
+        printf("command would overflow buffer, cmdSize=%u, bufSize=%zu\n", cmd->cmdSize, bufSize);
+        return -1;
+    }
+
+    std::map<uint32_t, Context*>::iterator it;
+    it = Context::map.find((uint32_t)ctx_id);
+    if (it == Context::map.end()) {
+        printf("command submit from invalid context %d, ignoring\n", ctx_id);
+        return 0;
+    }
+
+    Context* ctx = it->second;
+
+    // When the context is created, the remote side should send a test command
+    // (op == 0) which we use to set up our link to this context's 'response
+    // buffer'. Only apps using EGL or GLES have this. Gralloc contexts will
+    // never hit this path because they do not submit 3D commands.
+    if (cmd->op == 0) {
+        std::map<uint32_t, Resource*>::iterator it;
+        it = Resource::map.find(*(uint32_t*)cmd->buf);
+        if (it != Resource::map.end()) {
+            Resource* res = it->second;
+            size_t cmdRespBufSize = 0U;
+            for (size_t i = 0; i < res->num_iovs; i++)
+                cmdRespBufSize += res->iov[i].iov_len;
+            if (cmdRespBufSize == MAX_CMDRESPBUF_SIZE)
+                ctx->cmd_resp = res;
+        }
+    }
+
+    if (!ctx->cmd_resp) {
+        printf("context command response page not set up, ctx=%d\n", ctx_id);
+        return -1;
+    }
+
+    VirtioGpuCmd* cmd_resp = reinterpret_cast<VirtioGpuCmd*>(ctx->cmd_resp->linear);
+
+    // We can configure bits of the response now. The size, and any message, will
+    // be updated later. This must be done even for the dummy 'op == 0' command.
+    cmd_resp->op = cmd->op;
+    cmd_resp->cmdSize = sizeof(*cmd_resp);
+
+    if (cmd->op == 0) {
+        // Send back a no-op response, just to keep the protocol in check
+        virgl_box box = {
+            .w = cmd_resp->cmdSize,
+            .h = 1,
+        };
+        sync_linear_to_iovec(ctx->cmd_resp, 0, &box);
+    } else {
+        // If the rcSetPuid command was already processed, this command will be
+        // processed by another thread. If not, the command data will be copied
+        // here and responded to when ctx->setFence() is called later.
+        ctx->submitCommand(buffer, bufSize);
+    }
+
+    g_last_submit_cmd_ctx = ctx;
+    return 0;
+}
+
+void virgl_renderer_get_cap_set(uint32_t set, uint32_t* max_ver, uint32_t* max_size) {
+    if (!max_ver || !max_size)
+        return;
+
+    printf("Request for caps version %u\n", set);
+
+    switch (set) {
+        case 1:
+            *max_ver = 1;
+            *max_size = sizeof(virgl_caps_v1);
+            break;
+        case 2:
+            *max_ver = 2;
+            *max_size = sizeof(virgl_caps_v2);
+            break;
+        default:
+            *max_ver = 0;
+            *max_size = 0;
+            break;
+    }
+}
+
+void virgl_renderer_fill_caps(uint32_t set, uint32_t, void* caps_) {
+    union virgl_caps* caps = static_cast<union virgl_caps*>(caps_);
+    EGLSurface old_read_surface, old_draw_surface;
+    GLfloat range[2] = { 0.0f, 0.0f };
+    bool fill_caps_v2 = false;
+    EGLContext old_context;
+    GLint max = 0;
+
+    if (!caps)
+        return;
+
+    // We don't need to handle caps yet, because our guest driver's features
+    // should be as close as possible to the host driver's. But maybe some day
+    // we'll support gallium shaders and the virgl control stream, so it seems
+    // like a good idea to set up the driver caps correctly..
+
+    // If this is broken, nothing will work properly
+    old_read_surface = s_egl.eglGetCurrentSurface(EGL_READ);
+    old_draw_surface = s_egl.eglGetCurrentSurface(EGL_DRAW);
+    old_context = s_egl.eglGetCurrentContext();
+    if (!s_egl.eglMakeCurrent(g_dpy, g_ctx0_surface, g_ctx0_surface, g_ctx0_es1)) {
+        printf("Failed to make ES1 context current\n");
+        return;
+    }
+
+    // Don't validate 'version' because it looks like this was misdesigned
+    // upstream and won't be set; instead, 'set' was bumped from 1->2.
+
+    switch (set) {
+        case 0:
+        case 1:
+            memset(caps, 0, sizeof(virgl_caps_v1));
+            caps->max_version = 1;
+            break;
+        case 2:
+            memset(caps, 0, sizeof(virgl_caps_v2));
+            caps->max_version = 2;
+            fill_caps_v2 = true;
+            break;
+        default:
+            caps->max_version = 0;
+            return;
+    }
+
+    if (fill_caps_v2) {
+        printf("Will probe and fill caps version 2.\n");
+    }
+
+    // Formats supported for textures
+
+    caps->v1.sampler.bitmask[0] = (1 << (VIRGL_FORMAT_B8G8R8A8_UNORM - (0 * 32))) |
+                                  (1 << (VIRGL_FORMAT_B5G6R5_UNORM - (0 * 32)));
+    caps->v1.sampler.bitmask[2] = (1 << (VIRGL_FORMAT_R8G8B8A8_UNORM - (2 * 32)));
+    caps->v1.sampler.bitmask[4] = (1 << (VIRGL_FORMAT_R8G8B8X8_UNORM - (4 * 32)));
+
+    // Formats supported for rendering
+
+    caps->v1.render.bitmask[0] = (1 << (VIRGL_FORMAT_B8G8R8A8_UNORM - (0 * 32))) |
+                                 (1 << (VIRGL_FORMAT_B5G6R5_UNORM - (0 * 32)));
+    caps->v1.render.bitmask[2] = (1 << (VIRGL_FORMAT_R8G8B8A8_UNORM - (2 * 32)));
+    caps->v1.render.bitmask[4] = (1 << (VIRGL_FORMAT_R8G8B8X8_UNORM - (4 * 32)));
+
+    // Could parse s_gles1.glGetString(GL_SHADING_LANGUAGE_VERSION, ...)?
+    caps->v1.glsl_level = 300;  // OpenGL ES GLSL 3.00
+
+    // Call with any API (v1, v3) bound
+
+    caps->v1.max_viewports = 1;
+
+    s_gles1.glGetIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &max);
+    caps->v1.max_render_targets = max;
+
+    s_gles1.glGetIntegerv(GL_MAX_SAMPLES_EXT, &max);
+    caps->v1.max_samples = max;
+
+    if (fill_caps_v2) {
+        s_gles1.glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, range);
+        caps->v2.min_aliased_point_size = range[0];
+        caps->v2.max_aliased_point_size = range[1];
+
+        s_gles1.glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, range);
+        caps->v2.min_aliased_line_width = range[0];
+        caps->v2.max_aliased_line_width = range[1];
+
+        // An extension, but everybody has it
+        s_gles1.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max);
+        caps->v2.max_vertex_attribs = max;
+
+        // Call with ES 1.0 bound *only*
+
+        s_gles1.glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, range);
+        caps->v2.min_smooth_point_size = range[0];
+        caps->v2.max_smooth_point_size = range[1];
+
+        s_gles1.glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, range);
+        caps->v2.min_smooth_line_width = range[0];
+        caps->v2.max_smooth_line_width = range[1];
+    }
+
+    if (!s_egl.eglMakeCurrent(g_dpy, g_ctx0_surface, g_ctx0_surface, g_ctx0_es2)) {
+        s_egl.eglMakeCurrent(g_dpy, old_draw_surface, old_read_surface, old_context);
+        printf("Failed to make ES3 context current\n");
+        return;
+    }
+
+    // Call with ES 3.0 bound *only*
+
+    caps->v1.bset.primitive_restart = 1;
+    caps->v1.bset.seamless_cube_map = 1;
+    caps->v1.bset.occlusion_query = 1;
+    caps->v1.bset.instanceid = 1;
+    caps->v1.bset.ubo = 1;
+
+    s_gles1.glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &max);
+    caps->v1.max_texture_array_layers = max;
+
+    s_gles1.glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &max);
+    caps->v1.max_uniform_blocks = max + 1;
+
+    if (fill_caps_v2) {
+        s_gles1.glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS, &caps->v2.max_texture_lod_bias);
+
+        s_gles1.glGetIntegerv(GL_MAX_VERTEX_OUTPUT_COMPONENTS, &max);
+        caps->v2.max_vertex_outputs = max / 4;
+
+        s_gles1.glGetIntegerv(GL_MIN_PROGRAM_TEXEL_OFFSET, &caps->v2.min_texel_offset);
+        s_gles1.glGetIntegerv(GL_MAX_PROGRAM_TEXEL_OFFSET, &caps->v2.max_texel_offset);
+
+        s_gles1.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &max);
+        caps->v2.uniform_buffer_offset_alignment = max;
+    }
+
+    // ES 2.0 extensions (fixme)
+
+    // Gallium compatibility; not usable currently.
+    caps->v1.prim_mask = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);
+
+    if (!s_egl.eglMakeCurrent(g_dpy, old_draw_surface, old_read_surface, old_context)) {
+        printf("Failed to make no context current\n");
+    }
+}
+
+int virgl_renderer_create_fence(int client_fence_id, uint32_t cmd_type) {
+    switch (cmd_type) {
+        case VIRTIO_GPU_CMD_SUBMIT_3D:
+            if (g_last_submit_cmd_ctx) {
+                g_last_submit_cmd_ctx->setFence(client_fence_id);
+                break;
+            }
+            // Fall through
+        default: {
+            std::lock_guard<std::mutex> lk(g_fence_deque_mutex);
+            g_fence_deque.push_back(client_fence_id);
+            break;
+        }
+    }
+    return 0;
+}
+
+void virgl_renderer_force_ctx_0(void) {
+#ifdef QEMU_HARDWARE_GL_INTEROP
+    if (!g_ctx0_alt)
+        return;
+
+    if (g_cb->make_current(g_cookie, 0, g_ctx0_alt)) {
+        printf("Failed to make hardware GL context 0 current\n");
+        g_cb->destroy_gl_context(g_cookie, g_ctx0_alt);
+        g_ctx0_alt = nullptr;
+    }
+#endif
+}
+
+int virgl_renderer_resource_create(virgl_renderer_resource_create_args* args, iovec* iov,
+                                   uint32_t num_iovs) {
+    if (!args)
+        return EINVAL;
+
+    if (args->bind == VIRGL_RES_BIND_CURSOR) {
+        // Enforce limitation of current virtio-gpu-3d implementation
+        if (args->width != 64 || args->height != 64 || args->format != VIRGL_FORMAT_B8G8R8A8_UNORM)
+            return EINVAL;
+    }
+
+    assert(!Resource::map.count(args->handle) && "Can't insert same resource twice!");
+
+    Resource* res = new (std::nothrow) Resource(args, num_iovs, iov);
+    if (!res)
+        return ENOMEM;
+
+    printf("Creating Resource %u (num_iovs=%u)\n", args->handle, num_iovs);
+    return 0;
+}
+
+void virgl_renderer_resource_unref(uint32_t res_handle) {
+    std::map<uint32_t, Resource*>::iterator it;
+
+    it = Resource::map.find(res_handle);
+    if (it == Resource::map.end())
+        return;
+
+    Resource* res = it->second;
+
+    for (auto const& it : Context::map) {
+        Context const* ctx = it.second;
+
+        virgl_renderer_ctx_detach_resource(ctx->handle, res->args.handle);
+    }
+
+    assert(res->context_map.empty() && "Deleted resource was associated with contexts");
+
+    printf("Deleting Resource %u\n", res_handle);
+    delete res;
+}
+
+int virgl_renderer_resource_attach_iov(int res_handle, iovec* iov, int num_iovs) {
+    std::map<uint32_t, Resource*>::iterator it;
+
+    it = Resource::map.find((uint32_t)res_handle);
+    if (it == Resource::map.end())
+        return ENOENT;
+
+    Resource* res = it->second;
+
+    if (!res->iov) {
+        printf(
+            "Attaching backing store for Resource %d "
+            "(num_iovs=%d)\n",
+            res_handle, num_iovs);
+
+        res->num_iovs = num_iovs;
+        res->iov = iov;
+
+        res->reallocLinear();
+
+        // Assumes that when resources are attached, they contain junk, and we
+        // don't need to synchronize with the linear buffer
+    }
+
+    return 0;
+}
+
+void virgl_renderer_resource_detach_iov(int res_handle, iovec** iov, int* num_iovs) {
+    std::map<uint32_t, Resource*>::iterator it;
+
+    it = Resource::map.find((uint32_t)res_handle);
+    if (it == Resource::map.end())
+        return;
+
+    Resource* res = it->second;
+
+    printf("Detaching backing store for Resource %d\n", res_handle);
+
+    // Synchronize our linear buffer, if any, with the iovec that we are about
+    // to give up. Most likely this is not required, but it seems cleaner.
+    virgl_box box = {
+        .w = res->args.width,
+        .h = res->args.height,
+    };
+    sync_linear_to_iovec(res, 0, &box);
+
+    if (num_iovs)
+        *num_iovs = res->num_iovs;
+    res->num_iovs = 0U;
+
+    if (iov)
+        *iov = res->iov;
+    res->iov = nullptr;
+
+    res->reallocLinear();
+}
+
+int virgl_renderer_resource_get_info(int res_handle, virgl_renderer_resource_info* info) {
+    if (!info)
+        return EINVAL;
+
+    std::map<uint32_t, Resource*>::iterator it;
+
+    it = Resource::map.find((uint32_t)res_handle);
+    if (it == Resource::map.end())
+        return ENOENT;
+
+    Resource* res = it->second;
+
+    uint32_t bpp = 4U;
+    switch (res->args.format) {
+        case VIRGL_FORMAT_B8G8R8A8_UNORM:
+            info->drm_fourcc = DRM_FORMAT_BGRA8888;
+            break;
+        case VIRGL_FORMAT_B5G6R5_UNORM:
+            info->drm_fourcc = DRM_FORMAT_BGR565;
+            bpp = 2U;
+            break;
+        case VIRGL_FORMAT_R8G8B8A8_UNORM:
+            info->drm_fourcc = DRM_FORMAT_RGBA8888;
+            break;
+        case VIRGL_FORMAT_R8G8B8X8_UNORM:
+            info->drm_fourcc = DRM_FORMAT_RGBX8888;
+            break;
+        default:
+            return EINVAL;
+    }
+
+#ifdef QEMU_HARDWARE_GL_INTEROP
+    GLenum type = GL_UNSIGNED_BYTE;
+    GLenum format = GL_RGBA;
+    switch (res->args.format) {
+        case VIRGL_FORMAT_B8G8R8A8_UNORM:
+            format = 0x80E1;  // GL_BGRA
+            break;
+        case VIRGL_FORMAT_B5G6R5_UNORM:
+            type = GL_UNSIGNED_SHORT_5_6_5;
+            format = GL_RGB;
+            break;
+        case VIRGL_FORMAT_R8G8B8X8_UNORM:
+            format = GL_RGB;
+            break;
+    }
+
+    if (!res->tex_id) {
+        g_glGenTextures(1, &res->tex_id);
+        g_glBindTexture(GL_TEXTURE_2D, res->tex_id);
+        g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    } else {
+        g_glBindTexture(GL_TEXTURE_2D, res->tex_id);
+    }
+
+    g_glPixelStorei(GL_UNPACK_ROW_LENGTH, ALIGN(res->args.width, 16));
+    g_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, res->args.width, res->args.height, 0, format, type,
+                   res->linear);
+#endif
+
+    info->stride = ALIGN(res->args.width * bpp, 16U);
+    info->virgl_format = res->args.format;
+    info->handle = res->args.handle;
+    info->height = res->args.height;
+    info->width = res->args.width;
+    info->depth = res->args.depth;
+    info->flags = res->args.flags;
+    info->tex_id = res->tex_id;
+
+    printf("Scanning out Resource %d\n", res_handle);
+    dump_global_state();
+
+    return 0;
+}
+
+int virgl_renderer_context_create(uint32_t handle, uint32_t nlen, const char* name) {
+    assert(!Context::map.count(handle) && "Can't insert same context twice!");
+
+    Context* ctx = new (std::nothrow) Context(handle, name, nlen, process_cmd, g_dpy);
+    if (!ctx)
+        return ENOMEM;
+
+    printf("Creating Context %u (%.*s)\n", handle, (int)nlen, name);
+    return 0;
+}
+
+void virgl_renderer_context_destroy(uint32_t handle) {
+    std::map<uint32_t, Context*>::iterator it;
+    it = Context::map.find(handle);
+    if (it == Context::map.end())
+        return;
+
+    Context* ctx = it->second;
+    printf("Destroying Context %u\n", handle);
+    delete ctx;
+}
+
+int virgl_renderer_transfer_read_iov(uint32_t handle, uint32_t, uint32_t, uint32_t, uint32_t,
+                                     virgl_box* box, uint64_t offset, iovec*, int) {
+    // stride, layer_stride and level are not set by minigbm, so don't try to
+    // validate them right now. iov and iovec_cnt are always passed as nullptr
+    // and 0 by qemu, so ignore those too
+
+    std::map<uint32_t, Resource*>::iterator it;
+    it = Resource::map.find((uint32_t)handle);
+    if (it == Resource::map.end())
+        return EINVAL;
+
+    return sync_linear_to_iovec(it->second, offset, box);
+}
+
+int virgl_renderer_transfer_write_iov(uint32_t handle, uint32_t, int, uint32_t, uint32_t,
+                                      virgl_box* box, uint64_t offset, iovec*, unsigned int) {
+    // stride, layer_stride and level are not set by minigbm, so don't try to
+    // validate them right now. iov and iovec_cnt are always passed as nullptr
+    // and 0 by qemu, so ignore those too
+
+    std::map<uint32_t, Resource*>::iterator it;
+    it = Resource::map.find((uint32_t)handle);
+    if (it == Resource::map.end())
+        return EINVAL;
+
+    return sync_iovec_to_linear(it->second, offset, box);
+}
+
+void virgl_renderer_ctx_attach_resource(int ctx_id, int res_handle) {
+    std::map<uint32_t, Context*>::iterator ctx_it;
+
+    ctx_it = Context::map.find((uint32_t)ctx_id);
+    if (ctx_it == Context::map.end())
+        return;
+
+    Context* ctx = ctx_it->second;
+
+    assert(!ctx->resource_map.count((uint32_t)res_handle) &&
+           "Can't attach resource to context twice!");
+
+    std::map<uint32_t, Resource*>::iterator res_it;
+
+    res_it = Resource::map.find((uint32_t)res_handle);
+    if (res_it == Resource::map.end())
+        return;
+
+    Resource* res = res_it->second;
+
+    printf("Attaching Resource %d to Context %d\n", res_handle, ctx_id);
+    res->context_map.emplace((uint32_t)ctx_id, ctx);
+    ctx->resource_map.emplace((uint32_t)res_handle, res);
+}
+
+void virgl_renderer_ctx_detach_resource(int ctx_id, int res_handle) {
+    std::map<uint32_t, Context*>::iterator ctx_it;
+
+    ctx_it = Context::map.find((uint32_t)ctx_id);
+    if (ctx_it == Context::map.end())
+        return;
+
+    Context* ctx = ctx_it->second;
+
+    std::map<uint32_t, Resource*>::iterator res_it;
+
+    res_it = ctx->resource_map.find((uint32_t)res_handle);
+    if (res_it == ctx->resource_map.end())
+        return;
+
+    Resource* res = res_it->second;
+
+    ctx_it = res->context_map.find((uint32_t)ctx_id);
+    if (ctx_it == res->context_map.end())
+        return;
+
+    printf("Detaching Resource %d from Context %d\n", res_handle, ctx_id);
+    if (ctx->cmd_resp && ctx->cmd_resp->args.handle == (uint32_t)res_handle)
+        ctx->cmd_resp = nullptr;
+    ctx->resource_map.erase(res_it);
+    res->context_map.erase(ctx_it);
+}
diff --git a/host/libs/virglrenderer/Android.bp b/host/libs/virglrenderer/Android.bp
new file mode 100644
index 000000000..7fd35d904
--- /dev/null
+++ b/host/libs/virglrenderer/Android.bp
@@ -0,0 +1,43 @@
+//
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+cc_library_host_shared {
+    name: "libvirglrenderer",
+    include_dirs: [
+        "external/libdrm",
+        "external/libdrm/include",
+        "device/generic/goldfish-opengl/system",
+    ],
+    local_include_dirs: [ "include" ],
+    srcs: [
+        "AVDVirglRenderer.cpp",
+        "ChecksumCalculator.cpp",
+        "GLESv1.cpp",
+        "GLESv1_dec/gles1_dec.cpp",
+        "GLESv3.cpp",
+        "GLESv3_dec/gles3_dec.cpp",
+        "Gralloc1.cpp",
+        "OpenGLESDispatch/EGLDispatch.cpp",
+        "OpenGLESDispatch/GLESv1Dispatch.cpp",
+        "OpenGLESDispatch/GLESv3Dispatch.cpp",
+        "RenderControl.cpp",
+        "renderControl_dec/renderControl_dec.cpp",
+    ],
+    cflags: ["-Wno-unused-parameter", "-DOPENGL_DEBUG_PRINTOUT"],
+    host_ldlibs: [ "-ldl" ],
+    version_script : "libvirglrenderer.lds",
+    defaults: [ "cuttlefish_host_only" ],
+}
diff --git a/host/libs/virglrenderer/ChecksumCalculator.cpp b/host/libs/virglrenderer/ChecksumCalculator.cpp
index 7bd82fc76..b5d11c0cf 100644
--- a/host/libs/virglrenderer/ChecksumCalculator.cpp
+++ b/host/libs/virglrenderer/ChecksumCalculator.cpp
@@ -1,23 +1,21 @@
 /*
-* Copyright (C) 2016 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include "ChecksumCalculator.h"
 
-#include "android/base/files/Stream.h"
-
 #include <string>
 #include <vector>
 
@@ -140,33 +138,3 @@ uint32_t ChecksumCalculator::computeV1Checksum() const {
     revLen = (revLen & 0xaaaaaaaa) >> 1 | (revLen & 0x55555555) << 1;
     return revLen;
 }
-
-void ChecksumCalculator::save(android::base::Stream* stream) {
-    assert(!m_isEncodingChecksum);
-    switch (m_version) {
-    case 1:
-        assert(m_v1BufferTotalLength == 0);
-        break;
-    }
-
-    // Our checksum should never become > 255 bytes. Ever.
-    assert((uint8_t)m_checksumSize == m_checksumSize);
-    stream->putByte(m_checksumSize);
-    stream->putBe32(m_version);
-    stream->putBe32(m_numRead);
-    stream->putBe32(m_numWrite);
-}
-
-void ChecksumCalculator::load(android::base::Stream* stream) {
-    assert(!m_isEncodingChecksum);
-    switch (m_version) {
-    case 1:
-        assert(m_v1BufferTotalLength == 0);
-        break;
-    }
-
-    m_checksumSize = stream->getByte();
-    m_version = stream->getBe32();
-    m_numRead = stream->getBe32();
-    m_numWrite = stream->getBe32();
-}
diff --git a/host/libs/virglrenderer/ChecksumCalculator.h b/host/libs/virglrenderer/ChecksumCalculator.h
index df94403e2..8e8ce952a 100644
--- a/host/libs/virglrenderer/ChecksumCalculator.h
+++ b/host/libs/virglrenderer/ChecksumCalculator.h
@@ -1,18 +1,18 @@
 /*
-* Copyright (C) 2016 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #pragma once
 
@@ -29,7 +29,11 @@
 #define LOG_CHECKSUMHELPER(x...)
 #endif
 
-namespace android { namespace base { class Stream; } }
+namespace android {
+namespace base {
+class Stream;
+}
+}  // namespace android
 
 // ChecksumCalculator adds checksum as an array of bytes to GL pipe communication, which
 // size depends on the protocol version. Each pipe should use one ChecksumCalculator.
@@ -124,11 +128,13 @@ namespace android { namespace base { class Stream; } }
 // }
 
 class ChecksumCalculator {
-public:
+  public:
     static constexpr size_t kMaxChecksumLength = 8;
 
     // Get and set current checksum version
-    uint32_t getVersion() const { return m_version; }
+    uint32_t getVersion() const {
+        return m_version;
+    }
     // Call setVersion to set a checksum version. It should be called before
     // addBuffer(), writeChecksum() and validate(). And it should be called
     // exact once per rendering thread if both host and guest support checksum.
@@ -146,7 +152,9 @@ public:
     static const char* getMaxVersionStrPrefix();
 
     // Size of checksum in the current version
-    size_t checksumByteSize() const { return m_checksumSize; }
+    size_t checksumByteSize() const {
+        return m_checksumSize;
+    }
 
     // Update the current checksum value from the data
     // at |buf| of |bufLen| bytes. Once all buffers
@@ -169,11 +177,7 @@ public:
     // Will reset the list of buffers by calling resetChecksum.
     bool validate(const void* expectedChecksum, size_t expectedChecksumLen);
 
-    // Snapshot support.
-    void save(android::base::Stream* stream);
-    void load(android::base::Stream* stream);
-
-private:
+  private:
     static constexpr size_t kVersion1ChecksumSize = 8;  // 2 x uint32_t
 
     static_assert(kVersion1ChecksumSize <= kMaxChecksumLength,
diff --git a/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h b/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h
index e22d3bade..51f8e1c31 100644
--- a/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h
+++ b/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h
@@ -1,60 +1,45 @@
 /*
-* Copyright (C) 2016 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #pragma once
 
 #include "ChecksumCalculator.h"
 
-// ChecksumCalculatorThreadInfo is the class that makes ChecksumCalculator
-// thread-safe. On the host, please only use ChecksumCalculator through this
-// class.
+#include <stdio.h>
 
-class ChecksumCalculatorThreadInfo {
-public:
-    ChecksumCalculatorThreadInfo();
-    ~ChecksumCalculatorThreadInfo();
-
-    ChecksumCalculator& get();
+// NOTE: This fork of ChecksumCalculatorThreadInfo is *not* thread safe
 
-    static bool setVersion(uint32_t version);
-
-    static uint32_t getMaxVersion();
-    static const char* getMaxVersionString() {
-        return ChecksumCalculator::getMaxVersionStr();
+class ChecksumCalculatorThreadInfo {
+  public:
+    static bool writeChecksum(ChecksumCalculator* calc, void* buf, size_t bufLen,
+                              void* outputChecksum, size_t outputChecksumLen) {
+        calc->addBuffer(buf, bufLen);
+        return calc->writeChecksum(outputChecksum, outputChecksumLen);
     }
 
-    static bool writeChecksum(ChecksumCalculator* calc,
-                              void* buf,
-                              size_t bufLen,
-                              void* outputChecksum,
-                              size_t outputChecksumLen);
-
-    static bool validate(ChecksumCalculator* calc,
-                         void* buf,
-                         size_t bufLen,
-                         void* checksum,
-                         size_t checksumLen);
-
-    static void validOrDie(ChecksumCalculator* calc,
-                           void* buf,
-                           size_t bufLen,
-                           void* checksum,
-                           size_t checksumLen,
-                           const char* message);
+    static bool validate(ChecksumCalculator* calc, void* buf, size_t bufLen, void* checksum,
+                         size_t checksumLen) {
+        calc->addBuffer(buf, bufLen);
+        return calc->validate(checksum, checksumLen);
+    }
 
-private:
-    ChecksumCalculator m_protocol;
+    static void validOrDie(ChecksumCalculator* calc, void* buf, size_t bufLen, void* checksum,
+                           size_t checksumLen, const char* message) {
+        if (!validate(calc, buf, bufLen, checksum, checksumLen)) {
+            printf("%s\n", message);
+        }
+    }
 };
diff --git a/host/libs/virglrenderer/Context.h b/host/libs/virglrenderer/Context.h
new file mode 100644
index 000000000..53c5488cd
--- /dev/null
+++ b/host/libs/virglrenderer/Context.h
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#undef NDEBUG
+
+#include <cassert>
+#include <condition_variable>
+#include <cstdint>
+#include <map>
+#include <mutex>
+#include <string>
+#include <thread>
+
+#include "GLESv1.h"
+#include "GLESv3.h"
+#include "RenderControl.h"
+#include "Resource.h"
+
+struct EglContext;
+struct Context;
+
+typedef void (*PFNSUBMITCMD)(Context*, char*, size_t, int);
+
+struct Context {
+    static std::map<uint32_t, Context*> map;
+
+    Context(uint32_t handle_, const char* name_, uint32_t nlen_, PFNSUBMITCMD pfnProcessCmd_,
+            EGLDisplay dpy_)
+        : render_control(this, dpy_), worker(), name(std::string(name_, nlen_)), handle(handle_),
+          pfnProcessCmd(pfnProcessCmd_) {
+        map.emplace(handle, this);
+        reset();
+    }
+
+    ~Context() {
+        {
+            std::lock_guard<std::mutex> lk(m);
+            killWorker = true;
+        }
+        cv.notify_one();
+        if (worker.joinable())
+            worker.join();
+        map.erase(handle);
+    }
+
+    Context* bind(EglContext* ctx_) {
+        for (auto const& it : Context::map) {
+            Context* ctx = it.second;
+            if (ctx == this)
+                continue;
+            if (ctx->ctx == ctx_)
+                return ctx;
+        }
+        ctx = ctx_;
+        return nullptr;
+    }
+
+    void unbind() {
+        ctx = nullptr;
+    }
+
+    void setPidTid(int pid_, int tid_) {
+        if (pid != pid_ && tid != tid_) {
+            assert(!worker.joinable() && "Changing pid/tid is not allowed");
+            worker = std::thread(&Context::worker_func, this);
+        }
+        pid = pid_;
+        tid = tid_;
+    }
+
+    void submitCommand(void* buf, size_t bufSize) {
+        char* cmdBufCopy = new char[bufSize];
+        memcpy(cmdBufCopy, buf, bufSize);
+        {
+            std::lock_guard<std::mutex> lk(m);
+            cmdBufSize = bufSize;
+            cmdBuf = cmdBufCopy;
+        }
+        cv.notify_one();
+    }
+
+    void setFence(int fence_) {
+        {
+            std::lock_guard<std::mutex> lk(m);
+            fence = fence_;
+            if (!worker.joinable())
+                processCmd();
+        }
+        cv.notify_one();
+    }
+
+    std::map<uint32_t, Resource*> resource_map;
+    ChecksumCalculator checksum_calc;
+    RenderControl render_control;
+    Resource* cmd_resp = nullptr;
+    EglContext* ctx = nullptr;
+    std::thread worker;
+    std::string name;
+    uint32_t handle;
+    GLESv1 gles1;
+    GLESv3 gles3;
+    int pid = 0;
+    int tid = 0;
+
+  private:
+    std::condition_variable cv;
+    PFNSUBMITCMD pfnProcessCmd;
+    bool killWorker = false;
+    size_t cmdBufSize;
+    char* cmdBuf;
+    std::mutex m;
+    int fence;
+
+    void reset() {
+        cmdBuf = nullptr;
+        cmdBufSize = 0U;
+        fence = 0;
+    }
+
+    void worker_func() {
+        while (!killWorker) {
+            std::unique_lock<std::mutex> lk(m);
+            cv.wait(lk, [this] { return killWorker || (cmdBuf && fence); });
+            if (!killWorker)
+                processCmd();
+            lk.unlock();
+        }
+    }
+
+    void processCmd() {
+        pfnProcessCmd(this, cmdBuf, cmdBufSize, fence);
+        delete cmdBuf;
+        reset();
+    }
+};
diff --git a/host/libs/virglrenderer/EglConfig.h b/host/libs/virglrenderer/EglConfig.h
new file mode 100644
index 000000000..3b5cd2b49
--- /dev/null
+++ b/host/libs/virglrenderer/EglConfig.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+typedef EGLBoolean (*PFNEGLGETCONFIGATTRIB)(EGLDisplay, EGLConfig, EGLint, EGLint*);
+
+struct EglConfig {
+    static std::vector<EglConfig*> vec;
+
+    // clang-format off
+    static constexpr EGLint kAttribs[] = {
+        EGL_DEPTH_SIZE,
+        EGL_STENCIL_SIZE,
+        EGL_RENDERABLE_TYPE,
+        EGL_SURFACE_TYPE,
+        EGL_CONFIG_ID,
+        EGL_BUFFER_SIZE,
+        EGL_ALPHA_SIZE,
+        EGL_BLUE_SIZE,
+        EGL_GREEN_SIZE,
+        EGL_RED_SIZE,
+        EGL_CONFIG_CAVEAT,
+        EGL_LEVEL,
+        EGL_MAX_PBUFFER_HEIGHT,
+        EGL_MAX_PBUFFER_PIXELS,
+        EGL_MAX_PBUFFER_WIDTH,
+        EGL_NATIVE_RENDERABLE,
+        EGL_NATIVE_VISUAL_ID,
+        EGL_NATIVE_VISUAL_TYPE,
+        0x3030, // EGL_PRESERVED_RESOURCES
+        EGL_SAMPLES,
+        EGL_SAMPLE_BUFFERS,
+        EGL_TRANSPARENT_TYPE,
+        EGL_TRANSPARENT_BLUE_VALUE,
+        EGL_TRANSPARENT_GREEN_VALUE,
+        EGL_TRANSPARENT_RED_VALUE,
+        EGL_BIND_TO_TEXTURE_RGB,
+        EGL_BIND_TO_TEXTURE_RGBA,
+        EGL_MIN_SWAP_INTERVAL,
+        EGL_MAX_SWAP_INTERVAL,
+        EGL_LUMINANCE_SIZE,
+        EGL_ALPHA_MASK_SIZE,
+        EGL_COLOR_BUFFER_TYPE,
+        //EGL_MATCH_NATIVE_PIXMAP,
+        EGL_RECORDABLE_ANDROID,
+        EGL_CONFORMANT
+    };
+    // clang-format on
+
+    static constexpr size_t kNumAttribs = sizeof(kAttribs) / sizeof(kAttribs[0]);
+
+    EglConfig(EGLDisplay dpy, EGLConfig config_, PFNEGLGETCONFIGATTRIB pfnEglGetConfigAttrib)
+        : config(config_) {
+        for (size_t a = 0; a < kNumAttribs; a++) {
+            if (!pfnEglGetConfigAttrib(dpy, config, kAttribs[a], &attribs[a]))
+                attribs[a] = 0;
+        }
+        vec.push_back(this);
+    }
+
+    ~EglConfig() {
+        for (size_t i = 0; i < EglConfig::vec.size(); i++) {
+            if (vec[i] == this) {
+                vec.erase(vec.begin() + i);
+                break;
+            }
+        }
+    }
+
+    EGLint attribs[kNumAttribs];
+    EGLConfig config;
+};
diff --git a/host/libs/virglrenderer/EglContext.h b/host/libs/virglrenderer/EglContext.h
new file mode 100644
index 000000000..7283c08cd
--- /dev/null
+++ b/host/libs/virglrenderer/EglContext.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <map>
+
+#include <EGL/egl.h>
+
+struct EglContext {
+    enum GLESApi {
+        GLESApi_CM = 1,
+        GLESApi_2 = 2,
+        GLESApi_3_0 = 3,
+        GLESApi_3_1 = 4,
+    };
+
+    static std::map<uint32_t, EglContext*> map;
+    static uint32_t nextId;
+
+    EglContext(EGLContext context_, uint32_t ctx_, GLESApi api_)
+        : create_ctx(ctx_), context(context_), api(api_), id(nextId++) {
+        map.emplace(id, this);
+    }
+
+    ~EglContext() {
+        map.erase(id);
+    }
+
+    EglContext* bind(uint32_t ctx_) {
+        for (auto const& it : EglContext::map) {
+            EglContext* ctx = it.second;
+            if (ctx == this)
+                continue;
+            if (ctx->bound_ctx == ctx_)
+                return ctx;
+        }
+        bound_ctx = ctx_;
+        return nullptr;
+    }
+
+    void unbind() {
+        bound_ctx = 0U;
+    }
+
+    bool disposable() {
+        return context == EGL_NO_CONTEXT && bound_ctx == 0U;
+    }
+
+    uint32_t create_ctx;
+    EGLContext context;
+    enum GLESApi api;
+    uint32_t id;
+
+  private:
+    uint32_t bound_ctx = 0U;
+};
diff --git a/host/libs/virglrenderer/EglImage.h b/host/libs/virglrenderer/EglImage.h
new file mode 100644
index 000000000..09b968c20
--- /dev/null
+++ b/host/libs/virglrenderer/EglImage.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <map>
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+typedef EGLBoolean (*PFNEGLDESTROYIMAGEKHR)(EGLDisplay, EGLImageKHR);
+
+struct EglImage {
+    static std::map<uint32_t, EglImage*> map;
+    static uint32_t nextId;
+
+    EglImage(EGLDisplay dpy_, EGLImageKHR image_, PFNEGLDESTROYIMAGEKHR pfnEglDestroyImageKHR_)
+        : pfnEglDestroyImageKHR(pfnEglDestroyImageKHR_), image(image_), dpy(dpy_), id(nextId++) {
+        map.emplace(id, this);
+    }
+
+    ~EglImage() {
+        pfnEglDestroyImageKHR(dpy, image);
+        map.erase(id);
+    }
+
+    PFNEGLDESTROYIMAGEKHR pfnEglDestroyImageKHR;
+    EGLImageKHR image;
+    EGLDisplay dpy;
+    uint32_t id;
+};
diff --git a/host/libs/virglrenderer/EglSurface.h b/host/libs/virglrenderer/EglSurface.h
new file mode 100644
index 000000000..4bb880dbb
--- /dev/null
+++ b/host/libs/virglrenderer/EglSurface.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <map>
+
+#include <EGL/egl.h>
+
+struct ANativeWindow;
+
+struct EglSurface {
+    static std::map<uint32_t, EglSurface*> map;
+    static uint32_t nextId;
+
+    EglSurface(EGLConfig config_, uint32_t ctx_, uint32_t width_, uint32_t height_)
+        : create_ctx(ctx_), config(config_), height(height_), width(width_), id(nextId++) {
+        map.emplace(id, this);
+    }
+
+    ~EglSurface() {
+        map.erase(id);
+    }
+
+    EglSurface* bind(uint32_t ctx_, bool read_) {
+        for (auto const& it : EglSurface::map) {
+            EglSurface* sur = it.second;
+            if (sur == this)
+                continue;
+            if (sur->bound_ctx == ctx_) {
+                if (read_ && sur->read)
+                    return sur;
+                if (!read_ && sur->draw)
+                    return sur;
+            }
+        }
+        if (read_) {
+            read = true;
+        } else {
+            draw = true;
+        }
+        bound_ctx = ctx_;
+        return nullptr;
+    }
+
+    void unbind(bool read_) {
+        if (read || draw) {
+            if (read_)
+                read = false;
+            else
+                draw = false;
+            if (read || draw)
+                return;
+            bound_ctx = 0U;
+        }
+        return;
+    }
+
+    bool disposable() {
+        return surface == EGL_NO_SURFACE && bound_ctx == 0U;
+    }
+
+    EGLSurface surface = EGL_NO_SURFACE;
+    ANativeWindow* window = nullptr;
+    uint32_t create_ctx;
+    EGLConfig config;
+    uint32_t height;
+    uint32_t width;
+    uint32_t id;
+
+  private:
+    uint32_t bound_ctx = 0U;
+    bool draw = false;
+    bool read = false;
+};
diff --git a/host/libs/virglrenderer/EglSync.h b/host/libs/virglrenderer/EglSync.h
new file mode 100644
index 000000000..8dda71331
--- /dev/null
+++ b/host/libs/virglrenderer/EglSync.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <map>
+
+#include <EGL/egl.h>
+
+struct EglSync {
+    static std::map<uint64_t, EglSync*> map;
+    static uint64_t nextId;
+
+    EglSync(EGLSyncKHR sync_) : sync(sync_), id(nextId++) {
+        map.emplace(id, this);
+    }
+
+    ~EglSync() {
+        map.erase(id);
+    }
+
+    EGLSyncKHR sync;
+    uint64_t id;
+};
diff --git a/host/libs/virglrenderer/GLESv1.cpp b/host/libs/virglrenderer/GLESv1.cpp
new file mode 100644
index 000000000..17a7ae4b3
--- /dev/null
+++ b/host/libs/virglrenderer/GLESv1.cpp
@@ -0,0 +1,448 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <OpenGLESDispatch/GLESv1Dispatch.h>
+
+#include "GLESv1.h"
+
+// Stubs (common)
+
+static void glDeleteFencesNV(GLsizei, const GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glDisableDriverControlQCOM(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glDiscardFramebufferEXT(GLenum, GLsizei, const GLenum*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glEnableDriverControlQCOM(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glEndTilingQCOM(GLbitfield) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetBufferPointervQCOM(GLenum, GLvoid**) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetBuffersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetFramebuffersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetProgramBinarySourceQCOM(GLuint, GLenum, GLchar*, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetProgramsQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetRenderbuffersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetShadersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetTexLevelParameterivQCOM(GLuint, GLenum, GLint, GLenum, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetTexSubImageQCOM(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei,
+                                    GLenum, GLenum, GLvoid*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetTexturesQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glExtIsProgramBinaryQCOM(GLuint) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+static void glExtTexObjectStateOverrideiQCOM(GLenum, GLenum, GLint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glFinishFenceNV(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glFramebufferTexture2DMultisampleIMG(GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGenFencesNV(GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetDriverControlsQCOM(GLint*, GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetDriverControlStringQCOM(GLuint, GLsizei, GLsizei*, GLchar*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetFenceivNV(GLuint, GLenum, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glIsFenceNV(GLuint) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+static void* glMapBufferOES(GLenum, GLenum) {
+    printf("%s: not implemented\n", __func__);
+    return nullptr;
+}
+
+static void glMultiDrawArraysEXT(GLenum, const GLint*, const GLsizei*, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glMultiDrawElementsEXT(GLenum, const GLsizei*, GLenum, const GLvoid* const*, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glRenderbufferStorageMultisampleIMG(GLenum, GLsizei, GLenum, GLsizei, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glSetFenceNV(GLuint, GLenum) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glStartTilingQCOM(GLuint, GLuint, GLuint, GLuint, GLbitfield) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glTestFenceNV(GLuint) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+// Stubs (ES 1.1)
+
+static void glBindVertexArrayOES(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glCurrentPaletteMatrixOES(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glDeleteVertexArraysOES(GLsizei, const GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGenVertexArraysOES(GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetBufferPointervOES(GLenum, GLenum, GLvoid**) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetTexGenfvOES(GLenum, GLenum, GLfloat*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetTexGenivOES(GLenum, GLenum, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetTexGenxvOES(GLenum, GLenum, GLfixed*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glIsVertexArrayOES(GLuint) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+static void glLoadPaletteFromModelViewMatrixOES() {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glMatrixIndexPointerData(GLint, GLenum, GLsizei, void*, GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glMatrixIndexPointerOffset(GLint, GLenum, GLsizei, GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glMultiDrawArraysSUN(GLenum, GLint*, GLsizei*, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glMultiDrawElementsSUN(GLenum, const GLsizei*, GLenum, const GLvoid**, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLbitfield glQueryMatrixxOES(GLfixed*, GLint*) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static void glTexGenfOES(GLenum, GLenum, GLfloat) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glTexGenfvOES(GLenum, GLenum, const GLfloat*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glTexGeniOES(GLenum, GLenum, GLint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glTexGenivOES(GLenum, GLenum, const GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glTexGenxOES(GLenum, GLenum, GLfixed) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glTexGenxvOES(GLenum, GLenum, const GLfixed*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glUnmapBufferOES(GLenum) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+static void glWeightPointerData(GLint, GLenum, GLsizei, void*, GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glWeightPointerOffset(GLint, GLenum, GLsizei, GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+// Non-stubs (common)
+
+static void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* indices, GLuint) {
+    s_gles1.glDrawElements(mode, count, type, indices);
+}
+
+static void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset) {
+    s_gles1.glDrawElements(mode, count, type, reinterpret_cast<const GLvoid*>(offset));
+}
+
+static GLint glFinishRoundTrip() {
+    s_gles1.glFinish();
+    return 0;
+}
+
+static void glGetCompressedTextureFormats(int count, GLint* formats) {
+    int nFormats;
+    s_gles1.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nFormats);
+    if (nFormats <= count)
+        s_gles1.glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats);
+}
+
+// Non-stubs (ES 1.1)
+
+static void glColorPointerData(GLint size, GLenum type, GLsizei, void* data, GLuint) {
+    s_gles1.glColorPointer(size, type, 0, data);
+}
+
+static void glColorPointerOffset(GLint size, GLenum type, GLsizei, GLuint offset) {
+    s_gles1.glColorPointer(size, type, 0, reinterpret_cast<GLvoid*>(offset));
+}
+
+static void glNormalPointerData(GLenum type, GLsizei, void* data, GLuint) {
+    s_gles1.glNormalPointer(type, 0, data);
+}
+
+static void glNormalPointerOffset(GLenum type, GLsizei, GLuint offset) {
+    s_gles1.glNormalPointer(type, 0, reinterpret_cast<GLvoid*>(offset));
+}
+
+static void glPointSizePointerData(GLenum type, GLsizei, void* data, GLuint) {
+    s_gles1.glPointSizePointerOES(type, 0, data);
+}
+
+static void glPointSizePointerOffset(GLenum type, GLsizei, GLuint offset) {
+    s_gles1.glPointSizePointerOES(type, 0, reinterpret_cast<GLvoid*>(offset));
+}
+
+static void glTexCoordPointerData(GLint, GLint size, GLenum type, GLsizei, void* data, GLuint) {
+    // FIXME: unit?
+    s_gles1.glTexCoordPointer(size, type, 0, data);
+}
+
+static void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei, GLuint offset) {
+    s_gles1.glTexCoordPointer(size, type, 0, reinterpret_cast<GLvoid*>(offset));
+}
+
+static void glVertexPointerData(GLint size, GLenum type, GLsizei, void* data, GLuint) {
+    s_gles1.glVertexPointer(size, type, 0, data);
+}
+
+static void glVertexPointerOffset(GLint size, GLenum type, GLsizei, GLuint offset) {
+    s_gles1.glVertexPointer(size, type, 0, reinterpret_cast<GLvoid*>(offset));
+}
+
+#define KNIT(return_type, function_name, signature, callargs) function_name = s_gles1.function_name;
+
+GLESv1::GLESv1() {
+    LIST_GLES1_FUNCTIONS(KNIT, KNIT)
+
+    // Remap some ES 1.0 extensions that become core in ES 1.1
+    glAlphaFuncxOES = glAlphaFuncx;
+    glClearColorxOES = glClearColorx;
+    glClearDepthfOES = glClearDepthf;
+    glClearDepthxOES = glClearDepthx;
+    glClipPlanefIMG = glClipPlanef;
+    glClipPlanefOES = glClipPlanef;
+    glClipPlanexIMG = glClipPlanex;
+    glClipPlanexOES = glClipPlanex;
+    glColor4xOES = glColor4x;
+    glDepthRangefOES = glDepthRangef;
+    glDepthRangexOES = glDepthRangex;
+    glFogxOES = glFogx;
+    glFogxvOES = glFogxv;
+    glFrustumfOES = glFrustumf;
+    glFrustumxOES = glFrustumx;
+    glGetClipPlanefOES = glGetClipPlanef;
+    glGetClipPlanexOES = glGetClipPlanex;
+    glGetFixedvOES = glGetFixedv;
+    glGetLightxvOES = glGetLightxv;
+    glGetMaterialxvOES = glGetMaterialxv;
+    glGetTexEnvxvOES = glGetTexEnvxv;
+    glGetTexParameterxvOES = glGetTexParameterxv;
+    glLightModelxOES = glLightModelx;
+    glLightModelxvOES = glLightModelxv;
+    glLightxOES = glLightx;
+    glLightxvOES = glLightxv;
+    glLineWidthxOES = glLineWidthx;
+    glLoadMatrixxOES = glLoadMatrixx;
+    glMaterialxOES = glMaterialx;
+    glMaterialxvOES = glMaterialxv;
+    glMultiTexCoord4xOES = glMultiTexCoord4x;
+    glMultMatrixxOES = glMultMatrixx;
+    glNormal3xOES = glNormal3x;
+    glOrthofOES = glOrthof;
+    glOrthoxOES = glOrthox;
+    glPointParameterxOES = glPointParameterx;
+    glPointParameterxvOES = glPointParameterxv;
+    glPointSizexOES = glPointSizex;
+    glPolygonOffsetxOES = glPolygonOffsetx;
+    glRotatexOES = glRotatex;
+    glSampleCoveragexOES = glSampleCoveragex;
+    glScalexOES = glScalex;
+    glTexEnvxOES = glTexEnvx;
+    glTexEnvxvOES = glTexEnvxv;
+    glTexParameterxOES = glTexParameterx;
+    glTexParameterxvOES = glTexParameterxv;
+    glTranslatexOES = glTranslatex;
+
+    // Entrypoints requiring custom wrappers (common)
+    glDrawElementsData = ::glDrawElementsData;
+    glDrawElementsOffset = ::glDrawElementsOffset;
+    glFinishRoundTrip = ::glFinishRoundTrip;
+    glGetCompressedTextureFormats = ::glGetCompressedTextureFormats;
+
+    // Entrypoints requiring custom wrappers (ES 1.1)
+    glColorPointerData = ::glColorPointerData;
+    glColorPointerOffset = ::glColorPointerOffset;
+    glNormalPointerData = ::glNormalPointerData;
+    glNormalPointerOffset = ::glNormalPointerOffset;
+    glPointSizePointerData = ::glPointSizePointerData;
+    glPointSizePointerOffset = ::glPointSizePointerOffset;
+    glTexCoordPointerData = ::glTexCoordPointerData;
+    glTexCoordPointerOffset = ::glTexCoordPointerOffset;
+    glVertexPointerData = ::glVertexPointerData;
+    glVertexPointerOffset = ::glVertexPointerOffset;
+
+    // Stub some extensions we will never implement (common)
+    glDeleteFencesNV = ::glDeleteFencesNV;
+    glDisableDriverControlQCOM = ::glDisableDriverControlQCOM;
+    glDiscardFramebufferEXT = ::glDiscardFramebufferEXT;
+    glEnableDriverControlQCOM = ::glEnableDriverControlQCOM;
+    glEndTilingQCOM = ::glEndTilingQCOM;
+    glExtGetBufferPointervQCOM = ::glExtGetBufferPointervQCOM;
+    glExtGetBuffersQCOM = ::glExtGetBuffersQCOM;
+    glExtGetFramebuffersQCOM = ::glExtGetFramebuffersQCOM;
+    glExtGetProgramBinarySourceQCOM = ::glExtGetProgramBinarySourceQCOM;
+    glExtGetProgramsQCOM = ::glExtGetProgramsQCOM;
+    glExtGetRenderbuffersQCOM = ::glExtGetRenderbuffersQCOM;
+    glExtGetShadersQCOM = ::glExtGetShadersQCOM;
+    glExtGetTexLevelParameterivQCOM = ::glExtGetTexLevelParameterivQCOM;
+    glExtGetTexSubImageQCOM = ::glExtGetTexSubImageQCOM;
+    glExtGetTexturesQCOM = ::glExtGetTexturesQCOM;
+    glExtIsProgramBinaryQCOM = ::glExtIsProgramBinaryQCOM;
+    glExtTexObjectStateOverrideiQCOM = ::glExtTexObjectStateOverrideiQCOM;
+    glFinishFenceNV = ::glFinishFenceNV;
+    glFramebufferTexture2DMultisampleIMG = ::glFramebufferTexture2DMultisampleIMG;
+    glGenFencesNV = ::glGenFencesNV;
+    glGetDriverControlsQCOM = ::glGetDriverControlsQCOM;
+    glGetDriverControlStringQCOM = ::glGetDriverControlStringQCOM;
+    glGetFenceivNV = ::glGetFenceivNV;
+    glIsFenceNV = ::glIsFenceNV;
+    glMapBufferOES = ::glMapBufferOES;
+    glMultiDrawArraysEXT = ::glMultiDrawArraysEXT;
+    glMultiDrawElementsEXT = ::glMultiDrawElementsEXT;
+    glRenderbufferStorageMultisampleIMG = ::glRenderbufferStorageMultisampleIMG;
+    glSetFenceNV = ::glSetFenceNV;
+    glStartTilingQCOM = ::glStartTilingQCOM;
+    glTestFenceNV = ::glTestFenceNV;
+
+    // Stub some extensions we will never implement (ES 1.1)
+    glBindVertexArrayOES = ::glBindVertexArrayOES;
+    glCurrentPaletteMatrixOES = ::glCurrentPaletteMatrixOES;
+    glDeleteVertexArraysOES = ::glDeleteVertexArraysOES;
+    glGenVertexArraysOES = ::glGenVertexArraysOES;
+    glGetBufferPointervOES = ::glGetBufferPointervOES;
+    glGetTexGenfvOES = ::glGetTexGenfvOES;
+    glGetTexGenivOES = ::glGetTexGenivOES;
+    glGetTexGenxvOES = ::glGetTexGenxvOES;
+    glIsVertexArrayOES = ::glIsVertexArrayOES;
+    glLoadPaletteFromModelViewMatrixOES = ::glLoadPaletteFromModelViewMatrixOES;
+    glMatrixIndexPointerData = ::glMatrixIndexPointerData;
+    glMatrixIndexPointerOffset = ::glMatrixIndexPointerOffset;
+    glMultiDrawArraysSUN = ::glMultiDrawArraysSUN;
+    glMultiDrawElementsSUN = ::glMultiDrawElementsSUN;
+    glQueryMatrixxOES = ::glQueryMatrixxOES;
+    glTexGenfOES = ::glTexGenfOES;
+    glTexGenfvOES = ::glTexGenfvOES;
+    glTexGeniOES = ::glTexGeniOES;
+    glTexGenivOES = ::glTexGenivOES;
+    glTexGenxOES = ::glTexGenxOES;
+    glTexGenxvOES = ::glTexGenxvOES;
+    glUnmapBufferOES = ::glUnmapBufferOES;
+    glWeightPointerData = ::glWeightPointerData;
+    glWeightPointerOffset = ::glWeightPointerOffset;
+}
diff --git a/host/libs/virglrenderer/GLESv1.h b/host/libs/virglrenderer/GLESv1.h
new file mode 100644
index 000000000..f8b90732b
--- /dev/null
+++ b/host/libs/virglrenderer/GLESv1.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "GLESv1_dec/gles1_dec.h"
+
+struct GLESv1 : public gles1_decoder_context_t {
+    GLESv1();
+};
diff --git a/host/libs/virglrenderer/GLESv1_dec/gles1.attrib b/host/libs/virglrenderer/GLESv1_dec/gles1.attrib
index 3cbc9d37e..a1f1ee769 100644
--- a/host/libs/virglrenderer/GLESv1_dec/gles1.attrib
+++ b/host/libs/virglrenderer/GLESv1_dec/gles1.attrib
@@ -1,704 +1,444 @@
 GLOBAL
-	base_opcode 1024
-	encoder_headers "glUtils.h" "GLEncoderUtils.h"
-	
-#void glClipPlanef(GLenum plane, GLfloat *equation)
-glClipPlanef
-  dir equation in
-	len equation (4 * sizeof(float))
+    base_opcode 1024
 
-#void glFogfv(GLenum pname, GLfloat *params)
-glFogfv
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
+glClipPlanef
+    dir equation in
+    len equation (4 * sizeof(float))
 
-#void glGetFloatv(GLenum pname, GLfloat *params)
 glGetFloatv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
+    dir params out
 
-#void glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 glGetLightfv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
+    dir params out
 
-#void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 glGetMaterialfv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
+    dir params out
 
-#void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params)
 glGetTexEnvfv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
+    dir params out
 
-#void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 glGetTexParameterfv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-#void glLightModelfv(GLenum pname, GLfloat *params)
-glLightModelfv
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
+    dir params out
 
-#void glLightfv(GLenum light, GLenum pname, GLfloat *params)
-glLightfv
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-#void glLoadMatrixf(GLfloat *m)
 glLoadMatrixf
-	len m (16 * sizeof(GLfloat))
-
-#void glMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-glMaterialfv
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
+    len m (16 * sizeof(GLfloat))
 
-#void glMultMatrixf(GLfloat *m)
 glMultMatrixf
-	len m (16 * sizeof(GLfloat))
+    len m (16 * sizeof(GLfloat))
 
-#void glPointParameterfv(GLenum pname, GLfloat *params)
-glPointParameterfv
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-#void glTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-glTexEnvfv
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-#void glTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-glTexParameterfv
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-#void glBufferData(GLenum target, GLsizeiptr size, GLvoid *data, GLenum usage)
 glBufferData
-	len data size
-	var_flag data nullAllowed
+    len data size
+    var_flag data nullAllowed
 
-#void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 glBufferSubData
-	dir data in
-	len data size
-	var_flag data nullAllowed
+    dir data in
+    len data size
+    var_flag data nullAllowed
 
-#void glClipPlanex(GLenum plane, GLfixed *eqn)
 glClipPlanex
-	dir eqn in
-	len eqn (4 * sizeof(GLfixed))
+    dir eqn in
+    len eqn (4 * sizeof(GLfixed))
 
-#void glColorPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
-#we treat the pointer as offset to a VBO
 glColorPointer
-	len pointer (sizeof(unsigned int))
-	flag unsupported
+    len pointer (sizeof(unsigned int))
+    flag unsupported
 
-#void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid *data)
 glCompressedTexImage2D
-	len data imageSize
+    len data imageSize
     var_flag data nullAllowed
 
-#void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid *data)
 glCompressedTexSubImage2D
-	len data imageSize
+    len data imageSize
         var_flag data nullAllowed
 
-#void glDeleteBuffers(GLsizei n, GLuint *buffers)
 glDeleteBuffers
-    flag custom_decoder
-	len buffers (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    len buffers (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glDeleteTextures(GLsizei n, GLuint *textures)
 glDeleteTextures
-    flag custom_decoder
-	len textures (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    len textures (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#this function is marked as unsupported - it shouldn't be called directly
-#instead it translated into - glDrawDirectElements and glDrawIndirectElements
-#void glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid *indices)
 glDrawElements
-	flag unsupported
-
-
-#void glFogxv(GLenum pname, GLfixed *params)
-glFogxv
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    flag unsupported
 
-#void glGetBooleanv(GLenum pname, GLboolean *params)
 glGetBooleanv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLboolean))
+    dir params out
 
-#void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 glGetBufferParameteriv
-	len params (sizeof(GLint))
-	dir params out
+    len params (sizeof(GLint))
+    dir params out
 
-#void glGenBuffers(GLsizei n, GLuint *buffers)
 glGenBuffers
-    flag custom_decoder
-	len buffers (n * sizeof(GLuint))
-	dir buffers out
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    len buffers (n * sizeof(GLuint))
+    dir buffers out
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenTextures(GLsizei n, GLuint *textures)
 glGenTextures
-    flag custom_decoder
-	len textures (n * sizeof(GLuint))
-	dir textures out
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    len textures (n * sizeof(GLuint))
+    dir textures out
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGetFixedv(GLenum pname, GLfixed *params)
 glGetFixedv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetIntegerv(GLenum pname, GLint *params)
 glGetIntegerv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
+    dir params out
 
-#void glGetLightxv(GLenum light, GLenum pname, GLfixed *params)
 glGetLightxv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
 glGetMaterialxv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetPointerv(GLenum pname, void **params)
 glGetPointerv
-	flag unsupported
+    flag unsupported
 
-#GLubyte* glGetString(GLenum name)
 glGetString
-  flag unsupported
+    flag unsupported
 
-#void glGetTexEnviv(GLenum env, GLenum pname, GLint *params)
 glGetTexEnviv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
+    dir params out
 
-#void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params)
 glGetTexEnvxv
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 glGetTexParameteriv
-	dir params out
-	len params (sizeof(GLint))
+    dir params out
+    len params (sizeof(GLint))
 
-#void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
 glGetTexParameterxv
-	dir params out
-	len params (sizeof(GLfixed))
-
-#void glLightModelxv(GLenum pname, GLfixed *params)
-glLightModelxv
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
-
-#void glLightxv(GLenum light, GLenum pname, GLfixed *params)
-glLightxv
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
+    len params (sizeof(GLfixed))
 
-#void glLoadMatrixx(GLfixed *m)
 glLoadMatrixx
-	len m (16 * sizeof(GLfixed))
+    len m (16 * sizeof(GLfixed))
 
-#void glMaterialxv(GLenum face, GLenum pname, GLfixed *params)
-glMaterialxv
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
-
-#void glMultMatrixx(GLfixed *m)
 glMultMatrixx
-	len m (16 * sizeof(GLfixed))
+    len m (16 * sizeof(GLfixed))
 
-#void glNormalPointer(GLenum type, GLsizei stride, GLvoid *pointer)
-#we treat the pointer as an offset to a VBO
 glNormalPointer
-	len pointer (sizeof(unsigned int))
-	flag unsupported
-
-#void glPointParameterxv(GLenum pname, GLfixed *params)
-glPointParameterxv
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    len pointer (sizeof(unsigned int))
+    flag unsupported
 
-#void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 glReadPixels
-	dir pixels out
-	len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 1)
+    dir pixels out
+    len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 1)
 
-#void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
 glTexCoordPointer
-	len pointer (sizeof(unsigned int))
-	flag unsupported
-
-#void glTexEnviv(GLenum target, GLenum pname, GLint *params)
-glTexEnviv
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
-
-#void glTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
-glTexEnvxv
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    len pointer (sizeof(unsigned int))
+    flag unsupported
 
-#void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels)
 glTexImage2D
-	dir pixels in
-	len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0)
-	var_flag pixels nullAllowed isLarge
+    dir pixels in
+    len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0)
+    var_flag pixels nullAllowed isLarge
 
-#void glTexParameteriv(GLenum target, GLenum pname, GLint *params)
-glTexParameteriv
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
-
-#void glTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
-glTexParameterxv
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
-
-#void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 glTexSubImage2D
-	len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0)
-        var_flag pixels nullAllowed isLarge
+    len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0)
+    var_flag pixels nullAllowed isLarge
 
-#void glVertexPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
-# we treat the pointer as an offset to a VBO
 glVertexPointer
-	flag unsupported
+    flag unsupported
 
-#void glPointSizePointerOES(GLenum type, GLsizei stride, GLvoid *pointer)
 glPointSizePointerOES
-	len pointer (sizeof(unsigned int))
-	flag unsupported
+    len pointer (sizeof(unsigned int))
+    flag unsupported
 
-#void glGetClipPlanef(GLenum pname, GLfloat * eqn)
 glGetClipPlanef
-	dir eqn out
-	len eqn (4 * sizeof(GLfloat))
+    dir eqn out
+    len eqn (4 * sizeof(GLfloat))
 
-#void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void *data, GLuint datalen)
 glVertexPointerData
-	len data datalen
-	custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen)
-	flag custom_decoder
-	flag not_api
+    len data datalen
+    flag not_api
 
-#void glColorPointerData(GLint size, GLenum type, GLsizei stride, void *data, GLuint datalen)
 glColorPointerData
-	len data datalen
-	flag custom_decoder
-	custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen)
-	flag not_api
+    len data datalen
+    flag not_api
 
-#void glNormalPointerData(GLenum type, GLsizei stride, void *data, GLuint datalen)
 glNormalPointerData
-	len data datalen
-	flag custom_decoder
-	custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 3, type, stride, datalen)
-	flag not_api
+    len data datalen
+    flag not_api
 
-#void glPointSizePointerData(GLenum type, GLsizei stride, void *data, GLuint datalen)
 glPointSizePointerData
-	len data datalen
-	flag custom_decoder
-	custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 1, type, stride, datalen)
-	flag not_api
+    len data datalen
+    flag not_api
 
-#void glTexCoordPointerData(GLint size, GLenum type, GLsizei stride, void *data, GLuint datalen)
 glTexCoordPointerData
-	len data datalen
-	flag custom_decoder
-	custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen)
-	flag not_api
+    len data datalen
+    flag not_api
 
-#void glWeightPointerData(GLint size, GLenum type, GLsizei stride,  void * data, GLuint datalen)
 glWeightPointerData
-  	len data datalen
-  	custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen)
-  	flag custom_decoder
-	flag not_api
+    len data datalen
+    flag not_api
 
-#void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride,  void * data, GLuint datalen)
 glMatrixIndexPointerData
-	len data datalen
-  	custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen)
-  	flag custom_decoder
-	flag not_api
+    len data datalen
+    flag not_api
 
 glVertexPointerOffset
-	flag custom_decoder
-	flag not_api
+    flag not_api
+
 glNormalPointerOffset
-	flag custom_decoder
-	flag not_api
+    flag not_api
+
 glTexCoordPointerOffset
-	flag custom_decoder
-	flag not_api
+    flag not_api
+
 glPointSizePointerOffset
-	flag custom_decoder
-	flag not_api
+    flag not_api
+
 glColorPointerOffset
-	flag custom_decoder
-	flag not_api
+    flag not_api
+
 glWeightPointerOffset
-    flag custom_decoder
-	flag not_api
+    flag not_api
+
 glMatrixIndexPointerOffset
-    flag custom_decoder
-	flag not_api
+    flag not_api
 
 glDrawElementsData
-	len data datalen
-	flag custom_decoder
-	flag not_api
+    len data datalen
+    flag not_api
 
 glDrawElementsOffset
-	flag custom_decoder
-	flag not_api
+    flag not_api
 
 glGetCompressedTextureFormats
-	dir formats out
-	len formats (count * sizeof(GLint))
-	flag custom_decoder
-	flag not_api
+    dir formats out
+    len formats (count * sizeof(GLint))
+    flag not_api
 
 glFinishRoundTrip
-	flag custom_decoder
-	flag not_api
-
-#gles1 extensions
+    flag not_api
 
-#void glDrawTexsvOES(GLshort *coords)
 glDrawTexsvOES
-	len coords (5 * sizeof(GLshort))
+    len coords (5 * sizeof(GLshort))
 
-#void glDrawTexivOES(GLint *coords)
 glDrawTexivOES
-	len coords (5 * sizeof(GLint))
+    len coords (5 * sizeof(GLint))
 
-#void glDrawTexxvOES(GLfixed *coords)
 glDrawTexxvOES
-	len coords (5 * sizeof(GLfixed))
+    len coords (5 * sizeof(GLfixed))
 
-#void glDrawTexfvOES(GLfloat *coords)
 glDrawTexfvOES
-	len coords (5 * sizeof(GLfloat))
+    len coords (5 * sizeof(GLfloat))
 
-#glClipPlanexOES(GLenum plane, const GLfixed * equation)
 glClipPlanexOES
-	dir equation in
-	len equation (4 * sizeof(GLfixed))
+    dir equation in
+    len equation (4 * sizeof(GLfixed))
 
-#glClipPlanexIMG(GLenum plane, const GLfixed * equation)
 glClipPlanexIMG
-	dir equation in
-	len equation (4 * sizeof(GLfixed))
+    dir equation in
+    len equation (4 * sizeof(GLfixed))
 
-#void glFogxvOES(GLenum pname, GLfixed *params)
 glFogxvOES
-	dir params in
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params in
 
-#void glGetClipPlanexOES(GLenum pname,  GLfixed * eqn)
 glGetClipPlanexOES
-	dir eqn out
-	len eqn (4 * sizeof(GLfixed))
+    dir eqn out
+    len eqn (4 * sizeof(GLfixed))
 
-#void glGetClipPlanex(GLenum pname,  GLfixed * eqn)
 glGetClipPlanex
-	dir eqn out
-	len eqn (4 * sizeof(GLfixed))
+    dir eqn out
+    len eqn (4 * sizeof(GLfixed))
 
-#void glGetFixedvOES(GLenum pname, GLfixed *params)
 glGetFixedvOES
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params)
 glGetLightxvOES
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params)
 glGetMaterialxvOES
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params)
 glGetTexEnvxvOES
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
 glGetTexParameterxvOES
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params out
 
-#void glLightModelxvOES(GLenum pname, GLfixed *params)
 glLightModelxvOES
-	dir params in
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params in
 
-#void glLightxvOES(GLenum light, GLenum pname, GLfixed *params)
 glLightxvOES
-	dir params in
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params in
 
-#void glLoadMatrixxOES(GLfixed *m)
 glLoadMatrixxOES
-	dir m in
-	len m (16 * sizeof(GLfixed))
+    dir m in
+    len m (16 * sizeof(GLfixed))
 
-#void glMaterialxvOES(GLenum face, GLenum pname, GLfixed *params)
 glMaterialxvOES
-	dir params in
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params in
 
-#void glMultMatrixxOES(GLfixed *m)
 glMultMatrixxOES
-	dir m in
-	len m (16 * sizeof(GLfixed))
+    dir m in
+    len m (16 * sizeof(GLfixed))
 
-#void glPointParameterxvOES(GLenum pname, GLfixed *params)
 glPointParameterxvOES
-	dir params in
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params in
 
-#void glTexEnvxvOES(GLenum target, GLenum pname, GLfixed *params)
 glTexEnvxvOES
-	dir params in
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params in
 
-#void glTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
 glTexParameterxvOES
-	dir params in
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
+    dir params in
 
-#void glDeleteRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
 glDeleteRenderbuffersOES
-    flag custom_decoder
-	dir renderbuffers in
-	len renderbuffers (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir renderbuffers in
+    len renderbuffers (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
 glGenRenderbuffersOES
-    flag custom_decoder
-	dir renderbuffers out 
-	len renderbuffers (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir renderbuffers out
+    len renderbuffers (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
 glGetRenderbufferParameterivOES
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
+    dir params out
 
-#void glDeleteFramebuffersOES(GLsizei n, GLuint *framebuffers)
 glDeleteFramebuffersOES
-    flag custom_decoder
-	dir framebuffers in
-	len framebuffers (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir framebuffers in
+    len framebuffers (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenFramebuffersOES(GLsizei n, GLuint *framebuffers)
 glGenFramebuffersOES
-    flag custom_decoder
-	dir framebuffers out
-	len framebuffers (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir framebuffers out
+    len framebuffers (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 glGetFramebufferAttachmentParameterivOES
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
+    dir params out
 
-#void* glMapBufferOES(GLenum target, GLenum access)
 glMapBufferOES
-	flag unsupported
+    flag unsupported
 
-#void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid ** params)
 glGetBufferPointervOES
-	flag unsupported
+    flag unsupported
 
-#void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
 glMatrixIndexPointerOES
-	len pointer (sizeof(unsigned int))
-	flag unsupported
+    len pointer (sizeof(unsigned int))
+    flag unsupported
 
-#void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
 glWeightPointerOES
-	len pointer (sizeof(unsigned int))
-	flag unsupported
+    len pointer (sizeof(unsigned int))
+    flag unsupported
 
-#glQueryMatrixxOES(GLfixed * mantissa, GLint * exponent)
 glQueryMatrixxOES
-	dir mantissa out
-	len mantissa (16 * sizeof(GLfixed))
-	dir exponent out
-	len exponent (16 * sizeof(GLfixed))
+    dir mantissa out
+    len mantissa (16 * sizeof(GLfixed))
+    dir exponent out
+    len exponent (16 * sizeof(GLfixed))
 
-#void glClipPlanefOES(GLenum plane, GLfloat *equation)
 glClipPlanefOES
-	dir equation in
-	len equation (4 * sizeof(GLfloat))
+    dir equation in
+    len equation (4 * sizeof(GLfloat))
 
-#void glClipPlanefIMG(GLenum plane, GLfloat *equation)
 glClipPlanefIMG
-	dir equation in
-	len equation (4 * sizeof(GLfloat))
+    dir equation in
+    len equation (4 * sizeof(GLfloat))
 
-#void glGetClipPlanefOES(GLenum pname, GLfloat * eqn)
 glGetClipPlanefOES
-	dir eqn out
-	len eqn (4 * sizeof(GLfloat))
+    dir eqn out
+    len eqn (4 * sizeof(GLfloat))
 
-#void glTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
-glTexGenfvOES
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-#void glTexGenivOES(GLenum coord, GLenum pname, GLint *params)
-glTexGenivOES
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
-
-#void glTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
-glTexGenxvOES
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
-
-#void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
-glGetTexGenfvOES
-	len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-#void glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
-glGetTexGenivOES
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
-
-#void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
-glGetTexGenxvOES
-	len params (glUtilsParamSize(pname) * sizeof(GLfixed))
-
-#void glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
 glDeleteVertexArraysOES
-    flag custom_decoder
-	dir arrays in
-	len arrays (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir arrays in
+    len arrays (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenVertexArraysOES(GLsizei n, GLuint *arrays)
 glGenVertexArraysOES
-    flag custom_decoder
-	dir arrays out
-	len arrays (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir arrays out
+    len arrays (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 glDiscardFramebufferEXT
-	dir attachments in
-	len attachments (numAttachments * sizeof(const GLenum))
+    dir attachments in
+    len attachments (numAttachments * sizeof(const GLenum))
 
-#void glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
 glMultiDrawArraysEXT
-	flag unsupported
-	
-#void glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount)
+    flag unsupported
+
 glMultiDrawElementsEXT
-	flag unsupported
+    flag unsupported
 
-#void glMultiDrawArraysSUN(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount)
 glMultiDrawArraysSUN
-	flag unsupported
-	
-#void glMultiDrawElementsSUN(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount)
+    flag unsupported
+
 glMultiDrawElementsSUN
-	flag unsupported
+    flag unsupported
 
-#void glDeleteFencesNV(GLsizei n, const GLuint *fences)
 glDeleteFencesNV
-	dir fences in
-	len fences (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir fences in
+    len fences (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenFencesNV(GLsizei n, GLuint *fences)
 glGenFencesNV
-	dir fences in
-	len fences (n * sizeof(GLuint))
-    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } 
+    dir fences in
+    len fences (n * sizeof(GLuint))
+    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
 glGetFenceivNV
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
+    dir params out
 
-#void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls)
 glGetDriverControlsQCOM
-	dir num out
-	len num (1 * sizeof(GLint))
-	dir driverControls out
-	len driverControls (size * sizeof(GLuint))
+    dir num out
+    len num (1 * sizeof(GLint))
+    dir driverControls out
+    len driverControls (size * sizeof(GLuint))
 
-#void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString)
 glGetDriverControlStringQCOM
-	dir length out
-	len length (1 * sizeof(GLsizei))
-	dir driverControlString out
-	len driverControlString (1 * sizeof(GLchar))
+    dir length out
+    len length (1 * sizeof(GLsizei))
+    dir driverControlString out
+    len driverControlString (1 * sizeof(GLchar))
 
-#void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures)
 glExtGetTexturesQCOM
-	dir textures out
-	len textures (maxTextures * sizeof(GLuint))
-	dir numTextures out
-	len numTextures (1 * sizeof(GLint))
+    dir textures out
+    len textures (maxTextures * sizeof(GLuint))
+    dir numTextures out
+    len numTextures (1 * sizeof(GLint))
 
-#void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers)
 glExtGetBuffersQCOM
-	dir buffers out
-	len buffers (maxBuffers * sizeof(GLuint))
-	dir numBuffers out
-	len numBuffers (1 * sizeof(GLint))
+    dir buffers out
+    len buffers (maxBuffers * sizeof(GLuint))
+    dir numBuffers out
+    len numBuffers (1 * sizeof(GLint))
 
-#void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers)
 glExtGetRenderbuffersQCOM
-	dir renderbuffers out
-	len renderbuffers (maxRenderbuffers * sizeof(GLuint))
-	dir numRenderbuffers out
-	len numRenderbuffers (1 * sizeof(GLint))
+    dir renderbuffers out
+    len renderbuffers (maxRenderbuffers * sizeof(GLuint))
+    dir numRenderbuffers out
+    len numRenderbuffers (1 * sizeof(GLint))
 
-#void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers)
 glExtGetFramebuffersQCOM
-	dir framebuffers out
-	len framebuffers (maxFramebuffers * sizeof(GLuint))
-	dir numFramebuffers out
-	len numFramebuffers (1 * sizeof(GLint))
+    dir framebuffers out
+    len framebuffers (maxFramebuffers * sizeof(GLuint))
+    dir numFramebuffers out
+    len numFramebuffers (1 * sizeof(GLint))
 
-#void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params)
 glExtGetTexLevelParameterivQCOM
-	dir params out
-	len params (glUtilsParamSize(pname) * sizeof(GLint))
+    dir params out
 
-#void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels)
 glExtGetTexSubImageQCOM
-	dir texels out
-	len texels (depth * glesv1_enc::pixelDataSize(self, width, height, format, type, 0))
+    dir texels out
+    len texels (depth * glesv1_enc::pixelDataSize(self, width, height, format, type, 0))
 
-#void glExtGetBufferPointervQCOM(GLenum target, GLvoid **params)
 glExtGetBufferPointervQCOM
-	flag unsupported
+    flag unsupported
 
-#void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders)
 glExtGetShadersQCOM
-	dir shaders out
-	len shaders (maxShaders * sizeof(GLuint))
-	dir numShaders out
-	len numShaders (1 * sizeof(GLint))
+    dir shaders out
+    len shaders (maxShaders * sizeof(GLuint))
+    dir numShaders out
+    len numShaders (1 * sizeof(GLint))
 
-#void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms)
 glExtGetProgramsQCOM
-	dir programs out
-	len programs (maxPrograms * sizeof(GLuint))
-	dir numPrograms out
-	len numPrograms (1 * sizeof(GLint))
+    dir programs out
+    len programs (maxPrograms * sizeof(GLuint))
+    dir numPrograms out
+    len numPrograms (1 * sizeof(GLint))
 
-#void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length)
 glExtGetProgramBinarySourceQCOM
-	flag unsupported
+    flag unsupported
diff --git a/host/libs/virglrenderer/GLESv1_dec/gles1_types.h b/host/libs/virglrenderer/GLESv1_dec/gles1_types.h
index c8355ada1..097e03f71 100644
--- a/host/libs/virglrenderer/GLESv1_dec/gles1_types.h
+++ b/host/libs/virglrenderer/GLESv1_dec/gles1_types.h
@@ -1,21 +1,19 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef __GLES1_TYPES__H
-#define __GLES1_TYPES__H
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
 
-#include "gl_base_types.h"
-
-#endif  // __GLES1_TYPES__H
+#include <GLES/gl.h>
+#include <GLES/glext.h>
diff --git a/host/libs/virglrenderer/GLESv3.cpp b/host/libs/virglrenderer/GLESv3.cpp
new file mode 100644
index 000000000..dd2707d17
--- /dev/null
+++ b/host/libs/virglrenderer/GLESv3.cpp
@@ -0,0 +1,642 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <OpenGLESDispatch/GLESv3Dispatch.h>
+
+#include "GLESv3.h"
+
+#include <string>
+#include <vector>
+
+// Stubs (common)
+
+static void glDeleteFencesNV(GLsizei, const GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glDisableDriverControlQCOM(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glDiscardFramebufferEXT(GLenum, GLsizei, const GLenum*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glEnableDriverControlQCOM(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glEndTilingQCOM(GLbitfield) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetBufferPointervQCOM(GLenum, GLvoid**) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetBuffersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetFramebuffersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetProgramBinarySourceQCOM(GLuint, GLenum, GLchar*, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetProgramsQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetRenderbuffersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetShadersQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetTexLevelParameterivQCOM(GLuint, GLenum, GLint, GLenum, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetTexSubImageQCOM(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei,
+                                    GLenum, GLenum, GLvoid*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glExtGetTexturesQCOM(GLuint*, GLint, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glExtIsProgramBinaryQCOM(GLuint) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+static void glExtTexObjectStateOverrideiQCOM(GLenum, GLenum, GLint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glFinishFenceNV(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glFramebufferTexture2DMultisampleIMG(GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGenFencesNV(GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetDriverControlsQCOM(GLint*, GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetDriverControlStringQCOM(GLuint, GLsizei, GLsizei*, GLchar*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetFenceivNV(GLuint, GLenum, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glIsFenceNV(GLuint) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+static void* glMapBufferOES(GLenum, GLenum) {
+    printf("%s: not implemented\n", __func__);
+    return nullptr;
+}
+
+static void glMultiDrawArraysEXT(GLenum, const GLint*, const GLsizei*, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glMultiDrawElementsEXT(GLenum, const GLsizei*, GLenum, const GLvoid* const*, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glRenderbufferStorageMultisampleIMG(GLenum, GLsizei, GLenum, GLsizei, GLsizei) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glSetFenceNV(GLuint, GLenum) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glStartTilingQCOM(GLuint, GLuint, GLuint, GLuint, GLbitfield) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static GLboolean glTestFenceNV(GLuint) {
+    printf("%s: not implemented\n", __func__);
+    return GL_FALSE;
+}
+
+// Stubs (ES 3.1)
+
+static void glBeginPerfMonitorAMD(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glCoverageMaskNV(GLboolean) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glCoverageOperationNV(GLenum) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glDeletePerfMonitorsAMD(GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glEndPerfMonitorAMD(GLuint) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGenPerfMonitorsAMD(GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetPerfMonitorCounterDataAMD(GLuint, GLenum, GLsizei, GLuint*, GLint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetPerfMonitorCounterInfoAMD(GLuint, GLuint, GLenum, GLvoid*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetPerfMonitorCountersAMD(GLuint, GLint*, GLint*, GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetPerfMonitorCounterStringAMD(GLuint, GLuint, GLsizei, GLsizei*, GLchar*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetPerfMonitorGroupsAMD(GLint*, GLsizei, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glGetPerfMonitorGroupStringAMD(GLuint, GLsizei, GLsizei*, GLchar*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void glSelectPerfMonitorCountersAMD(GLuint, GLboolean, GLuint, GLint, GLuint*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+// Non-stubs (common)
+
+static void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* indices, GLuint) {
+    s_gles3.glDrawElements(mode, count, type, indices);
+}
+
+static void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset) {
+    s_gles3.glDrawElements(mode, count, type, reinterpret_cast<const GLvoid*>(offset));
+}
+
+static GLint glFinishRoundTrip() {
+    s_gles3.glFinish();
+    return 0;
+}
+
+static void glGetCompressedTextureFormats(int count, GLint* formats) {
+    int nFormats;
+    s_gles3.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nFormats);
+    if (nFormats <= count)
+        s_gles3.glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats);
+}
+
+// Non-stubs (ES 3.1)
+
+struct GlSync {
+    GlSync(GLESv3* ctx_, GLsync sync_) : sync(sync_), id(ctx_->sync_nextId++), ctx(ctx_) {
+        ctx->sync_map.emplace(id, this);
+    }
+
+    ~GlSync() {
+        ctx->sync_map.erase(id);
+    }
+
+    GLsync sync;
+    uint64_t id;
+
+  private:
+    GLESv3* ctx;
+};
+
+static GLenum glClientWaitSyncAEMU(void* ctx_, uint64_t wait_on, GLbitfield flags,
+                                   GLuint64 timeout) {
+    GLESv3* ctx = static_cast<GLESv3*>(ctx_);
+
+    std::map<uint64_t, GlSync*>::iterator it;
+    it = ctx->sync_map.find(wait_on);
+    if (it == ctx->sync_map.end())
+        return GL_INVALID_VALUE;
+
+    GlSync* sync = it->second;
+    return s_gles3.glClientWaitSync(sync->sync, flags, timeout);
+}
+
+static void glCompressedTexImage2DOffsetAEMU(GLenum target, GLint level, GLenum internalformat,
+                                             GLsizei width, GLsizei height, GLint border,
+                                             GLsizei imageSize, GLuint offset) {
+    s_gles3.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize,
+                                   reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glCompressedTexImage3DOffsetAEMU(GLenum target, GLint level, GLenum internalformat,
+                                             GLsizei width, GLsizei height, GLsizei depth,
+                                             GLint border, GLsizei imageSize, GLuint offset) {
+    s_gles3.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border,
+                                   imageSize, reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glCompressedTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset,
+                                                GLint yoffset, GLsizei width, GLsizei height,
+                                                GLenum format, GLsizei imageSize, GLuint offset) {
+    s_gles3.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
+                                      imageSize, reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glCompressedTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset,
+                                                GLint yoffset, GLint zoffset, GLsizei width,
+                                                GLsizei height, GLsizei depth, GLenum format,
+                                                GLsizei imageSize, GLuint offset) {
+    s_gles3.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth,
+                                      format, imageSize, reinterpret_cast<const GLvoid*>(offset));
+}
+
+static GLuint glCreateShaderProgramvAEMU(GLenum type, GLsizei, const char* packedStrings, GLuint) {
+    return s_gles3.glCreateShaderProgramv(type, 1, &packedStrings);
+}
+
+static void glDeleteSyncAEMU(void* ctx_, uint64_t to_delete) {
+    GLESv3* ctx = static_cast<GLESv3*>(ctx_);
+
+    std::map<uint64_t, GlSync*>::iterator it;
+    it = ctx->sync_map.find(to_delete);
+    if (it == ctx->sync_map.end())
+        return;
+
+    GlSync* sync = it->second;
+    s_gles3.glDeleteSync(sync->sync);
+    delete sync;
+}
+
+static void glDrawArraysIndirectDataAEMU(GLenum mode, const void* indirect, GLuint) {
+    s_gles3.glDrawArraysIndirect(mode, indirect);
+}
+
+static void glDrawArraysIndirectOffsetAEMU(GLenum mode, GLuint offset) {
+    s_gles3.glDrawArraysIndirect(mode, reinterpret_cast<const void*>(offset));
+}
+
+static void glDrawElementsIndirectDataAEMU(GLenum mode, GLenum type, const void* indirect, GLuint) {
+    s_gles3.glDrawElementsIndirect(mode, type, indirect);
+}
+
+static void glDrawElementsIndirectOffsetAEMU(GLenum mode, GLenum type, GLuint offset) {
+    s_gles3.glDrawElementsIndirect(mode, type, reinterpret_cast<const void*>(offset));
+}
+
+static void glDrawElementsInstancedDataAEMU(GLenum mode, GLsizei count, GLenum type,
+                                            const void* indices, GLsizei primcount, GLsizei) {
+    s_gles3.glDrawElementsInstanced(mode, count, type, indices, primcount);
+}
+
+static void glDrawElementsInstancedOffsetAEMU(GLenum mode, GLsizei count, GLenum type,
+                                              GLuint offset, GLsizei primcount) {
+    s_gles3.glDrawElementsInstanced(mode, count, type, reinterpret_cast<const void*>(offset),
+                                    primcount);
+}
+
+static void glDrawRangeElementsDataAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count,
+                                        GLenum type, const GLvoid* indices, GLsizei) {
+    s_gles3.glDrawRangeElements(mode, start, end, count, type, indices);
+}
+
+static void glDrawRangeElementsOffsetAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count,
+                                          GLenum type, GLuint offset) {
+    s_gles3.glDrawRangeElements(mode, start, end, count, type,
+                                reinterpret_cast<const GLvoid*>(offset));
+}
+
+static uint64_t glFenceSyncAEMU(void* ctx_, GLenum condition, GLbitfield flags) {
+    GLsync sync_ = s_gles3.glFenceSync(condition, flags);
+    if (sync_ == 0)
+        return 0U;
+
+    GLESv3* ctx = static_cast<GLESv3*>(ctx_);
+    GlSync* sync = new (std::nothrow) GlSync(ctx, sync_);
+    if (!sync) {
+        s_gles3.glDeleteSync(sync_);
+        return 0U;
+    }
+
+    return sync->id;
+}
+
+static void glFlushMappedBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length,
+                                         GLbitfield access, void* guest_buffer) {
+    if (guest_buffer && length) {
+        void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access);
+        if (gpuPtr) {
+            memcpy(gpuPtr, guest_buffer, length);
+            s_gles3.glFlushMappedBufferRange(target, 0, length);
+            s_gles3.glUnmapBuffer(target);
+        }
+    }
+}
+
+static void glGetSyncivAEMU(void* ctx_, uint64_t sync_, GLenum pname, GLsizei bufSize,
+                            GLsizei* length, GLint* values) {
+    GLESv3* ctx = static_cast<GLESv3*>(ctx_);
+
+    std::map<uint64_t, GlSync*>::iterator it;
+    it = ctx->sync_map.find(sync_);
+    if (it == ctx->sync_map.end())
+        return;
+
+    GlSync* sync = it->second;
+    s_gles3.glGetSynciv(sync->sync, pname, bufSize, length, values);
+}
+
+static std::vector<std::string> sUnpackVarNames(GLsizei count, const char* packedNames) {
+    std::vector<std::string> unpacked;
+    GLsizei current = 0;
+
+    while (current < count) {
+        const char* delimPos = strstr(packedNames, ";");
+        size_t nameLen = delimPos - packedNames;
+        std::string next;
+        next.resize(nameLen);
+        memcpy(&next[0], packedNames, nameLen);
+        unpacked.push_back(next);
+        packedNames = delimPos + 1;
+        current++;
+    }
+
+    return unpacked;
+}
+
+static void glGetUniformIndicesAEMU(GLuint program, GLsizei uniformCount, const GLchar* packedNames,
+                                    GLsizei packedLen, GLuint* uniformIndices) {
+    std::vector<std::string> unpacked = sUnpackVarNames(uniformCount, packedNames);
+    GLchar** unpackedArray = new GLchar*[unpacked.size()];
+    GLsizei i = 0;
+    for (auto& elt : unpacked) {
+        unpackedArray[i] = (GLchar*)&elt[0];
+        i++;
+    }
+
+    s_gles3.glGetUniformIndices(program, uniformCount, const_cast<const GLchar**>(unpackedArray),
+                                uniformIndices);
+    delete[] unpackedArray;
+}
+
+static GLboolean glIsSyncAEMU(void* ctx_, uint64_t sync) {
+    GLESv3* ctx = static_cast<GLESv3*>(ctx_);
+    return ctx->sync_map.count(sync) ? GL_TRUE : GL_FALSE;
+}
+
+static void glMapBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length,
+                                 GLbitfield access, void* mapped) {
+    if ((access & GL_MAP_READ_BIT) ||
+        ((access & GL_MAP_WRITE_BIT) &&
+         (!(access & GL_MAP_INVALIDATE_RANGE_BIT) && !(access & GL_MAP_INVALIDATE_BUFFER_BIT)))) {
+        void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access);
+        if (gpuPtr) {
+            if (mapped)
+                memcpy(mapped, gpuPtr, length);
+            s_gles3.glUnmapBuffer(target);
+        }
+    }
+}
+
+static void glReadPixelsOffsetAEMU(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
+                                   GLenum type, GLuint offset) {
+    s_gles3.glReadPixels(x, y, width, height, format, type, reinterpret_cast<GLvoid*>(offset));
+}
+
+static void glShaderString(GLuint shader, const GLchar* string, GLsizei) {
+    s_gles3.glShaderSource(shader, 1, &string, NULL);
+}
+
+static void glTexImage2DOffsetAEMU(GLenum target, GLint level, GLint internalformat, GLsizei width,
+                                   GLsizei height, GLint border, GLenum format, GLenum type,
+                                   GLuint offset) {
+    s_gles3.glTexImage2D(target, level, internalformat, width, height, border, format, type,
+                         reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glTexImage3DOffsetAEMU(GLenum target, GLint level, GLint internalFormat, GLsizei width,
+                                   GLsizei height, GLsizei depth, GLint border, GLenum format,
+                                   GLenum type, GLuint offset) {
+    s_gles3.glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type,
+                         reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset,
+                                      GLsizei width, GLsizei height, GLenum format, GLenum type,
+                                      GLuint offset) {
+    s_gles3.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
+                            reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset,
+                                      GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
+                                      GLenum format, GLenum type, GLuint offset) {
+    s_gles3.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format,
+                            type, reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glTransformFeedbackVaryingsAEMU(GLuint program, GLsizei count,
+                                            const char* packedVaryings, GLuint packedVaryingsLen,
+                                            GLenum bufferMode) {
+    std::vector<std::string> unpacked = sUnpackVarNames(count, packedVaryings);
+    char** unpackedArray = new char*[unpacked.size()];
+    GLsizei i = 0;
+    for (auto& elt : unpacked) {
+        unpackedArray[i] = &elt[0];
+        i++;
+    }
+
+    s_gles3.glTransformFeedbackVaryings(program, count, const_cast<const char**>(unpackedArray),
+                                        bufferMode);
+    delete[] unpackedArray;
+}
+
+static void glUnmapBufferAEMU(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access,
+                              void* guest_buffer, GLboolean* out_res) {
+    *out_res = GL_TRUE;
+
+    if (access & GL_MAP_WRITE_BIT) {
+        if (guest_buffer) {
+            void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access);
+            if (gpuPtr)
+                memcpy(gpuPtr, guest_buffer, length);
+        }
+
+        *out_res = s_gles3.glUnmapBuffer(target);
+    }
+}
+
+static void glVertexAttribIPointerDataAEMU(GLuint index, GLint size, GLenum type, GLsizei,
+                                           void* data, GLuint) {
+    s_gles3.glVertexAttribIPointer(index, size, type, 0, data);
+}
+
+static void glVertexAttribIPointerOffsetAEMU(GLuint index, GLint size, GLenum type, GLsizei,
+                                             GLuint offset) {
+    s_gles3.glVertexAttribIPointer(index, size, type, 0, reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized,
+                                      GLsizei, void* data, GLuint) {
+    s_gles3.glVertexAttribPointer(indx, size, type, normalized, 0, data);
+}
+
+static void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized,
+                                        GLsizei, GLuint offset) {
+    s_gles3.glVertexAttribPointer(indx, size, type, normalized, 0,
+                                  reinterpret_cast<const GLvoid*>(offset));
+}
+
+static void glWaitSyncAEMU(void* ctx_, uint64_t wait_on, GLbitfield flags, GLuint64 timeout) {
+    GLESv3* ctx = static_cast<GLESv3*>(ctx_);
+
+    std::map<uint64_t, GlSync*>::iterator it;
+    it = ctx->sync_map.find(wait_on);
+    if (it == ctx->sync_map.end())
+        return;
+
+    GlSync* sync = it->second;
+    s_gles3.glWaitSync(sync->sync, flags, timeout);
+}
+
+#define KNIT(return_type, function_name, signature, callargs) function_name = s_gles3.function_name;
+
+GLESv3::GLESv3() {
+    LIST_GLES3_FUNCTIONS(KNIT, KNIT)
+
+    // Remap some ES 2.0 extensions that become core in ES 3.1
+    glBindVertexArrayOES = glBindVertexArray;
+    glDeleteVertexArraysOES = glDeleteVertexArrays;
+    glGenVertexArraysOES = glGenVertexArrays;
+    glGetProgramBinaryOES = glGetProgramBinary;
+    glIsVertexArrayOES = glIsVertexArray;
+    glProgramBinaryOES = glProgramBinary;
+    glUnmapBufferOES = glUnmapBuffer;
+
+    // Entrypoints requiring custom wrappers (common)
+    glDrawElementsData = ::glDrawElementsData;
+    glDrawElementsOffset = ::glDrawElementsOffset;
+    glFinishRoundTrip = ::glFinishRoundTrip;
+    glGetCompressedTextureFormats = ::glGetCompressedTextureFormats;
+
+    // Entrypoints requiring custom wrappers (ES 3.1)
+    glClientWaitSyncAEMU = ::glClientWaitSyncAEMU;
+    glCompressedTexImage2DOffsetAEMU = ::glCompressedTexImage2DOffsetAEMU;
+    glCompressedTexImage3DOffsetAEMU = ::glCompressedTexImage3DOffsetAEMU;
+    glCompressedTexSubImage2DOffsetAEMU = ::glCompressedTexSubImage2DOffsetAEMU;
+    glCompressedTexSubImage3DOffsetAEMU = ::glCompressedTexSubImage3DOffsetAEMU;
+    glCreateShaderProgramvAEMU = ::glCreateShaderProgramvAEMU;
+    glDeleteSyncAEMU = ::glDeleteSyncAEMU;
+    glDrawArraysIndirectDataAEMU = ::glDrawArraysIndirectDataAEMU;
+    glDrawArraysIndirectOffsetAEMU = ::glDrawArraysIndirectOffsetAEMU;
+    glDrawElementsIndirectDataAEMU = ::glDrawElementsIndirectDataAEMU;
+    glDrawElementsIndirectOffsetAEMU = ::glDrawElementsIndirectOffsetAEMU;
+    glDrawElementsInstancedDataAEMU = ::glDrawElementsInstancedDataAEMU;
+    glDrawElementsInstancedOffsetAEMU = ::glDrawElementsInstancedOffsetAEMU;
+    glDrawRangeElementsDataAEMU = ::glDrawRangeElementsDataAEMU;
+    glDrawRangeElementsOffsetAEMU = ::glDrawRangeElementsOffsetAEMU;
+    glFenceSyncAEMU = ::glFenceSyncAEMU;
+    glFlushMappedBufferRangeAEMU = ::glFlushMappedBufferRangeAEMU;
+    glGetSyncivAEMU = ::glGetSyncivAEMU;
+    glGetUniformIndicesAEMU = ::glGetUniformIndicesAEMU;
+    glIsSyncAEMU = ::glIsSyncAEMU;
+    glMapBufferRangeAEMU = ::glMapBufferRangeAEMU;
+    glReadPixelsOffsetAEMU = ::glReadPixelsOffsetAEMU;
+    glShaderString = ::glShaderString;
+    glTexImage2DOffsetAEMU = ::glTexImage2DOffsetAEMU;
+    glTexImage3DOffsetAEMU = ::glTexImage3DOffsetAEMU;
+    glTexSubImage2DOffsetAEMU = ::glTexSubImage2DOffsetAEMU;
+    glTexSubImage3DOffsetAEMU = ::glTexSubImage3DOffsetAEMU;
+    glTransformFeedbackVaryingsAEMU = ::glTransformFeedbackVaryingsAEMU;
+    glUnmapBufferAEMU = ::glUnmapBufferAEMU;
+    glVertexAttribIPointerDataAEMU = ::glVertexAttribIPointerDataAEMU;
+    glVertexAttribIPointerOffsetAEMU = ::glVertexAttribIPointerOffsetAEMU;
+    glVertexAttribPointerData = ::glVertexAttribPointerData;
+    glVertexAttribPointerOffset = ::glVertexAttribPointerOffset;
+    glWaitSyncAEMU = ::glWaitSyncAEMU;
+
+    // Stub some extensions we will never implement (common)
+    glDeleteFencesNV = ::glDeleteFencesNV;
+    glDisableDriverControlQCOM = ::glDisableDriverControlQCOM;
+    glDiscardFramebufferEXT = ::glDiscardFramebufferEXT;
+    glEnableDriverControlQCOM = ::glEnableDriverControlQCOM;
+    glEndTilingQCOM = ::glEndTilingQCOM;
+    glExtGetBufferPointervQCOM = ::glExtGetBufferPointervQCOM;
+    glExtGetBuffersQCOM = ::glExtGetBuffersQCOM;
+    glExtGetFramebuffersQCOM = ::glExtGetFramebuffersQCOM;
+    glExtGetProgramBinarySourceQCOM = ::glExtGetProgramBinarySourceQCOM;
+    glExtGetProgramsQCOM = ::glExtGetProgramsQCOM;
+    glExtGetRenderbuffersQCOM = ::glExtGetRenderbuffersQCOM;
+    glExtGetShadersQCOM = ::glExtGetShadersQCOM;
+    glExtGetTexLevelParameterivQCOM = ::glExtGetTexLevelParameterivQCOM;
+    glExtGetTexSubImageQCOM = ::glExtGetTexSubImageQCOM;
+    glExtGetTexturesQCOM = ::glExtGetTexturesQCOM;
+    glExtIsProgramBinaryQCOM = ::glExtIsProgramBinaryQCOM;
+    glExtTexObjectStateOverrideiQCOM = ::glExtTexObjectStateOverrideiQCOM;
+    glFinishFenceNV = ::glFinishFenceNV;
+    glFramebufferTexture2DMultisampleIMG = ::glFramebufferTexture2DMultisampleIMG;
+    glGenFencesNV = ::glGenFencesNV;
+    glGetDriverControlsQCOM = ::glGetDriverControlsQCOM;
+    glGetDriverControlStringQCOM = ::glGetDriverControlStringQCOM;
+    glGetFenceivNV = ::glGetFenceivNV;
+    glIsFenceNV = ::glIsFenceNV;
+    glMapBufferOES = ::glMapBufferOES;
+    glMultiDrawArraysEXT = ::glMultiDrawArraysEXT;
+    glMultiDrawElementsEXT = ::glMultiDrawElementsEXT;
+    glRenderbufferStorageMultisampleIMG = ::glRenderbufferStorageMultisampleIMG;
+    glSetFenceNV = ::glSetFenceNV;
+    glStartTilingQCOM = ::glStartTilingQCOM;
+    glTestFenceNV = ::glTestFenceNV;
+
+    // Stub some extensions we will never implement (ES 3.1)
+    glBeginPerfMonitorAMD = ::glBeginPerfMonitorAMD;
+    glCoverageMaskNV = ::glCoverageMaskNV;
+    glCoverageOperationNV = ::glCoverageOperationNV;
+    glDeletePerfMonitorsAMD = ::glDeletePerfMonitorsAMD;
+    glEndPerfMonitorAMD = ::glEndPerfMonitorAMD;
+    glGenPerfMonitorsAMD = ::glGenPerfMonitorsAMD;
+    glGetPerfMonitorCounterDataAMD = ::glGetPerfMonitorCounterDataAMD;
+    glGetPerfMonitorCounterInfoAMD = ::glGetPerfMonitorCounterInfoAMD;
+    glGetPerfMonitorCountersAMD = ::glGetPerfMonitorCountersAMD;
+    glGetPerfMonitorCounterStringAMD = ::glGetPerfMonitorCounterStringAMD;
+    glGetPerfMonitorGroupsAMD = ::glGetPerfMonitorGroupsAMD;
+    glGetPerfMonitorGroupStringAMD = ::glGetPerfMonitorGroupStringAMD;
+    glSelectPerfMonitorCountersAMD = ::glSelectPerfMonitorCountersAMD;
+}
diff --git a/host/libs/virglrenderer/GLESv3.h b/host/libs/virglrenderer/GLESv3.h
new file mode 100644
index 000000000..33eab48f6
--- /dev/null
+++ b/host/libs/virglrenderer/GLESv3.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "GLESv3_dec/gles3_dec.h"
+
+#include <map>
+
+struct GlSync;
+
+struct GLESv3 : public gles3_decoder_context_t {
+    GLESv3();
+
+    glDrawBuffers_server_proc_t glDrawBuffersEXT;
+
+    glDrawArraysInstanced_server_proc_t glDrawArraysInstancedEXT;
+    glDrawElementsInstanced_server_proc_t glDrawElementsInstancedEXT;
+
+    glVertexAttribDivisor_server_proc_t glVertexAttribDivisorEXT;
+
+    std::map<uint64_t, GlSync*> sync_map;
+
+  private:
+    uint64_t sync_nextId = 1U;
+    friend struct GlSync;
+};
diff --git a/host/libs/virglrenderer/GLESv3_dec/gles3.attrib b/host/libs/virglrenderer/GLESv3_dec/gles3.attrib
index 6b452f409..d5d8d1836 100644
--- a/host/libs/virglrenderer/GLESv3_dec/gles3.attrib
+++ b/host/libs/virglrenderer/GLESv3_dec/gles3.attrib
@@ -1,120 +1,68 @@
 GLOBAL
     base_opcode 2048
-    encoder_headers <string.h> "glUtils.h" "GL2EncoderUtils.h"
 
-#void glBindAttribLocation(GLuint program, GLuint index, GLchar *name)
 glBindAttribLocation
-    flag custom_decoder
     len name (strlen(name) + 1)
 
-#void glBufferData(GLenum target, GLsizeiptr size, GLvoid *data, GLenum usage)
 glBufferData
     len data size
     var_flag data nullAllowed isLarge
 
-#void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 glBufferSubData
     len data size
     var_flag data nullAllowed isLarge
 
-#void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid *data)
 glCompressedTexImage2D
     len data imageSize
     param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
     var_flag data nullAllowed isLarge
     param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid *data)
 glCompressedTexSubImage2D
     len data imageSize
     param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
     var_flag data nullAllowed isLarge
     param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-glDeleteShader
-    flag custom_decoder
-
-glDeleteProgram
-    flag custom_decoder
-
-#void glDeleteBuffers(GLsizei n, GLuint *buffers)
 glDeleteBuffers
-    flag custom_decoder
     len buffers (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glDeleteFramebuffers(GLsizei n, GLuint *framebuffers)
 glDeleteFramebuffers
-    flag custom_decoder
     len framebuffers (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glDeleteRenderbuffers(GLsizei n, GLuint *renderbuffers)
 glDeleteRenderbuffers
-    flag custom_decoder
     len renderbuffers (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glDeleteTextures(GLsizei n, GLuint *textures)
 glDeleteTextures
-    flag custom_decoder
     len textures (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid *indices)
 glDrawElements
     flag unsupported
 
-glCreateShader
-    flag custom_decoder
-
-glCompileShader
-    flag custom_decoder
-
-glAttachShader
-    flag custom_decoder
-
-glDetachShader
-    flag custom_decoder
-
-glIsShader
-    flag custom_decoder
-
-glLinkProgram
-    flag custom_decoder
-
-glCreateProgram
-    flag custom_decoder
-
-#void glGenBuffers(GLsizei n, GLuint *buffers)
 glGenBuffers
-    flag custom_decoder
     len buffers (n * sizeof(GLuint))
     dir buffers out
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 glGenFramebuffers
-    flag custom_decoder
     len framebuffers (n * sizeof(GLuint))
     dir framebuffers out
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 glGenRenderbuffers
-    flag custom_decoder
     len renderbuffers (n * sizeof(GLuint))
     dir renderbuffers out
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenTextures(GLsizei n, GLuint *textures)
 glGenTextures
-    flag custom_decoder
     len textures (n * sizeof(GLuint))
     dir textures out
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 glGetActiveAttrib
     param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
     len name bufsize
@@ -130,12 +78,11 @@ glGetActiveAttrib
     len type (sizeof(GLenum))
     var_flag type nullAllowed
 
-#void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 glGetActiveUniform
     param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
     len name bufsize
     dir name out
-      var_flag name nullAllowed
+    var_flag name nullAllowed
     dir length out
     len length (sizeof(GLsizei))
     var_flag length nullAllowed
@@ -146,8 +93,6 @@ glGetActiveUniform
     len type (sizeof(GLenum))
     var_flag type nullAllowed
 
-
-#void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders)
 glGetAttachedShaders
     len shaders (maxcount*sizeof(GLuint))
     dir shaders out
@@ -155,44 +100,30 @@ glGetAttachedShaders
     var_flag count nullAllowed
     len count (sizeof(GLsizei))
 
-#int glGetAttribLocation(GLuint program, GLchar *name)
 glGetAttribLocation
     len name (strlen(name) + 1)
 
-#void glGetBooleanv(GLenum pname, GLboolean *params)
 glGetBooleanv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLboolean))
 
-#void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 glGetBufferParameteriv
     len params (sizeof(GLint))
     dir params out
 
-#void glGetFloatv(GLenum pname, GLfloat *params)
 glGetFloatv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
 
-#void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 glGetFramebufferAttachmentParameteriv
     dir params out
     len params (sizeof(GLint))
 
-#void glGetIntegerv(GLenum pname, GLint *params)
 glGetIntegerv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
-#void glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 glGetProgramiv
-    flag custom_decoder
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
-#void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length, GLchar *infolog)
 glGetProgramInfoLog
-    flag custom_decoder
     dir infolog out
     len infolog bufsize
     param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
@@ -200,22 +131,15 @@ glGetProgramInfoLog
     len length sizeof(GLsizei)
     var_flag length nullAllowed
 
-#void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 glGetRenderbufferParameteriv
     dir params out
     len params sizeof(GLint)
-# XXX - might change if pname with value larger then one is added
 
-#void glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 glGetShaderiv
-    flag custom_decoder
     dir params out
     len params sizeof(GLint)
-# XXX - might change if pname with value larger then one is added
 
-#void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *infolog)
 glGetShaderInfoLog
-    flag custom_decoder
     dir length out
     len length (sizeof(GLsizei))
     var_flag length nullAllowed
@@ -223,16 +147,13 @@ glGetShaderInfoLog
     len infolog bufsize
     param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 glGetShaderPrecisionFormat
     dir range out
     len range (2 * sizeof(GLint))
     dir precision out
     len precision (sizeof(GLint))
 
-#void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *source)
 glGetShaderSource
-    flag custom_decoder
     dir length out
     len length (sizeof(GLsizei))
     var_flag length nullAllowed
@@ -240,428 +161,310 @@ glGetShaderSource
     len source bufsize
     param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#GLubyte* glGetString(GLenum name)
 glGetString
     flag unsupported
 
-#void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 glGetTexParameterfv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
 
-#void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 glGetTexParameteriv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
-#void glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 glGetUniformfv
     dir params out
     len params glSizeof(glesv2_enc::uniformType(self, program, location))
 
-#void glGetUniformiv(GLuint program, GLint location, GLint *params)
 glGetUniformiv
     dir params out
     len params glSizeof(glesv2_enc::uniformType(self, program, location))
 
-#int glGetUniformLocation(GLuint program, GLchar *name)
 glGetUniformLocation
     len name (strlen(name) + 1)
 
-# client-state shall be handled locally by the encoder in most cases.
-# however, GL_CURRENT_VERTEX_ATTRIB and potential others are handled by the server side,
-# thus we still need to implement it.
-#void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 glGetVertexAttribfv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
 
-#see glGetVertexAttribfv for comments
-#void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 glGetVertexAttribiv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
-#void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 glReadPixels
     dir pixels out
     len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 1)
 
 glReadPixelsOffsetAEMU
-    flag custom_decoder
     flag not_api
 
-#void glShaderBinary(GLsizei n, GLuint *shaders, GLenum binaryformat, GLvoid *binary, GLsizei length)
 glShaderBinary
     flag unsupported
 
-#void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels)
 glTexImage2D
     dir pixels in
     len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 0)
     var_flag pixels nullAllowed isLarge
 
-#void glTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-glTexParameterfv
-    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-#void glTexParameteriv(GLenum target, GLenum pname, GLint *params)
-glTexParameteriv
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
-
-#void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 glTexSubImage2D
     len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 0)
     var_flag pixels nullAllowed isLarge
 
-#void glUniform1fv(GLint location, GLsizei count, GLfloat *v)
 glUniform1fv
     len v (count * sizeof(GLfloat))
 
-#void glUniform1iv(GLint location, GLsizei count, GLint *v)
 glUniform1iv
     len v (count * sizeof(GLint))
 
-#void glUniform2fv(GLint location, GLsizei count, GLfloat *v)
 glUniform2fv
     len v (count * 2 * sizeof(GLfloat))
 
-#void glUniform2iv(GLint location, GLsizei count, GLint *v)
 glUniform2iv
     len v (count * 2 * sizeof(GLint))
 
-#void glUniform3fv(GLint location, GLsizei count, GLfloat *v)
 glUniform3fv
     len v (count * 3 * sizeof(GLfloat))
 
-#void glUniform3iv(GLint location, GLsizei count, GLint *v)
 glUniform3iv
     len v (3 * count * sizeof(GLint))
 
-#void glUniform4fv(GLint location, GLsizei count, GLfloat *v)
 glUniform4fv
     len v (4 * count * sizeof(GLfloat))
 
-#void glUniform4iv(GLint location, GLsizei count, GLint *v)
 glUniform4iv
     len v (4 * count * sizeof(GLint))
 
-#void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value)
 glUniformMatrix2fv
     len value (count * 4 * sizeof(GLfloat))
 
-#void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value)
 glUniformMatrix3fv
     len value (count * 9 * sizeof(GLfloat))
 
-#void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value)
 glUniformMatrix4fv
     len value (count * 16 * sizeof(GLfloat))
 
-#void glVertexAttrib1fv(GLuint indx, GLfloat *values)
 glVertexAttrib1fv
     len values (sizeof(GLfloat))
-#void glVertexAttrib2fv(GLuint indx, GLfloat *values)
 glVertexAttrib2fv
     len values (2 * sizeof(GLfloat))
 
-#void glVertexAttrib3fv(GLuint indx, GLfloat *values)
 glVertexAttrib3fv
     len values (3 * sizeof(GLfloat))
 
-#void glVertexAttrib4fv(GLuint indx, GLfloat *values)
 glVertexAttrib4fv
     len values (4 * sizeof(GLfloat))
 
-#void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLvoid *ptr)
 glVertexAttribPointer
     flag unsupported
 
-#void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
 glGetProgramBinaryOES
     flag unsupported
 
-#void glProgramBinaryOES(GLuint program, GLenum binaryFormat, GLvoid *binary, GLint length)
 glProgramBinaryOES
     flag unsupported
 
-#void* glMapBufferOES(GLenum target, GLenum access)
 glMapBufferOES
     flag unsupported
 
-#void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid *pixels)
 glTexImage3DOES
     len pixels glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0)
     var_flag pixels nullAllowed isLarge
 
-#void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *pixels)
 glTexSubImage3DOES
     len pixels glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0)
     var_flag pixels nullAllowed isLarge
 
-#void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid *data)
 glCompressedTexImage3DOES
     len data imageSize
     param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
     var_flag data nullAllowed isLarge
 
-#void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid *data)
 glCompressedTexSubImage3DOES
     len data imageSize
     param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
     var_flag data nullAllowed isLarge
 
-#void glDeleteVertexArraysOES(GLsizei n, GLuint *arrays)
 glDeleteVertexArraysOES
-    flag custom_decoder
     len arrays (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-#void glGenVertexArraysOES(GLsizei n, GLuint *arrays)
 glGenVertexArraysOES
-    flag custom_decoder
     len arrays (n * sizeof(GLuint))
     dir arrays out
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-
-#void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, GLenum *attachments)
 glDiscardFramebufferEXT
     len attachments (numAttachments * sizeof(GLenum))
 
-#void glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
 glMultiDrawArraysEXT
     flag unsupported
-#void glMultiDrawElementsEXT(GLenum mode, GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount)
+
 glMultiDrawElementsEXT
     flag unsupported
 
-
-# handled by encoder
-#void glShaderSource(GLuint shader, GLsizei count, GLstr *string, const GLint *length)
 glShaderSource
     flag unsupported
 
-
-#void glGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups)
 glGetPerfMonitorGroupsAMD
     flag unsupported
 
-#void glGetPerfMonitorCountersAMD(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters)
 glGetPerfMonitorCountersAMD
     flag unsupported
 
-#void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString)
 glGetPerfMonitorGroupStringAMD
     flag unsupported
 
-#void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString)
 glGetPerfMonitorCounterStringAMD
     flag unsupported
 
-#void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid *data)
 glGetPerfMonitorCounterInfoAMD
     flag unsupported
 
-#void glGenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
 glGenPerfMonitorsAMD
     flag unsupported
 
-#void glDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
 glDeletePerfMonitorsAMD
     flag unsupported
 
-#void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList)
 glSelectPerfMonitorCountersAMD
     flag unsupported
 
-#void glBeginPerfMonitorAMD(GLuint monitor)
 glBeginPerfMonitorAMD
     flag unsupported
 
-#void glEndPerfMonitorAMD(GLuint monitor)
 glEndPerfMonitorAMD
     flag unsupported
 
-#void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten)
 glGetPerfMonitorCounterDataAMD
     flag unsupported
 
-#void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 glRenderbufferStorageMultisampleIMG
     flag unsupported
 
-#void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
 glFramebufferTexture2DMultisampleIMG
     flag unsupported
 
-#void glDeleteFencesNV(GLsizei n, GLuint *fences)
 glDeleteFencesNV
     flag unsupported
 
-#void glGenFencesNV(GLsizei n, GLuint *fences)
 glGenFencesNV
     flag unsupported
 
-#GLboolean glIsFenceNV(GLuint fence)
 glIsFenceNV
     flag unsupported
 
-#GLboolean glTestFenceNV(GLuint fence)
 glTestFenceNV
     flag unsupported
 
-#void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
 glGetFenceivNV
     flag unsupported
 
-#void glFinishFenceNV(GLuint fence)
 glFinishFenceNV
     flag unsupported
 
-#void glSetFenceNV(GLuint fence, GLenum condition)
 glSetFenceNV
     flag unsupported
 
-#void glCoverageMaskNV(GLboolean mask)
 glCoverageMaskNV
     flag unsupported
 
-#void glCoverageOperationNV(GLenum operation)
 glCoverageOperationNV
     flag unsupported
 
-#void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls)
 glGetDriverControlsQCOM
     flag unsupported
 
-#void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString)
 glGetDriverControlStringQCOM
     flag unsupported
 
-#void glEnableDriverControlQCOM(GLuint driverControl)
 glEnableDriverControlQCOM
     flag unsupported
 
-#void glDisableDriverControlQCOM(GLuint driverControl)
 glDisableDriverControlQCOM
     flag unsupported
 
-#void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures)
 glExtGetTexturesQCOM
     flag unsupported
 
-#void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers)
 glExtGetBuffersQCOM
     flag unsupported
 
-#void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers)
 glExtGetRenderbuffersQCOM
     flag unsupported
 
-#void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers)
 glExtGetFramebuffersQCOM
     flag unsupported
 
-#void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params)
 glExtGetTexLevelParameterivQCOM
     flag unsupported
 
-#void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
 glExtTexObjectStateOverrideiQCOM
     flag unsupported
 
-#void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels)
 glExtGetTexSubImageQCOM
     flag unsupported
 
-#void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr *params)
 glExtGetBufferPointervQCOM
     flag unsupported
 
-#void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders)
 glExtGetShadersQCOM
     flag unsupported
 
-#void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms)
 glExtGetProgramsQCOM
     flag unsupported
 
-#GLboolean glExtIsProgramBinaryQCOM(GLuint program)
 glExtIsProgramBinaryQCOM
     flag unsupported
 
-#void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length)
 glExtGetProgramBinarySourceQCOM
     flag unsupported
 
-#void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
 glStartTilingQCOM
     flag unsupported
 
-#void glEndTilingQCOM(GLbitfield preserveMask)
 glEndTilingQCOM
     flag unsupported
 
-
-#void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride,  void * data, GLuint datalen)
 glVertexAttribPointerData
     len data datalen
-    custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen)
-    flag custom_decoder
     flag not_api
 
 glVertexAttribPointerOffset
-    flag custom_decoder
     flag not_api
 
-#client-state, handled by the encoder
-#GL_ENTRY(void, glGetVertexAttribPointerv, GLuint index, GLenum pname, GLvoid** pointer)
 glGetVertexAttribPointerv
     flag unsupported
 
 glDrawElementsData
     len data datalen
-    flag custom_decoder
     flag not_api
 
 glDrawElementsOffset
-    flag custom_decoder
     flag not_api
 
-#GL_ENTRY(void, glGetCompressedTextureFormats, int count, GLint *formats)
 glGetCompressedTextureFormats
     dir formats out
     len formats (count * sizeof(GLint))
-    flag custom_decoder
     flag not_api
 
-#GL_ENTRY(void, glShaderString, GLuint shader, GLchar *string, GLsizei len)
 glShaderString
     len string len
-    flag custom_decoder
     flag not_api
 
 glFinishRoundTrip
-    flag custom_decoder
     flag not_api
 
-# GLES 3.0
-
 glGenVertexArrays
-    flag custom_decoder
     len arrays (n * sizeof(GLuint))
     dir arrays out
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
 glDeleteVertexArrays
-    flag custom_decoder
     len arrays (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
 glMapBufferRange
     flag unsupported
+
 glUnmapBuffer
     flag unsupported
+
 glFlushMappedBufferRange
     flag unsupported
 
@@ -669,7 +472,6 @@ glMapBufferRangeAEMU
     dir mapped out
     len mapped length
     var_flag mapped nullAllowed
-    flag custom_decoder
     flag not_api
 
 glUnmapBufferAEMU
@@ -678,34 +480,27 @@ glUnmapBufferAEMU
     var_flag guest_buffer nullAllowed
     dir out_res out
     len out_res (sizeof(GLboolean))
-    flag custom_decoder
     flag not_api
 
 glFlushMappedBufferRangeAEMU
     dir guest_buffer in
     len guest_buffer length
     var_flag guest_buffer nullAllowed
-    flag custom_decoder
     flag not_api
 
 glReadPixelsOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glCompressedTexImage2DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glCompressedTexSubImage2DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glTexImage2DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glTexSubImage2DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glCopyBufferSubData
@@ -740,7 +535,6 @@ glGetUniformIndicesAEMU
     len packedUniformNames packedLen
     dir uniformIndices out
     len uniformIndices (uniformCount * sizeof(GLuint))
-    flag custom_decoder
     flag not_api
 
 glGetActiveUniformBlockiv
@@ -805,33 +599,26 @@ glVertexAttribIPointer
     flag unsupported
 
 glVertexAttribIPointerOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glVertexAttribIPointerDataAEMU
     len data datalen
-    custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen)
-    flag custom_decoder
     flag not_api
 
 glGetVertexAttribIiv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
 glGetVertexAttribIuiv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLuint))
 
 glDrawElementsInstanced
     flag unsupported
 
 glDrawElementsInstancedDataAEMU
     len indices datalen
-    flag custom_decoder
     flag not_api
 
 glDrawElementsInstancedOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glDrawRangeElements
@@ -839,11 +626,9 @@ glDrawRangeElements
 
 glDrawRangeElementsDataAEMU
     len indices datalen
-    flag custom_decoder
     flag not_api
 
 glDrawRangeElementsOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glFenceSync
@@ -908,13 +693,11 @@ glInvalidateSubFramebuffer
     len attachments (numAttachments * sizeof(GLenum))
 
 glGenTransformFeedbacks
-    flag custom_decoder
     dir ids out
     len ids (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
 glDeleteTransformFeedbacks
-    flag custom_decoder
     len ids (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
@@ -924,7 +707,6 @@ glTransformFeedbackVaryings
 glTransformFeedbackVaryingsAEMU
     dir packedVaryings in
     len packedVaryings packedVaryingsLen
-    flag custom_decoder
     flag not_api
 
 glGetTransformFeedbackVarying
@@ -943,48 +725,34 @@ glGetTransformFeedbackVarying
     var_flag type nullAllowed
 
 glGenSamplers
-    flag custom_decoder
     dir samplers out
     len samplers (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
 glDeleteSamplers
-    flag custom_decoder
     len samplers (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
-glSamplerParameterfv
-    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
-
-glSamplerParameteriv
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
-
 glGetSamplerParameterfv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
 
 glGetSamplerParameteriv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
 glGenQueries
-    flag custom_decoder
     dir queries out
     len queries (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
 glDeleteQueries
-    flag custom_decoder
     len queries (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
 glGetQueryiv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
 glGetQueryObjectuiv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLuint))
 
 glProgramBinary
     len binary length
@@ -1004,11 +772,7 @@ glGetFragDataLocation
 
 glGetInteger64v
     dir data out
-    len data (glUtilsParamSize(pname) * sizeof(GLint64))
 
-# No need to account for custom sizes since indexed variants
-# are all on indxed buffers like transform feedback buffers,
-# UBOs, or SSBOs, and querying their sizes and offsets.
 glGetIntegeri_v
     dir data out
     len data (sizeof(GLint))
@@ -1023,7 +787,6 @@ glTexImage3D
     var_flag data nullAllowed isLarge
 
 glTexImage3DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glTexSubImage3D
@@ -1031,7 +794,6 @@ glTexSubImage3D
     var_flag data nullAllowed isLarge
 
 glTexSubImage3DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glCompressedTexImage3D
@@ -1040,7 +802,6 @@ glCompressedTexImage3D
     var_flag data nullAllowed isLarge
 
 glCompressedTexImage3DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glCompressedTexSubImage3D
@@ -1049,31 +810,25 @@ glCompressedTexSubImage3D
     var_flag data nullAllowed isLarge
 
 glCompressedTexSubImage3DOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glGetStringi
     flag unsupported
 
-# GLES 3.1
-
 glGetBooleani_v
     dir data out
     len data (sizeof(GLboolean))
 
 glGenProgramPipelines
-    flag custom_decoder
     dir pipelines out
     len pipelines (n * sizeof(GLuint))
 
 glDeleteProgramPipelines
-    flag custom_decoder
     len pipelines (n * sizeof(GLuint))
     param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 
 glGetProgramPipelineiv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
 glGetProgramPipelineInfoLog
     dir infoLog out
@@ -1088,7 +843,6 @@ glCreateShaderProgramv
 
 glCreateShaderProgramvAEMU
     len packedStrings packedLen
-    flag custom_decoder
     flag not_api
 
 glProgramUniform1fv
@@ -1156,7 +910,6 @@ glProgramUniformMatrix4x3fv
 
 glGetProgramInterfaceiv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
 glGetProgramResourceiv
     dir params out
@@ -1186,11 +939,9 @@ glDrawArraysIndirect
 
 glDrawArraysIndirectDataAEMU
     len indirect datalen
-    flag custom_decoder
     flag not_api
 
 glDrawArraysIndirectOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glDrawElementsIndirect
@@ -1198,218 +949,19 @@ glDrawElementsIndirect
 
 glDrawElementsIndirectDataAEMU
     len indirect datalen
-    flag custom_decoder
     flag not_api
 
 glDrawElementsIndirectOffsetAEMU
-    flag custom_decoder
     flag not_api
 
 glGetMultisamplefv
     dir val out
-    len val (glUtilsParamSize(pname) * sizeof(GLfloat))
 
 glGetFramebufferParameteriv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
 
 glGetTexLevelParameterfv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
 
 glGetTexLevelParameteriv
     dir params out
-    len params (glUtilsParamSize(pname) * sizeof(GLint))
-glUseProgram
-    flag custom_decoder
-
-glValidateProgram
-    flag custom_decoder
-
-glIsProgram
-    flag custom_decoder
-
-glGetActiveAttrib
-    flag custom_decoder
-
-glGetActiveUniform
-    flag custom_decoder
-
-glGetAttachedShaders
-    flag custom_decoder
-
-glGetAttribLocation
-    flag custom_decoder
-
-glGetUniformfv
-    flag custom_decoder
-
-glGetUniformiv
-    flag custom_decoder
-
-glGetUniformLocation
-    flag custom_decoder
-
-glGetProgramBinaryOES
-    flag custom_decoder
-
-glProgramBinaryOES
-    flag custom_decoder
-
-glUniformBlockBinding
-    flag custom_decoder
-
-glGetUniformBlockIndex
-    flag custom_decoder
-
-glGetActiveUniformBlockiv
-    flag custom_decoder
-
-glGetActiveUniformBlockName
-    flag custom_decoder
-
-glGetUniformuiv
-    flag custom_decoder
-
-glGetActiveUniformsiv
-    flag custom_decoder
-
-glTransformFeedbackVaryings
-    flag custom_decoder
-
-glGetTransformFeedbackVarying
-    flag custom_decoder
-
-glProgramParameteri
-    flag custom_decoder
-
-glProgramBinary
-    flag custom_decoder
-
-glGetProgramBinary
-    flag custom_decoder
-
-glGetFragDataLocation
-    flag custom_decoder
-
-glUseProgramStages
-    flag custom_decoder
-
-glActiveShaderProgram
-    flag custom_decoder
-
-glProgramUniform1f
-    flag custom_decoder
-
-glProgramUniform2f
-    flag custom_decoder
-
-glProgramUniform3f
-    flag custom_decoder
-
-glProgramUniform4f
-    flag custom_decoder
-
-glProgramUniform1i
-    flag custom_decoder
-
-glProgramUniform2i
-    flag custom_decoder
-
-glProgramUniform3i
-    flag custom_decoder
-
-glProgramUniform4i
-    flag custom_decoder
-
-glProgramUniform1ui
-    flag custom_decoder
-
-glProgramUniform2ui
-    flag custom_decoder
-
-glProgramUniform3ui
-    flag custom_decoder
-
-glProgramUniform4ui
-    flag custom_decoder
-
-glProgramUniform1fv
-    flag custom_decoder
-
-glProgramUniform2fv
-    flag custom_decoder
-
-glProgramUniform3fv
-    flag custom_decoder
-
-glProgramUniform4fv
-    flag custom_decoder
-
-glProgramUniform1iv
-    flag custom_decoder
-
-glProgramUniform2iv
-    flag custom_decoder
-
-glProgramUniform3iv
-    flag custom_decoder
-
-glProgramUniform4iv
-    flag custom_decoder
-
-glProgramUniform1uiv
-    flag custom_decoder
-
-glProgramUniform2uiv
-    flag custom_decoder
-
-glProgramUniform3uiv
-    flag custom_decoder
-
-glProgramUniform4uiv
-    flag custom_decoder
-
-glProgramUniformMatrix2fv
-    flag custom_decoder
-
-glProgramUniformMatrix3fv
-    flag custom_decoder
-
-glProgramUniformMatrix4fv
-    flag custom_decoder
-
-glProgramUniformMatrix2x3fv
-    flag custom_decoder
-
-glProgramUniformMatrix3x2fv
-    flag custom_decoder
-
-glProgramUniformMatrix2x4fv
-    flag custom_decoder
-
-glProgramUniformMatrix4x2fv
-    flag custom_decoder
-
-glProgramUniformMatrix3x4fv
-    flag custom_decoder
-
-glProgramUniformMatrix4x3fv
-    flag custom_decoder
-
-glGetProgramInterfaceiv
-    flag custom_decoder
-
-glGetProgramResourceiv
-    flag custom_decoder
-
-glGetProgramResourceIndex
-    flag custom_decoder
-
-glGetProgramResourceLocation
-    flag custom_decoder
-
-glGetProgramResourceName
-    flag custom_decoder
-
-
diff --git a/host/libs/virglrenderer/GLESv3_dec/gles3.in b/host/libs/virglrenderer/GLESv3_dec/gles3.in
index 50d9406a3..33eb3b396 100644
--- a/host/libs/virglrenderer/GLESv3_dec/gles3.in
+++ b/host/libs/virglrenderer/GLESv3_dec/gles3.in
@@ -196,7 +196,7 @@ GL_ENTRY(void, glExtGetFramebuffersQCOM, GLuint *framebuffers, GLint maxFramebuf
 GL_ENTRY(void, glExtGetTexLevelParameterivQCOM, GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params)
 GL_ENTRY(void, glExtTexObjectStateOverrideiQCOM, GLenum target, GLenum pname, GLint param)
 GL_ENTRY(void, glExtGetTexSubImageQCOM, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels)
-GL_ENTRY(void, glExtGetBufferPointervQCOM, GLenum target, GLvoidptr *params)
+GL_ENTRY(void, glExtGetBufferPointervQCOM, GLenum target, GLvoid** params)
 GL_ENTRY(void, glExtGetShadersQCOM, GLuint *shaders, GLint maxShaders, GLint *numShaders)
 GL_ENTRY(void, glExtGetProgramsQCOM, GLuint *programs, GLint maxPrograms, GLint *numPrograms)
 GL_ENTRY(GLboolean, glExtIsProgramBinaryQCOM, GLuint program)
@@ -309,7 +309,7 @@ GL_ENTRY(void, glUniformBlockBinding, GLuint program, GLuint uniformBlockIndex,
 GL_ENTRY(GLuint, glGetUniformBlockIndex, GLuint program, const GLchar *uniformBlockName)
 
 # Assume uniformNames packed into 1 buffer on the guest.
-GL_ENTRY(void, glGetUniformIndices, GLuint program, GLsizei uniformCount, const GLchar ** uniformNames, GLuint* uniformIndices)
+GL_ENTRY(void, glGetUniformIndices, GLuint program, GLsizei uniformCount, const GLchar*const* uniformNames, GLuint* uniformIndices)
 GL_ENTRY(void, glGetUniformIndicesAEMU, GLuint program, GLsizei uniformCount, const GLchar *packedUniformNames, GLsizei packedLen, GLuint *uniformIndices)
 
 GL_ENTRY(void, glGetActiveUniformBlockiv, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
@@ -319,7 +319,7 @@ GL_ENTRY(void, glGetActiveUniformBlockName, GLuint program, GLuint uniformBlockI
 GL_ENTRY(void, glUniform1ui, GLint location, GLuint v0)
 GL_ENTRY(void, glUniform2ui, GLint location, GLuint v0, GLuint v1)
 GL_ENTRY(void, glUniform3ui, GLint location, GLuint v0, GLuint v1, GLuint v2)
-GL_ENTRY(void, glUniform4ui, GLint location, GLint v0, GLuint v1, GLuint v2, GLuint v3)
+GL_ENTRY(void, glUniform4ui, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 GL_ENTRY(void, glUniform1uiv, GLint location, GLsizei count, const GLuint *value)
 GL_ENTRY(void, glUniform2uiv, GLint location, GLsizei count, const GLuint *value)
 GL_ENTRY(void, glUniform3uiv, GLint location, GLsizei count, const GLuint *value)
@@ -399,7 +399,7 @@ GL_ENTRY(void, glBindTransformFeedback, GLenum target, GLuint id)
 GL_ENTRY(void, glPauseTransformFeedback, void)
 GL_ENTRY(void, glResumeTransformFeedback, void)
 GL_ENTRY(GLboolean, glIsTransformFeedback, GLuint id)
-GL_ENTRY(void, glTransformFeedbackVaryings, GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode)
+GL_ENTRY(void, glTransformFeedbackVaryings, GLuint program, GLsizei count, const GLchar*const* varyings, GLenum bufferMode)
 GL_ENTRY(void, glTransformFeedbackVaryingsAEMU, GLuint program, GLsizei count, const char* packedVaryings, GLuint packedVaryingsLen, GLenum bufferMode)
 GL_ENTRY(void, glGetTransformFeedbackVarying, GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name)
 
@@ -473,7 +473,7 @@ GL_ENTRY(void, glUseProgramStages, GLuint pipeline, GLbitfield stages, GLuint pr
 
 # Separable shader programs - may need to change how program objects are represented and shared!
 GL_ENTRY(void, glActiveShaderProgram, GLuint pipeline, GLuint program);
-GL_ENTRY(GLuint, glCreateShaderProgramv, GLenum type, GLsizei count, const char ** strings)
+GL_ENTRY(GLuint, glCreateShaderProgramv, GLenum type, GLsizei count, const GLchar*const* strings)
 GL_ENTRY(GLuint, glCreateShaderProgramvAEMU, GLenum type, GLsizei count, const char *packedStrings, GLuint packedLen)
 # Uniforms should work easily if any program object representation problems are solved.
 GL_ENTRY(void, glProgramUniform1f, GLuint program, GLint location, GLfloat v0)
@@ -485,9 +485,9 @@ GL_ENTRY(void, glProgramUniform2i, GLuint program, GLint location, GLint v0, GLi
 GL_ENTRY(void, glProgramUniform3i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 GL_ENTRY(void, glProgramUniform4i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 GL_ENTRY(void, glProgramUniform1ui, GLuint program, GLint location, GLuint v0)
-GL_ENTRY(void, glProgramUniform2ui, GLuint program, GLint location, GLint v0, GLuint v1)
-GL_ENTRY(void, glProgramUniform3ui, GLuint program, GLint location, GLint v0, GLint v1, GLuint v2)
-GL_ENTRY(void, glProgramUniform4ui, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLuint v3)
+GL_ENTRY(void, glProgramUniform2ui, GLuint program, GLint location, GLuint v0, GLuint v1)
+GL_ENTRY(void, glProgramUniform3ui, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
+GL_ENTRY(void, glProgramUniform4ui, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 GL_ENTRY(void, glProgramUniform1fv, GLuint program, GLint location, GLsizei count, const GLfloat *value)
 GL_ENTRY(void, glProgramUniform2fv, GLuint program, GLint location, GLsizei count, const GLfloat *value)
 GL_ENTRY(void, glProgramUniform3fv, GLuint program, GLint location, GLsizei count, const GLfloat *value)
@@ -529,7 +529,7 @@ GL_ENTRY(void, glDispatchComputeIndirect, GLintptr indirect)
 
 # Separate vertex format / buffer binding
 ### Requires us tp really clean up how draws work in the encoder currently.
-GL_ENTRY(void, glBindVertexBuffer, GLuint bindingindex, GLuint buffer, GLintptr offset, GLintptr stride)
+GL_ENTRY(void, glBindVertexBuffer, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 GL_ENTRY(void, glVertexAttribBinding, GLuint attribindex, GLuint bindingindex);
 GL_ENTRY(void, glVertexAttribFormat, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 GL_ENTRY(void, glVertexAttribIFormat, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
diff --git a/host/libs/virglrenderer/GLESv3_dec/gles3_types.h b/host/libs/virglrenderer/GLESv3_dec/gles3_types.h
index bfff61de4..3347b9923 100644
--- a/host/libs/virglrenderer/GLESv3_dec/gles3_types.h
+++ b/host/libs/virglrenderer/GLESv3_dec/gles3_types.h
@@ -1,21 +1,19 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef _GL_2_TYPES_H_
-#define _GL_2_TYPES_H_
-#include "gl_base_types.h"
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
 
-typedef void *GLvoidptr;
-#endif
+#include <GLES3/gl31.h>
+#include <GLES2/gl2ext.h>
diff --git a/host/libs/virglrenderer/Gralloc1.cpp b/host/libs/virglrenderer/Gralloc1.cpp
new file mode 100644
index 000000000..a2fcd8147
--- /dev/null
+++ b/host/libs/virglrenderer/Gralloc1.cpp
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdint>
+
+extern "C" {
+#include "virgl_hw.h"
+}
+
+#include "Resource.h"
+
+#include <android/sync.h>
+#include <hardware/gralloc1.h>
+
+#include <cerrno>
+
+#define ALIGN(A, B) (((A) + (B)-1) / (B) * (B))
+
+static int gralloc1_device_open(const hw_module_t*, const char*, hw_device_t**);
+
+static hw_module_methods_t g_gralloc1_methods = {
+    .open = gralloc1_device_open,
+};
+
+static hw_module_t g_gralloc1_module = {
+    .tag = HARDWARE_MODULE_TAG,
+    .module_api_version = GRALLOC_MODULE_API_VERSION_1_0,
+    .hal_api_version = HARDWARE_HAL_API_VERSION,
+    .id = GRALLOC_HARDWARE_MODULE_ID,
+    .name = "AVDVirglRenderer",
+    .author = "Google",
+    .methods = &g_gralloc1_methods,
+};
+
+static int gralloc1_device_close(hw_device_t*) {
+    // No-op
+    return 0;
+}
+
+static void gralloc1_getCapabilities(gralloc1_device_t*, uint32_t* outCount, int32_t*) {
+    *outCount = 0U;
+}
+
+static int32_t gralloc1_lock(gralloc1_device_t*, buffer_handle_t buffer, uint64_t producerUsage,
+                             uint64_t consumerUsage, const gralloc1_rect_t* rect, void** outData,
+                             int32_t) {
+    uint32_t resource_id = (uint32_t) reinterpret_cast<uintptr_t>(buffer);
+    std::map<uint32_t, Resource*>::iterator it;
+    it = Resource::map.find(resource_id);
+    if (it == Resource::map.end())
+        return GRALLOC1_ERROR_BAD_HANDLE;
+
+    Resource* res = it->second;
+
+    // validate the lock rectangle
+    if (rect->width < 0 || rect->height < 0 || rect->left < 0 || rect->top < 0 ||
+        (uint32_t)rect->width + (uint32_t)rect->left > res->args.width ||
+        (uint32_t)rect->height + (uint32_t)rect->top > res->args.height) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+    }
+
+    uint32_t bpp;
+    switch (res->args.format) {
+        case VIRGL_FORMAT_R8_UNORM:
+            bpp = 1U;
+            break;
+        case VIRGL_FORMAT_B5G6R5_UNORM:
+            bpp = 2U;
+            break;
+        default:
+            bpp = 4U;
+            break;
+    }
+    uint32_t stride = ALIGN(res->args.width * bpp, 16U);
+    *outData = (char*)res->linear + rect->top * stride + rect->left * bpp;
+    return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t gralloc1_unlock(gralloc1_device_t*, buffer_handle_t buffer,
+                               int32_t* outReleaseFence) {
+    uint32_t resource_id = (uint32_t) reinterpret_cast<uintptr_t>(buffer);
+    std::map<uint32_t, Resource*>::iterator it;
+    it = Resource::map.find(resource_id);
+    if (it == Resource::map.end())
+        return GRALLOC1_ERROR_BAD_HANDLE;
+    if (outReleaseFence)
+        *outReleaseFence = -1;
+
+    return GRALLOC1_ERROR_NONE;
+}
+
+static gralloc1_function_pointer_t gralloc1_getFunction(gralloc1_device_t*, int32_t descriptor) {
+    switch (descriptor) {
+        case GRALLOC1_FUNCTION_LOCK:
+            return reinterpret_cast<gralloc1_function_pointer_t>(&gralloc1_lock);
+        case GRALLOC1_FUNCTION_UNLOCK:
+            return reinterpret_cast<gralloc1_function_pointer_t>(&gralloc1_unlock);
+        default:
+            return nullptr;
+    }
+}
+
+static gralloc1_device_t g_gralloc1_device = {
+    .common =
+        {
+            .tag = HARDWARE_DEVICE_TAG,
+            .module = &g_gralloc1_module,
+            .close = gralloc1_device_close,
+        },
+    .getCapabilities = gralloc1_getCapabilities,
+    .getFunction = gralloc1_getFunction,
+};
+
+static int gralloc1_device_open(const hw_module_t* module, const char* id, hw_device_t** device) {
+    if (module != &g_gralloc1_module)
+        return -EINVAL;
+    if (strcmp(id, g_gralloc1_module.id))
+        return -EINVAL;
+    *device = &g_gralloc1_device.common;
+    return 0;
+}
+
+int hw_get_module(const char* id, const hw_module_t** module) {
+    if (strcmp(id, g_gralloc1_module.id))
+        return -EINVAL;
+    *module = const_cast<const hw_module_t*>(&g_gralloc1_module);
+    return 0;
+}
+
+int sync_wait(int, int) {
+    return 0;
+}
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp
index f3de1bff6..40cf7fc37 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp
+++ b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp
@@ -1,56 +1,51 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "OpenGLESDispatch/EGLDispatch.h"
-
-#include "emugl/common/shared_library.h"
-
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <OpenGLESDispatch/EGLDispatch.h>
+
+#include <dlfcn.h>
 #include <stdio.h>
-#include <stdlib.h>
 
 EGLDispatch s_egl;
 
-#define DEFAULT_EGL_LIB EMUGL_LIBNAME("EGL_translator")
+#define DEFAULT_EGL_LIB "libEGL_swiftshader.so"
 
-#define RENDER_EGL_LOAD_FIELD(return_type, function_name, signature) \
-    s_egl. function_name = (function_name ## _t) lib->findSymbol(#function_name); \
+#define EGL_LOAD_FIELD(return_type, function_name, signature, callargs) \
+    s_egl.function_name = (function_name##_t)dlsym(handle, #function_name);
 
-#define RENDER_EGL_LOAD_FIELD_WITH_EGL(return_type, function_name, signature) \
-    if ((!s_egl. function_name) && s_egl.eglGetProcAddress) s_egl. function_name = \
-            (function_name ## _t) s_egl.eglGetProcAddress(#function_name); \
+#define EGL_LOAD_FIELD_WITH_EGL(return_type, function_name, signature, callargs) \
+    if ((!s_egl.function_name) && s_egl.eglGetProcAddress)                       \
+        s_egl.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name);
 
-#define RENDER_EGL_LOAD_OPTIONAL_FIELD(return_type, function_name, signature) \
-    if (s_egl.eglGetProcAddress) s_egl. function_name = \
-            (function_name ## _t) s_egl.eglGetProcAddress(#function_name); \
-    if (!s_egl.function_name || !s_egl.eglGetProcAddress) \
-            RENDER_EGL_LOAD_FIELD(return_type, function_name, signature)
+#define EGL_LOAD_OPTIONAL_FIELD(return_type, function_name, signature, callargs)          \
+    if (s_egl.eglGetProcAddress)                                                          \
+        s_egl.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name); \
+    if (!s_egl.function_name || !s_egl.eglGetProcAddress)                                 \
+    EGL_LOAD_FIELD(return_type, function_name, signature, callargs)
 
-bool init_egl_dispatch() {
-    const char *libName = getenv("ANDROID_EGL_LIB");
-    if (!libName) libName = DEFAULT_EGL_LIB;
-    char error[256];
-    emugl::SharedLibrary *lib = emugl::SharedLibrary::open(libName, error, sizeof(error));
-    if (!lib) {
-        printf("Failed to open %s: [%s]\n", libName, error);
+bool egl_dispatch_init() {
+    void* handle = dlopen(DEFAULT_EGL_LIB, RTLD_NOW);
+    if (!handle) {
+        printf("Failed to open %s\n", dlerror());
         return false;
     }
 
-    LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_LOAD_FIELD)
-    LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_LOAD_FIELD_WITH_EGL)
-    LIST_RENDER_EGL_EXTENSIONS_FUNCTIONS(RENDER_EGL_LOAD_OPTIONAL_FIELD)
-    LIST_RENDER_EGL_SNAPSHOT_FUNCTIONS(RENDER_EGL_LOAD_FIELD)
+    LIST_EGL_FUNCTIONS(EGL_LOAD_FIELD)
+    LIST_EGL_FUNCTIONS(EGL_LOAD_FIELD_WITH_EGL)
+    LIST_EGL_EXTENSIONS_FUNCTIONS(EGL_LOAD_OPTIONAL_FIELD)
 
     return true;
 }
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h
index 58102e95a..eb3cd880a 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h
+++ b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h
@@ -1,56 +1,41 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#pragma once
-
-#include "OpenGLESDispatch/RenderEGL_functions.h"
-#include "OpenGLESDispatch/RenderEGL_extensions_functions.h"
-#include "OpenGLESDispatch/RenderEGL_snapshot_functions.h"
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-// This header is used to define the EGLDispatch structure that contains
-// pointers to the EGL shared library used by libOpenglRender. Normally,
-// this will be our own libEGL_translator, but one could imagine a
-// vendor-specific being used instead.
+#pragma once
 
-// There is a single global instance of this structure, named |s_egl|,
-// which must be initialized by calling init_egl_dispatch() before use.
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
 
-// Note that our code requires the implementation of misc EGL extensions
-// including eglSetSwapRectangleANDROID(), see RenderEGL_extensions_functions.h
-// for a full list.
+#include <OpenGLESDispatch/egl_functions.h>
+#include <OpenGLESDispatch/egl_extensions_functions.h>
 
-#define RENDER_EGL_DEFINE_TYPE(return_type, function_name, signature) \
-    typedef return_type (EGLAPIENTRY *function_name ## _t) signature;
+#define EGL_DEFINE_TYPE(return_type, function_name, signature, callargs) \
+    typedef return_type(EGLAPIENTRY* function_name##_t) signature;
 
-#define RENDER_EGL_DECLARE_MEMBER(return_type, function_name, signature) \
-    function_name ## _t function_name;
+#define EGL_DECLARE_MEMBER(return_type, function_name, signature, callargs) \
+    function_name##_t function_name;
 
-// Define function typedefs.
-LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_DEFINE_TYPE)
-LIST_RENDER_EGL_EXTENSIONS_FUNCTIONS(RENDER_EGL_DEFINE_TYPE)
-LIST_RENDER_EGL_SNAPSHOT_FUNCTIONS(RENDER_EGL_DEFINE_TYPE)
+LIST_EGL_FUNCTIONS(EGL_DEFINE_TYPE)
+LIST_EGL_EXTENSIONS_FUNCTIONS(EGL_DEFINE_TYPE)
 
-// Define EGLDispatch structure.
 struct EGLDispatch {
-    LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_DECLARE_MEMBER)
-    LIST_RENDER_EGL_EXTENSIONS_FUNCTIONS(RENDER_EGL_DECLARE_MEMBER)
-    LIST_RENDER_EGL_SNAPSHOT_FUNCTIONS(RENDER_EGL_DECLARE_MEMBER)
+    LIST_EGL_FUNCTIONS(EGL_DECLARE_MEMBER)
+    LIST_EGL_EXTENSIONS_FUNCTIONS(EGL_DECLARE_MEMBER)
 };
 
-// Initialize EGLDispatch function. Return true on success, false on failure.
-bool init_egl_dispatch();
+bool egl_dispatch_init();
 
-// Global EGLDispatch instance. Call init_egl_dispatch() before using it.
 extern EGLDispatch s_egl;
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp
index fd520cb90..fd25afc5d 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp
+++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp
@@ -1,224 +1,42 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "OpenGLESDispatch/GLESv1Dispatch.h"
-
-#include "OpenGLESDispatch/EGLDispatch.h"
-
-#include "android/utils/debug.h"
-
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <OpenGLESDispatch/EGLDispatch.h>
+#include <OpenGLESDispatch/GLESv1Dispatch.h>
+
+#include <dlfcn.h>
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "emugl/common/shared_library.h"
-
-#define DEBUG 0
-
-#if DEBUG
-#define DPRINT(...) do { \
-    if (!VERBOSE_CHECK(gles1emu)) VERBOSE_ENABLE(gles1emu); \
-    VERBOSE_PRINT(gles1emu, __VA_ARGS__); \
-} while (0)
-#else
-#define DPRINT(...)
-#endif
-
-static emugl::SharedLibrary *s_gles1_lib = NULL;
-static emugl::SharedLibrary *s_underlying_gles2_lib = NULL;
-
-// An unimplemented function which prints out an error message.
-// To make it consistent with the guest, all GLES1 functions not supported by
-// the guest driver should be redirected to this function.
-
-void gles1_unimplemented() {
-    fprintf(stderr, "Called unimplemented GLESv1 API\n");
-}
-
-#define DEFAULT_GLES_CM_LIB EMUGL_LIBNAME("GLES_CM_translator")
-#define DEFAULT_UNDERLYING_GLES_V2_LIB EMUGL_LIBNAME("GLES_V2_translator")
-
-// This section of code (also in GLDispatch.cpp)
-// initializes all GLESv1 functions to dummy ones;
-// that is, in case we are using a library that doesn't
-// have GLESv1, we will still have stubs available to
-// signal that they are unsupported on the host.
 
-#define RETURN_void return
-#define RETURN_GLboolean return GL_FALSE
-#define RETURN_GLint return 0
-#define RETURN_GLuint return 0U
-#define RETURN_GLenum return 0
-#define RETURN_int return 0
-#define RETURN_GLconstubyteptr return NULL
-#define RETURN_voidptr return NULL
-
-#define RETURN_(x)  RETURN_ ## x
-
-#define DUMMY_MSG "Call to %s: host OpenGL driver does not support OpenGL ES v1. Skipping."
-
-#ifdef _WIN32
-
-#define DEFINE_DUMMY_FUNCTION(return_type, func_name, signature, args) \
-static return_type  __stdcall gles1_dummy_##func_name signature { \
-    fprintf(stderr, DUMMY_MSG, #func_name); \
-    RETURN_(return_type); \
-}
-
-#define DEFINE_DUMMY_EXTENSION_FUNCTION(return_type, func_name, signature, args) \
-static return_type __stdcall gles1_dummy_##func_name signature { \
-    fprintf(stderr, DUMMY_MSG, #func_name); \
-    RETURN_(return_type); \
-}
-
-#else
-
-#define DEFINE_DUMMY_FUNCTION(return_type, func_name, signature, args) \
-static return_type gles1_dummy_##func_name signature { \
-    fprintf(stderr, DUMMY_MSG, #func_name); \
-    RETURN_(return_type); \
-}
-
-#define DEFINE_DUMMY_EXTENSION_FUNCTION(return_type, func_name, signature, args) \
-static return_type gles1_dummy_##func_name signature { \
-    fprintf(stderr, DUMMY_MSG, #func_name); \
-    RETURN_(return_type); \
-}
+#define DEFAULT_GLES_CM_LIB "libGLES_CM_swiftshader.so"
 
-#endif
+GLESv1Dispatch s_gles1;
 
-LIST_GLES1_FUNCTIONS(DEFINE_DUMMY_FUNCTION, DEFINE_DUMMY_EXTENSION_FUNCTION);
-LIST_GLES12_TR_FUNCTIONS(DEFINE_DUMMY_FUNCTION);
+#define LOOKUP_SYMBOL(return_type, function_name, signature, callargs)        \
+    s_gles1.function_name = (function_name##_t)dlsym(handle, #function_name); \
+    if ((!s_gles1.function_name) && s_egl.eglGetProcAddress)                  \
+        s_gles1.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name);
 
-//
-// This function is called only once during initialiation before
-// any thread has been created - hence it should NOT be thread safe.
-//
-
-//
-// init dummy GLESv1 dispatch table
-//
-#define ASSIGN_DUMMY(return_type,function_name,signature,callargs) do { \
-        dispatch_table-> function_name = gles1_dummy_##function_name; \
-        } while(0);
-
-bool gles1_dispatch_init(GLESv1Dispatch* dispatch_table) {
-
-    dispatch_table->underlying_gles2_api = NULL;
-
-    const char* libName = getenv("ANDROID_GLESv1_LIB");
-    if (!libName) {
-        libName = DEFAULT_GLES_CM_LIB;
+bool gles1_dispatch_init() {
+    void* handle = dlopen(DEFAULT_GLES_CM_LIB, RTLD_NOW);
+    if (!handle) {
+        printf("Failed to open %s\n", dlerror());
+        return false;
     }
 
-    // If emugl_config has detected specifically a backend
-    // that supports only GLESv2, set GLESv1 entry points
-    // to the dummy functions.
-    if (!strcmp(libName, "<gles2_only_backend>")) {
-
-        LIST_GLES1_FUNCTIONS(ASSIGN_DUMMY,ASSIGN_DUMMY)
-
-        DPRINT("assigning dummies because <gles2_only_backend>");
-        return true;
-    } else {
-
-        char error[256];
-        s_gles1_lib = emugl::SharedLibrary::open(libName, error, sizeof(error));
-        if (!s_gles1_lib) {
-            fprintf(stderr, "%s: Could not load %s [%s]\n", __FUNCTION__,
-                    libName, error);
-            return false;
-        }
-
-        //
-        // init the GLES dispatch table
-        //
-#define LOOKUP_SYMBOL(return_type,function_name,signature,callargs) do { \
-        dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \
-                s_gles1_lib->findSymbol(#function_name)); \
-            if ((!dispatch_table-> function_name) && s_egl.eglGetProcAddress) \
-            dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \
-                s_egl.eglGetProcAddress(#function_name)); \
-        } while(0); \
-
-        LIST_GLES1_FUNCTIONS(LOOKUP_SYMBOL,LOOKUP_SYMBOL)
-
-        DPRINT("successful");
-
-        LIST_GLES12_TR_FUNCTIONS(ASSIGN_DUMMY);
-
-        // If we are using the translator,
-        // import the gles1->2 translator dll
-        if (strstr(libName, "GLES12Translator")) {
+    LIST_GLES1_FUNCTIONS(LOOKUP_SYMBOL, LOOKUP_SYMBOL)
 
-            DPRINT("trying to assign gles12-specific functions");
-            LIST_GLES12_TR_FUNCTIONS(LOOKUP_SYMBOL);
-            DPRINT("hopefully, successfully assigned "
-                   "12tr-specific functions...");
-
-            DPRINT("Now creating the underlying api");
-            UnderlyingApis* gles2api =
-                (UnderlyingApis*)dispatch_table->create_underlying_api();
-            dispatch_table->underlying_gles2_api = gles2api;
-
-            DPRINT("api ptr:%p", dispatch_table->underlying_gles2_api);
-
-#define SET_UNDERLYING_GLES2_FUNC(rett, function_name, sig, callargs) do { \
-    dispatch_table->underlying_gles2_api->angle-> function_name = \
-        reinterpret_cast< function_name ## _t >( \
-                s_underlying_gles2_lib->findSymbol(#function_name)); \
-} while(0);
-
-            DPRINT("trying to initialize GLESv1->2 translation");
-            const char* underlying_gles2_lib_name =
-                getenv("ANDROID_GLESv2_LIB");
-
-            if (!underlying_gles2_lib_name) {
-                underlying_gles2_lib_name = DEFAULT_UNDERLYING_GLES_V2_LIB;
-            }
-            s_underlying_gles2_lib =
-                emugl::SharedLibrary::open(underlying_gles2_lib_name,
-                                           error, sizeof(error));
-            if (!s_underlying_gles2_lib) {
-                DPRINT("Could not load underlying gles2 lib %s [%s]",
-                        libName, error);
-                return false;
-            }
-            DPRINT("done trying to get gles2 lib");
-
-            LIST_GLES2_FUNCTIONS(SET_UNDERLYING_GLES2_FUNC,
-                                 SET_UNDERLYING_GLES2_FUNC);
-       }
-       return true;
-    }
-}
-
-//
-// This function is called only during initialization of the decoder before
-// any thread has been created - hence it should NOT be thread safe.
-//
-void *gles1_dispatch_get_proc_func(const char *name, void *userData)
-{
-    void* func = NULL;
-    if (s_gles1_lib) {
-        func = (void *)s_gles1_lib->findSymbol(name);
-    }
-    // To make it consistent with the guest, redirect any unsupported functions
-    // to gles1_unimplemented.
-    if (!func) {
-        func = (void *)gles1_unimplemented;
-    }
-    return func;
+    return true;
 }
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h
index ad71f81d2..b65b83cdc 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h
+++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h
@@ -1,49 +1,40 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #pragma once
 
-#include "OpenGLESDispatch/gldefs.h"
-#include "OpenGLESDispatch/gles_functions.h"
-#include "KHR/khrplatform.h"
+#include <GLES/gl.h>
+
+#include <OpenGLESDispatch/gles_functions.h>
 
-#include "GLES12Translator/underlying_apis.h"
+#define GLES1_DISPATCH_DEFINE_TYPE(return_type, func_name, signature, callargs) \
+    typedef return_type(KHRONOS_APIENTRY* func_name##_t) signature;
 
-// Define function pointer types.
-#define GLES1_DISPATCH_DEFINE_TYPE(return_type,func_name,signature,callargs) \
-    typedef return_type (KHRONOS_APIENTRY * func_name ## _t) signature;
+#define GLES1_DISPATCH_DECLARE_POINTER(return_type, func_name, signature, callargs) \
+    func_name##_t func_name;
 
-LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DEFINE_TYPE,GLES1_DISPATCH_DEFINE_TYPE)
-    LIST_GLES12_TR_FUNCTIONS(GLES1_DISPATCH_DEFINE_TYPE)
+LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DEFINE_TYPE, GLES1_DISPATCH_DEFINE_TYPE)
 
 struct GLESv1Dispatch {
-#define GLES1_DISPATCH_DECLARE_POINTER(return_type,func_name,signature,callargs) \
-        func_name ## _t func_name;
-    LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DECLARE_POINTER,
-                         GLES1_DISPATCH_DECLARE_POINTER)
-    LIST_GLES12_TR_FUNCTIONS(GLES1_DISPATCH_DECLARE_POINTER)
-    UnderlyingApis* underlying_gles2_api;
+    LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DECLARE_POINTER, GLES1_DISPATCH_DECLARE_POINTER)
 };
 
-#undef GLES1_DISPATCH_DECLARE_POINTER
 #undef GLES1_DISPATCH_DEFINE_TYPE
+#undef GLES1_DISPATCH_DECLARE_POINTER
 
-bool gles1_dispatch_init(GLESv1Dispatch* dispatch_table);
-
-// Used to initialize the decoder.
-void* gles1_dispatch_get_proc_func(const char* name, void* userData);
+bool gles1_dispatch_init();
 
-// Used to check for unimplemented.
-void gles1_unimplemented();
+extern GLESv1Dispatch s_gles1;
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp
index 24b73012d..4aaa5180c 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp
+++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp
@@ -1,88 +1,42 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "OpenGLESDispatch/GLESv2Dispatch.h"
-
-#include "OpenGLESDispatch/EGLDispatch.h"
-
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <OpenGLESDispatch/EGLDispatch.h>
+#include <OpenGLESDispatch/GLESv3Dispatch.h>
+
+#include <dlfcn.h>
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "emugl/common/shared_library.h"
 
-static emugl::SharedLibrary *s_gles2_lib = NULL;
+#define DEFAULT_GLESv2_LIB "libGLESv2_swiftshader.so"
 
-#define DEFAULT_GLES_V2_LIB EMUGL_LIBNAME("GLES_V2_translator")
-
-// An unimplemented function which prints out an error message.
-// To make it consistent with the guest, all GLES2 functions not supported by
-// the driver should be redirected to this function.
-
-void gles2_unimplemented() {
-    fprintf(stderr, "Called unimplemented GLES API\n");
-}
+GLESv3Dispatch s_gles3;
 
-//
-// This function is called only once during initialiation before
-// any thread has been created - hence it should NOT be thread safe.
-//
-bool gles2_dispatch_init(GLESv2Dispatch* dispatch_table)
-{
-    const char *libName = getenv("ANDROID_GLESv2_LIB");
-    if (!libName) {
-        libName = DEFAULT_GLES_V2_LIB;
-    }
+#define LOOKUP_SYMBOL(return_type, function_name, signature, callargs)        \
+    s_gles3.function_name = (function_name##_t)dlsym(handle, #function_name); \
+    if ((!s_gles3.function_name) && s_egl.eglGetProcAddress)                  \
+        s_gles3.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name);
 
-    char error[256];
-    s_gles2_lib = emugl::SharedLibrary::open(libName, error, sizeof(error));
-    if (!s_gles2_lib) {
-        fprintf(stderr, "%s: Could not load %s [%s]\n", __FUNCTION__,
-                libName, error);
+bool gles3_dispatch_init() {
+    void* handle = dlopen(DEFAULT_GLESv2_LIB, RTLD_NOW);
+    if (!handle) {
+        printf("Failed to open %s\n", dlerror());
         return false;
     }
 
-    //
-    // init the GLES dispatch table
-    //
-#define LOOKUP_SYMBOL(return_type,function_name,signature,callargs) \
-    dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \
-            s_gles2_lib->findSymbol(#function_name)); \
-    if ((!dispatch_table-> function_name) && s_egl.eglGetProcAddress) \
-        dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \
-            s_egl.eglGetProcAddress(#function_name)); \
-
-    LIST_GLES2_FUNCTIONS(LOOKUP_SYMBOL,LOOKUP_SYMBOL)
+    LIST_GLES3_FUNCTIONS(LOOKUP_SYMBOL, LOOKUP_SYMBOL)
 
     return true;
 }
-
-//
-// This function is called only during initialization before
-// any thread has been created - hence it should NOT be thread safe.
-//
-void *gles2_dispatch_get_proc_func(const char *name, void *userData)
-{
-    void* func = NULL;
-    if (s_gles2_lib) {
-        func = (void *)s_gles2_lib->findSymbol(name);
-    }
-    // To make it consistent with the guest, redirect any unsupported functions
-    // to gles2_unimplemented.
-    if (!func) {
-        func = (void *)gles2_unimplemented;
-    }
-    return func;
-}
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h
index 00841567f..afdd0007d 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h
+++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h
@@ -1,56 +1,41 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #pragma once
 
-#include "OpenGLESDispatch/gldefs.h"
-#include "OpenGLESDispatch/gles_functions.h"
-#include "KHR/khrplatform.h"
+#include <GLES3/gl31.h>
+
+#include <OpenGLESDispatch/gles_functions.h>
 
 // Define function pointer types.
-#define GLES2_DISPATCH_DEFINE_TYPE(return_type,func_name,signature,callargs) \
-    typedef return_type (KHRONOS_APIENTRY * func_name ## _t) signature;
+#define GLES3_DISPATCH_DEFINE_TYPE(return_type, func_name, signature, callargs) \
+    typedef return_type(KHRONOS_APIENTRY* func_name##_t) signature;
 
-LIST_GLES2_FUNCTIONS(GLES2_DISPATCH_DEFINE_TYPE,GLES2_DISPATCH_DEFINE_TYPE)
+#define GLES3_DISPATCH_DECLARE_POINTER(return_type, func_name, signature, callargs) \
+    func_name##_t func_name;
 
-struct GLESv2Dispatch {
-#define GLES2_DISPATCH_DECLARE_POINTER(return_type,func_name,signature,callargs) \
-        func_name ## _t func_name;
-    LIST_GLES2_FUNCTIONS(GLES2_DISPATCH_DECLARE_POINTER,
-                         GLES2_DISPATCH_DECLARE_POINTER)
-};
+LIST_GLES3_FUNCTIONS(GLES3_DISPATCH_DEFINE_TYPE, GLES3_DISPATCH_DEFINE_TYPE)
 
-#undef GLES2_DISPATCH_DECLARE_POINTER
-#undef GLES2_DISPATCH_DEFINE_TYPE
-
-bool gles2_dispatch_init(GLESv2Dispatch* dispatch_table);
-
-// Used to initialize the decoder.
-void* gles2_dispatch_get_proc_func(const char* name, void* userData);
-// Used to check for unimplemented.
-void gles2_unimplemented();
-
-// Used to query max GLES version support based on what the dispatch mechanism
-// has found in the GLESv2 library.
-// First, a enum for tracking the detected GLES version based on dispatch.
-// We support 2 minimally.
-enum GLESDispatchMaxVersion {
-    GLES_DISPATCH_MAX_VERSION_2 = 0,
-    GLES_DISPATCH_MAX_VERSION_3_0 = 1,
-    GLES_DISPATCH_MAX_VERSION_3_1 = 2,
-    GLES_DISPATCH_MAX_VERSION_3_2 = 3,
+struct GLESv3Dispatch {
+    LIST_GLES3_FUNCTIONS(GLES3_DISPATCH_DECLARE_POINTER, GLES3_DISPATCH_DECLARE_POINTER)
 };
 
-GLESDispatchMaxVersion gles2_dispatch_get_max_version();
+#undef GLES3_DISPATCH_DEFINE_TYPE
+#undef GLES3_DISPATCH_DECLARE_POINTER
+
+bool gles3_dispatch_init();
+
+extern GLESv3Dispatch s_gles3;
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/egl.entries b/host/libs/virglrenderer/OpenGLESDispatch/egl.entries
index e6279a3ed..46d4c0dd8 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/egl.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/egl.entries
@@ -1,28 +1,44 @@
-# The list of EGL functions used by libOpenglRender, without extensions.
-# This is only a subset of the full EGL API.
+!egl
 
-!Render_EGL
 %#include <EGL/egl.h>
 
+%// Return types must be single words, see GLDispatch.cpp
+%typedef const char* EGLconstcharptr;
+
+EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
+EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx);
+EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface);
+EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+EGLDisplay eglGetCurrentDisplay(void);
+EGLSurface eglGetCurrentSurface(EGLint readdraw);
+EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id);
 EGLint eglGetError(void);
-EGLDisplay eglGetDisplay(EGLNativeDisplayType dpy);
+void* eglGetProcAddress(const char *procname);
+EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
+EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+EGLconstcharptr eglQueryString(EGLDisplay dpy, EGLint name);
+EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface);
 EGLBoolean eglTerminate(EGLDisplay dpy);
-EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor);
-char* eglQueryString(EGLDisplay dpy, EGLint id);
-EGLBoolean eglGetConfigs(EGLDisplay display, EGLConfig* configs, EGLint config_size, EGLint* num_config);
-EGLBoolean eglChooseConfig(EGLDisplay display, const EGLint* attribs, EGLConfig* configs, EGLint config_size, EGLint* num_config);
-EGLBoolean eglGetConfigAttrib(EGLDisplay display, EGLConfig config, EGLint attribute, EGLint* value);
-EGLSurface eglCreateWindowSurface(EGLDisplay display, EGLConfig config, EGLNativeWindowType native_window, const EGLint* attrib_list);
-EGLSurface eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, const EGLint* attrib_list);
-EGLBoolean eglDestroySurface(EGLDisplay display, EGLSurface surface);
+EGLBoolean eglWaitGL(void);
+EGLBoolean eglWaitNative(EGLint engine);
+
+EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval);
+
 EGLBoolean eglBindAPI(EGLenum api);
 EGLenum eglQueryAPI(void);
+EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
 EGLBoolean eglReleaseThread(void);
-EGLContext eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, const EGLint* attrib_list);
-EGLBoolean eglDestroyContext(EGLDisplay display, EGLContext context);
-EGLBoolean eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);
+EGLBoolean eglWaitClient(void);
+
 EGLContext eglGetCurrentContext(void);
-EGLSurface eglGetCurrentSurface(EGLint readdraw);
-EGLBoolean eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint *value);
-EGLBoolean eglSwapBuffers(EGLDisplay display, EGLSurface surface);
-void* eglGetProcAddress(const char* function_name);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries b/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries
index 186f1f06e..e1e0bc7de 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries
@@ -1,19 +1,11 @@
-# The list of EGL extension functions used by libOpenglRender.
-# This is only a subset of the full EGL API.
+!egl_extensions
 
-!Render_EGL_extensions
-
-%#include <EGL/egl.h>
-%#define EGL_EGLEXT_PROTOTYPES
 %#include <EGL/eglext.h>
 
-EGLImageKHR eglCreateImageKHR(EGLDisplay display, EGLContext context, EGLenum target, EGLClientBuffer buffer, const EGLint* attrib_list);
-EGLBoolean eglDestroyImageKHR(EGLDisplay display, EGLImageKHR image);
-EGLSyncKHR eglCreateSyncKHR(EGLDisplay display, EGLenum type, const EGLint* attribs);
-EGLint eglClientWaitSyncKHR(EGLDisplay display, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
-EGLint eglWaitSyncKHR(EGLDisplay display, EGLSyncKHR sync, EGLint flags);
-EGLBoolean eglDestroySyncKHR(EGLDisplay display, EGLSyncKHR sync);
-EGLint eglGetMaxGLESVersion(EGLDisplay display);
-void eglBlitFromCurrentReadBufferANDROID(EGLDisplay display, EGLImageKHR image);
-void* eglSetImageFenceANDROID(EGLDisplay display, EGLImageKHR image);
-void eglWaitImageFenceANDROID(EGLDisplay display, void* fence);
+EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
+EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
+EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
+EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
+
+EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
+EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries
index f42e279f3..8c7f95376 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries
@@ -1,16 +1,153 @@
-!gles12_tr
+!gles1_core
 
-# Functions which are needed ONLY for implementing GLES 1->2 translation
+%#include <GLES/gl.h>
 
-%typedef void* voidptr;
+%// Return types must be single words, see GLDispatch.cpp
+%typedef const GLubyte* GL1constubyteptr;
 
-voidptr create_gles1_context(void* share, const void* underlying_apis);
-voidptr get_current_gles_context(void);
-void set_current_gles_context(void* ctx);
-voidptr create_underlying_api(void);
+void glAlphaFunc(GLenum func, GLclampf ref);
+void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void glClearDepthf(GLclampf depth);
+void glClipPlanef(GLenum plane, const GLfloat *equation);
+void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void glDepthRangef(GLclampf zNear, GLclampf zFar);
+void glFogf(GLenum pname, GLfloat param);
+void glFogfv(GLenum pname, const GLfloat *params);
+void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
+void glGetClipPlanef(GLenum pname, GLfloat *eqn);
+void glGetFloatv(GLenum pname, GLfloat *params);
+void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
+void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
+void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params);
+void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
+void glLightModelf(GLenum pname, GLfloat param);
+void glLightModelfv(GLenum pname, const GLfloat *params);
+void glLightf(GLenum light, GLenum pname, GLfloat param);
+void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
+void glLineWidth(GLfloat width);
+void glLoadMatrixf(const GLfloat *m);
+void glMaterialf(GLenum face, GLenum pname, GLfloat param);
+void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
+void glMultMatrixf(const GLfloat *m);
+void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
+void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
+void glPointParameterf(GLenum pname, GLfloat param);
+void glPointParameterfv(GLenum pname, const GLfloat *params);
+void glPointSize(GLfloat size);
+void glPolygonOffset(GLfloat factor, GLfloat units);
+void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void glScalef(GLfloat x, GLfloat y, GLfloat z);
+void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
+void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
+void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
+void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
+void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
+void glActiveTexture(GLenum texture);
+void glAlphaFuncx(GLenum func, GLclampx ref);
+void glBindBuffer(GLenum target, GLuint buffer);
+void glBindTexture(GLenum target, GLuint texture);
+void glBlendFunc(GLenum sfactor, GLenum dfactor);
+void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+void glClear(GLbitfield mask);
+void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
+void glClearDepthx(GLclampx depth);
+void glClearStencil(GLint s);
+void glClientActiveTexture(GLenum texture);
+void glClipPlanex(GLenum plane, const GLfixed *equation);
+void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
+void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void glCullFace(GLenum mode);
+void glDeleteBuffers(GLsizei n, const GLuint *buffers);
+void glDeleteTextures(GLsizei n, const GLuint *textures);
+void glDepthFunc(GLenum func);
+void glDepthMask(GLboolean flag);
+void glDepthRangex(GLclampx zNear, GLclampx zFar);
+void glDisable(GLenum cap);
+void glDisableClientState(GLenum array);
+void glDrawArrays(GLenum mode, GLint first, GLsizei count);
+void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void glEnable(GLenum cap);
+void glEnableClientState(GLenum array);
+void glFinish(void);
+void glFlush(void);
+void glFogx(GLenum pname, GLfixed param);
+void glFogxv(GLenum pname, const GLfixed *params);
+void glFrontFace(GLenum mode);
+void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
+void glGetBooleanv(GLenum pname, GLboolean *params);
+void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
+void glGetClipPlanex(GLenum pname, GLfixed *eqn);
+void glGenBuffers(GLsizei n, GLuint *buffers);
+void glGenTextures(GLsizei n, GLuint *textures);
+GLenum glGetError(void);
+void glGetFixedv(GLenum pname, GLfixed *params);
+void glGetIntegerv(GLenum pname, GLint *params);
+void glGetLightxv(GLenum light, GLenum pname, GLfixed *params);
+void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params);
+void glGetPointerv(GLenum pname, GLvoid **params);
+GL1constubyteptr glGetString(GLenum name);
+void glGetTexEnviv(GLenum env, GLenum pname, GLint *params);
+void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params);
+void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
+void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params);
+void glHint(GLenum target, GLenum mode);
+GLboolean glIsBuffer(GLuint buffer);
+GLboolean glIsEnabled(GLenum cap);
+GLboolean glIsTexture(GLuint texture);
+void glLightModelx(GLenum pname, GLfixed param);
+void glLightModelxv(GLenum pname, const GLfixed *params);
+void glLightx(GLenum light, GLenum pname, GLfixed param);
+void glLightxv(GLenum light, GLenum pname, const GLfixed *params);
+void glLineWidthx(GLfixed width);
+void glLoadIdentity(void);
+void glLoadMatrixx(const GLfixed *m);
+void glLogicOp(GLenum opcode);
+void glMaterialx(GLenum face, GLenum pname, GLfixed param);
+void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params);
+void glMatrixMode(GLenum mode);
+void glMultMatrixx(const GLfixed *m);
+void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
+void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz);
+void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
+void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
+void glPixelStorei(GLenum pname, GLint param);
+void glPointParameterx(GLenum pname, GLfixed param);
+void glPointParameterxv(GLenum pname, const GLfixed *params);
+void glPointSizex(GLfixed size);
+void glPolygonOffsetx(GLfixed factor, GLfixed units);
+void glPopMatrix(void);
+void glPushMatrix(void);
+void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
+void glSampleCoverage(GLclampf value, GLboolean invert);
+void glSampleCoveragex(GLclampx value, GLboolean invert);
+void glScalex(GLfixed x, GLfixed y, GLfixed z);
+void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+void glShadeModel(GLenum mode);
+void glStencilFunc(GLenum func, GLint ref, GLuint mask);
+void glStencilMask(GLuint mask);
+void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
+void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void glTexEnvi(GLenum target, GLenum pname, GLint param);
+void glTexEnvx(GLenum target, GLenum pname, GLfixed param);
+void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
+void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params);
+void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void glTexParameteri(GLenum target, GLenum pname, GLint param);
+void glTexParameterx(GLenum target, GLenum pname, GLfixed param);
+void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
+void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params);
+void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void glTranslatex(GLfixed x, GLfixed y, GLfixed z);
+void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
 
-# Extra setup on making a emulated GLES1 context current
-void make_current_setup(uint32_t surf_width, uint32_t surf_height);
-
-# destroying GLES1 contexts
-void destroy_gles1_context(void* ctx);
+void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries
index 2670bae7c..a2e990acf 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries
@@ -1,17 +1,35 @@
 !gles1_extensions
 
-# OpenGL functions which are needed ONLY for implementing GLES 1.1 EXTENSIONS
-void glCurrentPaletteMatrixARB(GLint index);
-void glMatrixIndexuivARB(GLint size, GLuint * indices);
-void glMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
-void glWeightPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
-void glTexGenf(GLenum coord, GLenum pname, GLfloat param );
-void glTexGeni(GLenum coord, GLenum pname, GLint param );
-void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params );
-void glTexGeniv(GLenum coord, GLenum pname, const GLint *params );
-void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params );
-void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params );
-void glColorPointerWithDataSize(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
-void glNormalPointerWithDataSize(GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
-void glTexCoordPointerWithDataSize(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
-void glVertexPointerWithDataSize(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
+%#include <GLES/glext.h>
+
+void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha);
+void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+void glBlendEquationOES(GLenum mode);
+
+void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
+void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height);
+void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
+void glDrawTexsvOES(const GLshort *coords);
+void glDrawTexivOES(const GLint *coords);
+void glDrawTexxvOES(const GLfixed *coords);
+void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
+void glDrawTexfvOES(const GLfloat *coords);
+
+void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);
+void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image);
+
+GLboolean glIsRenderbufferOES(GLuint renderbuffer);
+void glBindRenderbufferOES(GLenum target, GLuint renderbuffer);
+void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers);
+void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers);
+void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params);
+GLboolean glIsFramebufferOES(GLuint framebuffer);
+void glBindFramebufferOES(GLenum target, GLuint framebuffer);
+void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers);
+void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers);
+GLenum glCheckFramebufferStatusOES(GLenum target);
+void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params);
+void glGenerateMipmapOES(GLenum target);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries
index 0eaa0aec0..6cab5f8fa 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries
@@ -1,85 +1,146 @@
-!gles2_only
+!gles2_core
 
-# OpenGL functions which are needed ONLY for implementing GLES 2.0
-void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-void glStencilMaskSeparate(GLenum face, GLuint mask);
-void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-GLboolean glIsProgram(GLuint program);
-GLboolean glIsShader(GLuint shader);
-void glVertexAttrib1f(GLuint indx, GLfloat x);
-void glVertexAttrib1fv(GLuint indx, const GLfloat* values);
-void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
-void glVertexAttrib2fv(GLuint indx, const GLfloat* values);
-void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-void glVertexAttrib3fv(GLuint indx, const GLfloat* values);
-void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-void glVertexAttrib4fv(GLuint indx, const GLfloat* values);
-void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr);
-void glDisableVertexAttribArray(GLuint index);
-void glEnableVertexAttribArray(GLuint index);
-void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params);
-void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params);
-void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer);
-void glUniform1f(GLint location, GLfloat x);
-void glUniform1fv(GLint location, GLsizei count, const GLfloat* v);
-void glUniform1i(GLint location, GLint x);
-void glUniform1iv(GLint location, GLsizei count, const GLint* v);
-void glUniform2f(GLint location, GLfloat x, GLfloat y);
-void glUniform2fv(GLint location, GLsizei count, const GLfloat* v);
-void glUniform2i(GLint location, GLint x, GLint y);
-void glUniform2iv(GLint location, GLsizei count, const GLint* v);
-void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
-void glUniform3fv(GLint location, GLsizei count, const GLfloat* v);
-void glUniform3i(GLint location, GLint x, GLint y, GLint z);
-void glUniform3iv(GLint location, GLsizei count, const GLint* v);
-void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-void glUniform4fv(GLint location, GLsizei count, const GLfloat* v);
-void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
-void glUniform4iv(GLint location, GLsizei count, const GLint* v);
-void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+%#include <GLES3/gl31.h>
+
+void glActiveTexture(GLenum texture);
 void glAttachShader(GLuint program, GLuint shader);
-void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name);
+void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
+void glBindBuffer(GLenum target, GLuint buffer);
+void glBindFramebuffer(GLenum target, GLuint framebuffer);
+void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
+void glBindTexture(GLenum target, GLuint texture);
+void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void glBlendEquation(GLenum mode);
+void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
+void glBlendFunc(GLenum sfactor, GLenum dfactor);
+void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
+GLenum glCheckFramebufferStatus(GLenum target);
+void glClear(GLbitfield mask);
+void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void glClearDepthf(GLfloat d);
+void glClearStencil(GLint s);
+void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
 void glCompileShader(GLuint shader);
+void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
+void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
+void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
 GLuint glCreateProgram(void);
 GLuint glCreateShader(GLenum type);
+void glCullFace(GLenum mode);
+void glDeleteBuffers(GLsizei n, const GLuint *buffers);
+void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
 void glDeleteProgram(GLuint program);
+void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
 void glDeleteShader(GLuint shader);
+void glDeleteTextures(GLsizei n, const GLuint *textures);
+void glDepthFunc(GLenum func);
+void glDepthMask(GLboolean flag);
+void glDepthRangef(GLfloat n, GLfloat f);
 void glDetachShader(GLuint program, GLuint shader);
-void glLinkProgram(GLuint program);
-void glUseProgram(GLuint program);
-void glValidateProgram(GLuint program);
-void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-int  glGetAttribLocation(GLuint program, const GLchar* name);
-void glGetProgramiv(GLuint program, GLenum pname, GLint* params);
-void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-void glGetShaderiv(GLuint shader, GLenum pname, GLint* params);
-void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
-void glGetUniformfv(GLuint program, GLint location, GLfloat* params);
-void glGetUniformiv(GLuint program, GLint location, GLint* params);
-int  glGetUniformLocation(GLuint program, const GLchar* name);
-void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
-
-# The following are not used by GLDispatch but by GLESv2Dispatch
-void glBindFramebuffer(GLenum target, GLuint framebuffer);
-void glGenFramebuffers(GLsizei n, GLuint* framebuffers);
+void glDisable(GLenum cap);
+void glDisableVertexAttribArray(GLuint index);
+void glDrawArrays(GLenum mode, GLint first, GLsizei count);
+void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
+void glEnable(GLenum cap);
+void glEnableVertexAttribArray(GLuint index);
+void glFinish(void);
+void glFlush(void);
+void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-GLenum glCheckFramebufferStatus(GLenum target);
+void glFrontFace(GLenum mode);
+void glGenBuffers(GLsizei n, GLuint *buffers);
+void glGenerateMipmap(GLenum target);
+void glGenFramebuffers(GLsizei n, GLuint *framebuffers);
+void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
+void glGenTextures(GLsizei n, GLuint *textures);
+void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
+GLint glGetAttribLocation(GLuint program, const GLchar *name);
+void glGetBooleanv(GLenum pname, GLboolean *data);
+void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
+GLenum glGetError(void);
+void glGetFloatv(GLenum pname, GLfloat *data);
+void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
+void glGetIntegerv(GLenum pname, GLint *data);
+void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
+void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
+void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
+void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
+void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+const GLubyte *glGetString(GLenum name);
+void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
+void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
+void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
+void glGetUniformiv(GLuint program, GLint location, GLint *params);
+GLint glGetUniformLocation(GLuint program, const GLchar *name);
+void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
+void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
+void glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer);
+void glHint(GLenum target, GLenum mode);
+GLboolean glIsBuffer(GLuint buffer);
+GLboolean glIsEnabled(GLenum cap);
 GLboolean glIsFramebuffer(GLuint framebuffer);
-void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
-
+GLboolean glIsProgram(GLuint program);
 GLboolean glIsRenderbuffer(GLuint renderbuffer);
-void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
-void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
+GLboolean glIsShader(GLuint shader);
+GLboolean glIsTexture(GLuint texture);
+void glLineWidth(GLfloat width);
+void glLinkProgram(GLuint program);
+void glPixelStorei(GLenum pname, GLint param);
+void glPolygonOffset(GLfloat factor, GLfloat units);
+void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+void glReleaseShaderCompiler(void);
 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
-void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-
-void glGenerateMipmap(GLenum target);
+void glSampleCoverage(GLfloat value, GLboolean invert);
+void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);
+void glShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
+void glStencilFunc(GLenum func, GLint ref, GLuint mask);
+void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
+void glStencilMask(GLuint mask);
+void glStencilMaskSeparate(GLenum face, GLuint mask);
+void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
+void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
+void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
+void glTexParameteri(GLenum target, GLenum pname, GLint param);
+void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
+void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+void glUniform1f(GLint location, GLfloat v0);
+void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
+void glUniform1i(GLint location, GLint v0);
+void glUniform1iv(GLint location, GLsizei count, const GLint *value);
+void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
+void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
+void glUniform2i(GLint location, GLint v0, GLint v1);
+void glUniform2iv(GLint location, GLsizei count, const GLint *value);
+void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
+void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+void glUniform3iv(GLint location, GLsizei count, const GLint *value);
+void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
+void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+void glUniform4iv(GLint location, GLsizei count, const GLint *value);
+void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUseProgram(GLuint program);
+void glValidateProgram(GLuint program);
+void glVertexAttrib1f(GLuint index, GLfloat x);
+void glVertexAttrib1fv(GLuint index, const GLfloat *v);
+void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
+void glVertexAttrib2fv(GLuint index, const GLfloat *v);
+void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+void glVertexAttrib3fv(GLuint index, const GLfloat *v);
+void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void glVertexAttrib4fv(GLuint index, const GLfloat *v);
+void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries
index 99abf3c13..1453e8744 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries
@@ -1,7 +1,20 @@
 !gles2_extensions
 
-# GLES 2.0 extensions
-void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-void glReleaseShaderCompiler(void);
-void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);
-void glVertexAttribPointerWithDataSize(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr, GLsizei dataSize);
+%#include <GLES2/gl2ext.h>
+
+void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);
+void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image);
+
+void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
+void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
+void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
+void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
+void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+
+void glDrawBuffersEXT(GLsizei n, const GLenum *bufs);
+
+void glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount);
+void glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
+
+void glVertexAttribDivisorEXT(GLuint index, GLuint divisor);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries
index d6062f28d..53cc1e199 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries
@@ -1,51 +1,38 @@
 !gles31_only
 
-# GLES 3.1 functions required by the translator library.
-
-%#include <GLES/gl.h>
-%#include <GLES3/gl3.h>
 %#include <GLES3/gl31.h>
 
-## New gets
-void glGetBooleani_v(GLenum target, GLuint index, GLboolean * data);
-
-## Memory barriers
-void glMemoryBarrier(GLbitfield barriers);
-void glMemoryBarrierByRegion(GLbitfield barriers);
-
-## Program pipelines
-void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
-void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-void glBindProgramPipeline(GLuint pipeline);
-
-void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
-void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-
-void glValidateProgramPipeline(GLuint pipeline);
-GLboolean glIsProgramPipeline(GLuint pipeline);
+void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
+void glDispatchComputeIndirect(GLintptr indirect);
+void glDrawArraysIndirect(GLenum mode, const void *indirect);
+void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
+void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
+void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
+void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
+GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
+void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
+void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
+GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
 void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-
-## Separable shader programs
 void glActiveShaderProgram(GLuint pipeline, GLuint program);
-
-GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const char **strings);
-
-void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
-void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings);
+void glBindProgramPipeline(GLuint pipeline);
+void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
+void glGenProgramPipelines(GLsizei n, GLuint *pipelines);
+GLboolean glIsProgramPipeline(GLuint pipeline);
+void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
 void glProgramUniform1i(GLuint program, GLint location, GLint v0);
 void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
 void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
 void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
 void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-void glProgramUniform2ui(GLuint program, GLint location, GLint v0, GLuint v1);
-void glProgramUniform3ui(GLuint program, GLint location, GLint v0, GLint v1, GLuint v2);
-void glProgramUniform4ui(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLuint v3);
-void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
+void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
+void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
+void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
 void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
 void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
 void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
@@ -54,6 +41,10 @@ void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const G
 void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
 void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
 void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
+void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
 void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
@@ -63,40 +54,19 @@ void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count,
 void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint * params);
-void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params);
-
-GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const char * name);
-GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const char * name);
-void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, char * name);
-
-## Compute shaders
+void glValidateProgramPipeline(GLuint pipeline);
+void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
 void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-void glDispatchComputeIndirect(GLintptr indirect);
-
-## Separate vertex format / buffer binding
-void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLintptr stride);
-void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
+void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
+void glMemoryBarrier(GLbitfield barriers);
+void glMemoryBarrierByRegion(GLbitfield barriers);
+void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
+void glSampleMaski(GLuint maskNumber, GLbitfield mask);
+void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
+void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
 void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
 void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
 void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
-
-## Indirect draws
-void glDrawArraysIndirect(GLenum mode, const void *indirect);
-void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
-
-## Multisampling
-void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-void glSampleMaski(GLuint maskNumber, GLbitfield mask);
-void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-
-## New framebuffer parameters
-void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
-void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint * params);
-
-## Texture LOD queries
-# Already used in Translator's validations.
-# void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params);
-# void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only_functions.h b/host/libs/virglrenderer/OpenGLESDispatch/gles31_only_functions.h
deleted file mode 100644
index a89faf760..000000000
--- a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only_functions.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Auto-generated with: android/scripts/gen-entries.py --mode=funcargs android/android-emugl/host/libs/libOpenGLESDispatch/gles31_only.entries --output=android/android-emugl/host/include/OpenGLESDispatch/gles31_only_functions.h
-// DO NOT EDIT THIS FILE
-
-#ifndef GLES31_ONLY_FUNCTIONS_H
-#define GLES31_ONLY_FUNCTIONS_H
-
-#include <GLES/gl.h>
-#include <GLES3/gl3.h>
-#include <GLES3/gl31.h>
-#define LIST_GLES31_ONLY_FUNCTIONS(X) \
-  X(void, glGetBooleani_v, (GLenum target, GLuint index, GLboolean * data), (target, index, data)) \
-  X(void, glMemoryBarrier, (GLbitfield barriers), (barriers)) \
-  X(void, glMemoryBarrierByRegion, (GLbitfield barriers), (barriers)) \
-  X(void, glGenProgramPipelines, (GLsizei n, GLuint * pipelines), (n, pipelines)) \
-  X(void, glDeleteProgramPipelines, (GLsizei n, const GLuint * pipelines), (n, pipelines)) \
-  X(void, glBindProgramPipeline, (GLuint pipeline), (pipeline)) \
-  X(void, glGetProgramPipelineiv, (GLuint pipeline, GLenum pname, GLint * params), (pipeline, pname, params)) \
-  X(void, glGetProgramPipelineInfoLog, (GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog), (pipeline, bufSize, length, infoLog)) \
-  X(void, glValidateProgramPipeline, (GLuint pipeline), (pipeline)) \
-  X(GLboolean, glIsProgramPipeline, (GLuint pipeline), (pipeline)) \
-  X(void, glUseProgramStages, (GLuint pipeline, GLbitfield stages, GLuint program), (pipeline, stages, program)) \
-  X(GLuint, glCreateShaderProgramv, (GLenum type, GLsizei count, const char ** strings), (type, count, strings)) \
-  X(void, glProgramUniform1f, (GLuint program, GLint location, GLfloat v0), (program, location, v0)) \
-  X(void, glProgramUniform2f, (GLuint program, GLint location, GLfloat v0, GLfloat v1), (program, location, v0, v1)) \
-  X(void, glProgramUniform3f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2), (program, location, v0, v1, v2)) \
-  X(void, glProgramUniform4f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3), (program, location, v0, v1, v2, v3)) \
-  X(void, glProgramUniform1i, (GLuint program, GLint location, GLint v0), (program, location, v0)) \
-  X(void, glProgramUniform2i, (GLuint program, GLint location, GLint v0, GLint v1), (program, location, v0, v1)) \
-  X(void, glProgramUniform3i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2), (program, location, v0, v1, v2)) \
-  X(void, glProgramUniform4i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3), (program, location, v0, v1, v2, v3)) \
-  X(void, glProgramUniform1ui, (GLuint program, GLint location, GLuint v0), (program, location, v0)) \
-  X(void, glProgramUniform2ui, (GLuint program, GLint location, GLint v0, GLuint v1), (program, location, v0, v1)) \
-  X(void, glProgramUniform3ui, (GLuint program, GLint location, GLint v0, GLint v1, GLuint v2), (program, location, v0, v1, v2)) \
-  X(void, glProgramUniform4ui, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLuint v3), (program, location, v0, v1, v2, v3)) \
-  X(void, glProgramUniform1fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \
-  X(void, glProgramUniform2fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \
-  X(void, glProgramUniform3fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \
-  X(void, glProgramUniform4fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \
-  X(void, glProgramUniform1iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \
-  X(void, glProgramUniform2iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \
-  X(void, glProgramUniform3iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \
-  X(void, glProgramUniform4iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \
-  X(void, glProgramUniform1uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \
-  X(void, glProgramUniform2uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \
-  X(void, glProgramUniform3uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \
-  X(void, glProgramUniform4uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \
-  X(void, glProgramUniformMatrix2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix2x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix3x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix2x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix4x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix3x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glProgramUniformMatrix4x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \
-  X(void, glGetProgramInterfaceiv, (GLuint program, GLenum programInterface, GLenum pname, GLint * params), (program, programInterface, pname, params)) \
-  X(void, glGetProgramResourceiv, (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params), (program, programInterface, index, propCount, props, bufSize, length, params)) \
-  X(GLuint, glGetProgramResourceIndex, (GLuint program, GLenum programInterface, const char * name), (program, programInterface, name)) \
-  X(GLint, glGetProgramResourceLocation, (GLuint program, GLenum programInterface, const char * name), (program, programInterface, name)) \
-  X(void, glGetProgramResourceName, (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, char * name), (program, programInterface, index, bufSize, length, name)) \
-  X(void, glBindImageTexture, (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format), (unit, texture, level, layered, layer, access, format)) \
-  X(void, glDispatchCompute, (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z), (num_groups_x, num_groups_y, num_groups_z)) \
-  X(void, glDispatchComputeIndirect, (GLintptr indirect), (indirect)) \
-  X(void, glBindVertexBuffer, (GLuint bindingindex, GLuint buffer, GLintptr offset, GLintptr stride), (bindingindex, buffer, offset, stride)) \
-  X(void, glVertexAttribBinding, (GLuint attribindex, GLuint bindingindex), (attribindex, bindingindex)) \
-  X(void, glVertexAttribFormat, (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset), (attribindex, size, type, normalized, relativeoffset)) \
-  X(void, glVertexAttribIFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset), (attribindex, size, type, relativeoffset)) \
-  X(void, glVertexBindingDivisor, (GLuint bindingindex, GLuint divisor), (bindingindex, divisor)) \
-  X(void, glDrawArraysIndirect, (GLenum mode, const void * indirect), (mode, indirect)) \
-  X(void, glDrawElementsIndirect, (GLenum mode, GLenum type, const void * indirect), (mode, type, indirect)) \
-  X(void, glTexStorage2DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations), (target, samples, internalformat, width, height, fixedsamplelocations)) \
-  X(void, glSampleMaski, (GLuint maskNumber, GLbitfield mask), (maskNumber, mask)) \
-  X(void, glGetMultisamplefv, (GLenum pname, GLuint index, GLfloat * val), (pname, index, val)) \
-  X(void, glFramebufferParameteri, (GLenum target, GLenum pname, GLint param), (target, pname, param)) \
-  X(void, glGetFramebufferParameteriv, (GLenum target, GLenum pname, GLint * params), (target, pname, params)) \
-
-
-#endif  // GLES31_ONLY_FUNCTIONS_H
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries
index 89103fea9..9742d382e 100644
--- a/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries
+++ b/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries
@@ -1,149 +1,111 @@
 !gles3_only
 
-# GLES 3.0 functions required by the translator library.
+%#include <GLES3/gl31.h>
 
-%#include <GLES/gl.h>
-%#include <GLES3/gl3.h>
-%#include <GLES3/gl3ext.h>
+%// Return types must be single words, see GLDispatch.cpp
+%typedef const GLubyte* GL3constubyteptr;
 
-# glGetStringi
-GLconstubyteptr glGetStringi(GLenum name, GLint index);
-
-# VAOs
-void glGenVertexArrays(GLsizei n, GLuint* arrays);
+void glReadBuffer(GLenum src);
+void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
+void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
+void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
+void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
+void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
+void glGenQueries(GLsizei n, GLuint *ids);
+void glDeleteQueries(GLsizei n, const GLuint *ids);
+GLboolean glIsQuery(GLuint id);
+void glBeginQuery(GLenum target, GLuint id);
+void glEndQuery(GLenum target);
+void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
+void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
+GLboolean glUnmapBuffer(GLenum target);
+void glGetBufferPointerv(GLenum target, GLenum pname, void **params);
+void glDrawBuffers(GLsizei n, const GLenum *bufs);
+void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+void* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
 void glBindVertexArray(GLuint array);
 void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
+void glGenVertexArrays(GLsizei n, GLuint *arrays);
 GLboolean glIsVertexArray(GLuint array);
-
-# Buffers
-void *glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-GLboolean glUnmapBuffer(GLenum target);
-void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-
+void glGetIntegeri_v(GLenum target, GLuint index, GLint *data);
+void glBeginTransformFeedback(GLenum primitiveMode);
+void glEndTransformFeedback(void);
 void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
 void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
-
-void glCopyBufferSubData(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size);
-
-void glClearBufferiv(GLenum buffer, GLint drawBuffer, const GLint * value);
-void glClearBufferuiv(GLenum buffer, GLint drawBuffer, const GLuint * value);
-void glClearBufferfv(GLenum buffer, GLint drawBuffer, const GLfloat * value);
-void glClearBufferfi(GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil);
-
-void glGetBufferParameteri64v(GLenum target, GLenum value, GLint64 * data);
-void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params);
-
-# UBOs
-void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-
-GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
-void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar **uniformNames, GLuint *uniformIndices);
-
-void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-
-# More uniform setters
+void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode);
+void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
+void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
+void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
+void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
+void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+void glVertexAttribI4iv(GLuint index, const GLint *v);
+void glVertexAttribI4uiv(GLuint index, const GLuint *v);
+void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
+GLint glGetFragDataLocation(GLuint program, const GLchar *name);
 void glUniform1ui(GLint location, GLuint v0);
 void glUniform2ui(GLint location, GLuint v0, GLuint v1);
 void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-void glUniform4ui(GLint location, GLint v0, GLuint v1, GLuint v2, GLuint v3);
+void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
 void glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
 void glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
 void glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
 void glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
-void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-
-void glGetUniformuiv(GLuint program, GLint location, GLuint *params);
+void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
+void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
+void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
+void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+GL3constubyteptr glGetStringi(GLenum name, GLuint index);
+void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
 void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-
-# More vertex attribute setters / queries
-void glVertexAttribI4i(GLuint index, GLint v0, GLint v1, GLint v2, GLint v3);
-void glVertexAttribI4ui(GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-void glVertexAttribI4iv(GLuint index, const GLint *v);
-void glVertexAttribI4uiv(GLuint index, const GLuint *v);
-void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
-void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-
-# Instanced draws
-void glVertexAttribDivisor(GLuint index, GLuint divisor);
-void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
-void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount);
-
-# Draw with known index range
-void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices);
-
-# Sync
+GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
+void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
 GLsync glFenceSync(GLenum condition, GLbitfield flags);
-GLenum glClientWaitSync(GLsync wait_on, GLbitfield flags, GLuint64 timeout);
-void glWaitSync(GLsync wait_on, GLbitfield flags, GLuint64 timeout);
-void glDeleteSync(GLsync to_delete);
 GLboolean glIsSync(GLsync sync);
+void glDeleteSync(GLsync sync);
+GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+void glGetInteger64v(GLenum pname, GLint64 *data);
 void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-
-# MRT / MSAA render buffer
-void glDrawBuffers(GLsizei n, const GLenum *bufs);
-void glReadBuffer(GLenum src);
-void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-
-# Transform feedback
-void glBeginTransformFeedback(GLenum primitiveMode);
-void glEndTransformFeedback(void);
-void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
-void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
+void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
+void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
+void glGenSamplers(GLsizei count, GLuint *samplers);
+void glDeleteSamplers(GLsizei count, const GLuint *samplers);
+GLboolean glIsSampler(GLuint sampler);
+void glBindSampler(GLuint unit, GLuint sampler);
+void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
+void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
+void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
+void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
+void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
+void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
+void glVertexAttribDivisor(GLuint index, GLuint divisor);
 void glBindTransformFeedback(GLenum target, GLuint id);
+void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
+void glGenTransformFeedbacks(GLsizei n, GLuint *ids);
+GLboolean glIsTransformFeedback(GLuint id);
 void glPauseTransformFeedback(void);
 void glResumeTransformFeedback(void);
-GLboolean glIsTransformFeedback(GLuint id);
-void glTransformFeedbackVaryings(GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode);
-void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name);
-
-# Sampler objects
-void glGenSamplers(GLsizei n, GLuint *samplers);
-void glDeleteSamplers(GLsizei n, const GLuint * samplers);
-void glBindSampler(GLuint unit, GLuint sampler);
-void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * params);
-void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint * params);
-void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat * params);
-void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint * params);
-GLboolean glIsSampler(GLuint sampler);
-
-# Query objects
-void glGenQueries(GLsizei n, GLuint * queries);
-void glDeleteQueries(GLsizei n, const GLuint * queries);
-void glBeginQuery(GLenum target, GLuint query);
-void glEndQuery(GLenum target);
-void glGetQueryiv(GLenum target, GLenum pname, GLint * params);
-void glGetQueryObjectuiv(GLuint query, GLenum pname, GLuint * params);
-GLboolean glIsQuery(GLuint query);
-
-# Shader binary objects
-void glProgramParameteri(GLuint program, GLenum pname, GLint value);
+void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
 void glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
-void glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary);
-
-# New glGets
-GLint glGetFragDataLocation(GLuint program, const char * name);
-void glGetInteger64v(GLenum pname, GLint64 * data);
-void glGetIntegeri_v(GLenum target, GLuint index, GLint * data);
-void glGetInteger64i_v(GLenum target, GLuint index, GLint64 * data);
-
-# Array/3D textures
-void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * data);
+void glProgramParameteri(GLuint program, GLenum pname, GLint value);
+void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
+void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
+void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
 void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * data);
-void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data);
-void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data);
-void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles_functions.h b/host/libs/virglrenderer/OpenGLESDispatch/gles_functions.h
new file mode 100644
index 000000000..d45dda39c
--- /dev/null
+++ b/host/libs/virglrenderer/OpenGLESDispatch/gles_functions.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "OpenGLESDispatch/gles1_core_functions.h"
+#include "OpenGLESDispatch/gles1_extensions_functions.h"
+#include "OpenGLESDispatch/gles2_core_functions.h"
+#include "OpenGLESDispatch/gles2_extensions_functions.h"
+#include "OpenGLESDispatch/gles3_only_functions.h"
+#include "OpenGLESDispatch/gles31_only_functions.h"
+
+#define LIST_GLES1_FUNCTIONS(X, Y) \
+    LIST_GLES1_CORE_FUNCTIONS(X) \
+    LIST_GLES1_EXTENSIONS_FUNCTIONS(Y) \
+
+#define LIST_GLES3_FUNCTIONS(X, Y) \
+    LIST_GLES2_CORE_FUNCTIONS(X) \
+    LIST_GLES2_EXTENSIONS_FUNCTIONS(Y) \
+    LIST_GLES3_ONLY_FUNCTIONS(X) \
+    LIST_GLES31_ONLY_FUNCTIONS(X)
diff --git a/host/libs/virglrenderer/OpenglRender/IOStream.h b/host/libs/virglrenderer/OpenglRender/IOStream.h
index ab561ec1d..82e5bdea5 100644
--- a/host/libs/virglrenderer/OpenglRender/IOStream.h
+++ b/host/libs/virglrenderer/OpenglRender/IOStream.h
@@ -1,105 +1,63 @@
 /*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#pragma once
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-#include "ErrorLog.h"
-#include "android/base/files/Stream.h"
+#pragma once
 
-#include <assert.h>
-#include <inttypes.h>
-#include <stdlib.h>
-#include <stdio.h>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
 
 class IOStream {
-protected:
-    explicit IOStream(size_t bufSize) : m_bufsize(bufSize) {}
-
-    ~IOStream() {
-        // NOTE: m_buf was owned by the child class thus we expect it to be
-        // released before the object destruction.
-    }
-
-public:
-    size_t read(void* buf, size_t bufLen) {
-        if (!readRaw(buf, &bufLen)) {
-            return 0;
-        }
-        return bufLen;
+  public:
+    IOStream(unsigned char* buf, size_t bufSize) : m_buf(buf), m_bufSize(bufSize) {
     }
 
     unsigned char* alloc(size_t len) {
-        if (m_buf && len > m_free) {
-            if (flush() < 0) {
-                ERR("Failed to flush in alloc\n");
-                return NULL; // we failed to flush so something is wrong
-            }
+        if (m_allocSize + len > m_bufSize) {
+            printf("Command response is too large.\n");
+            return nullptr;
         }
-
-        if (!m_buf || len > m_bufsize) {
-            int allocLen = m_bufsize < len ? len : m_bufsize;
-            m_buf = (unsigned char *)allocBuffer(allocLen);
-            if (!m_buf) {
-                ERR("Alloc (%u bytes) failed\n", allocLen);
-                return NULL;
-            }
-            m_bufsize = m_free = allocLen;
-        }
-
-        unsigned char* ptr = m_buf + (m_bufsize - m_free);
-        m_free -= len;
-
-        return ptr;
+        unsigned char* buf = m_buf + m_allocSize;
+        m_allocSize += len;
+        return buf;
     }
 
     int flush() {
-        if (!m_buf || m_free == m_bufsize) return 0;
-
-        int stat = commitBuffer(m_bufsize - m_free);
-        m_buf = NULL;
-        m_free = 0;
-        return stat;
+        m_flushSize = m_allocSize;
+        return 0;
     }
 
-    void save(android::base::Stream* stream) {
-        stream->putBe32(m_bufsize);
-        stream->putBe32(m_free);
-        stream->putByte(m_buf != nullptr);
-        onSave(stream);
+    void* getDmaForReading(uint64_t guest_paddr) {
+        // GLDMA is not supported, so we don't have to implement this. Just keep
+        // a stub here to keep the generated decoder stubs happy
+        return nullptr;
     }
 
-    void load(android::base::Stream* stream) {
-        m_bufsize = stream->getBe32();
-        m_free = stream->getBe32();
-        const bool haveBuf = stream->getByte();
-        const auto buf = onLoad(stream);
-        m_buf = haveBuf ? buf : nullptr;
+    void unlockDma(uint64_t guest_paddr) {
+        // GLDMA is not supported, so we don't have to implement this. Just keep
+        // a stub here to keep the generated decoder stubs happy
     }
 
-    virtual void* getDmaForReading(uint64_t guest_paddr) = 0;
-    virtual void unlockDma(uint64_t guest_paddr) = 0;
-
-protected:
-    virtual void *allocBuffer(size_t minSize) = 0;
-    virtual int commitBuffer(size_t size) = 0;
-    virtual const unsigned char *readRaw(void *buf, size_t *inout_len) = 0;
-    virtual void onSave(android::base::Stream* stream) = 0;
-    virtual unsigned char* onLoad(android::base::Stream* stream) = 0;
+    size_t getFlushSize() {
+        return m_flushSize;
+    }
 
-private:
-    unsigned char* m_buf = nullptr;
-    size_t m_bufsize;
-    size_t m_free = 0;
+  private:
+    size_t m_allocSize = 0U;
+    size_t m_flushSize = 0U;
+    unsigned char* m_buf;
+    size_t m_bufSize;
 };
diff --git a/host/libs/virglrenderer/ProtocolUtils.h b/host/libs/virglrenderer/ProtocolUtils.h
index 7c323c979..fd0bebef3 100644
--- a/host/libs/virglrenderer/ProtocolUtils.h
+++ b/host/libs/virglrenderer/ProtocolUtils.h
@@ -1,3 +1,19 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #pragma once
 
 #include <assert.h>
diff --git a/host/libs/virglrenderer/README.md b/host/libs/virglrenderer/README.md
new file mode 100644
index 000000000..e9b13789c
--- /dev/null
+++ b/host/libs/virglrenderer/README.md
@@ -0,0 +1,112 @@
+# AVDVirglRenderer
+
+This project implements an alternative for 'virglrenderer', a part of the
+Virgil 3D GPU project that normally implements the translation from the
+virtio-gpu-3d command stream & tgsi/gallium shaders, to desktop OpenGL.
+
+This version of the library keeps translation to a minimum and only works with
+a true EGL/GLES driver implementation on the host. It won't intercept and
+translate shaders, and no part of the GL state machine is processed in the
+emulated guest.
+
+The wire protocol used between the virtio-gpu DRM driver and QEMU's
+virtio-gpu-3d device is the same as that used by goldfish (the classic Android
+emulator). Submits (writes) are made with an `DRM_VIRTGPU_EXECBUFFER` call; the
+response comes back through a separate memory mapped buffer. Responses are very
+expensive and are minimized where possible, as they involve a pipeline flush and
+roundtrip to the host.
+
+## Structure
+
+### [`AVDVirglRenderer`](AVDVirglRenderer.cpp)[](#AVDVirglRenderer)
+
+Provides the entrypoints expected by QEMU for its libvirglrenderer integration.
+
+This is where contexts, resources and fences are monitored.
+
+### [`RenderControl`](RenderControl.cpp) [`Header`](RenderControl.h) [`Decoder`](renderControl_dec)[](#RenderControl)
+
+The RenderControl is analogous to EGL on the guest side. It has a similar API to
+EGL, except that not every EGL function can be implemented as one API call, and
+instead multiple RenderControl calls are made. The RenderControl architecture
+was precipitated by goldfish's requirement that EGL window surfaces and images
+would be directly mapped to GL texture names, but in AVDVirglRenderer we
+preserve them as EGL objects on the host side.
+
+This component contains a decoder for the wire protocol, and stubs for any
+functions that we do not need to implement. The wire protocol is completely
+unmodified.
+
+### [`GLESv1`](GLESv1.cpp) [`Header`](GLESv1.h) [`Decoder`](GLESv1_dec)[](#GLESv1)
+
+This component contains a decoder for the wire protocol, and stubs for any
+functions that we do not need to implement. Only the GL ES 1.1 extensions
+implemented by SwiftShader are implemented, and only if they are needed by
+Android. Any extensions provided by the wire protocol that are not supported by
+either are intentionally stubbed.
+
+### [`GLESv3`](GLESv3.cpp) [`Header`](GLESv3.h) [`Decoder`](GLESv3_dec)[](#GLESv3)
+
+This component contains a decoder for the wire protocol, and stubs for any
+functions that we do not need to implement. Only the core GL ES 3.0 API is
+implemented; no ES 2.0 extensions are supported, unless they are remappable to
+GL ES 3.0 features. GL ES 3.1 is not currently supported. Any extensions
+provided by the wire protocol that are not supported by either Android or
+SwiftShader are intentionally stubbed.
+
+Note that we are *not* stubbing ES 3.1 functions; these will crash if called.
+
+### [`ChecksumCalculator`](OpenglRenderer/ChecksumCalculator.cpp)[`Header`](ChecksumCalculator.h)[](#ChecksumCalculator)
+
+This code was taken from the Android emulator. The header has been slightly
+trimmed but its functionality has not been changed.
+
+### [`ChecksumCalculatorThreadInfo`](ChecksumCalculatorThreadInfo.h)[](#ChecksumCalculatorThreadInfo)
+
+This header has been added for compatibility with the decoder code generated by
+the `emugen_cuttlefish` tool. Unlike the original implementation, it is not
+thread safe. We do not require thread safety because no decoder state is shared
+between threads in AVDVirglRenderer without its own locking.
+
+### [`Context`](Context.h)[](#Context)
+
+The Context structure represents a virglrenderer context assigned by QEMU. Each
+time the driver's device node is opened by the guest, a new context is created.
+In the design of AVDVirglRenderer, there are two kinds of context. The first
+kind of context is for `gralloc`, and there is one of these contexts per guest
+process. The second kind of context is per-thread, used by the EGL/GLES
+implementation. This second kind of context can receive 3D commands, which are
+processed in their own thread by AVDVirglRenderer so as to minimize the number
+of synthetic calls we have to make (such as eglMakeCurrent()).
+
+### [`Resource`](Resource.h)[](#Resource)
+
+The Resource structure represents a virglrenderer resource assigned by QEMU.
+Each time the driver allocates memory through the device driver's interface, a
+new resource is created. Resources can be owned by the kernel (for example, the
+primary framebuffer surfaces), Gralloc (EGL window surfaces or images), or used
+for other purposes such as the Context response buffer and fencing.
+
+### [`EglConfig`](EglConfig.h)[](EglConfig)
+
+The EglConfig structure maintains a list of available EGLConfigs.
+
+### [`EglContext`](EglContext.h)[](EglContext)
+
+The EglContext structure maintains a list of active EGLContexts, and decides
+when they can be disposed of.
+
+### [`EglImage`](EglImage.h)[](EglImage)
+
+The EglImage structure maintains a list of active EGLImageKHRs, and decides
+when they can be disposed of.
+
+### [`EglSurface`](EglSurface.h)[](EglSurface)
+
+The EglSurface structure maintains a list of active EGLSurfaces, and decides
+when they can be disposed of.
+
+### [`EglSync`](EglSync.h)[](EglSync)
+
+The EglSync structure maintains a list of active EGLSyncKHRs, and decides
+when they can be disposed of.
diff --git a/host/libs/virglrenderer/RenderControl.cpp b/host/libs/virglrenderer/RenderControl.cpp
new file mode 100644
index 000000000..fd84eb548
--- /dev/null
+++ b/host/libs/virglrenderer/RenderControl.cpp
@@ -0,0 +1,868 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#undef NDEBUG
+
+#include "Context.h"
+#include "EglConfig.h"
+#include "EglContext.h"
+#include "EglImage.h"
+#include "EglSurface.h"
+#include "EglSync.h"
+
+#include <cassert>
+#include <cerrno>
+#include <cstring>
+#include <string>
+
+#include <unistd.h>
+
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+
+#include <OpenGLESDispatch/EGLDispatch.h>
+#include <OpenGLESDispatch/GLESv1Dispatch.h>
+#include <OpenGLESDispatch/GLESv3Dispatch.h>
+
+#include "virgl_hw.h"
+
+#include "RenderControl.h"
+
+#include <hardware/gralloc.h>
+#include <hardware/gralloc1.h>
+#include <nativebase/nativebase.h>
+#include <system/window.h>
+
+static void incRefANWB(android_native_base_t* base) {
+    ANativeWindowBuffer* anwb = reinterpret_cast<ANativeWindowBuffer*>(base);
+    anwb->layerCount++;
+}
+
+static void decRefANWB(android_native_base_t* base) {
+    ANativeWindowBuffer* anwb = reinterpret_cast<ANativeWindowBuffer*>(base);
+    if (anwb->layerCount > 0) {
+        anwb->layerCount--;
+        if (anwb->layerCount == 0)
+            delete anwb;
+    }
+}
+struct FakeANativeWindowBuffer : public ANativeWindowBuffer {
+    FakeANativeWindowBuffer() {
+        ANativeWindowBuffer();
+
+        common.incRef = incRefANWB;
+        common.decRef = decRefANWB;
+        layerCount = 0U;
+    }
+};
+
+static void incRefANW(android_native_base_t* base) {
+    ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(base);
+    anw->oem[0]++;
+}
+
+static void decRefANW(android_native_base_t* base) {
+    ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(base);
+    if (anw->oem[0] > 0) {
+        anw->oem[0]--;
+        if (anw->oem[0] == 0)
+            delete anw;
+    }
+}
+
+static int setSwapInterval(ANativeWindow*, int) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static int dequeueBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer** buffer) {
+    if (!window->oem[1])
+        return -EINVAL;
+    *buffer = reinterpret_cast<ANativeWindowBuffer*>(window->oem[1]);
+    window->oem[1] = 0;
+    return 0;
+}
+
+static int lockBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static int queueBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static int query(const ANativeWindow* window, int what, int* value) {
+    switch (what) {
+        case NATIVE_WINDOW_WIDTH:
+            return static_cast<int>(window->oem[2]);
+        case NATIVE_WINDOW_HEIGHT:
+            return static_cast<int>(window->oem[3]);
+        default:
+            return -EINVAL;
+    }
+}
+
+static int perform(ANativeWindow*, int, ...) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static int cancelBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static int dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd) {
+    *fenceFd = -1;
+    return dequeueBuffer_DEPRECATED(window, buffer);
+}
+
+static int queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
+    if (fenceFd >= 0)
+        close(fenceFd);
+    return queueBuffer_DEPRECATED(window, buffer);
+}
+
+static int cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
+    if (fenceFd >= 0)
+        close(fenceFd);
+    return cancelBuffer_DEPRECATED(window, buffer);
+}
+
+struct FakeANativeWindow : public ANativeWindow {
+    FakeANativeWindow(uint32_t width, uint32_t height) {
+        ANativeWindow();
+
+        common.incRef = incRefANW;
+        common.decRef = decRefANW;
+        oem[0] = 0;
+        oem[2] = static_cast<intptr_t>(width);
+        oem[3] = static_cast<intptr_t>(height);
+
+        this->setSwapInterval = ::setSwapInterval;
+        this->dequeueBuffer_DEPRECATED = ::dequeueBuffer_DEPRECATED;
+        this->lockBuffer_DEPRECATED = ::lockBuffer_DEPRECATED;
+        this->queueBuffer_DEPRECATED = ::queueBuffer_DEPRECATED;
+        this->query = ::query;
+        this->perform = ::perform;
+        this->cancelBuffer_DEPRECATED = ::cancelBuffer_DEPRECATED;
+        this->dequeueBuffer = ::dequeueBuffer;
+        this->queueBuffer = ::queueBuffer;
+        this->cancelBuffer = ::cancelBuffer;
+    }
+};
+
+// Helpers
+
+static ANativeWindowBuffer* resourceToANWB(Resource* res) {
+    ANativeWindowBuffer* buffer = new (std::nothrow) FakeANativeWindowBuffer();
+    if (!buffer)
+        return nullptr;
+
+    buffer->width = res->args.width;
+    buffer->height = res->args.height;
+    buffer->stride = res->args.width;
+    buffer->handle = reinterpret_cast<const native_handle_t*>(res->args.handle);
+    buffer->usage_deprecated = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
+                               GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER;
+    buffer->usage =
+        GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN | GRALLOC1_CONSUMER_USAGE_CPU_WRITE_OFTEN |
+        GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE | GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN |
+        GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN | GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET;
+
+    switch (res->args.format) {
+        case VIRGL_FORMAT_B8G8R8A8_UNORM:
+            buffer->format = HAL_PIXEL_FORMAT_BGRA_8888;
+            break;
+        case VIRGL_FORMAT_B5G6R5_UNORM:
+            buffer->format = HAL_PIXEL_FORMAT_RGB_565;
+            break;
+        case VIRGL_FORMAT_R8G8B8A8_UNORM:
+            buffer->format = HAL_PIXEL_FORMAT_RGBA_8888;
+            break;
+        case VIRGL_FORMAT_R8G8B8X8_UNORM:
+            buffer->format = HAL_PIXEL_FORMAT_RGBX_8888;
+            break;
+        default:
+            delete buffer;
+            return nullptr;
+    }
+
+    return buffer;
+}
+
+// RenderControl
+
+static GLint rcGetRendererVersion() {
+    return 1;  // seems to be hard-coded
+}
+
+static EGLint rcGetEGLVersion(void* ctx_, EGLint* major, EGLint* minor) {
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    return s_egl.eglInitialize(rc->dpy, major, minor);
+}
+
+static EGLint rcQueryEGLString(void* ctx_, EGLenum name, void* buffer, EGLint bufferSize) {
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    const char* str = s_egl.eglQueryString(rc->dpy, name);
+    if (!str)
+        str = "";
+
+    if (strlen(str) > (size_t)bufferSize) {
+        memset(buffer, 0, bufferSize);
+        return -strlen(str);
+    }
+
+    char* strOut = static_cast<char*>(buffer);
+    strncpy(strOut, str, bufferSize - 1);
+    strOut[bufferSize - 1] = 0;
+
+    return strlen(strOut) + 1U;
+}
+
+static std::string replaceESVersionString(const std::string& prev, const char* const newver) {
+    // Do not touch ES 1.x contexts (they will all be 1.1 anyway)
+    if (prev.find("ES-CM") != std::string::npos)
+        return prev;
+
+    size_t esStart = prev.find("ES ");
+    size_t esEnd = prev.find(" ", esStart + 3);
+
+    // Do not change out-of-spec version strings.
+    if (esStart == std::string::npos || esEnd == std::string::npos)
+        return prev;
+
+    std::string res = prev.substr(0, esStart + 3);
+    res += newver;
+    res += prev.substr(esEnd);
+    return res;
+}
+
+static EGLint rcGetGLString(void* ctx_, EGLenum name, void* buffer, EGLint bufferSize) {
+    std::string glStr;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    if (rc->ctx->ctx) {
+        const char* str = nullptr;
+        switch (rc->ctx->ctx->api) {
+            case EglContext::GLESApi::GLESApi_CM:
+                str = reinterpret_cast<const char*>(s_gles1.glGetString(name));
+                break;
+            default:
+                str = reinterpret_cast<const char*>(s_gles3.glGetString(name));
+                break;
+        }
+        if (str)
+            glStr += str;
+    }
+
+    // FIXME: Should probably filter the extensions list like the emulator
+    //        does. We need to handle ES2 on ES3 compatibility for older
+    //        Android versions, as well as filter out unsupported features.
+
+    if (name == GL_EXTENSIONS) {
+        glStr += ChecksumCalculator::getMaxVersionStr();
+        glStr += " ";
+
+        // FIXME: Hard-coded to 3.0 for now. We should attempt to detect 3.1.
+        glStr += "ANDROID_EMU_gles_max_version_3_0";
+        glStr += " ";
+    }
+
+    // FIXME: Add support for async swap and the fence_sync extensions
+
+    // We don't support GLDMA; use VIRTGPU_RESOURCE_CREATE and a combination of
+    // VIRTGPU_TRANSFER_TO_HOST and VIRTGPU_TRANSFER_FROM_HOST.
+
+    // FIXME: Add support for 'no host error'
+
+    if (name == GL_VERSION)
+        glStr = replaceESVersionString(glStr, "3.0");
+
+    int nextBufferSize = glStr.size() + 1;
+
+    if (!buffer || nextBufferSize > bufferSize)
+        return -nextBufferSize;
+
+    snprintf((char*)buffer, nextBufferSize, "%s", glStr.c_str());
+    return nextBufferSize;
+}
+
+static EGLint rcGetNumConfigs(uint32_t* numAttribs) {
+    *numAttribs = EglConfig::kNumAttribs;
+    return EglConfig::vec.size();
+}
+
+static EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer) {
+    size_t configAttribBytes = sizeof(EglConfig::kAttribs);
+    size_t nConfigs = EglConfig::vec.size();
+    size_t sizeNeeded = configAttribBytes + nConfigs * configAttribBytes;
+
+    if (bufSize < sizeNeeded)
+        return -sizeNeeded;
+
+    memcpy(buffer, &EglConfig::kAttribs, configAttribBytes);
+    size_t offset = EglConfig::kNumAttribs;
+    for (auto const& config : EglConfig::vec) {
+        memcpy(&buffer[offset], config->attribs, configAttribBytes);
+        offset += EglConfig::kNumAttribs;
+    }
+
+    return nConfigs;
+}
+
+static EGLint rcChooseConfig(void* ctx_, EGLint* attribs, uint32_t, uint32_t* config_ints,
+                             uint32_t configs_size) {
+    EGLint num_config;
+    EGLConfig configs[configs_size];
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    EGLBoolean ret = s_egl.eglChooseConfig(rc->dpy, attribs, configs, configs_size, &num_config);
+    if (!ret)
+        num_config = 0;
+
+    if (configs_size) {
+        for (EGLint i = 0; i < num_config; i++) {
+            config_ints[i] = ~0U;
+            EGLint config_id;
+            if (s_egl.eglGetConfigAttrib(rc->dpy, configs[i], EGL_CONFIG_ID, &config_id)) {
+                for (size_t i = 0; i < EglConfig::vec.size(); i++) {
+                    if (EglConfig::vec[i]->attribs[4] == config_id)
+                        config_ints[i] = i;
+                }
+            }
+            if (config_ints[i] == ~0U) {
+                num_config = 0;
+                break;
+            }
+        }
+        if (!num_config)
+            memset(config_ints, 0, configs_size * sizeof(uint32_t));
+    }
+
+    return num_config;
+}
+
+static EGLint rcGetFBParam(EGLint) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static uint32_t rcCreateContext(void* ctx_, uint32_t config_, uint32_t share_, uint32_t glVersion) {
+    // clang-format off
+    EGLint attrib_list[] = {
+        EGL_CONTEXT_CLIENT_VERSION,    0,
+        EGL_CONTEXT_MINOR_VERSION_KHR, 0,
+        EGL_NONE
+    };
+    // clang-format on
+    switch (glVersion) {
+        case EglContext::GLESApi::GLESApi_CM:
+            attrib_list[1] = 1;
+            attrib_list[3] = 1;
+            break;
+        case EglContext::GLESApi::GLESApi_2:
+            attrib_list[1] = 2;
+            break;
+        case EglContext::GLESApi::GLESApi_3_0:
+            attrib_list[1] = 3;
+            break;
+        case EglContext::GLESApi::GLESApi_3_1:
+            attrib_list[1] = 3;
+            attrib_list[3] = 1;
+            break;
+    }
+    if (!attrib_list[1])
+        return 0U;
+
+    if (config_ > EglConfig::vec.size())
+        return 0U;
+    EglConfig const* config = EglConfig::vec[config_];
+
+    EGLContext share_context = EGL_NO_CONTEXT;
+    if (share_ > 0) {
+        std::map<uint32_t, EglContext*>::iterator context_it;
+        context_it = EglContext::map.find(share_);
+        if (context_it == EglContext::map.end())
+            return 0U;
+
+        EglContext const* share = context_it->second;
+        share_context = share->context;
+    }
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    EGLContext context_ =
+        s_egl.eglCreateContext(rc->dpy, config->config, share_context, attrib_list);
+    if (context_ == EGL_NO_CONTEXT)
+        return 0U;
+
+    EglContext* context = new (std::nothrow)
+        EglContext(context_, rc->ctx->handle, (enum EglContext::GLESApi)glVersion);
+    if (!context) {
+        s_egl.eglDestroyContext(rc->dpy, context_);
+        return 0U;
+    }
+
+    return context->id;
+}
+
+static void rcDestroyContext(void* ctx_, uint32_t ctx) {
+    std::map<uint32_t, EglContext*>::iterator it;
+    it = EglContext::map.find(ctx);
+    if (it == EglContext::map.end())
+        return;
+
+    EglContext* context = it->second;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    s_egl.eglDestroyContext(rc->dpy, context->context);
+    context->context = EGL_NO_CONTEXT;
+    if (context->disposable())
+        delete context;
+}
+
+static uint32_t rcCreateWindowSurface(void* ctx_, uint32_t config_, uint32_t width,
+                                      uint32_t height) {
+    if (config_ > EglConfig::vec.size())
+        return 0U;
+
+    EglConfig const* config = EglConfig::vec[config_];
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    EglSurface* surface =
+        new (std::nothrow) EglSurface(config->config, rc->ctx->handle, width, height);
+    if (!surface)
+        return 0U;
+
+    return surface->id;
+}
+
+static void rcDestroyWindowSurface(void* ctx_, uint32_t surface_) {
+    std::map<uint32_t, EglSurface*>::iterator it;
+    it = EglSurface::map.find(surface_);
+    if (it == EglSurface::map.end())
+        return;
+
+    EglSurface* surface = it->second;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    s_egl.eglDestroySurface(rc->dpy, surface->surface);
+    surface->surface = EGL_NO_SURFACE;
+    if (surface->disposable()) {
+        delete surface->window;
+        delete surface;
+    }
+}
+
+static uint32_t rcCreateColorBuffer(uint32_t, uint32_t, GLenum) {
+    // NOTE: This CreateColorBuffer implementation is a no-op which returns a
+    //       special surface ID to indicate that a pbuffer surface should be
+    //       created. This is necessary because the emulator does not create a
+    //       true pbuffer, it always creates a fake one. We don't want this.
+    return ~1U;
+}
+
+static void rcOpenColorBuffer(uint32_t) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void rcCloseColorBuffer(uint32_t) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void rcSetWindowColorBuffer(void* ctx_, uint32_t windowSurface, uint32_t colorBuffer) {
+    std::map<uint32_t, EglSurface*>::iterator surface_it;
+    surface_it = EglSurface::map.find(windowSurface);
+    if (surface_it == EglSurface::map.end())
+        return;
+
+    EglSurface* surface = surface_it->second;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+
+    if (colorBuffer == ~1U) {
+        EGLint const attrib_list[] = { EGL_WIDTH, (EGLint)surface->width, EGL_HEIGHT,
+                                       (EGLint)surface->height, EGL_NONE };
+        assert(surface->surface == EGL_NO_SURFACE && "Pbuffer set twice");
+        surface->surface = s_egl.eglCreatePbufferSurface(rc->dpy, surface->config, attrib_list);
+    } else {
+        std::map<uint32_t, Resource*>::iterator resource_it;
+        resource_it = Resource::map.find(colorBuffer);
+        if (resource_it == Resource::map.end())
+            return;
+
+        Resource* res = resource_it->second;
+        ANativeWindowBuffer* buffer = resourceToANWB(res);
+        if (!buffer)
+            return;
+
+        if (surface->surface == EGL_NO_SURFACE) {
+            surface->window =
+                new (std::nothrow) FakeANativeWindow(res->args.width, res->args.height);
+            if (!surface->window)
+                return;
+
+            NativeWindowType native_window = reinterpret_cast<NativeWindowType>(surface->window);
+            surface->window->oem[1] = (intptr_t)buffer;
+            surface->surface =
+                s_egl.eglCreateWindowSurface(rc->dpy, surface->config, native_window, nullptr);
+        } else {
+            surface->window->oem[1] = (intptr_t)buffer;
+            s_egl.eglSwapBuffers(rc->dpy, surface->surface);
+        }
+    }
+}
+
+static int rcFlushWindowColorBuffer(uint32_t windowSurface) {
+    std::map<uint32_t, EglSurface*>::iterator it;
+    it = EglSurface::map.find(windowSurface);
+    return it == EglSurface::map.end() ? -1 : 0;
+}
+
+static EGLint rcMakeCurrent(void* ctx_, uint32_t context_, uint32_t drawSurf, uint32_t readSurf) {
+    std::map<uint32_t, EglContext*>::iterator context_it;
+    context_it = EglContext::map.find(context_);
+    if (context_it == EglContext::map.end())
+        return EGL_FALSE;
+
+    EglContext* context = context_it->second;
+
+    std::map<uint32_t, EglSurface*>::iterator surface_it;
+    surface_it = EglSurface::map.find(drawSurf);
+    if (surface_it == EglSurface::map.end())
+        return EGL_FALSE;
+
+    EglSurface* draw_surface = surface_it->second;
+
+    surface_it = EglSurface::map.find(readSurf);
+    if (surface_it == EglSurface::map.end())
+        return EGL_FALSE;
+
+    EglSurface* read_surface = surface_it->second;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+
+    EglSurface* old_draw_surface = draw_surface->bind(rc->ctx->handle, false);
+    if (old_draw_surface)
+        old_draw_surface->unbind(false);
+
+    EglSurface* old_read_surface = read_surface->bind(rc->ctx->handle, true);
+    if (old_read_surface)
+        old_read_surface->unbind(true);
+
+    EglContext* old_context = context->bind(rc->ctx->handle);
+    if (old_context)
+        old_context->unbind();
+
+    EGLBoolean ret = s_egl.eglMakeCurrent(rc->dpy, draw_surface->surface, read_surface->surface,
+                                          context->context);
+    if (!ret) {
+        // If eglMakeCurrent fails, it's specified *not* to have unbound the
+        // previous contexts or surfaces, but many implementations do. This bug
+        // isn't worked around here, and we just assume the implementations obey
+        // the spec.
+        context->unbind();
+        if (old_context)
+            old_context->bind(rc->ctx->handle);
+        read_surface->unbind(true);
+        if (old_read_surface)
+            old_read_surface->bind(rc->ctx->handle, true);
+        draw_surface->unbind(false);
+        if (old_draw_surface)
+            old_draw_surface->bind(rc->ctx->handle, false);
+    } else {
+        if (old_context && old_context->disposable())
+            delete old_context;
+        if (old_read_surface && old_read_surface->disposable())
+            delete old_read_surface;
+        if (old_draw_surface && old_draw_surface->disposable())
+            delete old_draw_surface;
+        rc->ctx->unbind();
+        rc->ctx->bind(context);
+    }
+
+    return (EGLint)ret;
+}
+
+static void rcFBPost(uint32_t) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static void rcFBSetSwapInterval(void* ctx_, EGLint interval) {
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    s_egl.eglSwapInterval(rc->dpy, interval);
+}
+
+static void rcBindTexture(void* ctx_, uint32_t colorBuffer) {
+    std::map<uint32_t, Resource*>::iterator it;
+    it = Resource::map.find(colorBuffer);
+    if (it == Resource::map.end())
+        return;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    Resource* res = it->second;
+    if (!res->image) {
+        ANativeWindowBuffer* buffer = resourceToANWB(res);
+        if (!buffer)
+            return;
+
+        EGLClientBuffer client_buffer = static_cast<EGLClientBuffer>(buffer);
+        EGLImageKHR image = s_egl.eglCreateImageKHR(
+            rc->dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, client_buffer, nullptr);
+        if (image == EGL_NO_IMAGE_KHR)
+            return;
+
+        EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR);
+        if (!img) {
+            s_egl.eglDestroyImageKHR(rc->dpy, image);
+            return;
+        }
+
+        // FIXME: House keeping, because we won't get asked to delete the image
+        //        object otherwise, so we need to keep a reference to it..
+        res->image = img;
+    }
+
+    if (rc->ctx->ctx->api == EglContext::GLESApi::GLESApi_CM) {
+        // FIXME: Unconditional use of GL_TEXTURE_2D here is wrong
+        s_gles1.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, res->image->image);
+    } else {
+        // FIXME: Unconditional use of GL_TEXTURE_2D here is wrong
+        s_gles3.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, res->image->image);
+    }
+}
+
+static void rcBindRenderbuffer(void* ctx_, uint32_t colorBuffer) {
+    std::map<uint32_t, Resource*>::iterator it;
+    it = Resource::map.find(colorBuffer);
+    if (it == Resource::map.end())
+        return;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    Resource* res = it->second;
+    if (!res->image) {
+        ANativeWindowBuffer* buffer = resourceToANWB(res);
+        if (!buffer)
+            return;
+
+        EGLClientBuffer client_buffer = static_cast<EGLClientBuffer>(buffer);
+        EGLImageKHR image = s_egl.eglCreateImageKHR(
+            rc->dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, client_buffer, nullptr);
+        if (image == EGL_NO_IMAGE_KHR)
+            return;
+
+        EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR);
+        if (!img) {
+            s_egl.eglDestroyImageKHR(rc->dpy, image);
+            return;
+        }
+
+        // FIXME: House keeping, because we won't get asked to delete the image
+        //        object otherwise, so we need to keep a reference to it..
+        res->image = img;
+    }
+
+    if (rc->ctx->ctx->api == EglContext::GLESApi::GLESApi_CM) {
+        s_gles1.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, res->image->image);
+    } else {
+        s_gles3.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, res->image->image);
+    }
+}
+
+static EGLint rcColorBufferCacheFlush(uint32_t, EGLint, int) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static void rcReadColorBuffer(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*) {
+    printf("%s: not implemented\n", __func__);
+}
+
+static int rcUpdateColorBuffer(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static int rcOpenColorBuffer2(uint32_t) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static uint32_t rcCreateClientImage(void* ctx_, uint32_t context_, EGLenum target, GLuint buffer_) {
+    std::map<uint32_t, EglContext*>::iterator it;
+    it = EglContext::map.find(context_);
+    if (it == EglContext::map.end())
+        return 0U;
+
+    EglContext* context = it->second;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    EGLClientBuffer buffer = reinterpret_cast<EGLClientBuffer>(buffer_);
+    EGLImageKHR image = s_egl.eglCreateImageKHR(rc->dpy, context, target, buffer, nullptr);
+    EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR);
+    if (!img) {
+        s_egl.eglDestroyImageKHR(rc->dpy, image);
+        return 0U;
+    }
+
+    return img->id;
+}
+
+static int rcDestroyClientImage(uint32_t image_) {
+    std::map<uint32_t, EglImage*>::iterator it;
+    it = EglImage::map.find(image_);
+    if (it == EglImage::map.end())
+        return EGL_FALSE;
+
+    EglImage* image = it->second;
+
+    delete image;
+    return EGL_TRUE;
+}
+
+static void rcSelectChecksumHelper(void* ctx_, uint32_t protocol, uint32_t) {
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    rc->ctx->checksum_calc.setVersion(protocol);
+}
+
+static void rcCreateSyncKHR(void* ctx_, EGLenum type, EGLint* attribs, uint32_t, int,
+                            uint64_t* glsync_out, uint64_t* syncthread_out) {
+    *syncthread_out = 0ULL;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    EGLSyncKHR sync = s_egl.eglCreateSyncKHR(rc->dpy, type, attribs);
+    if (sync == EGL_NO_SYNC_KHR) {
+        *glsync_out = 0ULL;
+        return;
+    }
+
+    EglSync* syn = new (std::nothrow) EglSync(sync);
+    if (!syn) {
+        s_egl.eglDestroySyncKHR(rc->dpy, sync);
+        *glsync_out = 0ULL;
+        return;
+    }
+
+    *glsync_out = syn->id;
+}
+
+static EGLint rcClientWaitSyncKHR(void* ctx_, uint64_t sync_, EGLint flags, uint64_t timeout) {
+    std::map<uint64_t, EglSync*>::iterator it;
+    it = EglSync::map.find(sync_);
+    if (it == EglSync::map.end())
+        return EGL_CONDITION_SATISFIED_KHR;
+
+    EglSync* sync = it->second;
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    return s_egl.eglClientWaitSyncKHR(rc->dpy, sync->sync, flags, timeout);
+}
+
+static void rcFlushWindowColorBufferAsync(uint32_t windowSurface) {
+    // No-op
+}
+
+static int rcDestroySyncKHR(void* ctx_, uint64_t sync_) {
+    std::map<uint64_t, EglSync*>::iterator it;
+    it = EglSync::map.find(sync_);
+    if (it == EglSync::map.end())
+        return EGL_FALSE;
+
+    EglSync* sync = it->second;
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    return s_egl.eglDestroySyncKHR(rc->dpy, sync->sync);
+}
+
+static void rcSetPuid(void* ctx_, uint64_t proto) {
+    union {
+        uint64_t proto;
+        struct {
+            int pid;
+            int tid;
+        } id;
+    } puid;
+
+    puid.proto = proto;
+
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    rc->ctx->setPidTid(puid.id.pid, puid.id.tid);
+}
+
+static int rcUpdateColorBufferDMA(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*,
+                                  uint32_t) {
+    printf("%s: not implemented\n", __func__);
+    return 0;
+}
+
+static uint32_t rcCreateColorBufferDMA(uint32_t, uint32_t, GLenum, int) {
+    printf("%s: not implemented\n", __func__);
+    return 0U;
+}
+
+static void rcWaitSyncKHR(void* ctx_, uint64_t sync_, EGLint flags) {
+    std::map<uint64_t, EglSync*>::iterator it;
+    it = EglSync::map.find(sync_);
+    if (it == EglSync::map.end())
+        return;
+
+    EglSync* sync = it->second;
+    RenderControl* rc = static_cast<RenderControl*>(ctx_);
+    // FIXME: No eglWaitSyncKHR support in SwiftShader
+    //        This call will BLOCK when it should be asynchronous!
+    s_egl.eglClientWaitSyncKHR(rc->dpy, sync->sync, flags, EGL_FOREVER_KHR);
+}
+
+RenderControl::RenderControl(Context* ctx_, EGLDisplay dpy_) {
+    rcGetRendererVersion = ::rcGetRendererVersion;
+    rcGetEGLVersion_dec = ::rcGetEGLVersion;
+    rcQueryEGLString_dec = ::rcQueryEGLString;
+    rcGetGLString_dec = ::rcGetGLString;
+    rcGetNumConfigs = ::rcGetNumConfigs;
+    rcGetConfigs = ::rcGetConfigs;
+    rcChooseConfig_dec = ::rcChooseConfig;
+    rcGetFBParam = ::rcGetFBParam;
+    rcCreateContext_dec = ::rcCreateContext;
+    rcDestroyContext_dec = ::rcDestroyContext;
+    rcCreateWindowSurface_dec = ::rcCreateWindowSurface;
+    rcDestroyWindowSurface_dec = ::rcDestroyWindowSurface;
+    rcCreateColorBuffer = ::rcCreateColorBuffer;
+    rcOpenColorBuffer = ::rcOpenColorBuffer;
+    rcCloseColorBuffer = ::rcCloseColorBuffer;
+    rcSetWindowColorBuffer_dec = ::rcSetWindowColorBuffer;
+    rcFlushWindowColorBuffer = ::rcFlushWindowColorBuffer;
+    rcMakeCurrent_dec = ::rcMakeCurrent;
+    rcFBPost = ::rcFBPost;
+    rcFBSetSwapInterval_dec = ::rcFBSetSwapInterval;
+    rcBindTexture_dec = ::rcBindTexture;
+    rcBindRenderbuffer_dec = ::rcBindRenderbuffer;
+    rcColorBufferCacheFlush = ::rcColorBufferCacheFlush;
+    rcReadColorBuffer = ::rcReadColorBuffer;
+    rcUpdateColorBuffer = ::rcUpdateColorBuffer;
+    rcOpenColorBuffer2 = ::rcOpenColorBuffer2;
+    rcCreateClientImage_dec = ::rcCreateClientImage;
+    rcDestroyClientImage = ::rcDestroyClientImage;
+    rcSelectChecksumHelper_dec = ::rcSelectChecksumHelper;
+    rcCreateSyncKHR_dec = ::rcCreateSyncKHR;
+    rcClientWaitSyncKHR_dec = ::rcClientWaitSyncKHR;
+    rcFlushWindowColorBufferAsync = ::rcFlushWindowColorBufferAsync;
+    rcDestroySyncKHR_dec = ::rcDestroySyncKHR;
+    rcSetPuid_dec = ::rcSetPuid;
+    rcUpdateColorBufferDMA = ::rcUpdateColorBufferDMA;
+    rcCreateColorBufferDMA = ::rcCreateColorBufferDMA;
+    rcWaitSyncKHR_dec = ::rcWaitSyncKHR;
+
+    dpy = dpy_;
+    ctx = ctx_;
+}
diff --git a/host/libs/virglrenderer/RenderControl.h b/host/libs/virglrenderer/RenderControl.h
new file mode 100644
index 000000000..146adf49e
--- /dev/null
+++ b/host/libs/virglrenderer/RenderControl.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "renderControl_dec/renderControl_dec.h"
+
+typedef void* EGLDisplay;
+
+struct Context;
+
+struct RenderControl : public renderControl_decoder_context_t {
+    RenderControl(Context* ctx_, EGLDisplay dpy_);
+    EGLDisplay dpy;
+    Context* ctx;
+};
diff --git a/host/libs/virglrenderer/Resource.h b/host/libs/virglrenderer/Resource.h
new file mode 100644
index 000000000..eb127827d
--- /dev/null
+++ b/host/libs/virglrenderer/Resource.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+extern "C" {
+#include <virgl/virglrenderer.h>
+}
+
+#include <cstdint>
+#include <cstdlib>
+#include <map>
+
+#include <GLES/gl.h>
+
+#include <sys/uio.h>
+
+#include "EglImage.h"
+
+struct Context;
+
+struct Resource {
+    static std::map<uint32_t, Resource*> map;
+
+    Resource(virgl_renderer_resource_create_args* args_, uint32_t num_iovs_, iovec* iov_)
+        : args(*args_), num_iovs(num_iovs_), tex_id(0U), iov(iov_) {
+        reallocLinear();
+        map.emplace(args.handle, this);
+    }
+
+    ~Resource() {
+        map.erase(args.handle);
+        delete image;
+    }
+
+    void reallocLinear() {
+        if (linearShadow && num_iovs <= 1)
+            free(linear);
+        linearShadow = num_iovs > 1 ? true : false;
+        if (linearShadow) {
+            uint32_t i;
+            for (i = 0, linearSize = 0U; i < num_iovs; i++)
+                linearSize += iov[i].iov_len;
+            linear = realloc(linear, linearSize);
+        } else if (num_iovs == 1) {
+            linearSize = iov[0].iov_len;
+            linear = iov[0].iov_base;
+        } else {
+            linearSize = 0U;
+            linear = nullptr;
+        }
+    }
+
+    std::map<uint32_t, Context*> context_map;
+    virgl_renderer_resource_create_args args;
+    EglImage* image = nullptr;
+    size_t linearSize = 0U;
+    void* linear = nullptr;
+    uint32_t num_iovs;
+    GLuint tex_id;
+    iovec* iov;
+
+  private:
+    bool linearShadow = false;
+};
diff --git a/host/libs/virglrenderer/emugl/common/logging.h b/host/libs/virglrenderer/emugl/common/logging.h
index e5c77ef17..081df6132 100644
--- a/host/libs/virglrenderer/emugl/common/logging.h
+++ b/host/libs/virglrenderer/emugl/common/logging.h
@@ -1,22 +1,22 @@
 /*
-* Copyright (C) 2016 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #pragma once
 
-#include "OpenglRender/render_api_types.h"
+typedef void (*emugl_logger_t)(const char* fmt, ...);
 
 extern emugl_logger_t emugl_logger;
 extern emugl_logger_t emugl_cxt_logger;
diff --git a/host/libs/virglrenderer/include/VirtioGpuCmd.h b/host/libs/virglrenderer/include/VirtioGpuCmd.h
new file mode 100644
index 000000000..6ffacd3fc
--- /dev/null
+++ b/host/libs/virglrenderer/include/VirtioGpuCmd.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+struct VirtioGpuCmd {
+    uint32_t op;
+    uint32_t cmdSize;
+    unsigned char buf[0];
+} __attribute__((packed));
diff --git a/host/libs/virglrenderer/include/android/api-level.h b/host/libs/virglrenderer/include/android/api-level.h
new file mode 100644
index 000000000..2d2f0968c
--- /dev/null
+++ b/host/libs/virglrenderer/include/android/api-level.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef ANDROID_API_LEVEL_H
+#define ANDROID_API_LEVEL_H
+
+/*
+ * Magic version number for a current development build, which has
+ * not yet turned into an official release.
+ */
+#define __ANDROID_API__ 10000
+
+#endif /* ANDROID_API_LEVEL_H */
diff --git a/host/libs/virglrenderer/include/android/sync.h b/host/libs/virglrenderer/include/android/sync.h
new file mode 100644
index 000000000..1ae728a5a
--- /dev/null
+++ b/host/libs/virglrenderer/include/android/sync.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+extern "C" {
+int sync_wait(int fd, int timeout);
+};
diff --git a/host/libs/virglrenderer/include/cutils/native_handle.h b/host/libs/virglrenderer/include/cutils/native_handle.h
new file mode 100644
index 000000000..b92a66385
--- /dev/null
+++ b/host/libs/virglrenderer/include/cutils/native_handle.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+struct native_handle_t;
+
+typedef const struct native_handle_t* buffer_handle_t;
diff --git a/host/libs/virglrenderer/include/hardware/gralloc.h b/host/libs/virglrenderer/include/hardware/gralloc.h
new file mode 100644
index 000000000..8446ba4ea
--- /dev/null
+++ b/host/libs/virglrenderer/include/hardware/gralloc.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cutils/native_handle.h>
+
+#include <hardware/hardware.h>
+
+struct android_ycbcr;
+
+enum {
+    GRALLOC_USAGE_SW_READ_OFTEN = 0x00000003U,
+    GRALLOC_USAGE_SW_WRITE_OFTEN = 0x00000030U,
+    GRALLOC_USAGE_HW_TEXTURE = 0x00000100U,
+    GRALLOC_USAGE_HW_RENDER = 0x00000200U,
+};
+
+struct gralloc_module_t {
+    hw_module_t common;
+    int (*registerBuffer)(gralloc_module_t const*, buffer_handle_t);
+    int (*unregisterBuffer)(gralloc_module_t const*, buffer_handle_t);
+    int (*lock)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int, void**);
+    int (*unlock)(gralloc_module_t const*, buffer_handle_t);
+    int (*perform)(gralloc_module_t const*, int, ...);
+    int (*lock_ycbcr)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int,
+                      android_ycbcr*);
+    int (*lockAsync)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int, void**, int);
+    int (*unlockAsync)(gralloc_module_t const*, buffer_handle_t, int*);
+    int (*lockAsync_ycbcr)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int,
+                           android_ycbcr*, int);
+    void* reserved_proc[3];
+};
diff --git a/host/libs/virglrenderer/include/hardware/gralloc1.h b/host/libs/virglrenderer/include/hardware/gralloc1.h
new file mode 100644
index 000000000..b02decfa0
--- /dev/null
+++ b/host/libs/virglrenderer/include/hardware/gralloc1.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <hardware/hardware.h>
+
+#include <cutils/native_handle.h>
+
+#define GRALLOC_MODULE_API_VERSION_1_0 HARDWARE_MAKE_API_VERSION(1, 0)
+
+#define GRALLOC_HARDWARE_MODULE_ID "gralloc"
+
+enum {
+    GRALLOC1_ERROR_NONE = 0,
+    GRALLOC1_ERROR_BAD_HANDLE = 2,
+    GRALLOC1_ERROR_BAD_VALUE = 3,
+    GRALLOC1_ERROR_UNDEFINED = 6,
+};
+
+enum {
+    GRALLOC1_FUNCTION_LOCK = 18,
+    GRALLOC1_FUNCTION_UNLOCK = 20,
+};
+
+enum {
+    GRALLOC1_CONSUMER_USAGE_CPU_READ = 1ULL << 1,
+    GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN = 1ULL << 2 | GRALLOC1_CONSUMER_USAGE_CPU_READ,
+    GRALLOC1_CONSUMER_USAGE_CPU_WRITE = 1ULL << 5,
+    GRALLOC1_CONSUMER_USAGE_CPU_WRITE_OFTEN = 1ULL << 6 | GRALLOC1_CONSUMER_USAGE_CPU_WRITE,
+    GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE = 1ULL << 8,
+};
+
+enum {
+    GRALLOC1_PRODUCER_USAGE_CPU_READ = 1ULL << 1,
+    GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN = 1ULL << 2 | GRALLOC1_PRODUCER_USAGE_CPU_READ,
+    GRALLOC1_PRODUCER_USAGE_CPU_WRITE = 1ULL << 5,
+    GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN = 1ULL << 6 | GRALLOC1_PRODUCER_USAGE_CPU_WRITE,
+    GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET = 1ULL << 9,
+};
+
+typedef void (*gralloc1_function_pointer_t)();
+
+struct gralloc1_rect_t {
+    int32_t left;
+    int32_t top;
+    int32_t width;
+    int32_t height;
+};
+
+struct gralloc1_device_t {
+    hw_device_t common;
+    void (*getCapabilities)(gralloc1_device_t*, uint32_t*, int32_t*);
+    gralloc1_function_pointer_t (*getFunction)(gralloc1_device_t*, int32_t);
+};
+
+typedef int32_t (*GRALLOC1_PFN_LOCK)(gralloc1_device_t*, buffer_handle_t, uint64_t, uint64_t,
+                                     const gralloc1_rect_t*, void**, int32_t);
+typedef int32_t (*GRALLOC1_PFN_UNLOCK)(gralloc1_device_t*, buffer_handle_t, int32_t*);
+
+static inline int gralloc1_open(const hw_module_t* module, gralloc1_device_t** device) {
+    return module->methods->open(module, GRALLOC_HARDWARE_MODULE_ID,
+                                 reinterpret_cast<hw_device_t**>(device));
+}
diff --git a/host/libs/virglrenderer/include/hardware/hardware.h b/host/libs/virglrenderer/include/hardware/hardware.h
new file mode 100644
index 000000000..21d6dc4ab
--- /dev/null
+++ b/host/libs/virglrenderer/include/hardware/hardware.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+#define MAKE_TAG_CONSTANT(A, B, C, D) (((A) << 24) | ((B) << 16) | ((C) << 8) | (D))
+
+#define HARDWARE_MODULE_TAG MAKE_TAG_CONSTANT('H', 'W', 'M', 'T')
+#define HARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT('H', 'W', 'D', 'T')
+
+#define HARDWARE_MAKE_API_VERSION(maj, min) ((((maj)&0xff) << 8) | ((min)&0xff))
+
+#define HARDWARE_HAL_API_VERSION HARDWARE_MAKE_API_VERSION(1, 0)
+
+struct hw_module_methods_t;
+
+struct hw_module_t {
+    uint32_t tag;
+    uint16_t module_api_version;
+    uint16_t hal_api_version;
+    const char* id;
+    const char* name;
+    const char* author;
+    hw_module_methods_t* methods;
+    void* dso;
+#ifdef __LP64__
+    uint64_t reserved[32 - 7];
+#else
+    uint32_t reserved[32 - 7];
+#endif
+};
+
+struct hw_device_t {
+    uint32_t tag;
+    uint32_t version;
+    struct hw_module_t* module;
+#ifdef __LP64__
+    uint64_t reserved[12];
+#else
+    uint32_t reserved[12];
+#endif
+    int (*close)(hw_device_t* device);
+};
+
+struct hw_module_methods_t {
+    int (*open)(const hw_module_t*, const char*, hw_device_t**);
+};
+
+extern "C" {
+int hw_get_module(const char* id, const hw_module_t** module);
+};
diff --git a/host/libs/virglrenderer/include/nativebase/nativebase.h b/host/libs/virglrenderer/include/nativebase/nativebase.h
new file mode 100644
index 000000000..c2e84d79a
--- /dev/null
+++ b/host/libs/virglrenderer/include/nativebase/nativebase.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cutils/native_handle.h>
+
+#include <cstdint>
+#include <cstring>
+
+// clang-format off
+#define ANDROID_NATIVE_MAKE_CONSTANT(a, b, c, d) \
+    ((static_cast<unsigned int>(a) << 24) | \
+     (static_cast<unsigned int>(b) << 16) | \
+     (static_cast<unsigned int>(c) <<  8) | \
+     (static_cast<unsigned int>(d) <<  0))
+// clang-format on
+
+struct android_native_base_t {
+    int magic;
+    int version;
+    void* reserved[4];
+    void (*incRef)(android_native_base_t*);
+    void (*decRef)(android_native_base_t*);
+};
+
+#define ANDROID_NATIVE_BUFFER_MAGIC ANDROID_NATIVE_MAKE_CONSTANT('_', 'b', 'f', 'r')
+
+struct ANativeWindowBuffer {
+    ANativeWindowBuffer() {
+        common.magic = ANDROID_NATIVE_BUFFER_MAGIC;
+        common.version = sizeof(ANativeWindowBuffer);
+        memset(common.reserved, 0, sizeof(common.reserved));
+    }
+
+    android_native_base_t common;
+
+    int width;
+    int height;
+    int stride;
+    int format;
+    int usage_deprecated;
+    uintptr_t layerCount;
+
+    void* reserved[1];
+
+    const native_handle_t* handle;
+    uint64_t usage;
+
+    void* reserved_proc[8 - (sizeof(uint64_t) / sizeof(void*))];
+};
diff --git a/host/libs/virglrenderer/include/sync/sync.h b/host/libs/virglrenderer/include/sync/sync.h
new file mode 100644
index 000000000..1ae728a5a
--- /dev/null
+++ b/host/libs/virglrenderer/include/sync/sync.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+extern "C" {
+int sync_wait(int fd, int timeout);
+};
diff --git a/host/libs/virglrenderer/include/system/graphics.h b/host/libs/virglrenderer/include/system/graphics.h
new file mode 100644
index 000000000..884db9cc2
--- /dev/null
+++ b/host/libs/virglrenderer/include/system/graphics.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+enum {
+    HAL_PIXEL_FORMAT_RGBA_8888 = 1,
+    HAL_PIXEL_FORMAT_RGBX_8888 = 2,
+    HAL_PIXEL_FORMAT_RGB_888 = 3,
+    HAL_PIXEL_FORMAT_RGB_565 = 4,
+    HAL_PIXEL_FORMAT_BGRA_8888 = 5,
+    HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED = 34,
+    HAL_PIXEL_FORMAT_YV12 = 842094169,
+};
diff --git a/host/libs/virglrenderer/include/system/window.h b/host/libs/virglrenderer/include/system/window.h
new file mode 100644
index 000000000..f986274c1
--- /dev/null
+++ b/host/libs/virglrenderer/include/system/window.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <nativebase/nativebase.h>
+#include <system/graphics.h>
+
+#define ANDROID_NATIVE_WINDOW_MAGIC ANDROID_NATIVE_MAKE_CONSTANT('_', 'w', 'n', 'd')
+
+enum {
+    NATIVE_WINDOW_WIDTH = 0,
+    NATIVE_WINDOW_HEIGHT = 1,
+};
+
+struct ANativeWindow {
+    ANativeWindow() : flags(0), minSwapInterval(0), maxSwapInterval(0), xdpi(0), ydpi(0) {
+        common.magic = ANDROID_NATIVE_BUFFER_MAGIC;
+        common.version = sizeof(ANativeWindowBuffer);
+        memset(common.reserved, 0, sizeof(common.reserved));
+    }
+
+    android_native_base_t common;
+
+    const uint32_t flags;
+    const int minSwapInterval;
+    const int maxSwapInterval;
+    const float xdpi;
+    const float ydpi;
+    intptr_t oem[4];
+
+    int (*setSwapInterval)(ANativeWindow*, int);
+    int (*dequeueBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer**);
+    int (*lockBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer*);
+    int (*queueBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer*);
+    int (*query)(const ANativeWindow*, int, int*);
+    int (*perform)(ANativeWindow*, int, ...);
+    int (*cancelBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer*);
+    int (*dequeueBuffer)(ANativeWindow*, ANativeWindowBuffer**, int*);
+    int (*queueBuffer)(ANativeWindow*, ANativeWindowBuffer*, int);
+    int (*cancelBuffer)(ANativeWindow*, ANativeWindowBuffer*, int);
+};
+
+static inline int native_window_set_usage(ANativeWindow*, uint64_t) {
+    // No-op
+    return 0;
+}
+
+static inline int native_window_dequeue_buffer_and_wait(ANativeWindow* anw,
+                                                        ANativeWindowBuffer** anwb) {
+    return anw->dequeueBuffer_DEPRECATED(anw, anwb);
+}
diff --git a/host/libs/virglrenderer/libvirglrenderer.lds b/host/libs/virglrenderer/libvirglrenderer.lds
new file mode 100644
index 000000000..9fc62d540
--- /dev/null
+++ b/host/libs/virglrenderer/libvirglrenderer.lds
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+{
+global:
+	# virglrenderer API
+	virgl_renderer_init;
+	virgl_renderer_poll;
+	virgl_renderer_get_cursor_data;
+	virgl_renderer_resource_create;
+	virgl_renderer_resource_unref;
+	virgl_renderer_context_create;
+	virgl_renderer_context_destroy;
+	virgl_renderer_submit_cmd;
+	virgl_renderer_transfer_read_iov;
+	virgl_renderer_transfer_write_iov;
+	virgl_renderer_get_cap_set;
+	virgl_renderer_fill_caps;
+	virgl_renderer_resource_attach_iov;
+	virgl_renderer_resource_detach_iov;
+	virgl_renderer_create_fence;
+	virgl_renderer_force_ctx_0;
+	virgl_renderer_ctx_attach_resource;
+	virgl_renderer_ctx_detach_resource;
+	virgl_renderer_resource_get_info;
+
+	# fake gralloc1 implementation
+	hw_get_module;
+
+	# fake libsync implementation
+	sync_wait;
+
+	# Type-strings and type-infos required by sanitizers
+	_ZTS*;
+	_ZTI*;
+
+local:
+	*;
+};
diff --git a/host/libs/virglrenderer/renderControl_dec/renderControl.attrib b/host/libs/virglrenderer/renderControl_dec/renderControl.attrib
index 7e06ce419..6ff20b66e 100644
--- a/host/libs/virglrenderer/renderControl_dec/renderControl.attrib
+++ b/host/libs/virglrenderer/renderControl_dec/renderControl.attrib
@@ -1,21 +1,20 @@
-# For documentation on the .attrib file format, see:
-# android/android-emugl/host/tools/emugen/README
-
 GLOBAL
-	base_opcode 10000
-	encoder_headers <stdint.h> <EGL/egl.h> "glUtils.h"
+    base_opcode 10000
 
 rcGetEGLVersion
+    flag custom_decoder
     dir major out
     len major sizeof(EGLint)
     dir minor out
     len minor sizeof(EGLint)
 
 rcQueryEGLString
+    flag custom_decoder
     dir buffer out
     len buffer bufferSize
 
 rcGetGLString
+    flag custom_decoder
     dir buffer out
     len buffer bufferSize
 
@@ -28,34 +27,79 @@ rcGetConfigs
     len buffer bufSize
 
 rcChooseConfig
+    flag custom_decoder
     dir attribs in
     len attribs attribs_size
     dir configs out
     var_flag configs nullAllowed
     len configs configs_size*sizeof(uint32_t)
 
+rcCreateContext
+    flag custom_decoder
+
+rcDestroyContext
+    flag custom_decoder
+
+rcCreateWindowSurface
+    flag custom_decoder
+
+rcDestroyWindowSurface
+    flag custom_decoder
+
+rcCloseColorBuffer
+    flag flushOnEncode
+
+rcSetWindowColorBuffer
+    flag custom_decoder
+
+rcMakeCurrent
+    flag custom_decoder
+
+rcFBSetSwapInterval
+    flag custom_decoder
+
+rcBindTexture
+    flag custom_decoder
+
+rcBindRenderbuffer
+    flag custom_decoder
+
 rcReadColorBuffer
     dir pixels out
-    len pixels (((glUtilsPixelBitSize(format, type) * width) >> 3) * height)
 
 rcUpdateColorBuffer
     dir pixels in
-    len pixels (((glUtilsPixelBitSize(format, type) * width) >> 3) * height)
     var_flag pixels isLarge
 
-rcUpdateColorBufferDMA
-    dir pixels in
-    len pixels pixels_size
-    var_flag pixels DMA
-    flag flushOnEncode
+rcCreateClientImage
+    flag custom_decoder
 
-rcCloseColorBuffer
-    flag flushOnEncode
+rcSelectChecksumHelper
+    flag custom_decoder
 
 rcCreateSyncKHR
+    flag custom_decoder
     dir attribs in
     len attribs num_attribs
     dir glsync_out out
     len glsync_out sizeof(uint64_t)
     dir syncthread_out out
     len syncthread_out sizeof(uint64_t)
+
+rcClientWaitSyncKHR
+    flag custom_decoder
+
+rcDestroySyncKHR
+    flag custom_decoder
+
+rcSetPuid
+    flag custom_decoder
+
+rcUpdateColorBufferDMA
+    dir pixels in
+    len pixels pixels_size
+    var_flag pixels DMA
+    flag flushOnEncode
+
+rcWaitSyncKHR
+    flag custom_decoder
diff --git a/host/libs/virglrenderer/renderControl_dec/renderControl.in b/host/libs/virglrenderer/renderControl_dec/renderControl.in
index 0cf77f653..e1dea92c1 100644
--- a/host/libs/virglrenderer/renderControl_dec/renderControl.in
+++ b/host/libs/virglrenderer/renderControl_dec/renderControl.in
@@ -20,7 +20,7 @@ GL_ENTRY(void, rcFBPost, uint32_t colorBuffer)
 GL_ENTRY(void, rcFBSetSwapInterval, EGLint interval)
 GL_ENTRY(void, rcBindTexture, uint32_t colorBuffer)
 GL_ENTRY(void, rcBindRenderbuffer, uint32_t colorBuffer)
-GL_ENTRY(EGLint, rcColorBufferCacheFlush, uint32_t colorbuffer, EGLint postCount,int forRead)
+GL_ENTRY(EGLint, rcColorBufferCacheFlush, uint32_t colorbuffer, EGLint postCount, int forRead)
 GL_ENTRY(void, rcReadColorBuffer, uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void *pixels)
 GL_ENTRY(int, rcUpdateColorBuffer, uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void *pixels)
 GL_ENTRY(int, rcOpenColorBuffer2, uint32_t colorbuffer)
diff --git a/host/libs/virglrenderer/renderControl_dec/renderControl_types.h b/host/libs/virglrenderer/renderControl_dec/renderControl_types.h
new file mode 100644
index 000000000..dd6b41271
--- /dev/null
+++ b/host/libs/virglrenderer/renderControl_dec/renderControl_types.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <EGL/egl.h>
+
+#include <GLES/gl.h>