I&#39;m not completely sure: 

 - the eabi stands for the compilation of code which will run on bare metal arm core.
 - the gnueabi stands for the compilation of code for linux

For the gnueabi/gnueabi-hf part, I found an answer [here][1].

&gt;gcc-arm-linux-gnueabi is the cross-toolchain package for the armel architecture. This toolchain implies the EABI generated by gcc&#39;s -mfloat-abi=soft or -mfloat-abi=softfp options.
&gt;
&gt;gcc-arm-linux-gnueabihf is the cross-toolchain package for the armhf architecture. This toolchain implies the EABI generated by the gcc -mfloat-abi=hard option. 


  [1]: http://nairobi-embedded.org/050_linaro_arm_toolchain.html

&#39;hf&#39; means hard-float which indicates that the compiler and its underlying libraries are using hardware floating point instructions rather than a software implementation of floating point such as fixed point software implementations.
The &#39;eabi&#39; refers to what the underlying binary is going to look like.
It can be argued that these can be achieved with flags to gcc but the issue is that of bare metal pre-compiled libraries. Unless you are recompiling everything from source, it may not be feasible to use gcc with flags alone. Even in that case you might have to carefully configure each package or library with the appropriate compile options.

**UPDATE July 2020:**

`dplyr` 1.0 has changed pretty much everything about this question as well as all of the answers. See the `dplyr` programming vignette here:

https://cran.r-project.org/web/packages/dplyr/vignettes/programming.html

The new way to refer to columns when their identifier is stored as a character vector is to use the `.data` pronoun from `rlang`, and then subset as you would in base R. 

```
library(dplyr)

key &lt;- &quot;v3&quot;
val &lt;- &quot;v2&quot;
drp &lt;- &quot;v1&quot;

df &lt;- tibble(v1 = 1:5, v2 = 6:10, v3 = c(rep(&quot;A&quot;, 3), rep(&quot;B&quot;, 2)))

df %&gt;% 
    select(-matches(drp)) %&gt;% 
    group_by(.data[[key]]) %&gt;% 
    summarise(total = sum(.data[[val]], na.rm = TRUE))

#&gt; `summarise()` ungrouping output (override with `.groups` argument)
#&gt; # A tibble: 2 x 2
#&gt;   v3    total
#&gt;   &lt;chr&gt; &lt;int&gt;
#&gt; 1 A        21
#&gt; 2 B        19

```

If your code is in a package function, you can `@importFrom rlang .data` to avoid R check notes about undefined globals. 

**ORIGINAL QUESTION:**

I want to refer to an unknown column name inside a `summarise`. The standard evaluation functions introduced in `dplyr 0.3` allow column names to be referenced using variables, but this doesn&#39;t appear to work when you call a `base` R function within e.g. a `summarise`. 

    library(dplyr)
     
    key &lt;- &quot;v3&quot;
    val &lt;- &quot;v2&quot;
    drp &lt;- &quot;v1&quot;
     
    df &lt;- data_frame(v1 = 1:5, v2 = 6:10, v3 = c(rep(&quot;A&quot;, 3), rep(&quot;B&quot;, 2)))
 
The df looks like this:

    &gt; df
    Source: local data frame [5 x 3]
    
      v1 v2 v3
    1  1  6  A
    2  2  7  A
    3  3  8  A
    4  4  9  B
    5  5 10  B

I want to drop v1, group by v3, and sum v2 for each group:

    df %&gt;% select(-matches(drp)) %&gt;% group_by_(key) %&gt;% summarise_(sum(val, na.rm = TRUE))

    Error in sum(val, na.rm = TRUE) : invalid &#39;type&#39; (character) of argument

The NSE version of `select()` works fine, since it can match a character string. The SE version of `group_by()` works fine, since it can now accept variables as arguments and evaluate them. However, I haven&#39;t found a way to achieve similar results when using base R functions inside `dplyr` functions. 

Things that don&#39;t work:

    df %&gt;% group_by_(key) %&gt;% summarise_(sum(get(val), na.rm = TRUE))
    Error in get(val) : object &#39;v2&#39; not found

    df %&gt;% group_by_(key) %&gt;% summarise_(sum(eval(as.symbol(val)), na.rm = TRUE))
    Error in eval(expr, envir, enclos) : object &#39;v2&#39; not found

