Fortran.CodeCompared.To/Assembly

The '(A)' format is doing real work here: print *, "Hello, World!" would emit leading whitespace, because list-directed output is free to lay the record out as it likes. That single detail is a fair summary of what the Fortran runtime is for — it owns record structure, unit numbers and formatting, none of which exists in the right-hand column, where a write is four registers and an instruction.

The flushing is the part worth noticing. A Fortran program that writes to a unit and then crashes may lose the last record; a program that stops cleanly will not. The assembly column has no such concern because write is a syscall — the bytes are handed to the kernel immediately, and there is no user-space buffer left holding anything.

Sixteen instructions and one division per digit. The I0 descriptor is the interesting comparison: I5 would right-justify in five columns and I2 would fill the field with asterisks rather than truncate, because a Fortran field that cannot hold its value is an error you can see. The assembly column has no field width at all — it writes exactly the bytes it produced.

The reason implicit none is the first line of every serious Fortran program is visible in the right-hand column: without a declaration there is nothing to check a name against, and Fortran's historical default typed any undeclared variable by its first letter. A typo then became a new variable rather than an error — the same failure mode as mistyping a register name here, except the assembler at least rejects a register that does not exist.

A narrowing conversion is free for the same reason in both columns: the bits were already there and the narrower name stops looking at the rest. The direction that costs an instruction is widening a signed value, where the sign bit must be smeared across the new high bits — that is movsx. Note that Fortran's kind numbers are not required by the standard to be byte counts, which is why selected_int_kind exists and why portable code uses it.

Writing the division and the remainder as separate expressions asks for the same division twice unless the compiler notices they are identical, which gfortran does. Note also the trap this row sits next to: 1/2 in Fortran is 0, not 0.5, because both operands are integers — the same truncation the div instruction performs, surfacing as one of the commonest sources of silently wrong numerical results.

Fortran's if (smaller < larger) compiles to a compare and a jump reading exactly this flag. The flag is invisible, unnamed, and overwritten by the very next arithmetic instruction, which is why the jump must immediately follow the sub — inserting an unrelated add between them silently breaks the test with nothing to warn you.

The condition is inverted, which is the commonest confusion when reading compiler output: the source says "if this is true, do the block" and the machine says "if this is false, skip the block". Note also that the two arms had to be arranged so control rejoins at print — end if is a single exit point in Fortran, and here you build that out of a jump.

The trip count being fixed up front is a real guarantee and not a detail: it is what lets the compiler know how many iterations there will be before the loop starts, which is the precondition for unrolling it or splitting it across threads. Modifying the loop variable inside the body is forbidden for the same reason. The choice of rbx over rcx here is the sort of thing a register allocator decides silently — get it wrong by hand and the write in the middle destroys the counter.

The dec rcx is free in practice: the compiler folds the subtraction into the addressing mode's displacement, so a 1-based array and a 0-based one generate identical code. That answers the old claim that 1-based indexing must be slower — the lower bound is a compile-time constant, and constants cost nothing. What it buys is that the declared range is checkable, which -fcheck=bounds turns into a real test.

Read the two offsets: stepping the first subscript moved one slot, stepping the second moved rows slots. That is the whole reason a Fortran loop nest should have the first subscript innermost — consecutive iterations then touch consecutive addresses, which is what a cache line is for. C stores rows contiguously instead, so the identical nest wants the opposite order, and getting it backwards is the classic silent performance bug when porting between the two.

The second lea is the surprise: even intent(in) is passed by address, because intent is a promise the compiler checks rather than a change to the convention. That is why passing a literal to an old-style Fortran routine was historically dangerous — the caller had to materialize the constant somewhere so its address could be taken, and a routine that wrote through that address could corrupt the constant itself.

This convention is why linking Fortran and C by hand means writing double_it_ on the C side, and why the underscore count differed between compilers historically — g77 used two for names already containing one. A procedure inside a module is mangled far more elaborately still (__modulename_MOD_procname), which is why bind(C) exists and is the subject of a later row.

The descriptor is why an explicit interface is mandatory for an assumed-shape argument: the caller has to know to build one, and without an interface it would pass a bare address that the callee then reads as a struct — reliably wrong, and reliably confusing. It is also why passing a Fortran assumed-shape array to C does not work: C expects the address, so the interface must use an explicit-shape or assumed-size dummy, or bind(C).

Compare this against the by-reference row: three leas became three movs, and the symbol lost its underscore. That is the whole of what bind(C) buys, and the whole of what it costs — you give up assumed-shape arrays, optional arguments and Fortran's own name resolution in exchange for a symbol any linker can find. The iso_c_binding kinds exist so the widths provably agree rather than agreeing by luck.

One instruction, jae, does the work of both halves of the Fortran test: after subtracting the lower bound, an index below the range wraps to an enormous unsigned value and fails the same upper comparison. That trick is what -fcheck=bounds emits, which is why bounds checking costs two instructions per access rather than four — and why leaving it on in a debug build is usually the right trade.

Reading rcx after that syscall would print whatever the kernel left behind — no crash, no complaint, just a wrong answer that changes with the kernel version. This is the concrete shape of what a calling convention is: an agreement about which registers survive a call, obeyed by everything the compiler emits, and enforced by nothing at all.