It is for resolving circular dependences between several libraries (listed between `-(` and `-)`).

Citing https://stackoverflow.com/questions/45135/linker-order-gcc/409470#409470 or `man ld` http://linux.die.net/man/1/ld 

&gt; `-(` *archives* `-)` or `--start-group` *archives* `--end-group` 
&gt;
&gt; The *archives* should be a list of archive files. They may be either explicit file names, or -l options.
&gt;    
&gt;    The specified archives are searched repeatedly until no new undefined references are created. Normally, an archive is searched only once in the order that it is specified on the command line. If a symbol in that archive is needed to resolve an undefined symbol referred to by an object in an archive that appears later on the command line, the linker would not be able to resolve that reference. By grouping the archives, they all be searched repeatedly until all possible references are resolved.
&gt;    
&gt;    Using this option has a significant performance cost. It is best to use it only when there are unavoidable circular references between two or more archives.

So, libraries inside the group can be searched for new symbols several time, and you need no ugly constructs like `-llib1 -llib2 -llib1`

PS archive means basically a static library (`*.a` files)

Is try-catch the only method to do that?


How to check if a deque is empty

I just came across a neat CSS trick. Check out the fiddle...

&lt;!-- begin snippet: js hide: false --&gt;

&lt;!-- language: lang-css --&gt;

    .tooltiptail {
      display: block;
      border-color: #ffffff #a0c7ff #ffffff #ffffff;
      border-style: solid;
      border-width: 20px;
      width: 0px;
      height: 0px;
    }
    .anothertail {
      background-image: url(http://static.jqueryfordesigners.com/demo/images/coda/bubble-tail2.png);
      display: block;
      height: 29px;
      width: 30px;
    }

&lt;!-- language: lang-html --&gt;

    &lt;div&gt;Cool Trick:
      &lt;br /&gt;
      &lt;div class=&quot;tooltiptail&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;
    &lt;br /&gt;

    &lt;div&gt;How do I get this effect with only CSS?
      &lt;br /&gt;
      &lt;div class=&quot;anothertail&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;

&lt;!-- end snippet --&gt;

This creates a little arrow/triangle-like effect, a &quot;tooltip tail&quot;. This blows my mind! **I&#39;m really interested in knowing how this works?!**

Further, is there a way to extend this CSS trick to create an effect as follows:

![enter image description here][1]

This is an interesting problem. Can this be done using only CSS, ignoring the shadow for now?


----------


UPDATE 1
-----------------------

I figured out a solution to my initial question. Here&#39;s the fiddle... 

http://jsfiddle.net/duZAx/7/

HTML

    &lt;div style=&quot;position: relative;&quot;&gt;Cool Trick:&lt;br /&gt;
        &lt;div class=&quot;tooltiptail&quot;&gt;&lt;/div&gt;
        &lt;div class=&quot;tooltiptail2&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;

CSS

    .tooltiptail {
        display: block;
        border-color: #ffffff #a0c7ff #ffffff #ffffff;
        border-style: solid;
        border-width: 20px;
        width: 0px;
        height: 0px;
    }
    .tooltiptail2 {
        display: block;
        border-color: transparent #ffffff transparent transparent;
        border-style: solid;
        border-width: 18px;
        width: 0px;
        height: 0px;
        position: relative;
        left: 4px;
        top: -38px;
    }

Now, how do I exactly mimic the little picture above using pure CSS, including the shadow and having it cross-browser compatible?


----------


UPDATE 2
---------------------------

Here&#39;s my solution after a combination of the answers below. I haven&#39;t tested it across multiple browsers, but it looks great in Chrome. 

http://jsfiddle.net/UnsungHero97/MZXCj/688/

HTML

    &lt;div id=&quot;toolTip&quot;&gt;
        &lt;p&gt;i can haz css tooltip&lt;/p&gt;
        &lt;div id=&quot;tailShadow&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;tail1&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;tail2&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;

CSS
    
    #toolTip {
        background-color: #ffffff;
        border: 1px solid #73a7f0;
        width: 200px;
        height: 100px;
        margin-left: 32px;
        position:relative;
        border-radius: 4px;
        -moz-border-radius: 4px;
        -webkit-border-radius: 4px;
        box-shadow: 0px 0px 8px -1px black;
        -moz-box-shadow: 0px 0px 8px -1px black;
        -webkit-box-shadow: 0px 0px 8px -1px black;
    }
    
    #toolTip p {
        padding:10px;
    }
    
    #tailShadow {
        background-color: transparent;
        width: 4px;
        height: 4px;
        position: absolute;
        top: 16px;
        left: -8px;
        z-index: -10;
        box-shadow: 0px 0px 8px 1px black;
        -moz-box-shadow: 0px 0px 8px 1px black;
        -webkit-box-shadow: 0px 0px 8px 1px black;
    }
    
    #tail1 {
        width: 0px;
        height: 0px;
        border: 10px solid;
        border-color: transparent #73a7f0 transparent transparent;
        position:absolute;
        top: 8px;
        left: -20px;
    }
    
    #tail2 {
        width: 0px;
        height: 0px;
        border: 10px solid;
        border-color: transparent #ffffff transparent transparent;
        position:absolute;
        left: -18px;
        top: 8px;
    }