I&#39;ve checked out [several][1] [related][2] [questions][3], but none of the proposed solutions have worked for me so far. 


  [1]: https://stackoverflow.com/questions/21208801/group-by-multiple-columns-in-dplyr-using-string-vector-input
  [2]: https://stackoverflow.com/questions/21390141/specify-dplyr-column-names
  [3]: https://stackoverflow.com/questions/26492280/non-standard-evaluation-nse-in-dplyrs-filter-pulling-data-from-mysql

standard evaluation in dplyr: summarise a variable given as a character string

I am novice in OpenCV. Recently, I have troubles finding OpenCV functions to convert from Mat to Array. I researched with .ptr and .at methods available in OpenCV APIs, but I could not get proper data. I would like to have direct conversion from Mat to Array(if available, if not to Vector). I need OpenCV functions because the code has to be undergo high level synthesis in Vivado HLS. Please help. 

Convert Mat to Array/Vector in OpenCV

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

<p>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?</p>


Why does this program print “forked!” 4 times?

    #include &lt;stdio.h&gt;
    #include &lt;unistd.h&gt;

    int main(void) {

      fork() &amp;&amp; (fork() || fork());

      printf(&quot;forked!\n&quot;);
      return 0;
    }

Why does this program print &quot;forked!&quot; 4 times?

While I was playing around in my shell investigating the answer to [this question][1], I noticed that, even though `/bin/sh` was pointing to `/bin/bash` on my system, the two commands behave differently.  First of all, the output of

    ls -lh /bin/sh

is:

    lrwxrwxrwx 1 root root 4 Apr 22  2013 /bin/sh -&gt; bash*

However, invoking the following command through `/bin/sh`:

    /bin/sh -c &quot;script.sh 2&gt; &gt;( grep -v FILTER 2&gt;&amp;1 )&quot;

returns this error:

    /bin/sh: -c: line 0: syntax error near unexpected token &#39;&gt;&#39;
    /bin/sh: -c: line 0: &#39;script.sh 2&gt; &gt;( grep -v FILTER 2&gt;&amp;1 )&#39;

While running the same command through `/bin/bash`:

    /bin/bash -c &quot;script.sh 2&gt; &gt;( grep -v FILTER 2&gt;&amp;1 )&quot;

executes successfully, here is the output:

    This should be on stderr

For reference, here is the contents of `script.sh`:

    #!/bin/sh
    echo &quot;FILTER: This should be filtered out&quot; 1&gt;&amp;2
    echo &quot;This should be on stderr&quot; 1&gt;&amp;2
    echo &quot;FILTER: This should be filtered out&quot; 1&gt;&amp;2

Why do the two invocations behave differently?

  [1]: https://stackoverflow.com/questions/26707034/redirect-stderr-through-grep-v-in-lsf-batch-job




Why does /bin/sh behave differently to /bin/bash even if one points to the other?

Yesterday, I wrote and ran a python `script` which executes a `shell` using `subprocess.Popen(command.split())` where command is string which constitutes `.sh` script and its argument. This script was working fine until yesterday. Today, I ran the same script and now I am continuously hitting this error.

    p=subprocess.Popen(shell_command.split())
    File &quot;/usr/lib/python2.7/subprocess.py&quot;, line 679, in __init__
    errread, errwrite)
    File &quot;/usr/lib/python2.7/subprocess.py&quot;, line 1249, in _execute_child
    raise child_exception
    OSError: [Errno 8] Exec format error
   
I know there are similar questions that have been asked before related to this question, but in my case I tried everything which doesn&#39;t solve my purpose. Using `shell=True` does not work because my shell script calls an another shell script before which some environment has to be set in order to run that script. I am badly stuck in this. I just restart my system once. I am using `ubuntu 12.04`

**EDIT:**
     
     import subprocess
     import os
     import sys

     arg1=sys.argv[1]
     arg2=sys.argve[2]

     shell_command = &#39;my_path/my_shell.sh &#39; + arg1 + &#39; &#39;+ arg2
     P = subprocess.Popen(shell_command.split())
     P.wait()

**my_shell.sh:**

      arg1=$1
      arg2=$2

      cd $TOP
      setup the environment and run shell script
      build the kernel ...
      execute shell command .....

subprocess.Popen(): OSError: [Errno 8] Exec format error in python?

I need to find the OS name and version on Unix/Linux platform. For this I tried following:

1. `lsb_release` utility

2. `/etc/redhat-release` or specific file

But it does not seem to be best solution as LSB_RELEASE support is no longer for RHEL 7.

Is there any way that will work on any Unix or Linux platform?

Best way to find os name and version in Unix/Linux platform

