Can I pass variables to a GNU Makefile as command line arguments? In other words, I want to pass some arguments which will eventually become variables in the Makefile.

Passing additional variables from command line to make

What is the command to make [less][1] display line numbers in the left column?

  [1]: https://linux.die.net/man/1/less


How to display line numbers in &#39;less&#39; (GNU)

Is it possible to check a bash script syntax without executing it?

Using Perl, I can run `perl -c &#39;script name&#39;`. Is there any equivalent command for bash scripts?

How do I syntax check a Bash script without running it?

Today I had to use the `basename()` function, and the `man 3 basename` ([here][1]) gave me some strange message:

&gt;**Notes**
&gt;
&gt;There are two different versions of *basename()* - the **POSIX** version described above, and the **GNU version**, which one gets after  
&gt;  
&gt;`#define _GNU_SOURCE`  
&gt;`#include &lt;string.h&gt; `

I&#39;m wondering what this `#define _GNU_SOURCE` means: is it *tainting* the code I write with a GNU-related license? Or is it simply used to tell the compiler something like &quot;*Well, I know, this set of functions is not POSIX, thus not portable, but I&#39;d like to use it anyway*&quot;.

If so, why not give people different headers, instead of having to define some obscure macro to get one function implementation or the other? 

Something also bugs me: how does the compiler know which function implementation to link with the executable? Does it use this `#define` as well?

Anybody have some pointers to give me?


  [1]: http://www.kernel.org/doc/man-pages/online/pages/man3/basename.3.html#NOTES

What does &quot;#define _GNU_SOURCE&quot; imply?

There are plenty of programs out there that can create a diff patch, but I&#39;m having a heck of a time trying to apply one. I&#39;m trying to distribute a patch, and I got a question from a user about how to apply it. So I tried to figure it out on my own and found out that I have no clue, and most of the tools I can find are command-line. (I can handle a command line, but a lot of people would be lost without a nice, friendly GUI. So those are no good for this purpose.)

I tried using TortoiseSVN. I have the patch I&#39;d like to apply. I right-click on the patch, and there&#39;s an option under the TortoiseSVN submenu that says &quot;Apply patch.&quot; All it does is pull up an empty window.

So I tried hitting Open. It has two options: merge and apply unified diff. (The patch is in unified diff format, luckily.) But the apply option just plain doesn&#39;t work: It asks for the patch and a folder. Somehow it forgot to ask for the *file to apply the patch to!* So TortoiseSVN just plain doesn&#39;t work. Is there a Windows GUI-based utility that will take a patch and a file and apply it properly?

EDIT: Looking at the replies so far, it seems that Tortoise will only do it right if it&#39;s a file that&#39;s already versioned. That&#39;s not the case here. I need to be able to apply a patch to a file that did not come out of an SVN repository. I just tried using Tortoise, because I happen to know that SVN uses diffs and has to know how to both create them and apply them.


How do I apply a diff patch on Windows?

Under Mac OS 10.10.3, I installed gnu-sed by typing:

    brew install gnu-sed --default-names

When I type it again, I get the message:

gnu-sed-4.2.2 already installed

However, even after rebooting the system and restarting Terminal, I still cannot use the GNU version of sed. For example:

    echo a |&#160;sed ’s_A_X_i’

returns:
bad flag in substitution command &#39;i&#39;

What should I do to get the GNU version working?
Here are the paths in my $PATH variable.

    /Users/WN/-myUnix
    /opt/local/bin
    /opt/local/sbin
    /usr/bin
    /bin
    /usr/sbin
    /sbin
    /usr/local/bin
    /Applications/calibre.app/Contents/MacOS
    /opt/ImageMagick/bin
    /usr/texbin 

I&#39;m sorry if my question seems obvious, but I am learning shell scripting on my own and don&#39;t quite understand yet how UNIX programs are installed. Any help to use GNU compliant commands (in this case sed, but soon I&#39;ll need others as well) on my Mac without causing damage or unnecessary clutter would be greatly appreciated.

How to use GNU sed on Mac OS 10.10+, &#39;brew install --default-names&#39; no longer supported

I have a textfile, containing something like:

    12,34 EUR 
     5,67 EUR
     ...

There is one whitespace before &#39;EUR&#39; and I ignore 0,XX EUR.

I tried: 

`grep &#39;[1-9][0-9]*,[0-9]\{2\}\sEUR&#39; =&gt; didn&#39;t match !`

`grep &#39;[1-9][0-9]*,[0-9]\{2\} EUR&#39; =&gt; worked !`

`grep &#39;[1-9][0-9]*,[0-9]\{2\}\s*EUR&#39; =&gt; worked !`

`grep &#39;[1-9][0-9]*,[0-9]\{2\}\s[E]UR&#39;  =&gt; worked !`

