Ok, I am trying to make an OpenGL Application to use a Fragment Shader. I need to get some variables into the fragment shader using glUniform.
I've seen some examples that look like this:
static PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
they have like 10 of those. When I put them in, it says, previous declaration of glShaderSourceARB, or glShaderSourceARB was declared 'extern' and then later 'static'.
When I DON'T put it in, every time I use glShaderSourceARB, I get an Undefined Reference to glShaderSourceARB.
HOW is this possible? It gets mad at me for declaring it twice, but if I take out 1 declaration, it says its not declared at all. Can someone explain how this is supposed to work?
Okay, your problem stems from lack of knowledge about C storage and scope qualifiers.
static in the global scope means: This symbol is visible to only the compilation unit its in and only that compilation unit. Other compilation units may have static symbols of the same name, but those are their own private symbols as well and they don't interfere.
extern means, that the symbol it refers to is defined and exposed (i.e. not static) somewhere else unit. You normally use it in headers. While it's certainly possible to write extern static this usually makes little sense to do.
Now what you did was introducing a new, global symbol with static scope, while the header already declared a not static symbol of the same name to exist. And the compiler tells you "sorry, this name is already taken; but your symbol doesn't match the extern declaration, so get lost."
However with just a extern declaration, but no actual definition of the symbol, the linker will at the end tell you: "There are a few parts missing, where is xyz, did nobody actually define it; everybody is referring to it (extern), but nobody actually provides it."
Okay, so should you define glShaderSourceARB as non-static then? No!
Because having that symbol around does not suffice. You also have to initialize it to something. For that you use glXGetProcAddress or wglGetProcAddress. You have to call that with the function name, for each and every symbol. And because in Windows the function addresses may depend on the active OpenGL context you have to put those symbols into thread local storage and reinitialize them everytime wglMakeCurrent is called.
What you really should do is get yourself a library that does all this tedious work drop it into your program and no longer think about it. Like GLEW, available at http://glew.sourceforge.net – read the documentation carefully, follow each step and things will work (if you follow the documentation). A word of recommendation: Embedding GLEW statically simplifies program distribution.
You evidently have a header where the function signatures are declared, but you don't have any library linked, which would actually contain the functions (that is the undefined reference error).
In Windows, the library does not contain shader functions (only functions up to OpenGL 1.1) and some third party library such as GLEW or GLEE is a must. You can also see how MiniShader is implemented (it does what GLEW / GLEE do, except it is optimized for minimal code size, such as in 4k intros).
In Linux, just linking with -lGL could help linking with the OpenGL library abd thus avoiding undefined references (if not, then use GLEW just as well).
Related
I'm developing a shared library using C++ and want a C header for user to include.
The library exports a thread_local global variable, so that an extern instruction should be writed in the header.
And this variable only be modified in library code (C++), and readonly in user's code (C language).
However C language doesn't have thread_local keyword.
So, Any idea about it?
Does the simply extern type variable is definitely correct?
And the case of modifying the variable in C ? Does everything still works?
I imagine the variable is referenced relative to a pointer that is stored in the thread context. May be even a register. When a thread is created the data is allocated and the pointer is initialised to point to it. (Space will always be required for the context.) When the process switches from one thread to another the current context is stored a different context restored, including the indirect pointer. If you do not use the correct type the patching at link time will not be correct and the correct area of memory will not be used. I do not know if the patching will just be wrong, or if the linker knows the symbol type, giving ether an explicit error or just seeing the global as undefined. Ie i don't know if it sees it as a different symbol, the same symbol but declared with conflicting types, or the same symbol, but will the mixed up reference methods will be break the code.
I'm currently updating a C++ library for Arduino (Specifically 8-bit AVR processors compiled using avr-gcc).
Typically the authors of the default Arduino libraries like to include an extern variable for the class inside the header, which is defined in the class .cpp file also. This I assume is basically to have everything provided ready to go for newbies as built-in objects.
The scenario I have is: The library I have updated no longer requires the .cpp file and I have removed it from the library. It wasn't until I went on a final pass checking for bugs that I realized, no linker error was produced despite the fact a definition wasn't provided for the extern variable in a .cpp file.
This is as simple as I can get it (header file):
struct Foo{
void method() {}
};
extern Foo foo;
Including this code and using it in one or many source files does not cause any linker error. I have tried it in both versions of GCC which Arduino uses (4.3.7, 4.8.1) and with C++11 enabled/disabled.
In my attempt to cause an error, I found it was only possible when doing something like taking the address of the object or modifying the contents of a dummy variable I added.
After discovering this I find its important to note:
The class functions only return other objects, as in, nothing like operators returning references to itself, or even a copy.
It only modifies external objects (registers which are effectively volatile uint8_t references in code), and returns temporaries of other classes.
All of the class functions in this header are so basic that they cost less than or equal to the cost of a function call, therefore they are (in my tests) completely in-lined into the caller. A typical statement may create many temporary objects in the call chain, however the compiler sees through these and outputs efficient code modifying registers directly, rather than a set of nested function calls.
I also recall reading in n3797 7.1.1 - 8 that extern can be used on incomplete types, however the class is fully defined whereas the declaration is not (this is probably irrelevant).
I'm led to believe that this may be a result of optimizations at play. I have seen the effect that taking the address has on objects which would otherwise be considered constant and compiled without RAM usage. By adding any layer of indirection to an object in which the compiler cannot guarantee state will cause this RAM consuming behavior.
So, maybe I've answered my question by simply asking it, however I'm still making assumptions and it bothers me. After quite some time hobby-coding C++, literally the only thing on my list of do-not's is making assumptions.
Really, what I want to know is:
With respect to the working solution I have, is it a simple case of documenting the inability to take the address (cause indirection) of the class?
Is it just an edge case behavior caused by optimizations eliminating the need for something to be linked?
Or is plain and simple undefined behavior. As in GCC may have a bug and is permitting code that might fail if optimizations were lowered or disabled?
Or one of you may be lucky enough to be in possession of a decoder ring that can find a suitable paragraph in the standard outlining the specifics.
This is my first question here, so let me know if you would like to know certain details, I can also provide GitHub links to the code if needed.
Edit: As the library needs to be compatible with existing code I need to maintain the ability to use the dot syntax, otherwise I'd simply have a class of static functions.
To remove assumptions for now, I see two options:
Add a .cpp just for the variable declaration.
Use a define in the header like #define foo (Foo()) allowing dot syntax via a temporary.
I prefer the method using a define, what does the community think?
Cheers.
Declaring something extern just informs the assembler and the linker that whenever you use that label/symbol, it should refer to entry in the symbol table, instead of a locally allocated symbol.
The role of the linker is to replace symbol table entries with an actual reference to the address space whenever possible.
If you don't use the symbol at all in your C file, it will not show up in the assembly code, and thus will not cause any linker error when your module is linked with others, since there is no undefined reference.
It is either an edge case behaviour caused by optimization, or you never use the foo variable in your code. I'm not 100% sure it is formally not an undefined behavior, but i'm quite sure it isn't undefined from practical point of view.
extern variables are implemented in such way, that code compiled with them produces so-called relocations - empty places where addres of variable should be placed - which are then filled by linker. Apparently foo is never used in your code in such a way that would need getting it's address and therefore linker doesn't even try to find that symbol. If you turn optimization off (-O0) you will probably get linker error.
Update: If you want to keep "dot notation" but remove the problem with undefined extern, you may replace extern with static (in header file), creating separate "instance" of variable for each TU. As this variable is going to be optimized out anyway, this will not change the real code at all, but will also work for unoptimized build.
Is there any way to find the file/shared_object from where linking is happenning for an extern variable used in current file/module.
for example: In a large application sofware in linux, I want to find the declaration of a particular variable that I have externed in my module ...
Thanks in advance.
I am not entirely sure to understand your question, but perhaps dladdr should be suitable for your needs. dladdr is a Gnu/Glibc extension. From its manual:
The function dladdr() takes a function pointer and tries to resolve name and file where it is located. (and it very probably could be used with the pointer to a global variable).
However, I am puzzled by the phrasing of your question. The "declaration of a variable" has no sense inside executable ELF binaries or shared objects, because declaration is essentially a source code concept, not an object code one. And practically speaking, most declarations (of global variables) are inside some header file.
Be aware of C++ name mangling
If you have the source code of your application, you could use textual tools (like grep or etags) or even extend the GCC compiler thru plugins or MELT extensions to find such declarations.
Of course, you can also use dlsym to find the address of some symbol, given its name.
Lets take this code sample
//header
struct A { };
struct B { };
struct C { };
extern C c;
//code
A myfunc(B&b){ A a; return a; }
void myfunc(B&b, C&c){}
C c;
Lets do this line by line starting from the code section.
When the compiler sees the first myfunc method it does not care about A or B because its use is internal. Each c++ file will know what it takes in, what it returns. Although there needs to be a name for each of the two overload so how is that chosen and how does the linker know which means what?
Next is C c; I once had a bug were the linker wouldnt reconize thus allow me access to C in other C++ files. It was because that cpp didnt know c was extern and i had to mark it as extern in the header before i could link successfully. Now i am not sure if the class type has any involvement with the linker and the variable C. I dont know how RTTI will be involved but i do know C needs to be visible by other files.
How does the linker work and name mangling and such.
We first need to understand where compilation ends and linking begins. Compilation involves taking a compilation unit (a C or C++ source file) and turning it into an object file. Simplistically, this involves generating snippets of machine code for each function as well as a symbol table for all functions and static (global) variables. Placeholders are used for any symbols needed by the compilation unit that are external to the said compilation unit.
The linker is then responsible for loading all the object files and resolving all the place-holder symbols with real addresses (or offsets for machine independent code). This is placed into various sections that can be read by the operating system's dynamic loader when loading an executable.
So for the specifics. In order to avoid errors during linking, the compiler requires you to declare all external symbols that will be used by the current compilation unit. For global variables one must use the extern keyword, for functions this is optional.
All functions and global variables defined in a compilation unit have external linkage (i.e., can be referenced by other compilation units) unless one declares that with the static keyword (or the unnamed namespace in C++). In C++, the vtable will also have a symbol needed for linkage.
Now in C++, since functions can be overloaded, the parameters also form part of the function name. Since machine-code is just addresses and registers, extra information needs to be added to the function name in the symbols table. This extra parameter information comes in the form of a mangled name and ensures that the linker links to the correct version of an overloaded function.
If you really are interested in the gory details take a look at the ELF file format (PDF) used extensively on Linux. Windows has a different format but the principles can be expected to be the same.
Name mangling on the Itanuim (and ARM) platforms can be found here.
http://en.wikipedia.org/wiki/Name_mangling
What's the difference between the following two declarations? I thought they were equivalent, but the first sample works, and the second does not. I mean it compiles and runs, but the bitmap display code shows blank. I have not stepped through it yet, but am I missing something obvious? GUI_BITMAP is a simple structure describing a bitmap. This is for VC++ 2005, but I think it fails in VC++ 2008 also. Scratching my head on this one...
Sample 1:
extern "C" const GUI_BITMAP bmkeyA_cap_active;
extern "C" const GUI_BITMAP bmkeyA_cap_inactive;
Sample 2:
extern "C"
{
const GUI_BITMAP bmkeyA_cap_active;
const GUI_BITMAP bmkeyA_cap_inactive;
};
Edit: More exploring has shown that the second example is creating the structs, while the first is referring to external structs. The second example should fail to link, since there are two variables at global scope with the same name. But it doesn't, it sends a zero filled struct to the display code which gives up. Hmmm.....
Edit 2: Running the same code through another compiler (IAR) actually failed to compile on Sample 2, with an error about missing a default constructor. So I'm guessing there is something subtle about the "extern" keyword, structs, and C++ that I don't get. If the things in extern area were functions the two samples would be identical right?
Your linker may is silently resolving the duplicate symbols behind your back. You might get static libraries from a vendor and have to link them with your program - what is the solution for the situation where you have two such libraries and they both define a common symbol? The linker will just resolve that, choosing one or the other definition, and leaving you to deal with the fallout. How are you handling the link stage of your application? You may have better results if you link .o files directly instead of putting them into intermediate libraries before linking the final application.
This page of the ARM documentation describes the problem well - I expect similar behaviour is happening in your case:
Multiple definitions of a symbol in different library objects are not necessarily detected. Once the linker has found a suitable definition for a symbol it stops looking for others. Assuming the object containing the duplicate symbol is not loaded for other reasons no error will occur. This is intentional and particularly useful in some situations.
Edit: More searching has turned up that this problem is caused because of a violation of the "One Definition Rule", and as a result the compiler/linker aren't required to inform you of the problem. That makes your question a duplicate of this one.
The second example might be equivalent to the first with an extra extern in front of the const. In the first case, the compiler is probably combining the two uses of extern. In the second case, I would assume the compiler doesn't male everything in the extern scope extern for whatever reason.