This happens when compiling a file with `arm-none-eabi-gcc` in one machine/architecture to load it in an ARM target machine. Most probably you are not making use of semihosting, you want to retarget.

ARM&#174; Compiler toolchain Version 4.1 indicates:
&gt; Semihosting is a mechanism that enables code running on an ARM target to communicate and
&gt; use the Input/Output facilities on a host computer that is running a debugger.

From the toolchain&#39;s readme.txt (under folder `.../gcc-arm-none-eabi-VERSION/share/doc/gcc-arm-none-eabi`):

&gt;** non-semihosting/retarget

&gt; If you are using retarget, linking like:
&gt; $ arm-none-eabi-gcc --specs=nosys.specs $(OTHER_LINK_OPTIONS)

For me `--specs=nosys.specs` was enough ;)

Use `--specs=nosys.specs`:

    arm-none-eabi-gcc --specs=nosys.specs $(OTHER_LINK_OPTIONS)

Reference:

 * [ARM Options][1]
 * [GNU Tools for ARM Embedded Processors][2]


  [1]: http://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html
  [2]: https://launchpadlibrarian.net/170926122/readme.txt

I had the same problem.
The solution was as follows:

 - Add options `-ffreestanding -flto` into compiler call line. 
 - And add options `-flto -ffreestanding -nostdlib` into linker call line.

Can an Android device act as an iBeacon and figure out when other Android devices come in its range? Do those other Android devices need to have Bluetooth turned on?

If a customer comes into my shop and he doesn&#39;t have my app installed on his device, can iBeacon work, or must he install the app first? There are so many customers are visiting our shop daily, but if they don&#39;t have my app installed, does the iBeacon concept work?

Can an Android device act as an iBeacon?

I&#39;m attempting to capture arrow key presses in jQuery, but no events are being triggered.

    $(function(){
    	$(&#39;html&#39;).keypress(function(e){
    		console.log(e);
    	});
    });

This generates events for alphanumeric keys, but delete, arrow keys, etc generate no event.

What am I doing wrong to not be capturing those?

jQuery Keypress Arrow Keys

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'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:
<pre><code class="hljs language-ini">\ARM-GCC\bin\arm-none-eabi-gcc -O0 -ffunction-sections -Wall -std=gnu99 -mfloat-abi=soft 
-Wa,-adhlns="$@.lst" -fmessage-length=0 -mcpu=cortex-m0 -mthumb -g3 -gdwarf-2 -Wl,
--gc-sections -o &#x3C;Dir_name>\Build_Files\Blink_arm.cpp.elf &#x3C;Dir_name>\Build_Files\Blink_arm.cpp.o &#x3C;Dir_name>\Build_Files\core.a 
-L&#x3C;Dir_name>\Build_Files -lm 
</code></pre>
When I execute it I get the follwing error:
<pre><code class="hljs language-vbnet">tools/arm-gcc/bin/../lib/gcc/arm-none-eabi/4.6.2\libc.a(lib_a-exit.o): In function `exit':
exit.c:(.text+0x18): undefined reference to `_exit' 
collect2: ld returned 1 exit status
</code></pre>
May I get some help on what is this error and how can I solve it. And also I don't know what those options in the command line specify.

I have the easiest code ever:

    #include &lt;iostream&gt;
    #include &lt;thread&gt;
    
    void worker()
    {
        std::cout &lt;&lt; &quot;another thread&quot;;
    }
    
    int main()
    {
    	std::thread t(worker);
    	std::cout &lt;&lt; &quot;main thread&quot; &lt;&lt; std::endl;
    	t.join();
        return 0;
    }

though I still cannot compile it with `g++` to run.

More details:

    $ g++ --version
    g++ (Ubuntu/Linaro 4.8.1-10ubuntu8) 4.8.1
    Copyright (C) 2013 Free Software Foundation, Inc.
    This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Command to compile:

    $ g++ main.cpp -o main.out -pthread -std=c++11

Running:

    $ ./main.out 
    terminate called after throwing an instance of &#39;std::system_error&#39;
      what():  Enable multithreading to use std::thread: Operation not permitted
    Aborted (core dumped)