----------


  [1]: http://i.stack.imgur.com/zRBKQ.png



How can I create a &quot;tooltip tail&quot; using pure CSS?

What is the purpose of those command line options? Please help to decipher the meaning of the following command line:

    -Wl,--start-group -lmy_lib -lyour_lib -lhis_lib -Wl,--end-group -ltheir_lib

Apparently it has something to do with linking, but the GNU manual is quiet what exactly grouping means.

What are the --start-group and --end-group command line options?

What is the purpose of those command line options? Please help to decipher the meaning of the following command line:
<pre><code class="hljs language-vbnet">-Wl,--start-group -lmy_lib -lyour_lib -lhis_lib -Wl,--end-group -ltheir_lib
</code></pre>
Apparently it has something to do with linking, but the GNU manual is quiet what exactly grouping means.

Is gcc C compiler written in C itself ? Or is it written in Assembly ? If the compiler is written in C, then what is the compiler used to compile the compiler code ?


Is gcc C compiler written in C itself?

Is there any difference between `uint` and `unsigned int`?

I&#39;m looking in this site, but all questions refer to C# or C++.
I&#39;d like an answer about the C language.

If it is relevant, note that I&#39;m using GCC under Linux.

Difference between uint and unsigned int?

I am using opensuse, specific the variant on [mono&#39;s website when you click vmware](http://www.go-mono.com/mono-downloads/download.html)

I get this error. Does anyone know how i might fix it?

    make[4]: Entering directory `/home/rupert/Desktop/llvm/tools/clang/tools/driver&#39;
    llvm[4]: Linking Debug+Asserts executable clang
    collect2: ld terminated with signal 9 [Killed]
    make[4]: *** [/home/rupert/Desktop/llvm/Debug+Asserts/bin/clang] Error 1

The full text can be found [here](http://www.pastie.org/1798986)

Why is the linker terminating on me? when i build CLang

I have a question concerning llvm, clang, and gcc on OS X. 

What is the difference between the llvm-gcc 4.2, llvm 2.0 and clang? I know that they all build on llvm but how are they different? 

Besides faster compiling, what is the advantage of llvm over gcc?

LLVM vs clang on OS X

For this code:

    class B1{
    public:  
      virtual void f1() {}  
    };
     
    class D : public B1 {
    public:
      void f1() {}
    };
    
    int main () {
    	B1 *b1 = new B1();
    	D  *d  = new D();
    	
    	return 0;
    }

After compilation, the vtable I get with `g++ -fdump-class-hierarchy` is:

    Vtable for B1
    B1::_ZTV2B1: 3u entries
    0     (int (*)(...))0
    8     (int (*)(...))(&amp; _ZTI2B1)
    16    B1::f1
    
   
    Vtable for D
    D::_ZTV1D: 3u entries
    0     (int (*)(...))0
    8     (int (*)(...))(&amp; _ZTI1D)
    16    D::f1
   
I failed to understand what do the entries like *(int (*)(...))0* correspond to. Of course it means something like, it is a function which returns an int and takes unlimited number of arguments, I don&#39;t understand anything further.
To which function does this function pointer correspond to? and how do you know that? Mine is a 64 bit machine.

The second function pointer has an address associated at end?? To whom does that correspond to?

*EDIT*

The compiler, I use is g++:

    g++ -v
    Using built-in specs.
    Target: x86_64-suse-linux
    Configured with: ../configure --prefix=/usr --infodir=/usr/share/info --mandir=/usr/share/man --libdir=/usr/lib64 --libexecdir=/usr/lib64 --enable-languages=c,c++,objc,fortran,obj-c++,java,ada --enable-checking=release --with-gxx-include-dir=/usr/include/c++/4.4 --enable-ssp --disable-libssp --with-bugurl=http://bugs.opensuse.org/ --with-pkgversion=&#39;SUSE Linux&#39; --disable-libgcj --disable-libmudflap --with-slibdir=/lib64 --with-system-zlib --enable-__cxa_atexit --enable-libstdcxx-allocator=new --disable-libstdcxx-pch --enable-version-specific-runtime-libs --program-suffix=-4.4 --enable-linux-futex --without-system-libunwind --with-arch-32=i586 --with-tune=generic --build=x86_64-suse-linux
    Thread model: posix
    *gcc version 4.4.1 [gcc-4_4-branch revision 150839] (SUSE Linux)*



What is the first (int (*)(...))0 vtable entry in the output of g++ -fdump-class-hierarchy?

In the file `file1.c`, there is a call to a function that is implemented in the file `file2.c`.
When I link `file1.o` and `file2.o` into an executable, if the function in `file2` is very small, will the linker automatically detect that the function is small and inline its call?



Can the linker inline functions?

Got the following error when I tried to compile a C application in 64-bit FreeBSD:

&gt; relocation R_X86_64_32S can not be used when making a shared object; recompile with -fPIC

What is `R_X86_64_32S` relocation and what is `R_X86_64_64`?

I&#39;ve googled about the error, and it&#39;s possible causes - It&#39;d be great if anyone could tell what R_X86_64_32S really means.


What do R_X86_64_32S and R_X86_64_64 relocation mean?

Even trivially small Haskell programs turn into gigantic executables. 

I&#39;ve written a small program, that was compiled (with GHC) to the binary with the size extending 7 MB! 

What can cause even a small Haskell program to be compiled to the huge binary?

What, if anything, can I do to reduce this?



Small Haskell program compiled with GHC into huge binary

How does the compilation and linking process work?  

_&lt;sub&gt;
(Note: This is meant to be an entry to [Stack Overflow&#39;s C++ FAQ](https://stackoverflow.com/questions/tagged/c++-faq). If you want to critique the idea of providing an FAQ in this form, then [the posting on meta that started all this](https://meta.stackexchange.com/questions/68647/setting-up-a-faq-for-the-c-tag) would be the place to do that. Answers to that question are monitored in the [C++ chatroom](https://chat.stackoverflow.com/rooms/10/c-lounge), where the FAQ idea started out in the first place, so your answer is very likely to get read by those who came up with the idea.)
&lt;/sub&gt;_

How does the compilation/linking process work?

Sorry that there are many similar questions, but I do find that Googling for CMake queries always yields similar-but-not-the-same scenarios, conflicting CMake commands and so on!

I need to force my project to build 32-bit binaries because I have to link with a library which is only available as 32-bit.  I diagnosed this based on error messages such as:

    /usr/bin/ld: i386 architecture of input file `*external-32bit-lib*&#39; is incompatible with i386:x86-64 output

From what I gather, I should therefore use:

    set (CMAKE_CXX_FLAGS &quot;-m32&quot;)

This does change things - I now get several errors like:

    /usr/bin/ld: i386 architecture of input file `*project-output-lib*&#39; is incompatible with i386:x86-64 output

AND still get the same errors for the external library too.  I *think* this is because the `-m32` made gcc generate 32-bit binaries, but ld is still trying for 64-bit output?  Further Googling for this problem didn&#39;t give any success, so if anyone could verify that I am right and give the correct way of doing this, I would be very grateful!

Many thanks!

The proper way of forcing a 32-bit compile using CMake

I set the CFLAGS in CMake by CMAKE_C_FLAGS.
Is something like this to set LDFLAGS?

How to set the LDFLAGS in CMakeLists.txt?

I have a virtual Debian system which I use to develop.

Today I wanted to try llvm/clang.

After installing clang I can&#39;t compile my old c-projects (with gcc).
This is the error:

    ...
    /usr/bin/ld: cannot find crt1.o: No such file or directory
    /usr/bin/ld: cannot find crti.o: No such file or directory
    collect2: ld returned 1 exit status
    ...

I uninstalled clang and it still did not work.

Does anyone have any idea how I can fix this?

Compiling problems: cannot find crt1.o

For convenience I added the relevant manpages below. 

My (mis)understanding first: If I need to separate options with `,`, that means that the second `-Wl` is not another option because it comes before `,` which means it is an argument to the `-rpath` option. 

I don&#39;t understand how `-rpath` can have a `-Wl,.` argument! 

What would make sense in my mind would be this:

    -Wl,-rpath .

This should invoke `-rpath` linker option with the current directory argument.

---------------
man gcc:

&gt; -Wl,option 
&gt; 
&gt; Pass option as an option to the
&gt; linker. If option contains commas, it
&gt; is split into multiple options at the
&gt; commas. You can use this syntax to
&gt; pass an argument to the option. For
&gt; example, `-Wl,-Map,output.map` passes
&gt; `-Map output.map` to the linker. When
&gt; using the GNU linker, you can also get
&gt; the same effect with
&gt; `-Wl,-Map=output.map&#39;.

 

man ld:

&gt; -rpath=dir 

&gt; Add a directory to the
&gt; runtime library search path. This is
&gt; used when linking an ELF executable
&gt; with shared objects. All -rpath
&gt; arguments are concatenated and passed
&gt; to the runtime linker, which uses them
&gt; to locate shared objects at runtime.
&gt; The -rpath option is also used when
&gt; locating shared objects which are
&gt; needed by shared objects explicitly
&gt; included in the link;

I don&#39;t understand -Wl,-rpath -Wl,

I need to optimize the size of my executable severely (`ARM` development) and
I noticed that in my current build scheme (`gcc` + `ld`) unused symbols are not getting stripped.

The usage of the `arm-strip --strip-unneeded` for the resulting executables / libraries doesn&#39;t change the output size of the executable *(I have no idea why, maybe it simply can&#39;t)*.

What would be the way *(if it exists)* to modify my building pipeline, so that the unused symbols are stripped from the resulting file?

----------

I wouldn&#39;t even think of this, but my current embedded environment isn&#39;t very &quot;powerful&quot; and 
saving even `500K` out of `2M` results in a very nice loading performance boost.

**Update:**

Unfortunately the current `gcc` version I use doesn&#39;t have the `-dead-strip` option and the `-ffunction-sections... + --gc-sections` for `ld` doesn&#39;t give any significant difference for the resulting output.

*I&#39;m shocked that this even became a problem, because I was sure that `gcc + ld` should automatically strip unused symbols (why do they even have to keep them?).*


Content Type	Original Author	Original Content on Stackoverflow
Question	pic11	View Question on Stackoverflow
Solution 1 - Gcc	osgx	View Answer on Stackoverflow

What are the --start-group and --end-group command line options?

Gcc Problem Overview

Gcc Solutions

Solution 1 - Gcc

How can I create a "tooltip tail" using pure CSS?

How to check if a deque is empty

Attributions