Can somebody explain me pls, why I can&#39;t use `\s` but `\s*` and `\s[E]` matched?

OS: Ubuntu 10.04, grep v2.5



grep regex whitespace behavior

How can I compile a C++ program with the GCC compiler?

### File *info.c*

    #include&lt;iostream&gt;
    using std::cout;
    using std::endl;

    int main()
    {
       #ifdef __cplusplus
       cout &lt;&lt; &quot;C++ compiler in use and version is &quot; &lt;&lt; __cplusplus &lt;&lt; endl;
       #endif
       cout &lt;&lt;&quot;Version is &quot; &lt;&lt; __STDC_VERSION__ &lt;&lt; endl;
       cout &lt;&lt; &quot;Hi&quot; &lt;&lt; __FILE__ &lt;&lt; __LINE__ &lt;&lt; endl;
    }

And when I try to compile `info.c`:

`gcc info.C`

```lang-none
Undefined                       first referenced
 symbol                             in file
cout                                /var/tmp/ccPxLN2a.o
endl(ostream &amp;)                     /var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(ostream &amp;(*)(ostream &amp;))/var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(int)            /var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(long)           /var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(char const *)   /var/tmp/ccPxLN2a.o
ld: fatal: Symbol referencing errors. No output written to a.out
collect2: ld returned 1 exit status
```

Isn&#39;t the GCC compiler capable of compiling C++ programs?
On a related note, what is the difference between `gcc` and `g++`?




Compiling a C++ program with GCC

I&#39;m working on a backup script and want to tar up a file directory:

    tar czf ~/backup.tgz /home/username/drupal/sites/default/files

This tars it up, but when I untar the resulting file, it includes the full file structure: the files are in `home/username/drupal/sites/default/files`.

Is there a way to exclude the parent directories, so that the resulting tar just knows about the last directory (`files`)?

How do I tar a directory without retaining the directory structure?

Background: My boss has tried exporting an ASC key to me with public and private parts but whenever I get the file the private part never loads up and it won&#39;t decrypt any files.

We have tried Exporting the ASC Key using: 

- Windows Application Kleopatra 2.1 (included in gpg4win)
- Windows Application GNU Privacy Assistant (included in gpg4win) 


                Error: &quot;Decryption failed. Secret Key Not available.&quot; 

How do you properly export a secret or private asc key to decrypt gpg files? 

How to Export Private / Secret ASC Key to Decrypt GPG Files

From wiki [Executable and Linkable Format](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format):

&gt; The segments contain information that is necessary for runtime execution of the file, while sections contain important data for linking and relocation. Any byte in the entire file can be owned by at most one section, and there can be orphan bytes which are not owned by any section.

But what is the difference between section and segment? 
In an executable ELF file, does a segment contain one or more sections?

What&#39;s the difference of section and segment in ELF file format

I have a directory containing several files, some of which have spaces in their names:

    Test workspace/
    Another directory/
    file1.ext
    file2.ext
    demo 2012-03-23.odp

I use GNU&#39;s `$(wildcard)` command on this directory, and then iterate over the result using `$(foreach)`, printing everything out. Here&#39;s the code:

    FOO := $(wildcard *)
    $(info FOO = $(FOO))
    $(foreach PLACE,$(FOO),$(info PLACE = $(PLACE)))

Here&#39;s what I would expect to see printed out:

    Test workspace
    Another directory
    file1.ext
    file2.ext
    demo 2012-03-23.odp

Here&#39;s what I would actually get:

    Test
    workspace
    Another
    directory
    file1.ext
    file2.ext
    demo
    2012-03-23.odp

The latter is obviously of no use to me. The &lt;a href=&quot;http://www.gnu.org/software/make/manual/html_node/Wildcard-Function.html&quot;&gt;documentation&lt;/a&gt; for `$(wildcard)` flat-out states that it returns a &quot;space-separated list of names&quot; but completely fails to acknowledge the huge problems this raises. Nor does the &lt;a href=&quot;http://www.gnu.org/savannah-checkouts/gnu/make/manual/html_node/Foreach-Function.html&quot;&gt;documentation&lt;/a&gt; for `$(foreach)`.

Is it possible to work around this? If so, how? Renaming every file and directory to remove the spaces is not an option.

Can GNU make handle filenames with spaces?

When we debug a program using `gdb`, we usually see functions with strange names defined in `libc`(`glibc`?). My questions are:

1. Is `libc/glibc` the standard implementation of some standard C/C++ functions like `strcpy`,`strlen`,`malloc`?
2. Or, is it not only of the first usage as described above, but also an wrapper of Unix/Linux system calls like `open`,`close`,`fctl`? If so, why can&#39;t we issue syscalls directly, without `libc`?
3. Does `libc` only consist of one lib (`.a` or `.so`) file, or many lib files (in this case, `libc` is the general name of this set of libs)? Where do these lib file(s) reside?
4. What is the difference between `libc` and `glibc`?