And now I&#39;m in stuck. In every related thread over the internet it&#39;s recommended to add `-pthread` while I have it already.

What am I doing wrong?

PS: It&#39;s a brand new ubuntu 13.10 installation. Only `g++` package was installed and minor things like `chromium` etc

PPS:

    $ ldd ./a.out 
    linux-vdso.so.1 =&gt; (0x00007fff29fc1000) 
    libstdc++.so.6 =&gt; /usr/lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007fb85397d000) 
    libgcc_s.so.1 =&gt; /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007fb853767000) 
    libc.so.6 =&gt; /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb85339e000) 
    libm.so.6 =&gt; /lib/x86_64-linux-gnu/libm.so.6 (0x00007fb85309a000) 
    /lib64/ld-linux-x86-64.so.2 (0x00007fb853c96000)

PPPS: with `clang++` (v3.2) it compiles and runs fine

PPPPS: guys, it&#39;s not a duplicate of https://stackoverflow.com/questions/8649828/what-is-wrong-with-this-use-of-stdthread

PPPPPS:

    $ dpkg --get-selections | grep &#39;libc.*dev&#39;
    libc-dev-bin					install
    libc6-dev:amd64					install
    libclang-common-dev				install
    linux-libc-dev:amd64				install

Compiling multithread code with g++

I first noticed in 2009 that GCC (at least on my projects and on my machines) have the tendency to generate noticeably faster code if I optimize for **size** (`-Os`) instead of speed (`-O2` or `-O3`), and I have been wondering ever since why.

I have managed to create (rather silly) code that shows this surprising behavior and is sufficiently small to be posted here.

    const int LOOP_BOUND = 200000000;

    __attribute__((noinline))
    static int add(const int&amp; x, const int&amp; y) {
        return x + y;
    }

    __attribute__((noinline))
    static int work(int xval, int yval) {
        int sum(0);
        for (int i=0; i&lt;LOOP_BOUND; ++i) {
            int x(xval+sum);
            int y(yval+sum);
            int z = add(x, y);
            sum += z;
        }
        return sum;
    }

    int main(int , char* argv[]) {
        int result = work(*argv[1], *argv[2]);
        return result;
    }

If I compile it with `-Os`, it takes 0.38&amp;nbsp;s to execute this program, and 0.44&amp;nbsp;s if it is compiled with `-O2` or `-O3`. These times are obtained consistently and with practically no noise (gcc 4.7.2, x86_64 GNU/Linux, Intel Core i5-3320M).

*(Update: I have moved all assembly code to [GitHub][1]: They made the post bloated and apparently add very little value to the questions as the `fno-align-*` flags have the same effect.)*

Here is the generated assembly with [`-Os`][2] and [`-O2`][3].

Unfortunately, my understanding of assembly is very limited, so I have no idea whether what I did next was correct: I grabbed the assembly for `-O2` and merged all its differences into the assembly for `-Os` *except* the `.p2align` lines, result [here][4]. This code still runs in 0.38s and **the only difference is the** `.p2align` **stuff.**

