retdec VS compiler-explorer

found something called retdec @ https://github.com/avast/retdec

RetDec

https://github.com/avast/retdec (multiple machine code formats to C/C++)

// // This file was generated by the Retargetable Decompiler // Website: https://retdec.com // Copyright (c) Retargetable Decompiler // #include #include #include #include // ------------------------ Structures ------------------------ struct _IO_FILE { int32_t e0; }; // ------------------- Function Prototypes -------------------- int64_t __do_global_dtors_aux(void); int64_t __libc_csu_fini(void); int64_t __libc_csu_init(int64_t a1, int64_t a2, int64_t a3); int64_t _fini(void); int64_t _init(void); int64_t _start(int64_t a1, int64_t a2, int64_t a3, int64_t a4); int64_t deregister_tm_clones(void); int64_t frame_dummy(void); int32_t function_7b0(char * s1, char * s2, int32_t n); int32_t function_7c0(int64_t * ptr, int32_t size, int32_t n, struct _IO_FILE * stream); int32_t function_7d0(struct _IO_FILE * stream); void function_7e0(void); int32_t function_7f0(char * format, ...); char * function_800(char * s, int32_t n, struct _IO_FILE * stream); int32_t function_810(struct _IO_FILE * stream, char * buf, int32_t modes, int32_t n); struct _IO_FILE * function_820(char * filename, char * modes); void function_830(char * s); void function_840(int32_t status); void function_850(int64_t * d); int64_t readflag(void); int64_t register_tm_clones(void); // --------------------- Global Variables --------------------- int64_t g1 = 2400; // 0x200d70 int64_t g2 = 2336; // 0x200d78 struct _IO_FILE * g3 = NULL; // 0x201020 struct _IO_FILE * g4 = NULL; // 0x201030 char g5 = 0; // 0x201038 char * g6; // 0x201040 int32_t g7 = 0; // 0x400 int32_t g8; // ------------------------ Functions ------------------------- // Address range: 0x788 - 0x79f int64_t _init(void) { int64_t result = 0; // 0x796 if (*(int64_t *)0x200fe8 != 0) { // 0x798 __gmon_start__(); result = &g8; } // 0x79a return result; } // Address range: 0x7b0 - 0x7b6 int32_t function_7b0(char * s1, char * s2, int32_t n) { // 0x7b0 return strncmp(s1, s2, n); } // Address range: 0x7c0 - 0x7c6 int32_t function_7c0(int64_t * ptr, int32_t size, int32_t n, struct _IO_FILE * stream) { // 0x7c0 return fread(ptr, size, n, stream); } // Address range: 0x7d0 - 0x7d6 int32_t function_7d0(struct _IO_FILE * stream) { // 0x7d0 return fclose(stream); } // Address range: 0x7e0 - 0x7e6 void function_7e0(void) { // 0x7e0 __stack_chk_fail(); } // Address range: 0x7f0 - 0x7f6 int32_t function_7f0(char * format, ...) { // 0x7f0 return printf(format); } // Address range: 0x800 - 0x806 char * function_800(char * s, int32_t n, struct _IO_FILE * stream) { // 0x800 return fgets(s, n, stream); } // Address range: 0x810 - 0x816 int32_t function_810(struct _IO_FILE * stream, char * buf, int32_t modes, int32_t n) { // 0x810 return setvbuf(stream, buf, modes, n); } // Address range: 0x820 - 0x826 struct _IO_FILE * function_820(char * filename, char * modes) { // 0x820 return fopen(filename, modes); } // Address range: 0x830 - 0x836 void function_830(char * s) { // 0x830 perror(s); } // Address range: 0x840 - 0x846 void function_840(int32_t status) { // 0x840 exit(status); } // Address range: 0x850 - 0x856 void function_850(int64_t * d) { // 0x850 __cxa_finalize(d); } // Address range: 0x860 - 0x88b int64_t _start(int64_t a1, int64_t a2, int64_t a3, int64_t a4) { // 0x860 int64_t v1; // 0x860 __libc_start_main(2518, (int32_t)a4, (char **)&v1, (void (*)())2816, (void (*)())2928, (void (*)())a3); __asm_hlt(); // UNREACHABLE } // Address range: 0x890 - 0x8c2 int64_t deregister_tm_clones(void) { // 0x890 return (int64_t)&g3; } // Address range: 0x8d0 - 0x912 int64_t register_tm_clones(void) { // 0x8d0 return 0; } // Address range: 0x920 - 0x95a int64_t __do_global_dtors_aux(void) { // 0x920 if (g5 != 0) { // 0x958 int64_t result; // 0x920 return result; } // 0x929 if (*(int64_t *)0x200ff8 != 0) { // 0x937 __cxa_finalize((int64_t *)*(int64_t *)0x201008); } int64_t result2 = deregister_tm_clones(); // 0x943 g5 = 1; return result2; } // Address range: 0x960 - 0x96a int64_t frame_dummy(void) { // 0x960 return register_tm_clones(); } // Address range: 0x96a - 0x9d6 int64_t readflag(void) { struct _IO_FILE * file = fopen("flag", "rb"); // 0x980 if (file != NULL) { // 0x9a6 fread((int64_t *)&g6, (int32_t)&g7, 1, file); fclose(file); return 0; } // 0x990 perror("[-] flag file "); exit(0); // UNREACHABLE } // Address range: 0x9d6 - 0xaf7 int main(int argc, char ** argv) { int64_t v1 = __readfsqword(40); // 0x9e1 setvbuf(g3, NULL, 1, 0); setvbuf(g4, NULL, 1, 0); readflag(); printf("[+] password => %p\n", (int64_t *)"P4s$w0rD"); int64_t str; // bp-1048, 0x9d6 fgets((char *)&str, (int32_t)&g7, g4); printf((char *)&str); if (strncmp("P4s$w0rD", "weakpass", 8) != 0) { // 0xac4 printf("[!] password is %s\n", "P4s$w0rD"); } else { // 0xaaa printf("[+] %s", (char *)&g6); } int64_t result = 0; // 0xaee if (v1 != __readfsqword(40)) { // 0xaf0 __stack_chk_fail(); result = &g8; } // 0xaf5 return result; } // Address range: 0xb00 - 0xb65 int64_t __libc_csu_init(int64_t a1, int64_t a2, int64_t a3) { int64_t result = _init(); // 0xb2c if ((int64_t)&g2 - (int64_t)&g1 >> 3 == 0) { // 0xb56 return result; } int64_t v1 = 0; // 0xb34 while (v1 + 1 != (int64_t)&g2 - (int64_t)&g1 >> 3) { // 0xb40 v1++; } // 0xb56 return result; } // Address range: 0xb70 - 0xb72 int64_t __libc_csu_fini(void) { // 0xb70 int64_t result; // 0xb70 return result; } // Address range: 0xb74 - 0xb7d int64_t _fini(void) { // 0xb74 int64_t result; // 0xb74 return result; } // --------------- Dynamically Linked Functions --------------- // void __cxa_finalize(void * d); // void __gmon_start__(void); // int __libc_start_main(int *(main)(int, char **, char **), int argc, char ** ubp_av, void(* init)(void), void(* fini)(void), void(* rtld_fini)(void), void(* stack_end)); // void __stack_chk_fail(void); // void exit(int status); // int fclose(FILE * stream); // char * fgets(char * restrict s, int n, FILE * restrict stream); // FILE * fopen(const char * restrict filename, const char * restrict modes); // size_t fread(void * restrict ptr, size_t size, size_t n, FILE * restrict stream); // void perror(const char * s); // int printf(const char * restrict format, ...); // int setvbuf(FILE * restrict stream, char * restrict buf, int modes, size_t n); // int strncmp(const char * s1, const char * s2, size_t n); // --------------------- Meta-Information --------------------- // Detected compiler/packer: gcc (7.5.0) // Detected functions: 22