What is the role of libc(glibc) in our linux app?

grep fails when using both --ignore-case and --only-match options.
Example:

    $ echo &quot;abc&quot; | grep -io abc
    abc
    $ echo &quot;ABC&quot; | grep -io abc
    $ 
But

    $ echo &quot;abc&quot; | grep -i abc
    abc
    $ echo &quot;ABC&quot; | grep -i abc
    ABC

According to man page:
&gt;        -o, --only-matching
&gt;               Show only the part of a matching line that matches PATTERN.
&gt;        -i, --ignore-case
&gt;               Ignore case distinctions in both the PATTERN and the input files.

Is it a bug of grep or I didn&#39;t get the map page?

I am using Mac OS X 10.6.8 and 

    $ grep --version
    grep (GNU grep) 2.5.1

Found this link: http://lists.gnu.org/archive/html/bug-gnu-utils/2003-11/msg00040.html

Of course it is possible to use workaround like `grep -o [aA][bB][cC]`, but this doesn&#39;t seem to be a good option.

grep --ignore-case --only

I am aware that on most GNU/Linux systems, GCC can be invoked by the name &quot;cc&quot; from the command line (as opposed to &quot;gcc&quot;). Is there any difference in GCC&#39;s behavior when it is invoked one way versus the other?

For example, I know that invoking GCC through the name &quot;g++&quot; instead of &quot;gcc&quot; causes GCC to behave differently (it treats .c files as C++ source and links-in the C++ standard library). Is there any similar difference in behavior between &quot;gcc&quot; versus &quot;cc&quot;?

**EDIT:** None of the answers received so far gave a *definitive* &quot;yes&quot; or &quot;no&quot; as to whether GCC will behave differently if invoked one way versus the other. However, the idea given to dive into the source to check its behavior lead me down that path. Based upon what I found there, I now believe that the answer is:

**No. GCC behaves the same regardless of whether it is called via &quot;gcc&quot; or &quot;cc&quot;**.


Invoking GCC as &quot;cc&quot; versus &quot;gcc&quot;

I&#39;ve got a makefile (developed for `gmake` on Linux) that I&#39;m attempting to port to MacOS, but it seems like `sed` doesn&#39;t want to cooperate. What I do is use `GCC` to autogenerate dependency files, and then tweak them a bit using `sed`. The relevant portion of the `makefile`:

&lt;!-- language: lang-bash --&gt;

    $(OBJ_DIR)/%.d: $(SRC_DIR)/%.cpp
      $(CPPC) -MM -MD $&lt; -o $@
      sed -i &#39;s|$.*$\.o:|$(OBJ_DIR)/\1.o $(OBJ_DIR)/\1.d $(TEST_OBJ_DIR)/\1_utest.o:|&#39; $@

While this runs with no trouble under GNU/Linux, I get errors like the following when attempting to build on MacOS:

&lt;!-- language: lang-bash --&gt;

    sed: 1: &quot;test/obj/equipmentConta ...&quot;: undefined label &#39;est/obj/equipmentContainer_utest.d&#39;
    sed: 1: &quot;test/obj/dice_utest.d&quot;: undefined label &#39;est/obj/dice_utest.d&#39;
    sed: 1: &quot;test/obj/color-string_u ...&quot;: undefined label &#39;est/obj/color-string_utest.d&#39;

It would seem like `sed` is chopping off a character, but I can&#39;t see the solution.

sed -i command for in-place editing to work with both GNU sed and BSD/OSX

I want to disable builtin rules and variables as per passing the [`-r` and `-R` options][1] to GNU make, from inside the make file. Other solutions that allow me to do this implicitly and transparently are also welcome.

I&#39;ve found [several references][2] to using [`MAKEFLAGS`][3], and had similar problems.


  [1]: http://www.gnu.org/software/make/manual/make.html#Options-Summary
  [2]: http://blog.electric-cloud.com/2009/08/19/makefile-performance-built-in-rules/#comment-219
  [3]: http://www.gnu.org/software/make/manual/make.html#Quick-Reference

Disable make builtin rules and variables from inside the make file

I&#39;m having a hard time understanding why you would need asprintf. 
Here in the manual it says

&gt; The functions `asprintf()` and `vasprintf()` are analogs of `sprintf(3)` and
&gt; `vsprintf(3)`, except that they allocate a string large enough to hold
&gt; the output including the terminating null byte, and return a pointer
&gt; to it via the first argument.  This pointer should be passed to
&gt; `free(3)` to release the allocated storage when it is no longer needed.