If I guess correctly, these are paddings for stack alignment. According to [Why does GCC pad functions with NOPs?](https://stackoverflow.com/q/7912464/341970) it is done in the hope that the code will run faster, but apparently this optimization backfired in my case.

**Is it the padding that is the culprit in this case? Why and how?**

The noise it makes pretty much makes timing micro-optimizations impossible.

**How can I make sure that such accidental lucky / unlucky alignments are not interfering when I do micro-optimizations (unrelated to stack alignment) on C or C++ source code?**

---

**UPDATE:**

Following [Pascal Cuoq&#39;s answer][5] I tinkered a little bit with the alignments. By passing `-O2 -fno-align-functions -fno-align-loops` to gcc, all `.p2align` are gone from the assembly and the generated executable runs in 0.38s. According to the [gcc documentation](http://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html):

&gt; -Os enables all -O2 optimizations [but] -Os disables the following optimization flags:
&gt;
&gt;       -falign-functions  -falign-jumps  -falign-loops
&gt;       -falign-labels  -freorder-blocks  -freorder-blocks-and-partition
&gt;       -fprefetch-loop-arrays

**So, it pretty much seems like a (mis)alignment issue.**

I am still skeptical about `-march=native` as suggested in [Marat Dukhan&#39;s answer][6]. I am not convinced that it isn&#39;t just interfering with this (mis)alignment issue; it has absolutely no effect on my machine. (Nevertheless, I upvoted his answer.)

---

**UPDATE 2:**

**We can take `-Os` out of the picture.** The following times are obtained by compiling with

 - `-O2 -fno-omit-frame-pointer` 0.37s

 - `-O2 -fno-align-functions -fno-align-loops` 0.37s

 - `-S -O2` then manually moving the assembly of `add()` after `work()` 0.37s

 - `-O2` 0.44s

It looks like to me the distance of `add()` from the call site matters a lot. I have tried `perf`, but the output of `perf stat` and `perf report` makes very little sense to me. However, I could only get one consistent result out of it:

`-O2`:

     602,312,864 stalled-cycles-frontend   #    0.00% frontend cycles idle
           3,318 cache-misses
     0.432703993 seconds time elapsed
     [...]
     81.23%  a.out  a.out              [.] work(int, int)
     18.50%  a.out  a.out              [.] add(int const&amp;, int const&amp;) [clone .isra.0]
     [...]
           &#166;   __attribute__((noinline))
           &#166;   static int add(const int&amp; x, const int&amp; y) {
           &#166;       return x + y;
    100.00 &#166;     lea    (%rdi,%rsi,1),%eax
           &#166;   }
           &#166;   ? retq
    [...]
           &#166;            int z = add(x, y);
      1.93 &#166;    ? callq  add(int const&amp;, int const&amp;) [clone .isra.0]
           &#166;            sum += z;
     79.79 &#166;      add    %eax,%ebx

For `fno-align-*`:

     604,072,552 stalled-cycles-frontend   #    0.00% frontend cycles idle
           9,508 cache-misses
     0.375681928 seconds time elapsed
     [...]
     82.58%  a.out  a.out              [.] work(int, int)
     16.83%  a.out  a.out              [.] add(int const&amp;, int const&amp;) [clone .isra.0]
     [...]
           &#166;   __attribute__((noinline))
           &#166;   static int add(const int&amp; x, const int&amp; y) {
           &#166;       return x + y;
     51.59 &#166;     lea    (%rdi,%rsi,1),%eax
           &#166;   }
    [...]
           &#166;    __attribute__((noinline))
           &#166;    static int work(int xval, int yval) {
           &#166;        int sum(0);
           &#166;        for (int i=0; i&lt;LOOP_BOUND; ++i) {
           &#166;            int x(xval+sum);
      8.20 &#166;      lea    0x0(%r13,%rbx,1),%edi
           &#166;            int y(yval+sum);
           &#166;            int z = add(x, y);
     35.34 &#166;    ? callq  add(int const&amp;, int const&amp;) [clone .isra.0]
           &#166;            sum += z;
     39.48 &#166;      add    %eax,%ebx
           &#166;    }

For `-fno-omit-frame-pointer`:

     404,625,639 stalled-cycles-frontend   #    0.00% frontend cycles idle
          10,514 cache-misses
     0.375445137 seconds time elapsed
     [...]
     75.35%  a.out  a.out              [.] add(int const&amp;, int const&amp;) [clone .isra.0]                                                                                     &#166;
     24.46%  a.out  a.out              [.] work(int, int)
     [...]
           &#166;   __attribute__((noinline))
           &#166;   static int add(const int&amp; x, const int&amp; y) {
     18.67 &#166;     push   %rbp
           &#166;       return x + y;
     18.49 &#166;     lea    (%rdi,%rsi,1),%eax
           &#166;   const int LOOP_BOUND = 200000000;
           &#166;
           &#166;   __attribute__((noinline))
           &#166;   static int add(const int&amp; x, const int&amp; y) {
           &#166;     mov    %rsp,%rbp
           &#166;       return x + y;
           &#166;   }
     12.71 &#166;     pop    %rbp
           &#166;   ? retq
     [...]
           &#166;            int z = add(x, y);
           &#166;    ? callq  add(int const&amp;, int const&amp;) [clone .isra.0]
           &#166;            sum += z;
     29.83 &#166;      add    %eax,%ebx

It looks like we are stalling on the call to `add()` in the slow case.

I have examined *everything* that `perf -e` can spit out on my machine; not just the stats that are given above.

For the same executable, the `stalled-cycles-frontend` shows linear correlation with the execution time; I did not notice anything else that would correlate so clearly. (Comparing `stalled-cycles-frontend` for different executables doesn&#39;t make sense to me.)

I included the cache misses as it came up as the first comment. I examined all the cache misses that can be measured on my machine by `perf`, not just the ones given above. The cache misses are very very noisy and show little to no correlation with the execution times.

  [1]: http://en.wikipedia.org/wiki/GitHub
  [2]: https://gist.github.com/baharev/7069582#file-os
  [3]: https://gist.github.com/baharev/7069582#file-o2
  [4]: https://gist.github.com/baharev/7069582#file-o2merged
  [5]: https://stackoverflow.com/a/19471213/341970
  [6]: https://stackoverflow.com/a/19471823/341970


Why does GCC generate 15-20% faster code if I optimize for size instead of speed?

I just noticed that after installing OS X 10.9, the g++ compiler links to the clang compiler. Is there anyway to revert back to gcc/g++?

OS X 10.9 gcc links to clang

According to [this][1] movie (around minute 38), if I have two functions with the same local vars, they will use the same space. So the following program, should print `5`. Compiling it with `gcc` results `-1218960859`. why?

The program:

    #include &lt;stdio.h&gt;
    
    void A()
    {
    	int a;
    	printf(&quot;%i&quot;,a);
    }
    
    void B()
    {
    	int a;
    	a = 5;
    }
    
    int main()
    {
    	B();
    	A();
    	return 0;
    }

as requested, here is the output from the disassembler:

    0804840c &lt;A&gt;:
     804840c:	55                   	push   ebp
     804840d:	89 e5                	mov    ebp,esp
     804840f:	83 ec 28             	sub    esp,0x28
     8048412:	8b 45 f4             	mov    eax,DWORD PTR [ebp-0xc]
     8048415:	89 44 24 04          	mov    DWORD PTR [esp+0x4],eax
     8048419:	c7 04 24 e8 84 04 08 	mov    DWORD PTR [esp],0x80484e8
     8048420:	e8 cb fe ff ff       	call   80482f0 &lt;printf@plt&gt;
     8048425:	c9                   	leave  
     8048426:	c3                   	ret    
    
    08048427 &lt;B&gt;:
     8048427:	55                   	push   ebp
     8048428:	89 e5                	mov    ebp,esp
     804842a:	83 ec 10             	sub    esp,0x10
     804842d:	c7 45 fc 05 00 00 00 	mov    DWORD PTR [ebp-0x4],0x5
     8048434:	c9                   	leave  
     8048435:	c3                   	ret    
    
    08048436 &lt;main&gt;:
     8048436:	55                   	push   ebp
     8048437:	89 e5                	mov    ebp,esp
     8048439:	83 e4 f0             	and    esp,0xfffffff0
     804843c:	e8 e6 ff ff ff       	call   8048427 &lt;B&gt;
     8048441:	e8 c6 ff ff ff       	call   804840c &lt;A&gt;
     8048446:	b8 00 00 00 00       	mov    eax,0x0
     804844b:	c9                   	leave  
     804844c:	c3                   	ret    
     804844d:	66 90                	xchg   ax,ax
     804844f:	90                   	nop

  [1]: http://www.youtube.com/watch?v=1nYDflSL0Mg

Conflict between a Stanford tutorial and GCC

I&#39;m trying to compile a program in C on OS X 10.9 with GCC 4.9 (experimental). For some reason, I&#39;m getting the following error at compile time:

&lt;!-- language: none --&gt;

    gcc: fatal error: stdio.h: No such file or directory

I then tried a simple Hello World program:

&lt;!-- language: c --&gt;

    #include &lt;stdio.h&gt;
    
    int main(int argc, const char *argv[])
    {
        printf(&quot;Hello, world!&quot;);
        return 0;
    }

Again, upon running `gcc -o ~/hello ~/hello.c`, I got the same error. I&#39;m using an experimental version of `gcc`, but it seems implausible that there would be a release which generated errors upon importing `stdio`. What could be causing this issue, and how can it be fixed?

GCC fatal error: stdio.h: No such file or directory

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.


Quickly find whether a value is present in a C array?

What is the difference between arm-eabi, gnueabi and gnueabi-hf cross compilers?
I am kind of finding it difficult to choose the executable that is correct for my target platform.
Is there a native compiler for arm?

Difference between arm-eabi arm-gnueabi and gnueabi-hf compilers

*Update 2017-05-17. I no longer work for the company where this question originated, and do not have access to Delphi XEx. While I was there, the problem was solved by migrating to mixed FPC+GCC (Pascal+C), with NEON intrinsics for some routines where it made a difference. (FPC+GCC is highly recommended also because it enables using standard tools, particularly Valgrind.) If someone can demonstrate, with credible examples, how they are actually able to produce optimized ARM code from Delphi XEx, I&#39;m happy to accept the answer.*

______


Embarcadero&#39;s Delphi compilers use an LLVM backend to produce native ARM code for Android devices. I have large amounts of Pascal code that I need to compile into Android applications and I would like to know how to make Delphi generate more efficient code. Right now, I&#39;m not even talking about advanced features like automatic SIMD optimizations, just about producing reasonable code. Surely there must be a way to pass parameters to the LLVM side, or somehow affect the result? Usually, any compiler will have many options to affect code compilation and optimization, but Delphi&#39;s ARM targets seem to be just &quot;optimization on/off&quot; and that&#39;s it.

LLVM is supposed to be capable of producing reasonably tight and sensible code, but it seems that Delphi is using its facilities in a weird way. Delphi wants to use the stack very heavily, and it generally only utilizes the processor&#39;s registers r0-r3 as temporary variables. Perhaps the craziest of all, it seems to be loading normal 32 bit integers as four 1-byte load operations. How to make Delphi produce better ARM code, and without the byte-by-byte hassle it is making for Android? 

At first I thought the byte-by-byte loading was for swapping byte order from big-endian, but that was not the case, it is really just loading a 32 bit number with 4 single-byte loads.*  It might be to load the full 32 bits without doing an unaligned word-sized memory load. (whether it SHOULD avoid that is another thing, which would hint to the whole thing being a compiler bug)*

Let&#39;s look at this simple function:

&lt;!-- language: lang-pascal --&gt;
    
    function ReadInteger(APInteger : PInteger) : Integer;
    begin
      Result := APInteger^;
    end;

Even with optimizations switched on, Delphi XE7 with update pack 1, as well as XE6, produce the following ARM assembly code for that function:

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text._ZN16Uarmcodetestform11ReadIntegerEPi:
    
    00000000 &lt;_ZN16Uarmcodetestform11ReadIntegerEPi&gt;:
       0:	b580      	push	{r7, lr}
       2:	466f      	mov	r7, sp
       4:	b083      	sub	sp, #12
       6:	9002      	str	r0, [sp, #8]
       8:	78c1      	ldrb	r1, [r0, #3]
       a:	7882      	ldrb	r2, [r0, #2]
       c:	ea42 2101 	orr.w	r1, r2, r1, lsl #8
      10:	7842      	ldrb	r2, [r0, #1]
      12:	7803      	ldrb	r3, [r0, #0]
      14:	ea43 2202 	orr.w	r2, r3, r2, lsl #8
      18:	ea42 4101 	orr.w	r1, r2, r1, lsl #16
      1c:	9101      	str	r1, [sp, #4]
      1e:	9000      	str	r0, [sp, #0]
      20:	4608      	mov	r0, r1
      22:	b003      	add	sp, #12
      24:	bd80      	pop	{r7, pc}


Just count the number of instructions and memory accesses Delphi needs for that. And constructing a 32 bit integer from 4 single-byte loads... If I change the function a little bit and use a var parameter instead of a pointer, it is slightly less convoluted:

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text._ZN16Uarmcodetestform14ReadIntegerVarERi:
    
    00000000 &lt;_ZN16Uarmcodetestform14ReadIntegerVarERi&gt;:
       0:	b580      	push	{r7, lr}
       2:	466f      	mov	r7, sp
       4:	b083      	sub	sp, #12
       6:	9002      	str	r0, [sp, #8]
       8:	6801      	ldr	r1, [r0, #0]
       a:	9101      	str	r1, [sp, #4]
       c:	9000      	str	r0, [sp, #0]
       e:	4608      	mov	r0, r1
      10:	b003      	add	sp, #12
      12:	bd80      	pop	{r7, pc}

I won&#39;t include the disassembly here, but for iOS, Delphi produces identical code for the pointer and var parameter versions, and they are almost but not exactly the same as the Android var parameter version. 
*Edit: to clarify, the byte-by-byte loading is only on Android. And only on Android, the pointer and var parameter versions differ from each other. On iOS both versions generate exactly the same code.*

For comparison, here&#39;s what FPC 2.7.1 (SVN trunk version from March 2014) thinks of the function with optimization level -O2. The pointer and var parameter versions are exactly the same.

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text.n_p$armcodetest_$$_readinteger$pinteger$$longint:

    00000000 &lt;P$ARMCODETEST_$$_READINTEGER$PINTEGER$$LONGINT&gt;:
    
       0:	6800      	ldr	r0, [r0, #0]
       2:	46f7      	mov	pc, lr

I also tested an equivalent C function with the C compiler that comes with the Android NDK.

&lt;!-- language: lang-c --&gt;

    int ReadInteger(int *APInteger)
    {
    	return *APInteger;
    }

And this compiles into essentially the same thing FPC made:

&lt;!-- language: lang-asm --&gt;
    
    Disassembly of section .text._Z11ReadIntegerPi:
    
    00000000 &lt;_Z11ReadIntegerPi&gt;:
       0:	6800      	ldr	r0, [r0, #0]
       2:	4770      	bx	lr

How to affect Delphi XEx code generation for Android/ARM targets?

I am a bit confused about instruction sets. There are Thumb, ARM and Thumb 2. From what I have read Thumb instructions are all 16-bit but inside the **ARMv7M user manual** (page vi) there are Thumb 16-bit and Thumb 32-bit instructions mentioned. 

Now I have to overcome this confusion. It is said that Thumb 2 supports 16-bit and 32-bit instructions. So is ARMv7M in fact supporting Thumb 2 instructions and not just Thumb?  

One more thing. Can I say that Thumb (32-bit) is the same as ARM instructions which are allso 32-bit?

What is the difference between the ARM, Thumb and Thumb 2 instruction encodings?

I&#39;m new to Android Studio. My computer doesn&#39;t support HAXM so it won&#39;t let me install that to use for virtualization. In some similar questions on this website people mention setting up a virtual device with an ARM instead of HAXM. How can I do this? 

In the AVD manager all of the premade hardware profiles use HAXM, and when I click &quot;New Hardware Profile&quot; I don&#39;t see any option to use ARM. I looked in the SDK Manager and for API 22 I have installed &quot;ARM EABI v7a System Image&quot; and &quot;Google APIs ARM EABI v7a System Image&quot;, are those what I need? 

How can I create a custom virtual phone with ARM, or is there a way I can use one of the preexisting hardware devices with ARM instead of HAXM?

Content Type	Original Author	Original Content on Stackoverflow
Question	Sharath U	View Question on Stackoverflow
Solution 1 - Gcc	Calamar	View Answer on Stackoverflow
Solution 2 - Gcc	ele1000	View Answer on Stackoverflow
Solution 3 - Gcc	User Human	View Answer on Stackoverflow

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

Gcc Problem Overview

Gcc Solutions

Solution 1 - Gcc

Solution 2 - Gcc

Solution 3 - Gcc

jQuery Keypress Arrow Keys

Can an Android device act as an iBeacon?

Attributions