Related: Does a compiler always produce an assembly code? – more about why some compilers do compile only to asm, instead of straight to machine code in some object file format. There are several reasons that compiling to asm instead of machine code makes a compiler’s job easier and a compiler more easily portable. But compilers aren’t the only reason for asm existing.
why do we even need assembler?
Many people don’t need to know assembly language.
It exists so we can talk about / analyze machine code, and write/debug compilers more easily.
Compilers have to be written by humans. As @old_timer points out, when designing a new CPU architecture, you always give names to the opcodes and registers so you can talk about the design with other humans, and publish readable manuals.
Or for OS development, some special privileged instructions can’t be generated by compilers1. And you can’t write a context-switch function that saves registers in pure C.
CPUs run machine-code, not high-level languages directly, so computer security / exploits, and any serious low-level performance analysis / tuning of single loops require looking at the instructions the CPU is running. Mnemonic names for the opcodes are very helpful in thinking and writing about them. mov r32, imm32 is much easier to remember and more expressive than B8+rd imm32 (the range of opcodes for that mnemonic).
Footnote 1: Unless like MSVC you create intrinsics for all the special instructions like __invlpg() that OSes need to use, so you can write an OS without inline asm. (They still need some stand-alone asm for stuff like entry points, and probably for a context-switch function.) But then those intrinsics still need names in C so you might as well name them in asm.
I regularly use asm for easily creating the machine code I want to test for microbenchmarks. A compiler has to create efficient machine code, not just correct machine code, so it’s common for humans to play around with asm to see exactly what’s fast and what’s not on various CPUs.
See http://agner.org/optimize/, and other performance links in the x86 tag wiki.
e.g. see Can x86’s MOV really be “free”? Why can’t I reproduce this at all? and Micro fusion and addressing modes for examples of micro-benchmarking to learn something about what’s fast.
See C++ code for testing the Collatz conjecture faster than hand-written assembly – why? for more about writing asm by hand that’s faster than what I could hand-hold gcc or clang into emitting, even by adjusting the C source to look more like the asm I came up with.
(And obviously I had to know asm to be able to look at the compiler’s asm output and see how to do better. Compilers are far from perfect. Sometimes very far. Missed-optimization bugs are common. To think of new optimizations and suggest that compilers look for them, it’s a lot easier to think in terms of asm instructions than machine code.)
Wrong-code compiler bugs also sometimes happen, and verifying them basically requires looking at the compiler output.
Stack Overflow has several questions like “what’s faster: a++ or ++a?”, and the answer completely depends on exactly how it compiles into asm, not on source-level syntax differences. To understand why some kinds of source differences affect performance, you have to understand how code compiles to asm.
e.g. Adding a redundant assignment speeds up code when compiled without optimization. (People often fail to realize that compiling with/without optimization isn’t just a linear speedup, and that it’s basically pointless to benchmark un-optimized code. Un-optimized code has different bottlenecks… This is obvious if you look at the asm.)