So here is the example that I&#39;m trying to understand:

    asprintf(&amp;buffer, &quot;/bin/echo %s is cool&quot;, getenv(&quot;USER&quot;));

What&#39;s the difference if the buffer allocates a string large enough vs saying char* = (string)

Why use asprintf() instead of sprintf()?

The standard (low-cost) way to program ARM microcontrollers is using Eclipse with a complex toolchain plugged into it. Eclipse has definitely its merits, but I&#39;d like to feel independent from this IDE. I&#39;d like to discover what happens behind the scenes when I build (compile - link - flash) my software, and when I run a debug session. To get such deeper understanding, it would be wonderful to run the whole procedure from the command line.

Note: I&#39;m using 64-bit Windows 10. But most stuff explained here also applies on Linux systems. Please open all the command terminals with admin rights. This can save you lots of problems.

**1. Building the software**

The first &#39;mission&#39; is accomplished. I am now able to compile and link my software into a binary `.bin` and a `.elf` image through the command line. The key to success was finding out where Eclipse puts its make-files for a specific project. Once you know where they are, all you&#39;ve got to do is opening a command terminal, and type the `GNU make` command.

[![enter image description here][1]][1]

You don&#39;t need Eclipse anymore for that! Especially if you can read (and understand) the makefile and tweak it to your needs when your project advances.

Note that I found the GNU tools (compiler, linker, make utility, GDB, ...) in the following folder, after installing SW4STM32 (System Workbench for STM32):

    C:\Ac6\SystemWorkbench\plugins\fr.ac6.mcu.externaltools.arm-none.win32_1.7.0.201602121829\tools\compiler\

Next I made a new folder on my harddrive and copied all these GNU tools into it:

    C:\Apps\AC6GCC
               |-&gt; arm-none-eabi
               |-&gt; bin
               &#39;-&gt; lib

And I add these entries to the &quot;Environment Path variable&quot;:

     - C:\Apps\AC6GCC\bin
     - C:\Apps\AC6GCC\lib\gcc\arm-none-eabi\5.2.1

Huray, now I got all the GNU tools up and running on my system! I put the following `build.bat` file in the same folder as the `makefile`:

    @echo off
    echo.
    echo.&quot;--------------------------------&quot;
    echo.&quot;-           BUILD              -&quot;
    echo.&quot;--------------------------------&quot;
    echo.
    
    make -j8 -f makefile all
    
    echo.

Running this bat-file should do the job! If all goes well, you get one `.bin` and one `.elf` binary file as the result of the compilation.

**2. Flashing and debugging the firmware**

The natural following step is flashing the firmware to the chip and start a debug session. In Eclipse it&#39;s just one &#39;click on a button&#39; - at least if Eclipse is configured correctly for your microcontroller. But what happens behind the scenes?
I&#39;ve read (part of) the Master Thesis from Dominic Rath - the developer of OpenOCD. You can find it here: http://openocd.net/ . This is what I learned:

- Eclipse starts the OpenOCD software when you click the &#39;debug&#39; icon. Eclipse also provides some configuration files to OpenOCD - such that OpenOCD knows how to connect to your microcontroller. &#39;How to connect&#39; is not a trivial thing. OpenOCD needs to find the proper USB driver to connect to the JTAG adapter (for example STLink). Both the JTAG adapter and its USB driver are usually delivered by your chip manufacturer (for example STMicroelectronics). Eclipse also hands over a configuration file to OpenOCD that describes the specifications of the microcontroller. Once OpenOCD knows about all these things, it can make a reliable JTAG connection to the target device.

- OpenOCD starts two servers. The first one is a Telnet server on TCP port 4444. It gives access to the OpenOCD CLI (Command Line Interface). A Telnet client can connect and send commands to OpenOCD. Those commands can be a simple &#39;stop&#39;, &#39;run&#39;, &#39;set breakpoint&#39;, ... 

- Such commands could be sufficient for debugging your microcontroller, but many people were already familiar with the Gnu Debugger (GDB). This is why OpenOCD also starts a GDB server on TCP port 3333. A GDB client can connect to that port, and start debugging the microcontroller!

- The Gnu Debugger is a command line software. Many people prefer a visual interface. That is exactly what Eclipse does. Eclipse starts a GDB client that connects to OpenOCD - but that is all hidden to the user. Eclipse provides a graphical interface that interacts with the GDB client behind the scenes.

I&#39;ve made a figure to explain all these things:

[![enter image description here][2]][2]


**&gt;&gt; Starting up OpenOCD**

I managed to start up OpenOCD from the command line. I&#39;ll explain how.

 1. First make sure that your STLink-V2 JTAG programmer is properly installed. You can test the installation with the &quot;STLink Utility tool&quot; from STMicroelectronics. It has a nice GUI, and you simply click the connect button.
