How gcc optimize sum from 1 to 100 into 5050

See also questions close to this topic

• If user inputs "sum(x,y)" how can I get x and y as doubles

  I am writing a simple calculator program such that the user is entered into the programs own console environment. Each new line starts with a $. User will enter commands such as '''sum(x,y)''' '''mul(x,y)''' etc. and the program will take x and y as doubles and execute a function i.e. '''double mul(x, y){return x*y)''' and display the returned value.

  I have gotten it to correctly identify the command based on matching the first three characters in the string.

  I cant seem to read the numerical values correctly no matter what I do. Any suggestions are greatly appreciated!

  The Code below is from main()

      printf("%s", " $    ");
      fgets(input, sizeof(input), stdin);
      sscanf(input,"(%d,%d)",&arg1,&arg2);
  
      if(strstr(input,"sum")){
          //char *starting_pos = strchr(input,dlm);
          //int position = (starting_pos == NULL ? -1 : (uintptr_t)starting_pos);
  
          //arg1 = input[position + 1];
          //arg2 = input[position + 3];
          printf("DEBUG: arg1 is %d arg2 is %d\n", arg1,arg2);
          double output = sum(arg1,arg2);
          printf("DEBUG: Output should be: %d\n", output);
          printf("%d\n",output);
  
      }else if ...
  

  The commented section is the remnants of another way I was trying. If anyone can tell me what the right way to do this is I would be very grateful.
• What is the difference between the definitions "int main (void)" and "int main (int argc, char *argv[])" and when to use which?

  As per the current standard and cppreference these two are the correct way to define the main() function. I know what the parameters mean in either definition, and am not seeking clarifications on that aspect. What I'd like to understand is:

  1. When to use int main (void) v/s int main (int argc, char *argv[]).
  2. Hypothetically, when the program doesn't expect command-line arguments, is there any difference to the compiler (let's say gcc and clang) at all?
  3. (Just for the sake of writing self-documenting code) should I use int main (void) when the program doesn't expect command line arguments and int main (int argc, char *argv[]) when it does?
• Increment a number without using arithmetic operators

  All I want to do is increment the i++ at the end of the for loop without using arithmetic operators and I can only use bitwise operators. So no "+, ++, +=, -, --, -= ,∗, /, %". An exception is that I can use addition for pointer arithmetic like in the line

  result += multiplicand;
  

  Would I have to change it into a while loop or how would I do that?

  int result = 0;
  int i = 0;
  for (i=0; i<multiplier; i++){
        result += multiplicand;
      }
  
• docker <.h> no such file or directory

  what could be the reason gcc compiler throwing file not found error when compiled in docker container environment?

  In docker environment, error threw only one header file among 10 header files. It didn't throw for rest 9 include <.h> statement. I don't understand.

  It worked perfectly fine when compiled normally. I am pretty sure that I added all include library files on docker and made reference to it using -I, -L, and -l option in gcc command.
• Poco build: infinite loop when makedepend.gcc on Ubuntun 20.04 gcc/g++ version: 10.2

  I build Poco 1.9.0 with gcc/g++ 7.5.0 of Ubuntu 18.05, there is no any problem. However, the build fail on Ubuntu 20.04 with gcc/g++ 10.2.0 the build process go into infinite loop, it stuck at creating dependency refer the below message until I manually stop it with CTRL+C.

  ** Creating dependency info for src/LineEndingConverter.cpp mkdir -p /home/thales/LDC/Poco/Foundation/.dep/Linux/x86_64 /home/thales/LDC/Poco/build/script/makedepend.gcc src/LineEndingConverter.cpp ...........
• GCC [for ARM] force no floating point

  I would like to create a build of my embedded C code which specifically checks that floating point operations aren't introduced into it by accident. I've tried adding +nofp to my [cortex-m3] processor architecture but GCC for ARM doesn't like that (probably because the cortex-m3 doesn't have a floating point unit). I've tried specifying -mfpu=none but that isn't a permitted option. I've tried leaving -lm off the linker command-line but the linker seems too clever to be fooled by that and is compiling code with double in it and resolving pow() anyway.

  This post: https://gcc.gnu.org/legacy-ml/gcc-help/2011-07/msg00093.html from 2011 hints that GCC has no such option, since no-one is interested in it, which surprises me as it seems like a common thing to want, at least from an embedded standpoint, to avoid accidental C-library bloat.

  Does anyone know of a way to do this with GCC/newlib without me having to go through and manually hack stuff out of the C library file it chooses?
• Why the backtrace may be not correct when enable tail optimization

  Per https://www.gnu.org/software/libc/manual/html_node/Backtraces.html:

  Note that certain compiler optimizations may interfere with obtaining a valid backtrace. Function inlining causes the inlined function to not have a stack frame; tail call optimization replaces one stack frame with another; frame pointer elimination will stop backtrace from interpreting the stack contents correctly.

  I want to know why it should happen when enabling tail optimization and how to avoid it.