At least on android arm64, looks like a `dmb ishst` is emitted after the constructor, which allows future loads to not need an explicit barrier. Removing `final` from the field causes that barrier to not be emitted.

https://godbolt.org/#g:!((g:!((g:!((h:codeEditor,i:(filename...

You said You won't get "extreme performance" from C++ because it is buried under the weight of decades of compatibility hacks.

Now your whole comment is about vector behavior. You haven't talked about what 'decades of compatibility hacks' are holding back performance. Whatever behavior you want from a vector is not a language limitation.

You could write your own vector and be done with it, although I'm still not sure what you mean, since once you reserve capacity a vector still doubles capacity when you overrun it. The reason this is never a performance obstacle is that if you're going to use more memory anyway, you reserve more up front. This is what any normal programmer does and they move on.

Show what you mean here:

https://godbolt.org/

I've never used ISPC. It's somewhat interesting although since it's Intel focused of course it's not actually portable.

I guess now the goal posts are shifting. First it was that "C++ as a language has performance limitations" now it's "rust has a vector that has a function I want and also I want SIMD stuff that doesn't exist. It does exist? not like that!"

Try to stay on track. You said there were "decades of compatibility hacks" holding back C++ performance then you went down a rabbit hole that has nothing to do with supporting that.

C++ Insights is available online at https://cppinsights.io/