[![enter image description here][3]][3]
 1. Next download the OpenOCD software executable from this website: http://gnutoolchains.com/arm-eabi/openocd/ . Install it, and put it in a folder on your harddrive, like &quot;C:\Apps\&quot;.
 2. Open a command terminal, and start OpenOCD. You will need to give OpenOCD a few configuration files, such that it knows where to look for your microcontroller. Typically you need to give a configuration file that describes the JTAG programmer, and a configuration file that defines your microcontroller. Pass those files to OpenOCD with the `-f` argument in the command line. You will also need to give OpenOCD access to the `scripts` folder, by passing it with the `-s` argument. This is how I start OpenOCD on my computer with the command line:


        &gt; &quot;C:\Apps\OpenOCD-0.9.0-Win32\bin\openocd&quot; -f &quot;C:\Apps\OpenOCD-0.9.0-Win32\share\openocd\scripts\interface\stlink-v2.cfg&quot; -f &quot;C:\Apps\OpenOCD-0.9.0-Win32\share\openocd\scripts\target\stm32f7x.cfg&quot; -s &quot;C:\Apps\OpenOCD-0.9.0-Win32\share\openocd\scripts&quot;


 3. If you started OpenOCD properly (with the correct arguments), it will startup with the following message:

        Open On-Chip Debugger 0.9.0 (2015-08-15-12:41)
        Licensed under GNU GPL v2
        For bug reports, read
                http://openocd.org/doc/doxygen/bugs.html
        Info : auto-selecting first available session transport &quot;hla_swd&quot;. To override use &#39;transport select &lt;transport&gt;&#39;.
        Info : The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD
        adapter speed: 2000 kHz
        adapter_nsrst_delay: 100
        srst_only separate srst_nogate srst_open_drain connect_deassert_srst
        Info : Unable to match requested speed 2000 kHz, using 1800 kHz
        Info : Unable to match requested speed 2000 kHz, using 1800 kHz
        Info : clock speed 1800 kHz
        Info : STLINK v2 JTAG v24 API v2 SWIM v4 VID 0x0483 PID 0x3748
        Info : using stlink api v2
        Info : Target voltage: 3.231496
        Info : stm32f7x.cpu: hardware has 8 breakpoints, 4 watchpoints
        Info : accepting &#39;gdb&#39; connection on tcp/3333
        Info : flash size probed value 1024

 4. Notice that your terminal window is now blocked. You can no longer type commands. But that&#39;s normal. OpenOCD is running in the background, and it blocks the terminal. Now you&#39;ve got two options to interact with OpenOCD: you start a Telnet session in another terminal, and you log on to TCP port `localhost:4444`, so you can give commands to OpenOCD and receive feedback. Or you start a GDB client session, and connect it to TCP port `localhost:3333`.

**&gt;&gt; Starting up a Telnet session to interact with OpenOCD**

This is how you start a Telnet session to interact with the running OpenOCD program:

    &gt; dism /online /Enable-Feature /FeatureName:TelnetClient
    
    &gt; telnet 127.0.0.1 4444

If it works well, you&#39;ll get the following message on your terminal:

    Open On-Chip Debugger
    &gt; ..

And you&#39;re ready to send commmands to OpenOCD! But I&#39;ll now switch to the GDB session, since that&#39;s the most convenient way to interact with OpenOCD.

**&gt;&gt; Starting up a GDB client session to interact with OpenOCD**

Open yet another terminal window, and type the following command:

    &gt; &quot;C:\Apps\AC6GCC\bin\arm-none-eabi-gdb.exe&quot;

This command simply starts the `arm-none-eabi-gdb.exe` GDB client. If all goes well, GDB starts up with the following message:

        GNU gdb (GNU Tools for ARM Embedded Processors) 7.10.1.20151217-cvs
        Copyright (C) 2015 Free Software Foundation, Inc.
        License GPLv3+: GNU GPL version 3 or later &lt;http://gnu.org/licenses/gpl.html&gt;
        This is free software: you are free to change and redistribute it.
        There is NO WARRANTY, to the extent permitted by law.  Type &quot;show copying&quot;
        and &quot;show warranty&quot; for details.
        This GDB was configured as &quot;--host=i686-w64-mingw32 --target=arm-none-eabi&quot;.
        Type &quot;show configuration&quot; for configuration details.
        For bug reporting instructions, please see:
        &lt;http://www.gnu.org/software/gdb/bugs/&gt;.
        Find the GDB manual and other documentation resources online at:
        &lt;http://www.gnu.org/software/gdb/documentation/&gt;.
        For help, type &quot;help&quot;.
        Type &quot;apropos word&quot; to search for commands related to &quot;word&quot;.
        (gdb)..

Now connect this GDB client to the GDB server inside OpenOCD:

        (gdb) target remote localhost:3333