• GCC links symbols for an unreachable switch-case statement

  I'm writing a code with C that uses the factory pattern to initialize objects for specific interfaces. It simply assigns functions to related pointers according to the type. My interface and main application look like this:

  typedef enum
  {
      INTF_DEV_FOO,
      INTF_DEV_BAR
  } intf_dev_t;
  
  typedef struct
  {
      int (*exec)(void);
  } intf_t;
  

  static void intf_select_foo(intf_t* intf)
  {
      intf->exec = foo_exec;
  }
  
  static void intf_select_bar(intf_t* intf)
  {
      intf->exec = bar_exec;
  }
  
  int intf_init(intf_t* intf, intf_dev_t dev)
  {
      int result = 0;
  
      switch (dev)
      {
          case INTF_DEV_FOO:
              intf_select_foo(intf);
              break;
          case INTF_DEV_BAR:
              intf_select_bar(intf);
              break;
          default:
              result = -1;
      }
  
      return result;
  }
  

  int main(void)
  {
      intf_t intf = {0};
  
      intf_init(&intf, INTF_DEV_FOO);
      intf.exec();
  
      return 0;
  }
  

  I was expecting to see bar would be discarded since its statement is unreachable. But when I looked at the assembly code of the output, both of the functions were linked. Here is the disassembly code:

  004077e0 <_bar_exec>:
    4077e0:   83 ec 1c                sub    $0x1c,%esp
    4077e3:   c7 04 24 84 90 40 00    movl   $0x409084,(%esp)
    4077ea:   e8 b9 fc ff ff          call   4074a8 <_puts>
    4077ef:   31 c0                   xor    %eax,%eax
    4077f1:   83 c4 1c                add    $0x1c,%esp
    4077f4:   c3                      ret
  
  00407800 <_foo_exec>:
    407800:   83 ec 1c                sub    $0x1c,%esp
    407803:   c7 04 24 90 90 40 00    movl   $0x409090,(%esp)
    40780a:   e8 99 fc ff ff          call   4074a8 <_puts>
    40780f:   31 c0                   xor    %eax,%eax
    407811:   83 c4 1c                add    $0x1c,%esp
    407814:   c3                      ret
  
  00407820 <_intf_init>:
    407820:   8b 44 24 08             mov    0x8(%esp),%eax
    407824:   85 c0                   test   %eax,%eax
    407826:   74 1e                   je     407846 <_intf_init+0x26>
    407828:   83 f8 01                cmp    $0x1,%eax
    40782b:   75 13                   jne    407840 <_intf_init+0x20>
    40782d:   8b 44 24 04             mov    0x4(%esp),%eax
    407831:   c7 00 e0 77 40 00       movl   $0x4077e0,(%eax)
    407837:   31 c0                   xor    %eax,%eax
    407839:   c3                      ret    
    40783a:   8d b6 00 00 00 00       lea    0x0(%esi),%esi
    407840:   b8 ff ff ff ff          mov    $0xffffffff,%eax
    407845:   c3                      ret    
    407846:   8b 44 24 04             mov    0x4(%esp),%eax
    40784a:   c7 00 00 78 40 00       movl   $0x407800,(%eax)
    407850:   31 c0                   xor    %eax,%eax
    407852:   c3                      ret
  

  As far as I know, it should be part of the dead code elimination optimization. But when I add another module with another case statement, my code size is getting bigger and I see its symbols both in the map file and the assembly code.

  I'm compiling my code with GCC 8.0.0 on Windows. Here is my compilation setting:

  gcc *c -O3 -fdata-sections -ffunction-sections -o dce -Xlinker -Map='dce.map' '-Wl,--gc-sections'
  

  Am I missing something here or is this related to the optimization capabilities?
• Does v8 optimize string concatenation inside loops?

  TL;DR: Does v8 optimize string concatenation inside loops, or should I take care of it myself?

  ---

  From one of the episodes of HTTP 203 podcast (definitely check it out if you don't know about it) I heard about one of the optimizations that are generally handled by the compiler/optimizer: extracting constants out of loops. This made me think about the difference between the following two approaches:

  let string = "";
  
  getSubstrings().forEach((substring) => {
    string += substring;
  });
  
  doSmth(string);
  

  const chunks = new Array(getSubstringsCount()); // suppose we know array size in advance
  
  getSubstrings().forEach((substring, index) => {
    chunks[index] = substring;
  });
  
  const string = chunks.join("");
  
  doSmth(string);
  

  _{In the first approach, in each iteration we create a new string, that's bigger and bigger in each iteration, and it gets immediately abandoned in the next iteration. In the second approach, we have a fixed number of strings, plus one array object, plus one more .join() call.}

  I always leaned towards the second approach, but I can see how this might be a silly thing, given that v8 currently is sufficiently advanced from being indistinguishable from magic.

  In the case of a very big array (like 10⁸ items big), is this something I should worry about? Or v8 already takes care of that for me?