/*
* destination buffer size
*/
size_t
_elf32_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) {
Elf_Type type = src->d_type;
unsigned sv = src->d_version;
xlator op;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return (size_t)-1;
}
if (tof) {
/*
* Encoding doesn't really matter (the translator only looks at
* the source, which resides in memory), but we need a proper
* encoding to select a translator...
*/
encode = ELFDATA2LSB;
}
else if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return (size_t)-1;
}
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
if (!(op = translator(sv, dv, encode, type, tof))) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
return (*op)(NULL, src->d_buf, src->d_size);
}
/*
* direction-independent translation
*/
static Elf_Data*
elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
Elf_Type type;
int dv;
int sv;
size_t dsize;
size_t tmp;
xlator op;
if (!src || !dst) {
return NULL;
}
if (!src->d_buf || !dst->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return NULL;
}
sv = src->d_version;
dv = dst->d_version;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return NULL;
}
type = src->d_type;
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
op = translator(sv, dv, encode, type, tof);
if (!op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
dsize = (*op)(NULL, src->d_buf, src->d_size);
if (dsize == (size_t)-1) {
return NULL;
}
if (dst->d_size < dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (dsize) {
tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
if (tmp == (size_t)-1) {
return NULL;
}
elf_assert(tmp == dsize);
}
dst->d_size = dsize;
dst->d_type = type;
return dst;
}
/*
* direction-independent translation
*/
static Elf_Data*
elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
size_t ssize, dsize, count;
Elf_Type type;
int sv, dv;
xlator op;
if (!src || !dst) {
return NULL;
}
if (!src->d_buf || !dst->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return NULL;
}
sv = src->d_version;
dv = dst->d_version;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return NULL;
}
type = src->d_type;
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
ssize = _fmsize(ELFCLASS32, sv, type, 1 - tof);
dsize = _fmsize(ELFCLASS32, dv, type, tof);
op = translator(sv, dv, encode, type, tof);
if (!ssize || !dsize || !op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
count = src->d_size / ssize;
if (dst->d_size < count * dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (count) {
(*op)(dst->d_buf, src->d_buf, count);
}
dst->d_size = count * dsize;
dst->d_type = type;
return dst;
}
/*
* Extension: report memory size
*/
size_t
gelf_msize(Elf *elf, Elf_Type type, size_t count, unsigned ver) {
size_t n;
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (!valid_class(elf->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
}
else if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _msize(elf->e_class, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
else {
return count * n;
}
}
return 0;
}
/*
* Extension: report memory size
*/
size_t
gcgcef_msize(CGCEf *cgcef, CGCEf_Type type, size_t count, unsigned ver) {
size_t n;
if (cgcef) {
if (cgcef->e_kind != CGCEF_K_CGCEF) {
seterr(ERROR_NOTCGCEF);
}
else if (!valid_class(cgcef->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
}
else if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _msize(cgcef->e_class, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
else {
return count * n;
}
}
return 0;
}
static size_t
_elf_fsize(unsigned cls, Elf_Type type, unsigned ver) {
size_t n = 0;
if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _fsize(cls, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
return n;
}
unsigned
elf_version(unsigned ver) {
unsigned tmp;
if (ver == EV_NONE) {
return EV_CURRENT;
}
if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
return EV_NONE;
}
tmp = _elf_version == EV_NONE ? EV_CURRENT : _elf_version;
_elf_version = ver;
return tmp;
}
int main(int argc, char** argv)
{
int ch, client, major, minor, revision, profile;
GLint redbits, greenbits, bluebits, alphabits, depthbits, stencilbits;
int list_extensions = GLFW_FALSE, list_layers = GLFW_FALSE;
GLenum error;
GLFWwindow* window;
enum { CLIENT, CONTEXT, BEHAVIOR, DEBUG, FORWARD, HELP, EXTENSIONS, LAYERS,
MAJOR, MINOR, PROFILE, ROBUSTNESS, VERSION,
REDBITS, GREENBITS, BLUEBITS, ALPHABITS, DEPTHBITS, STENCILBITS,
ACCUMREDBITS, ACCUMGREENBITS, ACCUMBLUEBITS, ACCUMALPHABITS,
AUXBUFFERS, SAMPLES, STEREO, SRGB, SINGLEBUFFER, NOERROR_SRSLY };
const struct option options[] =
{
{ "behavior", 1, NULL, BEHAVIOR },
{ "client-api", 1, NULL, CLIENT },
{ "context-api", 1, NULL, CONTEXT },
{ "debug", 0, NULL, DEBUG },
{ "forward", 0, NULL, FORWARD },
{ "help", 0, NULL, HELP },
{ "list-extensions", 0, NULL, EXTENSIONS },
{ "list-layers", 0, NULL, LAYERS },
{ "major", 1, NULL, MAJOR },
{ "minor", 1, NULL, MINOR },
{ "profile", 1, NULL, PROFILE },
{ "robustness", 1, NULL, ROBUSTNESS },
{ "version", 0, NULL, VERSION },
{ "red-bits", 1, NULL, REDBITS },
{ "green-bits", 1, NULL, GREENBITS },
{ "blue-bits", 1, NULL, BLUEBITS },
{ "alpha-bits", 1, NULL, ALPHABITS },
{ "depth-bits", 1, NULL, DEPTHBITS },
{ "stencil-bits", 1, NULL, STENCILBITS },
{ "accum-red-bits", 1, NULL, ACCUMREDBITS },
{ "accum-green-bits", 1, NULL, ACCUMGREENBITS },
{ "accum-blue-bits", 1, NULL, ACCUMBLUEBITS },
{ "accum-alpha-bits", 1, NULL, ACCUMALPHABITS },
{ "aux-buffers", 1, NULL, AUXBUFFERS },
{ "samples", 1, NULL, SAMPLES },
{ "stereo", 0, NULL, STEREO },
{ "srgb", 0, NULL, SRGB },
{ "singlebuffer", 0, NULL, SINGLEBUFFER },
{ "no-error", 0, NULL, NOERROR_SRSLY },
{ NULL, 0, NULL, 0 }
};
// Initialize GLFW and create window
if (!valid_version())
exit(EXIT_FAILURE);
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
while ((ch = getopt_long(argc, argv, "a:b:c:dfhlm:n:p:s:v", options, NULL)) != -1)
{
switch (ch)
{
case 'a':
case CLIENT:
if (strcasecmp(optarg, API_NAME_OPENGL) == 0)
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
else if (strcasecmp(optarg, API_NAME_OPENGL_ES) == 0)
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 'b':
case BEHAVIOR:
if (strcasecmp(optarg, BEHAVIOR_NAME_NONE) == 0)
{
glfwWindowHint(GLFW_CONTEXT_RELEASE_BEHAVIOR,
GLFW_RELEASE_BEHAVIOR_NONE);
}
else if (strcasecmp(optarg, BEHAVIOR_NAME_FLUSH) == 0)
{
glfwWindowHint(GLFW_CONTEXT_RELEASE_BEHAVIOR,
GLFW_RELEASE_BEHAVIOR_FLUSH);
}
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 'c':
case CONTEXT:
if (strcasecmp(optarg, API_NAME_NATIVE) == 0)
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
else if (strcasecmp(optarg, API_NAME_EGL) == 0)
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 'd':
case DEBUG:
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
break;
case 'f':
case FORWARD:
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
break;
case 'h':
case HELP:
usage();
exit(EXIT_SUCCESS);
case 'l':
case EXTENSIONS:
list_extensions = GLFW_TRUE;
break;
case LAYERS:
list_layers = GLFW_TRUE;
break;
case 'm':
case MAJOR:
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, atoi(optarg));
break;
case 'n':
case MINOR:
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, atoi(optarg));
break;
case 'p':
case PROFILE:
if (strcasecmp(optarg, PROFILE_NAME_CORE) == 0)
{
glfwWindowHint(GLFW_OPENGL_PROFILE,
GLFW_OPENGL_CORE_PROFILE);
}
else if (strcasecmp(optarg, PROFILE_NAME_COMPAT) == 0)
{
glfwWindowHint(GLFW_OPENGL_PROFILE,
GLFW_OPENGL_COMPAT_PROFILE);
}
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 's':
case ROBUSTNESS:
if (strcasecmp(optarg, STRATEGY_NAME_NONE) == 0)
{
glfwWindowHint(GLFW_CONTEXT_ROBUSTNESS,
GLFW_NO_RESET_NOTIFICATION);
}
else if (strcasecmp(optarg, STRATEGY_NAME_LOSE) == 0)
{
glfwWindowHint(GLFW_CONTEXT_ROBUSTNESS,
GLFW_LOSE_CONTEXT_ON_RESET);
}
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 'v':
case VERSION:
print_version();
exit(EXIT_SUCCESS);
case REDBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_RED_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_RED_BITS, atoi(optarg));
break;
case GREENBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_GREEN_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_GREEN_BITS, atoi(optarg));
break;
case BLUEBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_BLUE_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_BLUE_BITS, atoi(optarg));
break;
case ALPHABITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_ALPHA_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_ALPHA_BITS, atoi(optarg));
break;
case DEPTHBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_DEPTH_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_DEPTH_BITS, atoi(optarg));
break;
case STENCILBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_STENCIL_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_STENCIL_BITS, atoi(optarg));
break;
case ACCUMREDBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_ACCUM_RED_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_ACCUM_RED_BITS, atoi(optarg));
break;
case ACCUMGREENBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_ACCUM_GREEN_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_ACCUM_GREEN_BITS, atoi(optarg));
break;
case ACCUMBLUEBITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_ACCUM_BLUE_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_ACCUM_BLUE_BITS, atoi(optarg));
break;
case ACCUMALPHABITS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_ACCUM_ALPHA_BITS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_ACCUM_ALPHA_BITS, atoi(optarg));
break;
case AUXBUFFERS:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_AUX_BUFFERS, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_AUX_BUFFERS, atoi(optarg));
break;
case SAMPLES:
if (strcmp(optarg, "-") == 0)
glfwWindowHint(GLFW_SAMPLES, GLFW_DONT_CARE);
else
glfwWindowHint(GLFW_SAMPLES, atoi(optarg));
break;
case STEREO:
glfwWindowHint(GLFW_STEREO, GLFW_TRUE);
break;
case SRGB:
glfwWindowHint(GLFW_SRGB_CAPABLE, GLFW_TRUE);
break;
case SINGLEBUFFER:
glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_FALSE);
break;
case NOERROR_SRSLY:
glfwWindowHint(GLFW_CONTEXT_NO_ERROR, GLFW_TRUE);
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
print_version();
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
window = glfwCreateWindow(200, 200, "Version", NULL, NULL);
if (!window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
error = glGetError();
if (error != GL_NO_ERROR)
printf("*** OpenGL error after make current: 0x%08x ***\n", error);
// Report client API version
client = glfwGetWindowAttrib(window, GLFW_CLIENT_API);
major = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
minor = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
revision = glfwGetWindowAttrib(window, GLFW_CONTEXT_REVISION);
profile = glfwGetWindowAttrib(window, GLFW_OPENGL_PROFILE);
printf("%s context version string: \"%s\"\n",
get_api_name(client),
glGetString(GL_VERSION));
printf("%s context version parsed by GLFW: %u.%u.%u\n",
get_api_name(client),
major, minor, revision);
// Report client API context properties
if (client == GLFW_OPENGL_API)
{
if (major >= 3)
{
GLint flags;
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
printf("%s context flags (0x%08x):", get_api_name(client), flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
printf(" forward-compatible");
if (flags & 2/*GL_CONTEXT_FLAG_DEBUG_BIT*/)
printf(" debug");
if (flags & GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB)
printf(" robustness");
if (flags & 8/*GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR*/)
printf(" no-error");
putchar('\n');
printf("%s context flags parsed by GLFW:", get_api_name(client));
if (glfwGetWindowAttrib(window, GLFW_OPENGL_FORWARD_COMPAT))
printf(" forward-compatible");
if (glfwGetWindowAttrib(window, GLFW_OPENGL_DEBUG_CONTEXT))
printf(" debug");
if (glfwGetWindowAttrib(window, GLFW_CONTEXT_ROBUSTNESS) == GLFW_LOSE_CONTEXT_ON_RESET)
printf(" robustness");
if (glfwGetWindowAttrib(window, GLFW_CONTEXT_NO_ERROR))
printf(" no-error");
putchar('\n');
}
if (major >= 4 || (major == 3 && minor >= 2))
{
GLint mask;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
printf("%s profile mask (0x%08x): %s\n",
get_api_name(client),
mask,
get_profile_name_gl(mask));
printf("%s profile mask parsed by GLFW: %s\n",
get_api_name(client),
get_profile_name_glfw(profile));
}
if (GLAD_GL_ARB_robustness)
{
const int robustness = glfwGetWindowAttrib(window, GLFW_CONTEXT_ROBUSTNESS);
GLint strategy;
glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
printf("%s robustness strategy (0x%08x): %s\n",
get_api_name(client),
strategy,
get_strategy_name_gl(strategy));
printf("%s robustness strategy parsed by GLFW: %s\n",
get_api_name(client),
get_strategy_name_glfw(robustness));
}
}
printf("%s context renderer string: \"%s\"\n",
get_api_name(client),
glGetString(GL_RENDERER));
printf("%s context vendor string: \"%s\"\n",
get_api_name(client),
glGetString(GL_VENDOR));
if (major >= 2)
{
printf("%s context shading language version: \"%s\"\n",
get_api_name(client),
glGetString(GL_SHADING_LANGUAGE_VERSION));
}
printf("%s framebuffer:\n", get_api_name(client));
if (client == GLFW_OPENGL_API && profile == GLFW_OPENGL_CORE_PROFILE)
{
glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE,
&redbits);
glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
&greenbits);
glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
&bluebits);
glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
&alphabits);
glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
GL_DEPTH,
GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
&depthbits);
glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
GL_STENCIL,
GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
&stencilbits);
}
else
{
glGetIntegerv(GL_RED_BITS, &redbits);
glGetIntegerv(GL_GREEN_BITS, &greenbits);
glGetIntegerv(GL_BLUE_BITS, &bluebits);
glGetIntegerv(GL_ALPHA_BITS, &alphabits);
glGetIntegerv(GL_DEPTH_BITS, &depthbits);
glGetIntegerv(GL_STENCIL_BITS, &stencilbits);
}
printf(" red: %u green: %u blue: %u alpha: %u depth: %u stencil: %u\n",
redbits, greenbits, bluebits, alphabits, depthbits, stencilbits);
if (client == GLFW_OPENGL_ES_API ||
GLAD_GL_ARB_multisample ||
major > 1 || minor >= 3)
{
GLint samples, samplebuffers;
glGetIntegerv(GL_SAMPLES, &samples);
glGetIntegerv(GL_SAMPLE_BUFFERS, &samplebuffers);
printf(" samples: %u sample buffers: %u\n", samples, samplebuffers);
}
if (client == GLFW_OPENGL_API && profile != GLFW_OPENGL_CORE_PROFILE)
{
GLint accumredbits, accumgreenbits, accumbluebits, accumalphabits;
GLint auxbuffers;
glGetIntegerv(GL_ACCUM_RED_BITS, &accumredbits);
glGetIntegerv(GL_ACCUM_GREEN_BITS, &accumgreenbits);
glGetIntegerv(GL_ACCUM_BLUE_BITS, &accumbluebits);
glGetIntegerv(GL_ACCUM_ALPHA_BITS, &accumalphabits);
glGetIntegerv(GL_AUX_BUFFERS, &auxbuffers);
printf(" accum red: %u accum green: %u accum blue: %u accum alpha: %u aux buffers: %u\n",
accumredbits, accumgreenbits, accumbluebits, accumalphabits, auxbuffers);
}
if (list_extensions)
list_context_extensions(client, major, minor);
printf("Vulkan loader: %s\n",
glfwVulkanSupported() ? "available" : "missing");
if (glfwVulkanSupported())
{
uint32_t i, re_count, pd_count;
const char** re;
VkApplicationInfo ai = {0};
VkInstanceCreateInfo ici = {0};
VkInstance instance;
VkPhysicalDevice* pd;
PFN_vkCreateInstance vkCreateInstance = (PFN_vkCreateInstance)
glfwGetInstanceProcAddress(NULL, "vkCreateInstance");
PFN_vkDestroyInstance vkDestroyInstance;
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
re = glfwGetRequiredInstanceExtensions(&re_count);
printf("Vulkan required instance extensions:");
for (i = 0; i < re_count; i++)
printf(" %s", re[i]);
putchar('\n');
if (list_extensions)
list_vulkan_instance_extensions();
if (list_layers)
list_vulkan_instance_layers();
ai.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
ai.pApplicationName = "glfwinfo";
ai.applicationVersion = GLFW_VERSION_MAJOR;
ai.pEngineName = "GLFW";
ai.engineVersion = GLFW_VERSION_MAJOR;
ai.apiVersion = VK_API_VERSION_1_0;
ici.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
ici.pApplicationInfo = &ai;
ici.enabledExtensionCount = re_count;
ici.ppEnabledExtensionNames = re;
if (vkCreateInstance(&ici, NULL, &instance) != VK_SUCCESS)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
vkDestroyInstance = (PFN_vkDestroyInstance)
glfwGetInstanceProcAddress(instance, "vkDestroyInstance");
vkEnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices)
glfwGetInstanceProcAddress(instance, "vkEnumeratePhysicalDevices");
vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)
glfwGetInstanceProcAddress(instance, "vkGetPhysicalDeviceProperties");
if (vkEnumeratePhysicalDevices(instance, &pd_count, NULL) != VK_SUCCESS)
{
vkDestroyInstance(instance, NULL);
glfwTerminate();
exit(EXIT_FAILURE);
}
pd = calloc(pd_count, sizeof(VkPhysicalDevice));
if (vkEnumeratePhysicalDevices(instance, &pd_count, pd) != VK_SUCCESS)
{
free(pd);
vkDestroyInstance(instance, NULL);
glfwTerminate();
exit(EXIT_FAILURE);
}
for (i = 0; i < pd_count; i++)
{
VkPhysicalDeviceProperties pdp;
vkGetPhysicalDeviceProperties(pd[i], &pdp);
printf("Vulkan %s device: \"%s\"\n",
get_device_type_name(pdp.deviceType),
pdp.deviceName);
if (list_extensions)
list_vulkan_device_extensions(instance, pd[i]);
if (list_layers)
list_vulkan_device_layers(instance, pd[i]);
}
free(pd);
vkDestroyInstance(instance, NULL);
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main(int argc, char** argv)
{
int ch, api = 0, profile = 0, strategy = 0, major = 1, minor = 0, revision;
GLboolean debug = GL_FALSE, forward = GL_FALSE, list = GL_FALSE;
GLint flags, mask;
GLFWwindow* window;
if (!valid_version())
exit(EXIT_FAILURE);
while ((ch = getopt(argc, argv, "a:dfhlm:n:p:r:")) != -1)
{
switch (ch)
{
case 'a':
if (strcasecmp(optarg, API_OPENGL) == 0)
api = GLFW_OPENGL_API;
else if (strcasecmp(optarg, API_OPENGL_ES) == 0)
api = GLFW_OPENGL_ES_API;
else
{
usage();
exit(EXIT_FAILURE);
}
case 'd':
debug = GL_TRUE;
break;
case 'f':
forward = GL_TRUE;
break;
case 'h':
usage();
exit(EXIT_SUCCESS);
case 'l':
list = GL_TRUE;
break;
case 'm':
major = atoi(optarg);
break;
case 'n':
minor = atoi(optarg);
break;
case 'p':
if (strcasecmp(optarg, PROFILE_NAME_CORE) == 0)
profile = GLFW_OPENGL_CORE_PROFILE;
else if (strcasecmp(optarg, PROFILE_NAME_COMPAT) == 0)
profile = GLFW_OPENGL_COMPAT_PROFILE;
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 'r':
if (strcasecmp(optarg, STRATEGY_NAME_NONE) == 0)
strategy = GLFW_NO_RESET_NOTIFICATION;
else if (strcasecmp(optarg, STRATEGY_NAME_LOSE) == 0)
strategy = GLFW_LOSE_CONTEXT_ON_RESET;
else
{
usage();
exit(EXIT_FAILURE);
}
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
// Initialize GLFW and create window
glfwSetErrorCallback(error_callback, NULL);
if (!glfwInit())
exit(EXIT_FAILURE);
if (major != 1 || minor != 0)
{
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, major);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minor);
}
if (api != 0)
glfwWindowHint(GLFW_CLIENT_API, api);
if (debug)
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
if (forward)
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
if (profile != 0)
glfwWindowHint(GLFW_OPENGL_PROFILE, profile);
if (strategy)
glfwWindowHint(GLFW_CONTEXT_ROBUSTNESS, strategy);
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
window = glfwCreateWindow(200, 200, "Version", NULL, NULL);
if (!window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
// Report client API version
api = glfwGetWindowAttrib(window, GLFW_CLIENT_API);
major = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
minor = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
revision = glfwGetWindowAttrib(window, GLFW_CONTEXT_REVISION);
printf("%s context version string: \"%s\"\n",
get_client_api_name(api),
glGetString(GL_VERSION));
printf("%s context version parsed by GLFW: %u.%u.%u\n",
get_client_api_name(api),
major, minor, revision);
// Report client API context properties
if (api == GLFW_OPENGL_API)
{
if (major >= 3)
{
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
printf("%s context flags (0x%08x):", get_client_api_name(api), flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
printf(" forward-compatible");
if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
printf(" debug");
if (flags & GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB)
printf(" robustness");
putchar('\n');
printf("%s context flags parsed by GLFW:", get_client_api_name(api));
if (glfwGetWindowAttrib(window, GLFW_OPENGL_FORWARD_COMPAT))
printf(" forward-compatible");
if (glfwGetWindowAttrib(window, GLFW_OPENGL_DEBUG_CONTEXT))
printf(" debug");
if (glfwGetWindowAttrib(window, GLFW_CONTEXT_ROBUSTNESS) != GLFW_NO_ROBUSTNESS)
printf(" robustness");
putchar('\n');
}
if (major > 3 || (major == 3 && minor >= 2))
{
int profile = glfwGetWindowAttrib(window, GLFW_OPENGL_PROFILE);
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
printf("%s profile mask (0x%08x): %s\n",
get_client_api_name(api),
mask,
get_profile_name_gl(mask));
printf("%s profile mask parsed by GLFW: %s\n",
get_client_api_name(api),
get_profile_name_glfw(profile));
}
if (glfwExtensionSupported("GL_ARB_robustness"))
{
int robustness;
GLint strategy;
glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
printf("%s robustness strategy (0x%08x): %s\n",
get_client_api_name(api),
strategy,
get_strategy_name_gl(strategy));
robustness = glfwGetWindowAttrib(window, GLFW_CONTEXT_ROBUSTNESS);
printf("%s robustness strategy parsed by GLFW: %s\n",
get_client_api_name(api),
get_strategy_name_glfw(robustness));
}
}
printf("%s context renderer string: \"%s\"\n",
get_client_api_name(api),
glGetString(GL_RENDERER));
printf("%s context vendor string: \"%s\"\n",
get_client_api_name(api),
glGetString(GL_VENDOR));
if (major > 1)
{
printf("%s context shading language version: \"%s\"\n",
get_client_api_name(api),
glGetString(GL_SHADING_LANGUAGE_VERSION));
}
// Report client API extensions
if (list)
list_extensions(api, major, minor);
glfwTerminate();
exit(EXIT_SUCCESS);
}
static off_t
scn_data_layout(Elf_Scn *scn, unsigned v, unsigned type, size_t *algn, unsigned *flag) {
Elf *elf = scn->s_elf;
Elf_Data *data;
int layout = (elf->e_elf_flags & ELF_F_LAYOUT) == 0;
size_t scn_align = 1;
size_t len = 0;
Scn_Data *sd;
size_t fsize;
if (!(sd = scn->s_data_1)) {
/* no data in section */
*algn = scn_align;
return (off_t)len;
}
/* load data from file, if any */
if (!(data = elf_getdata(scn, NULL))) {
return (off_t)-1;
}
elf_assert(data == &sd->sd_data);
for (; sd; sd = sd->sd_link) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
if (!valid_version(sd->sd_data.d_version)) {
return (off_t)-1;
}
fsize = sd->sd_data.d_size;
if (fsize && type != SHT_NOBITS && valid_type(sd->sd_data.d_type)) {
if (elf->e_class == ELFCLASS32) {
fsize = _elf32_xltsize(&sd->sd_data, v, ELFDATA2LSB, 1);
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
fsize = _elf64_xltsize(&sd->sd_data, v, ELFDATA2LSB, 1);
}
#endif /* __LIBELF64 */
else {
elf_assert(valid_class(elf->e_class));
seterr(ERROR_UNIMPLEMENTED);
return (off_t)-1;
}
if (fsize == (size_t)-1) {
return (off_t)-1;
}
}
if (layout) {
align(len, sd->sd_data.d_align);
scn_align = max(scn_align, sd->sd_data.d_align);
rewrite(sd->sd_data.d_off, (off_t)len, sd->sd_data_flags);
len += fsize;
}
else {
len = max(len, sd->sd_data.d_off + fsize);
}
*flag |= sd->sd_data_flags;
}
*algn = scn_align;
return (off_t)len;
}
static off_t
_elf64_layout(Elf *elf, unsigned *flag) {
int layout = (elf->e_elf_flags & ELF_F_LAYOUT) == 0;
Elf64_Ehdr *ehdr = (Elf64_Ehdr*)elf->e_ehdr;
size_t off = 0;
unsigned version;
unsigned encoding;
size_t align_addr;
size_t entsize;
unsigned shnum;
Elf_Scn *scn;
*flag = elf->e_elf_flags | elf->e_phdr_flags;
if ((version = ehdr->e_version) == EV_NONE) {
version = EV_CURRENT;
}
if (!valid_version(version)) {
seterr(ERROR_UNKNOWN_VERSION);
return -1;
}
if ((encoding = ehdr->e_ident[EI_DATA]) == ELFDATANONE) {
encoding = native_encoding;
}
if (!valid_encoding(encoding)) {
seterr(ERROR_UNKNOWN_ENCODING);
return -1;
}
entsize = _fsize(ELFCLASS64, version, ELF_T_EHDR);
elf_assert(entsize);
rewrite(ehdr->e_ehsize, entsize, elf->e_ehdr_flags);
off = entsize;
align_addr = _fsize(ELFCLASS64, version, ELF_T_ADDR);
elf_assert(align_addr);
if (elf->e_phnum) {
entsize = _fsize(ELFCLASS64, version, ELF_T_PHDR);
elf_assert(entsize);
if (layout) {
align(off, align_addr);
rewrite(ehdr->e_phoff, off, elf->e_ehdr_flags);
off += elf->e_phnum * entsize;
}
else {
off = max(off, ehdr->e_phoff + elf->e_phnum * entsize);
}
}
else {
entsize = 0;
if (layout) {
rewrite(ehdr->e_phoff, 0, elf->e_ehdr_flags);
}
}
rewrite(ehdr->e_phnum, elf->e_phnum, elf->e_ehdr_flags);
rewrite(ehdr->e_phentsize, entsize, elf->e_ehdr_flags);
for (scn = elf->e_scn_1, shnum = 0; scn; scn = scn->s_link, ++shnum) {
Elf64_Shdr *shdr = &scn->s_shdr64;
size_t scn_align = 1;
off_t len;
elf_assert(scn->s_index == shnum);
*flag |= scn->s_scn_flags;
if (scn->s_index == SHN_UNDEF) {
rewrite(shdr->sh_entsize, 0, scn->s_shdr_flags);
if (layout) {
rewrite(shdr->sh_offset, 0, scn->s_shdr_flags);
rewrite(shdr->sh_size, 0, scn->s_shdr_flags);
rewrite(shdr->sh_addralign, 0, scn->s_shdr_flags);
}
*flag |= scn->s_shdr_flags;
continue;
}
if (shdr->sh_type == SHT_NULL) {
*flag |= scn->s_shdr_flags;
continue;
}
len = scn_data_layout(scn, version, shdr->sh_type, &scn_align, flag);
if (len == -1) {
return -1;
}
/*
* Never override the program's choice.
*/
if (shdr->sh_entsize == 0) {
entsize = scn_entsize(elf, version, shdr->sh_type);
if (entsize > 1) {
rewrite(shdr->sh_entsize, entsize, scn->s_shdr_flags);
}
}
if (layout) {
align(off, scn_align);
rewrite(shdr->sh_offset, off, scn->s_shdr_flags);
rewrite(shdr->sh_size, (size_t)len, scn->s_shdr_flags);
rewrite(shdr->sh_addralign, scn_align, scn->s_shdr_flags);
if (shdr->sh_type != SHT_NOBITS) {
off += (size_t)len;
}
}
else if ((size_t)len > shdr->sh_size) {
seterr(ERROR_SCN2SMALL);
return -1;
}
else {
Elf_Scn *scn2;
size_t end1, end2;
end1 = shdr->sh_offset;
if (shdr->sh_type != SHT_NOBITS) {
end1 += shdr->sh_size;
}
if (shdr->sh_offset < off) {
/*
* check for overlapping sections
*/
for (scn2 = elf->e_scn_1; scn2; scn2 = scn2->s_link) {
if (scn2 == scn) {
break;
}
end2 = scn2->s_shdr64.sh_offset;
if (scn2->s_shdr64.sh_type != SHT_NOBITS) {
end2 += scn2->s_shdr64.sh_size;
}
if (end1 > scn2->s_shdr64.sh_offset
&& end2 > shdr->sh_offset) {
seterr(ERROR_SCN_OVERLAP);
return -1;
}
}
}
if (off < end1) {
off = end1;
}
}
*flag |= scn->s_shdr_flags;
}
if (shnum) {
entsize = _fsize(ELFCLASS64, version, ELF_T_SHDR);
elf_assert(entsize);
if (layout) {
align(off, align_addr);
rewrite(ehdr->e_shoff, off, elf->e_ehdr_flags);
off += shnum * entsize;
}
else {
off = max(off, ehdr->e_shoff + shnum * entsize);
}
}
else {
entsize = 0;
if (layout) {
rewrite(ehdr->e_shoff, 0, elf->e_ehdr_flags);
}
}
if (shnum >= SHN_LORESERVE) {
Elf_Scn *scn = elf->e_scn_1;
Elf64_Shdr *shdr = &scn->s_shdr64;
elf_assert(scn->s_index == 0);
rewrite(shdr->sh_size, shnum, scn->s_shdr_flags);
*flag |= scn->s_shdr_flags;
shnum = 0;
}
rewrite(ehdr->e_shnum, shnum, elf->e_ehdr_flags);
rewrite(ehdr->e_shentsize, entsize, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG0], ELFMAG0, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG1], ELFMAG1, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG2], ELFMAG2, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG3], ELFMAG3, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_CLASS], ELFCLASS64, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_DATA], encoding, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_VERSION], version, elf->e_ehdr_flags);
rewrite(ehdr->e_version, version, elf->e_ehdr_flags);
*flag |= elf->e_ehdr_flags;
return off;
}