I searched a lot of topic about &quot;user-data script is not working&quot; in these few days, but until now, I haven&#39;t gotten any idea about my case yet, please help me to figure out what happened, thanks a lot!

According to AWS [User-data](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) explanation:
&gt; When you launch an instance in Amazon EC2, you have the option of passing user data to the instance that can be used to perform common automated configuration tasks and even run scripts after the instance starts.

So I tried to pass my own user-data when instance launch, this is my user-data:

    \#!/bin/bash

    echo &#39;test&#39; &gt; /home/ec2-user/user-script-output.txt

But there is no file in this path: `/home/ec2-user/user-script-output.txt`

I checked `/var/lib/cloud/instance/user-data.txt`, the file is exist and same as my user-data script.

Also I checked the log in `/var/log/cloud-init.log`, there is no error message.

But the user-data script is working if I launch an new instance with Amazon linux(2014.09.01), but I&#39;m not sure what difference between my AMI (based on Amazon linux) and Amazon linux.

The only different part I saw is if I run this script:

    sudo yum list installed | grep cloud-init

My AMI:
&gt; cloud-init.noarch                    0.7.2-8.33.amzn1              @amzn-main 

Amazon linux:
&gt; cloud-init.noarch                     0.7.2-8.33.amzn1             installed    

I&#39;m not sure this is the reason?

If you need more information, I&#39;m glad to provide, please let me know what happened in my own AMI and how to fix it?

many thanks

**Update**