It is also available at a touch of a button within the most excellent https://godbolt.org/

along side the button that takes your code sample to https://quick-bench.com/

Those sites and https://cppreference.com/ are what I'm using constantly while coding.

I recently discovered https://whitebox.systems/ It's a local app with a $69 one-time charge. And, it only really works with "C With Classes" style functions. But, it looks promising as another productivity boost.

[P&H RISC] https://www.google.com/books/edition/_/e8DvDwAAQBAJ

Compiler Explorer by Matt Godbolt [Godbolt] can help better understand what code a compiler generates under different circumstances.

[Godbolt] https://godbolt.org

The official CPU architecture manuals from CPU vendors are surprisingly readable and information-rich. I only read the fragments that I need or that I am interested in and move on. Here is the Intel’s one [Intel]. I use the Combined Volume Set, which is a huge PDF comprising all the ten volumes. It is easier to search in when it’s all in one file. I can open several copies on different pages to make navigation easier.

Intel also has a whole optimization reference manual [Intel] (scroll down, it’s all on the same page). The manual helps understand what exactly the CPU is doing.

[Intel] https://www.intel.com/content/www/us/en/developer/articles/t...

Personally, I believe in automated benchmarks that measure end-to-end what is actually important and notify you when a change impacts performance for the worse.

Let's compile it with https://godbolt.org/, turn on some optimisations and inspect the IR (-O2 -emit-llvm). Copying out the part that corresponds to the while loop:

  4:

resources were extra useful when building deeper intuitions about GPU performance for ML models at work and in graduate school.

- CMU's "Deep Learning Systems" Course is hosted online and has YouTube lectures online. While not generally relevant to software performance, it is especially useful for engineers interested in building strong fundamentals that will serve them well when taking ML models into production environments: https://dlsyscourse.org/

- Compiler Explorer is a tool that allows you easily input some code in and check how the assembly output maps to the source. I think this is exceptionally useful for beginner/intermediate programmers who are familiar with one compiled high-level language and have not been exposed to reading lots of assembly. It is also great for testing how different compiler flags affect assembly output. Many people used to coding in C and C++ probably know about this, but I still run into people who haven't so I share it whenever performance comes up: https://godbolt.org/

To really understand what's going on here we can look at the compiled assembly code. I'm working on a Mac and can do this using the objdump tool. Compiler Explorer is also a handy tool but doesn't seem to support Arm assembly which is what Rust will use when compiling on Apple Silicon.

Play around with it in godbolt if you're really curious: https://godbolt.org/