liboffloadmic/runtime/offload_table.h - rust-lang/gcc - Git at Google

 /*
     Copyright (c) 2014-2016 Intel Corporation.  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.
       * Neither the name of Intel Corporation nor the names of its
         contributors may be used to endorse or promote products derived
         from this software without specific prior written permission.

     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
     HOLDER 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.
 */


 /*! \file
     \brief Function and Variable tables used by the runtime library
 */

 #ifndef OFFLOAD_TABLE_H_INCLUDED
 #define OFFLOAD_TABLE_H_INCLUDED

 #include "offload_util.h"

 #define OFFLOAD_VERSION_16   1600
 #define OFFLOAD_VERSION_17   1700

 // Template representing double linked list of tables
 template <typename T> class TableList {
 public:
     // table type
     typedef T Table;

     // List node
     struct Node {
         Table   table;
         Node*   prev;
         Node*   next;
     };

 public:
     explicit TableList(Node *node = 0) : m_head(node) {}

     void add_table(Node *node) {
         m_lock.lock();
         if (m_head != 0) {
             node->next = m_head;
             m_head->prev = node;
         }
         m_head = node;

         m_lock.unlock();
     }

     void remove_table(Node *node) {
         if (node->next != 0) {
             node->next->prev = node->prev;
         }
         if (node->prev != 0) {
             node->prev->next = node->next;
         }
         if (m_head == node) {
             m_head = node->next;
         }
     }

 protected:
     Node*           m_head;
     mutex_t         m_lock;
 };

 // Function lookup table.
 struct FuncTable {
     //! Function table entry
     /*! This table contains functions created from offload regions.   */
     /*! Each entry consists of a pointer to the function's "key"
         and the function address.                                     */
     /*! Each shared library or executable may contain one such table. */
     /*! The end of the table is marked with an entry whose name field
         has value -1.                                                 */
     struct Entry {
         const char* name; //!< Name of the function
         void*       func; //!< Address of the function
     };

     // entries
     const Entry *entries;

     // max name length
     int64_t max_name_len;
 };

 // Function table
 class DLL_LOCAL FuncList : public TableList<FuncTable> {
 public:
     explicit FuncList(Node *node = 0) : TableList<Table>(node),
                                         m_max_name_len(-1)
     {}

     // add table to the list
     void add_table(Node *node) {
         // recalculate max function name length
         m_max_name_len = -1;

         // add table
         TableList<Table>::add_table(node);
     }

     // find function address for the given name
     const void* find_addr(const char *name);

     // find function name for the given address
     const char* find_name(const void *addr);

     // max name length from all tables in the list
     int64_t max_name_length(void);

     // debug dump
     void dump(void);

 private:
     // max name length within from all tables
     int64_t m_max_name_len;
 };

 #define VAR_ALLOC_TYPE  uint64_t
 #define OPENMP_IMPLICIT   1    // Compiler promoted openmp declare var
                                // due to implicit use without openmp declare
 #define OPENMP_LINK       2    // Openmp link clause in openmp declare

 #define IS_OPENMP_IMPLICIT(var_alloc_type)         (var_alloc_type & 1)
 #define IS_OPENMP_LINK(var_alloc_type)             (var_alloc_type & 2)
 #define IS_OPENMP_IMPLICIT_OR_LINK(var_alloc_type) (var_alloc_type & 3)

 // Table entry for static variables
 struct VarTable {
     //! Variable table entry
     /*! This table contains statically allocated variables marked with
         __declspec(target(mic) or #pragma omp declare target.           */
     /*! Each entry consists of a pointer to the variable's "key",
         the variable address and its size in bytes.                     */
     /*! Because memory allocation is done from the host,
         the MIC table does not need the size of the variable.           */
     /*! Padding to make the table entry size a power of 2 is necessary
         to avoid "holes" between table contributions from different object
         files on Windows when debug information is specified with /Zi.  */
     struct Entry {
         const char* name; //!< Name of the variable
         void*       addr; //!< Address of the variable

 #if HOST_LIBRARY
         VAR_ALLOC_TYPE  var_alloc_type;
         uint64_t    size;
 #endif
     };

     // Table terminated by an entry with name == -1
     const Entry *entries;
 };

 // List of var tables
 class DLL_LOCAL VarList : public TableList<VarTable> {
 public:
     VarList() : TableList<Table>()
     {}

     // debug dump
     void dump();

 public:

     Node * get_head() {
         return m_head;
     }

 public:
     // Entry representation in a copy buffer
     struct BufEntry {
         intptr_t name;
         intptr_t addr;
     };

     // Calculate the number of elements in the table and
     // returns the size of buffer for the table
     int64_t table_size(int64_t &nelems);

     // Copy table contents to given buffer. It is supposed to be large
     // enough to hold all elements as string table.
     void table_copy(void *buf, int64_t nelems);

     // Patch name offsets in a table after it's been copied to other side
     static void table_patch_names(void *buf, int64_t nelems);
 };

 DLL_LOCAL extern FuncList __offload_entries;
 DLL_LOCAL extern FuncList __offload_funcs;
 DLL_LOCAL extern VarList  __offload_vars;

 // Section names where the lookup tables are stored
 #ifdef TARGET_WINNT
 #define OFFLOAD_ENTRY_TABLE_SECTION_START   ".OffloadEntryTable$a"
 #define OFFLOAD_ENTRY_TABLE_SECTION_END     ".OffloadEntryTable$z"

 #define OFFLOAD_FUNC_TABLE_SECTION_START    ".OffloadFuncTable$a"
 #define OFFLOAD_FUNC_TABLE_SECTION_END      ".OffloadFuncTable$z"

 #define OFFLOAD_VAR_TABLE_SECTION_START     ".OffloadVarTable$a"
 #define OFFLOAD_VAR_TABLE_SECTION_END       ".OffloadVarTable$z"

 #define OFFLOAD_CRTINIT_SECTION_START       ".CRT$XCT"

 #pragma section(OFFLOAD_CRTINIT_SECTION_START, read)

 #else  // TARGET_WINNT

 #define OFFLOAD_ENTRY_TABLE_SECTION_START   ".OffloadEntryTable."
 #define OFFLOAD_ENTRY_TABLE_SECTION_END     ".OffloadEntryTable."

 #define OFFLOAD_FUNC_TABLE_SECTION_START    ".OffloadFuncTable."
 #define OFFLOAD_FUNC_TABLE_SECTION_END      ".OffloadFuncTable."

 #define OFFLOAD_VAR_TABLE_SECTION_START     ".OffloadVarTable."
 #define OFFLOAD_VAR_TABLE_SECTION_END       ".OffloadVarTable."
 #endif // TARGET_WINNT

 #pragma section(OFFLOAD_ENTRY_TABLE_SECTION_START, read, write)
 #pragma section(OFFLOAD_ENTRY_TABLE_SECTION_END, read, write)

 #pragma section(OFFLOAD_FUNC_TABLE_SECTION_START, read, write)
 #pragma section(OFFLOAD_FUNC_TABLE_SECTION_END, read, write)

 #pragma section(OFFLOAD_VAR_TABLE_SECTION_START, read, write)
 #pragma section(OFFLOAD_VAR_TABLE_SECTION_END, read, write)


 // Set library version
 extern "C" void __offload_set_version(int v);

 // register/unregister given tables
 extern "C" void __offload_register_tables(
     FuncList::Node *entry_table,
     FuncList::Node *func_table,
     VarList::Node *var_table
 );

 extern "C" void __offload_unregister_tables(
     FuncList::Node *entry_table,
     FuncList::Node *func_table,
     VarList::Node *var_table
 );


 #ifdef MYO_SUPPORT

 #include <myotypes.h>
 #include <myoimpl.h>
 #include <myo.h>

 #ifdef TARGET_WINNT
 #define MYO_TABLE_END_MARKER() reinterpret_cast<const char*>(-1)
 #else // TARGET_WINNT
 #define MYO_TABLE_END_MARKER() reinterpret_cast<const char*>(0)
 #endif // TARGET_WINNT

 // Host and Target-side MYO shared variable table entry layout
 typedef MyoiSharedVarEntry SharedTableEntry;

 #if HOST_LIBRARY

 // Host-side MYO function table entry layout
 typedef struct {
     //! Function Name
     const char *funcName;
     //! Function Address
     void *funcAddr;
     //! Local Thunk Address
     void *localThunkAddr;
 #ifdef TARGET_WINNT
     // Dummy to pad up to 32 bytes
     void *dummy;
 #endif // TARGET_WINNT
 } FptrTableEntry;

 // Host-side MYO init routine table entry layout
 typedef struct {
 #ifdef TARGET_WINNT
     // Dummy to pad up to 16 bytes
     // Function Name
     const char *funcName;
 #endif // TARGET_WINNT
     void (*func)(MyoArena);
 } InitTableEntry;

 #else // HOST_LIBRARY

 // Target-side MYO function table entry layout
 typedef MyoiTargetSharedFptrEntry   FptrTableEntry;

 // Target-side MYO init routine table entry layout
 struct InitTableEntry {
     void (*func)(void);
 };

 #endif // HOST_LIBRARY

 #ifdef TARGET_WINNT

 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_START          ".MyoSharedTable$a"
 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_END            ".MyoSharedTable$z"

 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_START         ".MyoSharedVTable$a"
 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_END           ".MyoSharedVTable$z"

 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START     ".MyoSharedInitTable$a"
 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END       ".MyoSharedInitTable$z"

 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_START            ".MyoFptrTable$a"
 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_END              ".MyoFptrTable$z"

 #else  // TARGET_WINNT

 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_START          ".MyoSharedTable."
 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_END            ".MyoSharedTable."

 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_START         ".MyoSharedVTable."
 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_END           ".MyoSharedVTable."

 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START     ".MyoSharedInitTable."
 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END       ".MyoSharedInitTable."

 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_START            ".MyoFptrTable."
 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_END              ".MyoFptrTable."

 #endif // TARGET_WINNT

 #pragma section(OFFLOAD_MYO_SHARED_TABLE_SECTION_START, read, write)
 #pragma section(OFFLOAD_MYO_SHARED_TABLE_SECTION_END, read, write)

 #pragma section(OFFLOAD_MYO_SHARED_VTABLE_SECTION_START, read, write)
 #pragma section(OFFLOAD_MYO_SHARED_VTABLE_SECTION_END, read, write)

 #pragma section(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START, read, write)
 #pragma section(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END, read, write)

 #pragma section(OFFLOAD_MYO_FPTR_TABLE_SECTION_START, read, write)
 #pragma section(OFFLOAD_MYO_FPTR_TABLE_SECTION_END, read, write)

 // List of MYO shared variable tables
 struct MYOVarTable {
     typedef SharedTableEntry Entry;
     const Entry *entries;
 };

 class MYOVarTableList : public TableList<MYOVarTable> {
 public:
     MYOVarTableList() : TableList<Table>()
     {}

     // add table to the list
     void add_table(Node *node) {
         // add table
         TableList<Table>::add_table(node);
     }

     // debug dump
     void dump(void);

     // check if any shared variables
     bool is_empty();

     // process the table contents for ordinary variables
     void process();

     // process the table contents for vtable objects
     void process_vtable();
 };

 // List of MYO shared function tables
 struct MYOFuncTable {
     typedef FptrTableEntry Entry;
     const Entry *entries;
 };

 class MYOFuncTableList : public TableList<MYOFuncTable> {
 public:
     MYOFuncTableList() : TableList<Table>()
     {}

     // add table to the list
     void add_table(Node *node) {
         // add table
         TableList<Table>::add_table(node);
     }

     // debug dump
     void dump(void);

     // check if any shared functions
     bool is_empty();

     // process the table contents
     void process();
 };

 // List of MYO shared variable initialization routine tables
 struct MYOInitTable {
     typedef InitTableEntry Entry;
     const Entry *entries;
 };

 class MYOInitTableList : public TableList<MYOInitTable> {
 public:
     MYOInitTableList() : TableList<Table>()
     {}

     // add table to the list
     void add_table(Node *node) {
         // add table
         TableList<Table>::add_table(node);
     }

     // debug dump
     void dump(void);

     // check if any init routines
     bool is_empty();

     // process the table contents
     void process();
 };

 extern MYOVarTableList  __offload_myo_var_tables;
 extern MYOVarTableList  __offload_myo_vtable_tables;
 extern MYOFuncTableList __offload_myo_func_tables;
 extern MYOInitTableList __offload_myo_init_tables;

 extern "C" void __offload_myoRegisterTables1(
     MYOInitTableList::Node *init_table,
     MYOVarTableList::Node  *shared_table,
     MYOVarTableList::Node  *shared_vtable,
     MYOFuncTableList::Node *fptr_table
 );

 extern "C" void __offload_myoRemoveTables(
     MYOInitTableList::Node *init_table,
     MYOVarTableList::Node  *shared_table,
     MYOVarTableList::Node  *shared_vtable,
     MYOFuncTableList::Node *fptr_table
 );

 #endif // MYO_SUPPORT

 #endif  // OFFLOAD_TABLE_H_INCLUDED
	/*
	Copyright (c) 2014-2016 Intel Corporation. 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.
	* Neither the name of Intel Corporation nor the names of its
	contributors may be used to endorse or promote products derived
	from this software without specific prior written permission.

	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
	HOLDER 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.
	*/


	/*! \file
	\brief Function and Variable tables used by the runtime library
	*/

	#ifndef OFFLOAD_TABLE_H_INCLUDED
	#define OFFLOAD_TABLE_H_INCLUDED

	#include "offload_util.h"

	#define OFFLOAD_VERSION_16 1600
	#define OFFLOAD_VERSION_17 1700

	// Template representing double linked list of tables
	template <typename T> class TableList {
	public:
	// table type
	typedef T Table;

	// List node
	struct Node {
	Table table;
	Node* prev;
	Node* next;
	};

	public:
	explicit TableList(Node *node = 0) : m_head(node) {}

	void add_table(Node *node) {
	m_lock.lock();
	if (m_head != 0) {
	node->next = m_head;
	m_head->prev = node;
	}
	m_head = node;

	m_lock.unlock();
	}

	void remove_table(Node *node) {
	if (node->next != 0) {
	node->next->prev = node->prev;
	}
	if (node->prev != 0) {
	node->prev->next = node->next;
	}
	if (m_head == node) {
	m_head = node->next;
	}
	}

	protected:
	Node* m_head;
	mutex_t m_lock;
	};

	// Function lookup table.
	struct FuncTable {
	//! Function table entry
	/! This table contains functions created from offload regions. /
	/*! Each entry consists of a pointer to the function's "key"
	and the function address. */
	/! Each shared library or executable may contain one such table. /
	/*! The end of the table is marked with an entry whose name field
	has value -1. */
	struct Entry {
	const char* name; //!< Name of the function
	void* func; //!< Address of the function
	};

	// entries
	const Entry *entries;

	// max name length
	int64_t max_name_len;
	};

	// Function table
	class DLL_LOCAL FuncList : public TableList<FuncTable> {
	public:
	explicit FuncList(Node *node = 0) : TableList<Table>(node),
	m_max_name_len(-1)
	{}

	// add table to the list
	void add_table(Node *node) {
	// recalculate max function name length
	m_max_name_len = -1;

	// add table
	TableList<Table>::add_table(node);
	}

	// find function address for the given name
	const void* find_addr(const char *name);

	// find function name for the given address
	const char* find_name(const void *addr);

	// max name length from all tables in the list
	int64_t max_name_length(void);

	// debug dump
	void dump(void);

	private:
	// max name length within from all tables
	int64_t m_max_name_len;
	};

	#define VAR_ALLOC_TYPE uint64_t
	#define OPENMP_IMPLICIT 1 // Compiler promoted openmp declare var
	// due to implicit use without openmp declare
	#define OPENMP_LINK 2 // Openmp link clause in openmp declare

	#define IS_OPENMP_IMPLICIT(var_alloc_type) (var_alloc_type & 1)
	#define IS_OPENMP_LINK(var_alloc_type) (var_alloc_type & 2)
	#define IS_OPENMP_IMPLICIT_OR_LINK(var_alloc_type) (var_alloc_type & 3)

	// Table entry for static variables
	struct VarTable {
	//! Variable table entry
	/*! This table contains statically allocated variables marked with
	__declspec(target(mic) or #pragma omp declare target. */
	/*! Each entry consists of a pointer to the variable's "key",
	the variable address and its size in bytes. */
	/*! Because memory allocation is done from the host,
	the MIC table does not need the size of the variable. */
	/*! Padding to make the table entry size a power of 2 is necessary
	to avoid "holes" between table contributions from different object
	files on Windows when debug information is specified with /Zi. */
	struct Entry {
	const char* name; //!< Name of the variable
	void* addr; //!< Address of the variable

	#if HOST_LIBRARY
	VAR_ALLOC_TYPE var_alloc_type;
	uint64_t size;
	#endif
	};

	// Table terminated by an entry with name == -1
	const Entry *entries;
	};

	// List of var tables
	class DLL_LOCAL VarList : public TableList<VarTable> {
	public:
	VarList() : TableList<Table>()
	{}

	// debug dump
	void dump();

	public:

	Node * get_head() {
	return m_head;
	}

	public:
	// Entry representation in a copy buffer
	struct BufEntry {
	intptr_t name;
	intptr_t addr;
	};

	// Calculate the number of elements in the table and
	// returns the size of buffer for the table
	int64_t table_size(int64_t &nelems);

	// Copy table contents to given buffer. It is supposed to be large
	// enough to hold all elements as string table.
	void table_copy(void *buf, int64_t nelems);

	// Patch name offsets in a table after it's been copied to other side
	static void table_patch_names(void *buf, int64_t nelems);
	};

	DLL_LOCAL extern FuncList __offload_entries;
	DLL_LOCAL extern FuncList __offload_funcs;
	DLL_LOCAL extern VarList __offload_vars;

	// Section names where the lookup tables are stored
	#ifdef TARGET_WINNT
	#define OFFLOAD_ENTRY_TABLE_SECTION_START ".OffloadEntryTable$a"
	#define OFFLOAD_ENTRY_TABLE_SECTION_END ".OffloadEntryTable$z"

	#define OFFLOAD_FUNC_TABLE_SECTION_START ".OffloadFuncTable$a"
	#define OFFLOAD_FUNC_TABLE_SECTION_END ".OffloadFuncTable$z"

	#define OFFLOAD_VAR_TABLE_SECTION_START ".OffloadVarTable$a"
	#define OFFLOAD_VAR_TABLE_SECTION_END ".OffloadVarTable$z"

	#define OFFLOAD_CRTINIT_SECTION_START ".CRT$XCT"

	#pragma section(OFFLOAD_CRTINIT_SECTION_START, read)

	#else // TARGET_WINNT

	#define OFFLOAD_ENTRY_TABLE_SECTION_START ".OffloadEntryTable."
	#define OFFLOAD_ENTRY_TABLE_SECTION_END ".OffloadEntryTable."

	#define OFFLOAD_FUNC_TABLE_SECTION_START ".OffloadFuncTable."
	#define OFFLOAD_FUNC_TABLE_SECTION_END ".OffloadFuncTable."

	#define OFFLOAD_VAR_TABLE_SECTION_START ".OffloadVarTable."
	#define OFFLOAD_VAR_TABLE_SECTION_END ".OffloadVarTable."
	#endif // TARGET_WINNT

	#pragma section(OFFLOAD_ENTRY_TABLE_SECTION_START, read, write)
	#pragma section(OFFLOAD_ENTRY_TABLE_SECTION_END, read, write)

	#pragma section(OFFLOAD_FUNC_TABLE_SECTION_START, read, write)
	#pragma section(OFFLOAD_FUNC_TABLE_SECTION_END, read, write)

	#pragma section(OFFLOAD_VAR_TABLE_SECTION_START, read, write)
	#pragma section(OFFLOAD_VAR_TABLE_SECTION_END, read, write)


	// Set library version
	extern "C" void __offload_set_version(int v);

	// register/unregister given tables
	extern "C" void __offload_register_tables(
	FuncList::Node *entry_table,
	FuncList::Node *func_table,
	VarList::Node *var_table
	);

	extern "C" void __offload_unregister_tables(
	FuncList::Node *entry_table,
	FuncList::Node *func_table,
	VarList::Node *var_table
	);


	#ifdef MYO_SUPPORT

	#include <myotypes.h>
	#include <myoimpl.h>
	#include <myo.h>

	#ifdef TARGET_WINNT
	#define MYO_TABLE_END_MARKER() reinterpret_cast<const char*>(-1)
	#else // TARGET_WINNT
	#define MYO_TABLE_END_MARKER() reinterpret_cast<const char*>(0)
	#endif // TARGET_WINNT

	// Host and Target-side MYO shared variable table entry layout
	typedef MyoiSharedVarEntry SharedTableEntry;

	#if HOST_LIBRARY

	// Host-side MYO function table entry layout
	typedef struct {
	//! Function Name
	const char *funcName;
	//! Function Address
	void *funcAddr;
	//! Local Thunk Address
	void *localThunkAddr;
	#ifdef TARGET_WINNT
	// Dummy to pad up to 32 bytes
	void *dummy;
	#endif // TARGET_WINNT
	} FptrTableEntry;

	// Host-side MYO init routine table entry layout
	typedef struct {
	#ifdef TARGET_WINNT
	// Dummy to pad up to 16 bytes
	// Function Name
	const char *funcName;
	#endif // TARGET_WINNT
	void (*func)(MyoArena);
	} InitTableEntry;

	#else // HOST_LIBRARY

	// Target-side MYO function table entry layout
	typedef MyoiTargetSharedFptrEntry FptrTableEntry;

	// Target-side MYO init routine table entry layout
	struct InitTableEntry {
	void (*func)(void);
	};

	#endif // HOST_LIBRARY

	#ifdef TARGET_WINNT

	#define OFFLOAD_MYO_SHARED_TABLE_SECTION_START ".MyoSharedTable$a"
	#define OFFLOAD_MYO_SHARED_TABLE_SECTION_END ".MyoSharedTable$z"

	#define OFFLOAD_MYO_SHARED_VTABLE_SECTION_START ".MyoSharedVTable$a"
	#define OFFLOAD_MYO_SHARED_VTABLE_SECTION_END ".MyoSharedVTable$z"

	#define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START ".MyoSharedInitTable$a"
	#define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END ".MyoSharedInitTable$z"

	#define OFFLOAD_MYO_FPTR_TABLE_SECTION_START ".MyoFptrTable$a"
	#define OFFLOAD_MYO_FPTR_TABLE_SECTION_END ".MyoFptrTable$z"

	#else // TARGET_WINNT

	#define OFFLOAD_MYO_SHARED_TABLE_SECTION_START ".MyoSharedTable."
	#define OFFLOAD_MYO_SHARED_TABLE_SECTION_END ".MyoSharedTable."

	#define OFFLOAD_MYO_SHARED_VTABLE_SECTION_START ".MyoSharedVTable."
	#define OFFLOAD_MYO_SHARED_VTABLE_SECTION_END ".MyoSharedVTable."

	#define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START ".MyoSharedInitTable."
	#define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END ".MyoSharedInitTable."

	#define OFFLOAD_MYO_FPTR_TABLE_SECTION_START ".MyoFptrTable."
	#define OFFLOAD_MYO_FPTR_TABLE_SECTION_END ".MyoFptrTable."

	#endif // TARGET_WINNT

	#pragma section(OFFLOAD_MYO_SHARED_TABLE_SECTION_START, read, write)
	#pragma section(OFFLOAD_MYO_SHARED_TABLE_SECTION_END, read, write)

	#pragma section(OFFLOAD_MYO_SHARED_VTABLE_SECTION_START, read, write)
	#pragma section(OFFLOAD_MYO_SHARED_VTABLE_SECTION_END, read, write)

	#pragma section(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START, read, write)
	#pragma section(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END, read, write)

	#pragma section(OFFLOAD_MYO_FPTR_TABLE_SECTION_START, read, write)
	#pragma section(OFFLOAD_MYO_FPTR_TABLE_SECTION_END, read, write)

	// List of MYO shared variable tables
	struct MYOVarTable {
	typedef SharedTableEntry Entry;
	const Entry *entries;
	};

	class MYOVarTableList : public TableList<MYOVarTable> {
	public:
	MYOVarTableList() : TableList<Table>()
	{}

	// add table to the list
	void add_table(Node *node) {
	// add table
	TableList<Table>::add_table(node);
	}

	// debug dump
	void dump(void);

	// check if any shared variables
	bool is_empty();

	// process the table contents for ordinary variables
	void process();

	// process the table contents for vtable objects
	void process_vtable();
	};

	// List of MYO shared function tables
	struct MYOFuncTable {
	typedef FptrTableEntry Entry;
	const Entry *entries;
	};

	class MYOFuncTableList : public TableList<MYOFuncTable> {
	public:
	MYOFuncTableList() : TableList<Table>()
	{}

	// add table to the list
	void add_table(Node *node) {
	// add table
	TableList<Table>::add_table(node);
	}

	// debug dump
	void dump(void);

	// check if any shared functions
	bool is_empty();

	// process the table contents
	void process();
	};

	// List of MYO shared variable initialization routine tables
	struct MYOInitTable {
	typedef InitTableEntry Entry;
	const Entry *entries;
	};

	class MYOInitTableList : public TableList<MYOInitTable> {
	public:
	MYOInitTableList() : TableList<Table>()
	{}

	// add table to the list
	void add_table(Node *node) {
	// add table
	TableList<Table>::add_table(node);
	}

	// debug dump
	void dump(void);

	// check if any init routines
	bool is_empty();

	// process the table contents
	void process();
	};

	extern MYOVarTableList __offload_myo_var_tables;
	extern MYOVarTableList __offload_myo_vtable_tables;
	extern MYOFuncTableList __offload_myo_func_tables;
	extern MYOInitTableList __offload_myo_init_tables;

	extern "C" void __offload_myoRegisterTables1(
	MYOInitTableList::Node *init_table,
	MYOVarTableList::Node *shared_table,
	MYOVarTableList::Node *shared_vtable,
	MYOFuncTableList::Node *fptr_table
	);

	extern "C" void __offload_myoRemoveTables(
	MYOInitTableList::Node *init_table,
	MYOVarTableList::Node *shared_table,
	MYOVarTableList::Node *shared_vtable,
	MYOFuncTableList::Node *fptr_table
	);

	#endif // MYO_SUPPORT

	#endif // OFFLOAD_TABLE_H_INCLUDED