Just found an answer from this [post](https://stackoverflow.com/questions/25497689/how-to-make-ec2-user-data-work-on-freshly-built-ami-made-with-packer),

If I add #cloud-boothook in the top of user-data file, it works!

    #cloud-boothook
    #!/bin/bash
    echo &#39;test&#39; &gt; /home/ec2-user/user-script-output.txt
But still not sure why.

User-data scripts is not running on my custom AMI, but working in standard Amazon linux

I am working on a project that has been built with both gcc and msvc so far. We recently started building with clang as well.

There are some parts in the code, where platform-specific things are done:

    #ifndef _WIN32
    // ignore this in msvc
    #endif

Since gcc has previously been the only non-windows build, this was equivalent to saying &quot;do this only for gcc&quot;. But now it means &quot;do this only for gcc and clang&quot;.

However there are still situations, where I would like to handle something specifically for gcc, and not for clang. Is there a simple and robust way to detect gcc, i.e.

    #ifdef ???
    // do this *only* for gcc
    #endif

Detect gcc as opposed to msvc / clang with macro

Shall this be the example:

    #include &lt;iostream&gt;
    using namespace std;

    int main()
    {
        cout &lt;&lt; &quot;Hola, moondo.\n&quot;;
    }

It throws the error:

```lang-none
gcc -c main.cpp gcc -o edit main.o  main.o: In function `main&#39;:
main.cpp:(.text+0xa): undefined reference to `std::cout&#39;
main.cpp:(.text+0xf): undefined reference to `std::basic_ostream&lt;char,std::char_traits&lt;char&gt; &gt;&amp; std::operator&lt;&lt; &lt;std::char_traits&lt;char&gt;&gt;(std::basic_ostream&lt;char, std::char_traits&lt;char&gt; &gt;&amp;, char const*)&#39;
main.o: In function `__static_initialization_and_destruction_0(int,int)&#39;:
main.cpp:(.text+0x3d): undefined reference to `std::ios_base::Init::Init()&#39;
main.cpp:(.text+0x4c): undefined reference to `std::ios_base::Init::~Init()&#39; collect2: error: ld
returned 1 exit status make: *** [qs] Error 1
```

Also, this example:

    #include &lt;iostream&gt;

    int main()
    {
        std::cout &lt;&lt; &quot;Hola, moondo.\n&quot;;
    }

throws the error:

```lang-none
gcc -c main.cpp gcc -o edit main.o  main.o: In function `main&#39;:
main.cpp:(.text+0xa): undefined reference to `std::cout&#39;
main.cpp:(.text+0xf): undefined reference to `std::basic_ostream&lt;char,std::char_traits&lt;char&gt; &gt;&amp; std::operator&lt;&lt;&lt;std::char_traits&lt;char&gt;&gt;(std::basic_ostream&lt;char,std::char_traits&lt;char&gt; &gt;&amp;, char const*)&#39;
main.o: In function `__static_initialization_and_destruction_0(int,int)&#39;: main.cpp:(.text+0x3d): undefined reference to `std::ios_base::Init::Init()&#39;
main.cpp:(.text+0x4c): undefined reference to `std::ios_base::Init::~Init()&#39; collect2: error: ld
returned 1 exit status make: *** [qs] Error 1
```

Note: I am using [Debian 7][1] (Wheezy).

  [1]: https://en.wikipedia.org/wiki/Debian_version_history#Debian_7_(Wheezy)






Error &quot;undefined reference to &#39;std::cout&#39;&quot;

After experiencing crashes when introducing nested calls of std::async in my real program, I was able to reproduce the problem in the following **minimum example**. It crashes often, but not always. Do you see anything what goes wrong, or is it a compiler or standard library bug? Note that the problem remains if `get()` calls to the futures are added.

    #include &lt;future&gt;
    #include &lt;vector&gt;
    
    int main (int, char *[])
    {
        std::vector&lt;std::future&lt;void&gt;&gt; v;
        v.reserve(100);
        for (int i = 0; i != 100; ++i)
        {
            v.emplace_back(std::async(std::launch::async, [] () {
                std::async(std::launch::async, [] { });
            }));
        }

        return 0;
    }


**I observe two different kinds of crashes:** (in about every fifth run)

 - Termination with *&quot;This application has requested the Runtime to terminate it in an unusual way.&quot;*
 - Termination after throwing an instance of *&#39;std::future_error&#39;, what():  Promise already satisfied*.


**Environment:**

 - Windows 7
 - gcc version 4.8.2 (i686-posix-dwarf-rev3, Built by
   MinGW-W64 project), as provided by Qt 5.3.2
 - Command line call: `g++ -std=c++11 -pthread futures.cpp`
 - Compiled and run on two independent machines

**Option `-pthread`?**
Could it be that in my environment for some reason the option `-pthread` is silently not taken into account? I observe the same behavior with and without that option.


Using C++11 futures: Nested calls of std::async crash: Compiler/Standard library bug?

I&#39;m trying to optimize some matrix computations and I was wondering if it was possible to detect at compile-time if SSE/SSE2/AVX/AVX2/AVX-512/AVX-128-FMA/KCVI&lt;sup&gt;[1]&lt;/sup&gt; is enabled by the compiler ? Ideally for GCC and Clang, but I can manage with only one of them. 

I&#39;m not sure it is possible and perhaps I will use my own macro, but I&#39;d prefer detecting it rather and asking the user to select it. 

---

&lt;sup&gt;[1]&lt;/sup&gt; &quot;KCVI&quot; stands for Knights Corner Vector Instruction optimizations. Libraries like FFTW detect/utilize these newer instruction optimizations.

How to detect SSE/SSE2/AVX/AVX2/AVX-512/AVX-128-FMA/KCVI availability at compile-time?

The following code produces the subsequent compilation error on all versions of GCC that I&#39;ve tried, in C++98, C++11 and C++14 modes:

    struct T
    {
        T(void* x) : (x) {}
    };
    
    // main.cpp: In constructor &#39;T::T(void*)&#39;:
    // main.cpp:3:18: error: anachronistic old-style base class initializer [-fpermissive]
    //      T(void* x) : (x) {}
    //                   ^
    // main.cpp:3:16: error: unnamed initializer for &#39;T&#39;, which has no base classes
    //      T(void* x) : (x) {}

Sure, it&#39;s clearly broken code because I&#39;m not actually initialising anything.

**But why is it a base-class initialiser and why is it &quot;anachronistic&quot;, rather than simply wrong? Was it once valid? When? And what did it mean?**

---

The [only rel](http://studiofreya.com/2014/02/27/error-anachronistic-old-style-base-class-initializer/)[ated references](https://www.allegro.cc/forums/thread/274361) I&#39;ve found to this on the web have been people coming across the error when a member name was accidentally macro&#39;d out, effectively resulting in the same code as above:

    #define bar
    // ^ some library could have done this
    
    struct T
    {
        T(int x)
            : bar(x)   // effectively just `: (x)`
        {}
        
        int bar;       // will cause its own error
    };

Those people never did find out what the error meant, although they later at least discovered why their program was broken.

error: anachronistic old-style base class initializer

I&#39;m receiving the following warning from mongodb about THP

    2015-03-06T21:01:15.526-0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is &#39;always&#39;.
    2015-03-06T21:01:15.526-0800 I CONTROL  [initandlisten] **        We suggest setting it to &#39;never&#39;

But I did manage to turned THP off manually

    frederick@UbuntuVirtual:~$ cat /sys/kernel/mm/transparent_hugepage/enabled
    always madvise [never]
    frederick@UbuntuVirtual:~$ cat /sys/kernel/mm/transparent_hugepage/defrag
    always madvise [never]

I did the trick by adding `transparent_hugepage=never` to `GRUB_CMDLINE_LINUX_DEFAULT` in `/etc/default/grub` and adding

    if test -f /sys/kernel/mm/transparent_hugepage/defrag; then
       echo never &gt; /sys/kernel/mm/transparent_hugepage/defrag
    fi

to `/etc/rc.local`

How on earth can I avoid the warning?

How to avoid transparent_hugepage/defrag warning from mongodb?

How can docker run on a Debian host maybe an OpenSUSE in a container? It uses different kernel, with separated modules. Also older Debian versions have used older kernels, so how can run it on a kernel version 3.10+ ? Older kernels have only older built in functions, how can an old distro manage new features?
What is &quot;the trick&quot; in it?

How can Docker run distros with different kernels?

`ip link` shows this:

    [root@0-25-90-68-79-4a log]# ip link
    1: lo: &lt;LOOPBACK,UP,LOWER_UP&gt; mtu 65536 qdisc noqueue state UNKNOWN 
        link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    2: eth0: &lt;BROADCAST,MULTICAST,SLAVE,UP,LOWER_UP&gt; mtu 1500 qdisc mq master bond0 state UP qlen 1000
        link/ether 00:25:90:68:79:4a brd ff:ff:ff:ff:ff:ff
    5: bond0: &lt;BROADCAST,MULTICAST,MASTER,UP,LOWER_UP&gt; mtu 1500 qdisc noqueue state UP 
        link/ether 00:25:90:68:79:4a brd ff:ff:ff:ff:ff:ff
    8: gre0: &lt;NOARP&gt; mtu 1476 qdisc noop state DOWN 
        link/gre 0.0.0.0 brd 0.0.0.0
    10: 35978f0: &lt;BROADCAST,MULTICAST,UP,LOWER_UP&gt; mtu 1500 qdisc pfifo_fast master br35978f0 state UP qlen 32
        link/ether fe:ff:ff:ff:ff:ff brd ff:ff:ff:ff:ff:ff
    13: br35978f0: &lt;BROADCAST,MULTICAST,UP,LOWER_UP&gt; mtu 1500 qdisc noqueue state UP 
        link/ether fe:ff:ff:ff:ff:ff brd ff:ff:ff:ff:ff:ff

Here, the interface **35978f0** is the virtual interface which is tied to the bridge **br 35978f0**. I&#39;ve already done `ifconfig 35978f0 down` and `brctl delif br35978f0 35978f0`.

But how do I delete interface **35978f0**?


How do I delete virtual interface in Linux?

If I am running a container in privileged mode, does it have all the Kernel capabilities or do I need to add them separately?

Privileged containers and capabilities

TL;DR: **If the Linux kernel loses a buffered I/O write**, is there any way for the application to find out?

**I know you have to `fsync()` the file (and its parent directory) for durability**. The question is *if the kernel loses dirty buffers that are pending write* due to an I/O error, how can the application detect this and recover or abort?

Think database applications, etc, where order of writes and write durability can be crucial.

Lost writes? How?
---

The Linux kernel&#39;s block layer can under some circumstances *lose* buffered I/O requests that have been submitted successfully by `write()`, `pwrite()` etc, with an error like:

    Buffer I/O error on device dm-0, logical block 12345
    lost page write due to I/O error on dm-0

(See [`end_buffer_write_sync(...)` and `end_buffer_async_write(...)` in `fs/buffer.c`](http://lxr.free-electrons.com/source/fs/buffer.c?v=2.6.26#L445)).

[On newer kernels the error will instead contain &quot;lost async page write&quot;](http://lxr.free-electrons.com/source/fs/buffer.c?v=4.9#L353), like:

    Buffer I/O error on dev dm-0, logical block 12345, lost async page write

Since the application&#39;s `write()` will have already returned without error, there seems to be no way to report an error back to the application.

Detecting them?
---

I&#39;m not that familiar with the kernel sources, but I *think* that it sets `AS_EIO` on the buffer that failed to be written-out if it&#39;s doing an async write:

        set_bit(AS_EIO, &amp;page-&gt;mapping-&gt;flags);
        set_buffer_write_io_error(bh);
        clear_buffer_uptodate(bh);
        SetPageError(page);

but it&#39;s unclear to me if or how the application can find out about this when it later `fsync()`s the file to confirm it&#39;s on disk.

It looks like [`wait_on_page_writeback_range(...)` in `mm/filemap.c`](http://lxr.free-electrons.com/source/mm/filemap.c?v=2.6.26#L267) might by [`do_sync_mapping_range(...)` in `fs/sync.c`](http://lxr.free-electrons.com/source/fs/sync.c?v=2.6.26#L250) which is turn called by [`sys_sync_file_range(...)`](http://lxr.free-electrons.com/source/fs/sync.c?v=2.6.26#L177). It returns `-EIO` if one or more buffers could not be written.

If, as I&#39;m guessing, this propagates to `fsync()`&#39;s result, then if the app panics and bails out if it gets an I/O error from `fsync()` and knows how to re-do its work when restarted, that should be sufficient safeguard? 

There&#39;s presumably no way for the app to know *which* byte offsets in a file correspond to the lost pages so it can rewrite them if it knows how, but if the app repeats all its pending work since the last successful `fsync()` of the file, and that rewrites any dirty kernel buffers corresponding to lost writes against the file, that should clear any I/O error flags on the lost pages and allow the next `fsync()` to complete - right?

Are there then any other, harmless, circumstances where `fsync()` may return `-EIO` where bailing out and redoing work would be too drastic?

Why?
---

Of course such errors should not happen. In this case the error arose from an unfortunate interaction between the `dm-multipath` driver&#39;s defaults and the sense code used by the SAN to report failure to allocate thin-provisioned storage. But this isn&#39;t the only circumstance where they *can* happen - I&#39;ve also seen reports of it from thin provisioned LVM for example, as used by libvirt, Docker, and more. An critical application like a database should try to cope with such errors, rather than blindly carrying on as if all is well.

If the *kernel* thinks it&#39;s OK to lose writes without dying with a kernel panic, applications have to find a way to cope.

The practical impact is that I found a case where a multipath problem with a SAN caused lost writes that landed up causing database corruption because the DBMS didn&#39;t know its writes had failed. Not fun.


Writing programs to cope with I/O errors causing lost writes on Linux

*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?

Android Studio - How Can I Make an AVD With ARM Instead of HAXM?

I have two &quot;unlocked&quot; devices, an iPad mini 3, and a Galaxy Edge 6, both endowed with a terminal and a minimalistic set of unix commands. I thought both devices have arm64 processors but when I ran

    uname -a

on both devices I got the following :

for the iPad mini 3 :

    xxxxs-iPad:/var/mobile root# uname -a
    Darwin xxxx-iPad 14.0.0 Darwin Kernel Version 14.0.0: Wed Jun 24 00:50:15 PDT 2015; root:xnu-2784.30.7-30/RELEASE_ARM64_S5L8960X iPad4, **arm64**, J85mAP

for the Samsung Galaxy s6 Edge :

    u0_a203@zerolte:/ $ uname -a
    Linux localhost 3.10.61-4497415 #1 SMP PREEMPT Thu Apr 9 15:06:40 KST 2015 **aarch64** GNU/Linux

If I am not wrong, the last info in both case, J85mAP and GNU/Linux, stand for firmwares, and the antepenultimate infos, arm64 and aarch64, stand for the processors.

My questions are the following : obviously the strings &quot;arm64&quot; and &quot;aarch64&quot; are not the same, but I always thought arm64 and aarch64 were the same. (It&#39;s even told when you put the arm64 tag to a question here.)  

So, are they really identical?  

Especially, what should I worry about in case of cross-building libraries for both targets ? In fact, I have gcc 5.2.0 in mind, but maybe also lower versions. Can I just pass

    -target=arm64

or

    -target=aarch64

according to which device I target and just worry about the rest of options to configure?

**EDIT** Hum, look for this again, without success.

Differences between arm64 and aarch64

Raspberry Pi Type 3 has 64-bit CPU, but its architecture is not `arm64` but `armhf`.
What is the difference between `arm64` and `armhf`?


Content Type	Original Author	Original Content on Stackoverflow
Question	preetam	View Question on Stackoverflow
Solution 1 - Linux	Akhneyzar	View Answer on Stackoverflow

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

Linux Problem Overview

Linux Solutions

Solution 1 - Linux

Convert Mat to Array/Vector in OpenCV

standard evaluation in dplyr: summarise a variable given as a character string

Attributions