Toolchains have a loose name convention like `arch[-vendor][-os]-abi`.

 - `arch` is for architecture: **arm**, **mips**, **x86**, **i686**...
 - `vendor` is tool chain supplier: **apple**, 
 - `os` is for operating system: **linux**, **none** (bare metal)
 - `abi` is for application binary interface convention: **eabi**, **gnueabi**, **gnueabihf**

For your question, `arm-none-linux-gnueabi` and `arm-linux-gnueabi` is same thing. `arm-linux-gcc` is actually binary for gcc which produces objects for ARM architecture to be run on Linux with default configuration (abi) provided by toolchain.

Some nice reading: [Toolchains](http://web.eecs.umich.edu/~prabal/teaching/eecs373-f12/notes/notes-toolchain.pdf).

In my code I had the following validation with Shoulda matchers, which works fine:

    it { should validate_presence_of(:name) }

In my model, I&#39;ve added the condition to my validation:

    validates_presence_of :name, :if =&gt; eligible?

Is it possible to reflect it in the validations?

I&#39;ve tried looking at [documentation][1] for shoulda matchers, but haven&#39;t been able to locate the solution.

Many thanks!


  [1]: https://github.com/thoughtbot/shoulda-matchers

Shoulda/RSpec matchers - conditional validation

I came across this JSON code. I noticed that it makes use of `undefined` value. Where can I find more information about this value type?

      tracks:[
         (         {
            codec:&quot;h264&quot;,
            language:undefined,
            id:1,
            bitrate:785236,
            content:&quot;video&quot;
         }         ),
         (         {
            codec:&quot;aac&quot;,
            language:undefined,
            id:2,
            bitrate:75969,
            content:&quot;audio&quot;
         }         )
      ],

JSON undefined value type

What is the difference between arm-linux-gcc and arm-none-linux-gnueabi and arm-linux-gnueabi
toolchains?

Do they compile differently? 

What is the difference between arm-linux-gcc and arm-none-linux-gnueabi

<p>What is the difference between arm-linux-gcc and arm-none-linux-gnueabi and arm-linux-gnueabi
toolchains?</p>
<p>Do they compile differently?</p>


I was trying to reinstall my ffmpeg, following this [guide][1], on my ARM Ubuntu machine. Unfortunately, when I compile a program which uses this lib I get the following failure:

    /usr/bin/ld: /usr/local/lib/libavcodec.a(amrnbdec.o): relocation R_ARM_MOVW_ABS_NC against `a local symbol&#39; can not be used when making a shared object; recompile with -fPIC
    /usr/local/lib/libavcodec.a: could not read symbols: Bad value
    collect2: ld returned 1 exit status

Now I would like to recompile it with `-fPIC` like the compiler is suggesting but I have no idea how. Any help is appreciated. 

  [1]: https://ffmpeg.org/trac/ffmpeg/wiki/UbuntuCompilationGuide

How to recompile with -fPIC

So, I had this code:

    constexpr unsigned N = 1000;
    void f1(char* sum, char* a, char* b) {
        for(int i = 0; i &lt; N; ++i) {
            sum[i] = a[i] + b[i];
        }
    }
    
    void f2(char* sum, char* a, char* b) {
        char* end = sum + N;
        while(sum != end) {
            *sum++ = *a++ + *b++;
        }
    }

I wanted to see the code that GCC 4.7.2 would generate. So I ran `g++ -march=native -O3 -masm=intel -S a.c++ -std=c++11` And got the following output:

            .file   &quot;a.c++&quot;
            .intel_syntax noprefix
            .text
            .p2align 4,,15
            .globl  _Z2f1PcS_S_
            .type   _Z2f1PcS_S_, @function
    _Z2f1PcS_S_:
    .LFB0:
            .cfi_startproc
            lea     rcx, [rdx+16]
            lea     rax, [rdi+16]
            cmp     rdi, rcx
            setae   r8b
            cmp     rdx, rax
            setae   cl
            or      cl, r8b
            je      .L5
            lea     rcx, [rsi+16]
            cmp     rdi, rcx
            setae   cl
            cmp     rsi, rax
            setae   al
            or      cl, al
            je      .L5
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L3:
            movdqu  xmm0, XMMWORD PTR [rdx+rax]
            movdqu  xmm1, XMMWORD PTR [rsi+rax]
            paddb   xmm0, xmm1
            movdqu  XMMWORD PTR [rdi+rax], xmm0
            add     rax, 16
            cmp     rax, 992
            jne     .L3
            mov     ax, 8
            mov     r9d, 992
    .L2:
            sub     eax, 1
            lea     rcx, [rdx+r9]
            add     rdi, r9
            lea     r8, [rax+1]
            add     rsi, r9
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L4:
            movzx   edx, BYTE PTR [rcx+rax]
            add     dl, BYTE PTR [rsi+rax]
            mov     BYTE PTR [rdi+rax], dl
            add     rax, 1
            cmp     rax, r8
            jne     .L4
            rep
            ret
    .L5:
            mov     eax, 1000
            xor     r9d, r9d
            jmp     .L2
            .cfi_endproc
    .LFE0:
            .size   _Z2f1PcS_S_, .-_Z2f1PcS_S_
            .p2align 4,,15
            .globl  _Z2f2PcS_S_
            .type   _Z2f2PcS_S_, @function
    _Z2f2PcS_S_:
    .LFB1:
            .cfi_startproc
            lea     rcx, [rdx+16]
            lea     rax, [rdi+16]
            cmp     rdi, rcx
            setae   r8b
            cmp     rdx, rax
            setae   cl
            or      cl, r8b
            je      .L19
            lea     rcx, [rsi+16]
            cmp     rdi, rcx
            setae   cl
            cmp     rsi, rax
            setae   al
            or      cl, al
            je      .L19
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L17:
            movdqu  xmm0, XMMWORD PTR [rdx+rax]
            movdqu  xmm1, XMMWORD PTR [rsi+rax]
            paddb   xmm0, xmm1
            movdqu  XMMWORD PTR [rdi+rax], xmm0
            add     rax, 16
            cmp     rax, 992
            jne     .L17
            add     rdi, 992
            add     rsi, 992
            add     rdx, 992
            mov     r8d, 8
    .L16:
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L18:
            movzx   ecx, BYTE PTR [rdx+rax]
            add     cl, BYTE PTR [rsi+rax]
            mov     BYTE PTR [rdi+rax], cl
            add     rax, 1
            cmp     rax, r8
            jne     .L18
            rep
            ret
    .L19:
            mov     r8d, 1000
            jmp     .L16
            .cfi_endproc
    .LFE1:
            .size   _Z2f2PcS_S_, .-_Z2f2PcS_S_
            .ident  &quot;GCC: (GNU) 4.7.2&quot;
            .section        .note.GNU-stack,&quot;&quot;,@progbits

I suck at reading assembly, so I decided to add some markers to know where the bodies of the loops went:

    constexpr unsigned N = 1000;
    void f1(char* sum, char* a, char* b) {
        for(int i = 0; i &lt; N; ++i) {
            asm(&quot;# im in ur loop&quot;);
            sum[i] = a[i] + b[i];
        }
    }
    
    void f2(char* sum, char* a, char* b) {
        char* end = sum + N;
        while(sum != end) {
            asm(&quot;# im in ur loop&quot;);
            *sum++ = *a++ + *b++;
        }
    }

And GCC spat this out:

        .file   &quot;a.c++&quot;
        .intel_syntax noprefix
        .text
        .p2align 4,,15
        .globl  _Z2f1PcS_S_
        .type   _Z2f1PcS_S_, @function
    _Z2f1PcS_S_:
    .LFB0:
        .cfi_startproc
        xor eax, eax
        .p2align 4,,10
        .p2align 3
    .L2:
    #APP
    # 4 &quot;a.c++&quot; 1
        # im in ur loop
    # 0 &quot;&quot; 2
    #NO_APP
        movzx   ecx, BYTE PTR [rdx+rax]
        add cl, BYTE PTR [rsi+rax]
        mov BYTE PTR [rdi+rax], cl
        add rax, 1
        cmp rax, 1000
        jne .L2
        rep
        ret
        .cfi_endproc
    .LFE0:
        .size   _Z2f1PcS_S_, .-_Z2f1PcS_S_
        .p2align 4,,15
        .globl  _Z2f2PcS_S_
        .type   _Z2f2PcS_S_, @function
    _Z2f2PcS_S_:
    .LFB1:
        .cfi_startproc
        xor eax, eax
        .p2align 4,,10
        .p2align 3
    .L6:
    #APP
    # 12 &quot;a.c++&quot; 1
        # im in ur loop
    # 0 &quot;&quot; 2
    #NO_APP
        movzx   ecx, BYTE PTR [rdx+rax]
        add cl, BYTE PTR [rsi+rax]
        mov BYTE PTR [rdi+rax], cl
        add rax, 1
        cmp rax, 1000
        jne .L6
        rep
        ret
        .cfi_endproc
    .LFE1:
        .size   _Z2f2PcS_S_, .-_Z2f2PcS_S_
        .ident  &quot;GCC: (GNU) 4.7.2&quot;
        .section    .note.GNU-stack,&quot;&quot;,@progbits

This is considerably shorter, and has some significant differences like the lack of SIMD instructions. I was expecting the same output, with some comments somewhere in the middle of it. Am I making some wrong assumption here? Is GCC&#39;s optimizer hindered by asm comments?

Why does adding inline assembly comments cause such radical change in GCC&#39;s generated code?

Do standard C library implementations, especially **glibc** (the GNU C Library) provide linked lists, stack et al. data structures, or do we have to roll our own?


Thanks.

Does standard c library provides linked list etc. data structures?

I was trying to compile [this example program][1] using GCC (tested versions 4.5.1, 4.6.3, 4.8.4):

    #include &lt;iostream&gt;
    #include &lt;iomanip&gt;
    #include &lt;ctime&gt;
    #include &lt;chrono&gt;
     
    using std::chrono::system_clock;
     
    int main()
    {
        system_clock::time_point now = system_clock::now();
        std::time_t now_c = system_clock::to_time_t(
                                now - std::chrono::hours(24));
        std::cout &lt;&lt; &quot;One day ago, the time was &quot;
                  &lt;&lt; std::put_time(std::localtime(&amp;now_c), &quot;%F %T&quot;) &lt;&lt; &#39;\n&#39;;
    }

[But it tells me:][2]

    prog.cpp: In function &#39;int main()&#39;:
    prog.cpp:14:18: error: &#39;put_time&#39; is not a member of &#39;std&#39;

---

I thought, probably it&#39;s not implemented yet. So I tried to check the implementation status for this function. I only found this page:

 * http://gcc.gnu.org/projects/cxx0x.html

but there I could not find any note on `put_time` or `chrono` or alike. Can anyone point me to a resource that provides information on the implementation status for this library?

  [1]: http://en.cppreference.com/w/cpp/chrono/time_point
  [2]: http://ideone.com/XR1eF4

std::put_time implementation status in GCC?

I get `Illegal Instruction: 4` errors with binaries compiled with GCC 4.7.2 under Mac OS X 10.8.2 (&quot;Mountain Lion&quot;), when those binaries are run under Mac OS X 10.7.x (&quot;Lion&quot;) and earlier versions. The binaries work properly under Mac OS X 10.8.x.

I added `-mmacosx-version-min=10.5` to my compile flags and this seems to help resolve the issue for 10.5.x, 10.6.x and 10.7.x clients, whatever that issue is. 

Which gets to my question(s):

 * What is the `Illegal Instruction: 4` error?
 * Why does `-mmacosx-version-min=10.x` fix this specific error on `10.x` and greater clients?

I&#39;d like to apply this fix to my makefiles, but would like to know what it is doing before I pull the trigger. (Will I have larger binaries? Do I still have 64-bit binaries? Are there gotchas with this approach I should know about? Unintended side-effects? Etc.)

What is the &quot;Illegal Instruction: 4&quot; error and why does &quot;-mmacosx-version-min=10.x&quot; fix it?

Is the x86 Architecture specially designed to work with a keyboard while ARM expects to be mobile? What are the key differences between the two?

How does the ARM architecture differ from x86?

What basically `__asm__ __volatile__ ()` does and what is significance of `&quot;memory&quot;` for ARM architecture?


Working of __asm__ __volatile__ (&quot;&quot; : : : &quot;memory&quot;)

I am attempting to get cross-compiling for Raspberry Pi working on my Ubuntu machine. 

During my initial attempts I was using the arm-linux-gnueabi compiler, which is available in the Ubuntu repo. I got this working. I was able to build all my dependencies and use the cross-compiler in my cmake project.

However, I believe I should be using the hf version, so I switched to arm-linux-gnueabihf. Then I realized that this does not work with Raspberry Pi since it is armv6.

After some Googling, I then found the [pre-built toolchain from GitHub][1].

I downloaded the toolchain, but I don&#39;t really understand how to &quot;install&quot; it. I extracted the files to my home directory. The directory structure looks like this:

    /gcc-linearo-arm-linux-gnueabihf-raspbian
        /arm-linux-gnueabihf
            /bin
                (contains g++, gcc, etc)
            /lib
                (contains libstdc++ library)
        /bin
            (contains arm-linux-gnueabihf-g++, arm-linux-gnueabihf-...)
        /lib
            (gcc lib stuff)
       

If I change directory to the INNER bin folder I am able to compile a test program from the terminal without any problems.

    ~/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/
    arm-linux-gnueabihf/bin$ g++ test.cpp -o test

I then tried to compile a test program in the OUTER bin folder, which contains the prefixed versions of the tools.

     ~/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin$ 
     arm-linux-gnueabihf-g++ test.cpp -o test

However, when I try to use the compiler now (from outside the inner bin directory), it is unable to find the libstdc++ shared library that comes with the toolchain:

    arm-linux-gnueabihf-gcc: error while loading shared libraries: 
    libstdc++.so.6: cannot open shared object file: No such file or directory.

Furthermore, I want to be able to use the compiler without having to navigate to the bin directory. So I tried adding the OUTER bin directory (since I want the prefixed versions) and both lib directories to my PATH:

    export PATH=$PATH:~/tools/.../bin
    export PATH=$PATH:~/tools/.../lib
    export PATH=$PATH:~/tools/.../.../lib

However, this results in the same error. How should I &quot;install&quot; the toolchain so that I can use the toolchain from everywhere, just like I can when I use the cross-compilers from the Ubuntu repo?


  [1]: https://github.com/raspberrypi/tools

How to install the Raspberry Pi cross compiler on my Linux host machine?

I&#39;m new to the field of microcontrollers. I need to port an IDE which is compiling programs for AVR microcontrollers to compile programs for ARM microcontrollers. I have just replaced the compiler from AVR to ARM and added some options as told by someone.
The following is the command:

    \ARM-GCC\bin\arm-none-eabi-gcc -O0 -ffunction-sections -Wall -std=gnu99 -mfloat-abi=soft 
    -Wa,-adhlns=&quot;$@.lst&quot; -fmessage-length=0 -mcpu=cortex-m0 -mthumb -g3 -gdwarf-2 -Wl,
    --gc-sections -o &lt;Dir_name&gt;\Build_Files\Blink_arm.cpp.elf  &lt;Dir_name&gt;\Build_Files\Blink_arm.cpp.o &lt;Dir_name&gt;\Build_Files\core.a 
    -L&lt;Dir_name&gt;\Build_Files -lm 


When I execute it I get the follwing error:

    tools/arm-gcc/bin/../lib/gcc/arm-none-eabi/4.6.2\libc.a(lib_a-exit.o): In function `exit&#39;:
    exit.c:(.text+0x18): undefined reference to `_exit&#39;  
    collect2: ld returned 1 exit status

May I get some help on what is this error and how can I solve it. And also I don&#39;t know what those options in the command line specify.

exit.c:(.text+0x18): undefined reference to `_exit&#39; when using arm-none-eabi-gcc

I have an embedded application with a time-critical ISR that needs to iterate through an array of size 256 (preferably 1024, but 256 is the minimum) and check if a value matches the arrays contents. A `bool` will be set to true is this is the case.

The microcontroller is an NXP LPC4357, ARM Cortex M4 core, and the compiler is GCC. I already have combined optimisation level 2 (3 is slower) and placing the function in RAM instead of flash. I also use pointer arithmetic and a `for` loop, which does down-counting instead of up (checking if `i!=0` is faster than checking if `i&lt;256`). All in all, I end up with a duration of 12.5&amp;nbsp;&#181;s which has to be reduced drastically to be feasible. This is the (pseudo) code I use now:

    uint32_t i;
    uint32_t *array_ptr = &amp;theArray[0];
    uint32_t compareVal = 0x1234ABCD;
    bool validFlag = false;

    for (i=256; i!=0; i--)
    {
        if (compareVal == *array_ptr++)
        {
             validFlag = true;
             break;
         }
    }

What would be the absolute fastest way to do this? Using inline assembly is allowed. Other &#39;less elegant&#39; tricks are also allowed.


Content Type	Original Author	Original Content on Stackoverflow
Question	user1891109	View Question on Stackoverflow
Solution 1 - Gcc	auselen	View Answer on Stackoverflow

What is the difference between arm-linux-gcc and arm-none-linux-gnueabi

Gcc Problem Overview

Gcc Solutions

Solution 1 - Gcc

JSON undefined value type

Shoulda/RSpec matchers - conditional validation

Attributions