Now you&#39;re connected to OpenOCD! Good to know: if you want to use a native OpenOCD command (just like you would do in a Telnet session), just precede the command with the keyword `monitor`. This way the GDB server inside OpenOCD will not handle the command himself, but pass it on to the native OpenOCD deamon.

So, now it is time to reset the chip, erase it and halt it:

        (gdb) monitor reset halt
           target state: halted
           target halted due to debug-request, current mode: Thread
           xPSR: 0x01000000 pc: 0xfffffffe msp: 0xfffffffc
        (gdb) monitor halt
        
        (gdb) monitor flash erase_address 0x08000000 0x00100000
           erased address 0x08000000 (length 1048576) in 8.899024s (115.069 KiB/s)
        (gdb) monitor reset halt
           target state: halted
           target halted due to debug-request, current mode: Thread
           xPSR: 0x01000000 pc: 0xfffffffe msp: 0xfffffffc
        (gdb) monitor halt

The chip is now ready to get some instructions from us. First we will tell the chip that its flash sections 0 to 7 (that&#39;s all the flash sections in my 1Mb chip) should not be protected:

        (gdb) monitor flash protect 0 0 7 off
        
        (gdb) monitor flash info 0
           #0 : stm32f7x at 0x08000000, size 0x00100000, buswidth 0, chipwidth 0
                #  0: 0x00000000 (0x8000 32kB) not protected
                #  1: 0x00008000 (0x8000 32kB) not protected
                #  2: 0x00010000 (0x8000 32kB) not protected
                #  3: 0x00018000 (0x8000 32kB) not protected
                #  4: 0x00020000 (0x20000 128kB) not protected
                #  5: 0x00040000 (0x40000 256kB) not protected
                #  6: 0x00080000 (0x40000 256kB) not protected
                #  7: 0x000c0000 (0x40000 256kB) not protected

Next I halt the chip again. Just to be sure..

        (gdb) monitor halt

Finally I hand over the binary `.elf` file to GDB:

        (gdb) file C:\\..\\myProgram.elf
           A program is being debugged already.
           Are you sure you want to change the file? (y or n) y
           Reading symbols from C:\..\myProgram.elf ...done.

Now is the moment of truth. I ask GDB to load this binary into the chip. Fingers crossed:

        (gdb) load
           Loading section .isr_vector, size 0x1c8 lma 0x8000000
           Loading section .text, size 0x39e0 lma 0x80001c8
           Loading section .rodata, size 0x34 lma 0x8003ba8
           Loading section .init_array, size 0x4 lma 0x8003bdc
           Loading section .fini_array, size 0x4 lma 0x8003be0
           Loading section .data, size 0x38 lma 0x8003be4
           Error finishing flash operation

Sadly it was not successful. I get the following message in OpenOCD:

        Error: error waiting for target flash write algorithm
        Error: error writing to flash at address 0x08000000 at offset 0x00000000

------------------------------

**EDIT : Hardware issue fixed.**

Apparently it was a hardware issue. I had never thought that my chip would be defect, since loading the binary onto the chip with the STLink Utility tool worked without problem. Only OpenOCD was complaining and giving errors. So naturally I blamed OpenOCD - and not the chip itself. See my answer below for more details.

------------------------------

**EDIT : Alternative elegant way to flash the chip - using makefile!**

As the issue got fixed, I will now focus on an alternative way to execute the flash and debug of the chip. I believe this is really interesting for the community!

You might have noticed that I used Windows cmd commands to execute all the necessary steps. This can be automated in a batch file. But there is a more elegant way: to automate everything in a makefile!
Mr./Mss. Othane has suggested the following makefile for his/her Cortex-M? chip. I suppose that the procedure for a Cortex-M7 chip is very similar:

                #################################################
                #        MAKEFILE FOR BUILDING THE BINARY       #
                #        AND EVEN FLASHING THE CHIP!            #
                # Author: Othane                                #
                #################################################
                
		# setup compiler and flags for stm32f373 build 
		SELF_DIR := $(dir $(lastword $(MAKEFILE_LIST))) 
		 
		 
		CROSS_COMPILE ?= arm-none-eabi- 
		export CC = $(CROSS_COMPILE)gcc 
		export AS = $(CROSS_COMPILE)gcc -x assembler-with-cpp 
		export AR = $(CROSS_COMPILE)ar 
		export LD = $(CROSS_COMPILE)ld 
		export OD   = $(CROSS_COMPILE)objdump 
		export BIN  = $(CROSS_COMPILE)objcopy -O ihex 
		export SIZE = $(CROSS_COMPILE)size 
		export GDB = $(CROSS_COMPILE)gdb 

		 
		MCU = cortex-m4 
		FPU = -mfloat-abi=hard -mfpu=fpv4-sp-d16 -D__FPU_USED=1 -D__FPU_PRESENT=1 -DARM_MATH_CM4 
		DEFS = -DUSE_STDPERIPH_DRIVER -DSTM32F37X -DRUN_FROM_FLASH=1 -DHSE_VALUE=8000000 
		OPT ?= -O0  
		MCFLAGS = -mthumb -mcpu=$(MCU) $(FPU) 

		 
		export ASFLAGS  = $(MCFLAGS) $(OPT) -g -gdwarf-2 $(ADEFS) 
		CPFLAGS += $(MCFLAGS) $(OPT) -gdwarf-2 -Wall -Wno-attributes -fverbose-asm  
		CPFLAGS += -ffunction-sections -fdata-sections $(DEFS) 
		export CPFLAGS 
		export CFLAGS += $(CPFLAGS) 

		 
		export LDFLAGS  = $(MCFLAGS) -nostartfiles -Wl,--cref,--gc-sections,--no-warn-mismatch $(LIBDIR) 

		 
		HINCDIR += ./STM32F37x_DSP_StdPeriph_Lib_V1.0.0/Libraries/CMSIS/Include/ \ 
			./STM32F37x_DSP_StdPeriph_Lib_V1.0.0/Libraries/CMSIS/Device/ST/STM32F37x/Include/ \ 
			./STM32F37x_DSP_StdPeriph_Lib_V1.0.0/Libraries/STM32F37x_StdPeriph_Driver/inc/ \ 
			./ 
		export INCDIR = $(patsubst %,$(SELF_DIR)%,$(HINCDIR)) 

		 

		 
		# openocd variables and targets 
		OPENOCD_PATH ?= /usr/local/share/openocd/ 
		export OPENOCD_BIN = openocd 
		export OPENOCD_INTERFACE = $(OPENOCD_PATH)/scripts/interface/stlink-v2.cfg 
		export OPENOCD_TARGET = $(OPENOCD_PATH)/scripts/target/stm32f3x_stlink.cfg 

		 
		OPENOCD_FLASH_CMDS = &#39;&#39; 
		OPENOCD_FLASH_CMDS += -c &#39;reset halt&#39; 
		OPENOCD_FLASH_CMDS += -c &#39;sleep 10&#39;  
		OPENOCD_FLASH_CMDS += -c &#39;stm32f1x unlock 0&#39; 
		OPENOCD_FLASH_CMDS += -c &#39;flash write_image erase $(PRJ_FULL) 0 ihex&#39; 
		OPENOCD_FLASH_CMDS += -c shutdown 
		export OPENOCD_FLASH_CMDS 

		 
		OPENOCD_ERASE_CMDS = &#39;&#39; 
		OPENOCD_ERASE_CMDS += -c &#39;reset halt&#39; 
		OPENOCD_ERASE_CMDS += -c &#39;sleep 10&#39;  
		OPENOCD_ERASE_CMDS += -c &#39;sleep 10&#39;  
		OPENOCD_ERASE_CMDS += -c &#39;stm32f1x mass_erase 0&#39; 
		OPENOCD_ERASE_CMDS += -c shutdown 
		export OPENOCD_ERASE_CMDS 

		 
		OPENOCD_RUN_CMDS = &#39;&#39; 
		OPENOCD_RUN_CMDS += -c &#39;reset halt&#39; 
		OPENOCD_RUN_CMDS += -c &#39;sleep 10&#39; 
		OPENOCD_RUN_CMDS += -c &#39;reset run&#39; 
		OPENOCD_RUN_CMDS += -c &#39;sleep 10&#39;  
		OPENOCD_RUN_CMDS += -c shutdown 
		export OPENOCD_RUN_CMDS 

		 
		OPENOCD_DEBUG_CMDS = &#39;&#39; 
		OPENOCD_DEBUG_CMDS += -c &#39;halt&#39; 
		OPENOCD_DEBUG_CMDS += -c &#39;sleep 10&#39; 

		 
		.flash: 
			$(OPENOCD_BIN) -f $(OPENOCD_INTERFACE) -f $(OPENOCD_TARGET) -c init $(OPENOCD_FLASH_CMDS) 

		 
		.erase: 
			$(OPENOCD_BIN) -f $(OPENOCD_INTERFACE) -f $(OPENOCD_TARGET) -c init $(OPENOCD_ERASE_CMDS) 

		 
		.run: 
			$(OPENOCD_BIN) -f $(OPENOCD_INTERFACE) -f $(OPENOCD_TARGET) -c init $(OPENOCD_RUN_CMDS) 

		 
		.debug: 
			$(OPENOCD_BIN) -f $(OPENOCD_INTERFACE) -f $(OPENOCD_TARGET) -c init $(OPENOCD_DEBUG_CMDS) 

		 
Dear Mr./Mss. Othane, could you explain how to use this makefile for the following steps:

 - Build the binary from the source code
 - Flash the chip

I know some basics about makefiles, but your makefile is really going quite deep. You seem to use quite some features of the GNU make utility. Please give us some more explanation, and I&#39;ll grant you the bonus ;-)

------------------------------
------------------------------


  [1]: http://i.stack.imgur.com/zY6lR.png
  [2]: http://i.stack.imgur.com/LMxKN.png
  [3]: http://i.stack.imgur.com/cHn7P.png

How to use the GDB (Gnu Debugger) and OpenOCD for microcontroller debugging - from the terminal?

I was searching for the source code of the C standard libraries. What I mean with it is, for example, how are cos, abs, printf, scanf, fopen, and all the other standard C functions written, I mean to see their source code.

So while searching for this, I came across with GLIBC, but I don&#39;t know what it actually is. It is GNU C Library, and it contains some source codes, but what are they actually, are they the source code of the standard functions or are they something else? And what is it used for?

What is GLIBC? What is it used for?

&lt;!-- language-all: lang-none --&gt;

In OSX during C++ program compilation with `g++` I use

    LD_FLAGS= -Wl,-stack_size,0x100000000

but in SUSE Linux I constantly get errors like:

    x86_64-suse-linux/bin/ld: unrecognized option &#39;--stack&#39;

and similar.

I know that it is possible to use

    ulimit -s unlimited

but this is not nice as not always can a single user do that.

How can I increase the stack size in Linux with GCC for a single application?


Change stack size for a C++ application in Linux during compilation with GNU compiler

In my makefile, I would like to check for the existence of a library and give an informative error message. I created a conditional that should exit the make process when the file is not found:

     9: ifeq ($(${JSONLIBPATH}),)
    10:    JSONLIBPATH = ${ALTJSONLIBDIR}/${LIBJSON}
    11: endif
    12: ifeq ($(${JSONLIBPATH}),)
    13:    $(error JSON library is not found. Please install libjson before building)
    14: endif 

My makefile gets stuck on line 13:

    Makefile:13: *** commands commence before first target.  Stop.

After line 13, my makefile has its targets.

I tried putting this conditional block into a target (e.g. a target called `isJSONLibraryInstalled`) but this does not execute correctly.

How would I check for a file&#39;s existence and handle the error case, before processing targets? Apologies if this is a dumb question.

GNU make yields &quot;commands commence before first target&quot; error

I would like to use the `tr` command to replace all occurrences of the string &quot;\n&quot; with a new line (\n).

I tried `tr &#39;\\n&#39; &#39;\n&#39;` but this just seems to match any &#39;\&#39; and any &#39;n&#39;

tr command - how to replace the string &quot;\n&quot; with an actual newline (\n)

I&#39;m trying to use GNU find to find only the directories that contain no other directories, but may or may not contain regular files. 

My best guess so far has been:

    find dir -type d $ -not -exec ls -dA &#39;;&#39; $

but this just gets me a long list of &quot;.&quot;

Thanks!

Use GNU find to show only the leaf directories

I have been trying to use GNU parallel for some time, but I have never been able to get it to function at all!


For example, running (in a non-empty directory!):

    ls | parallel echo            # Outputs single new line
    ls | parallel echo echo echo  # Outputs three new lines.
    ls | parallel echo {}         # /bin/bash: {}: command not found
    ls | parallel echo &#39;{}&#39;       # /bin/bash: {}: command not found
    ls | parallel &#39;echo {}&#39;       # Outputs: {}
    ls | parallel -IMM &#39;echo MM&#39;  # Outputs: MM

It seems that it is simply executing each argument as a command, which makes no sense.

I have tried bash, zsh, tcsh, csh, and sh, to no avail.

GNU parallel not working at all

Some platforms mandate that you provide a list of a shared library&#39;s external symbols to the linker. However, on most unixish systems that&#39;s not necessary: all non-static symbols will be available by default.

My understanding is that the GNU toolchain can optionally restrict visibility just to symbols explicitly declared. How can that be achieved using GNU ld?

Limiting visibility of symbols when linking shared libraries

How to get the invoking target of the GNU make Makefile?

for example, I invoke `make` with the following command line:

    make a-target

How can I get the invoking target &quot;a-target&quot; in the Makefile and assign it to a variable?

Further more, if more than one target is specified on the command line:

    make target1 target2 ...

How do I get all of them?

How to get the invoking target of makefile?

By default, when you create a new window in GNU Screen, it will start in the directory where Screen is invoked. I want to start a new window in GNU Screen at the current working directory of the window I&#39;m currently in. How can I do that?


All Gnu Solutions on Gang of Coders

Total of 28 Gnu Solutions