5. Demystifying Swift Compiler Magic

Written by Aaqib Hussain

At first glance, the compilation process seems simple: you write code in Xcode, press CMD + R, and the app builds and runs. But does the compiler understand your Swift code “as is”? The answer is no.

Before your code can run, the compiler goes through a complex process. It begins by parsing your text and checking for type errors, then translates it into a powerful, Swift-specific format called the Swift Intermediate Language (SIL). From there, it is further optimized and compiled into the low-level machine code that your device’s CPU actually runs.

Understanding this journey offers a glimpse into the “dos and don’ts” of writing highly effective and efficient code. You’ll be able to understand why the compiler behaves a certain way with a particular piece of code. This deep knowledge can help you stand out among other engineers, many of whom may not be interested in learning these powerful aspects of programming.

The Swift Compiler Architecture: A Bird’s-Eye View

So, what exactly happens when you press CMD + R? Swift’s compiler kicks into gear. What does it do? You can think of it as an assembly line: an ice cream arrives on the conveyor belt, gets wrapped in a packet, and is then packed into boxes for shipping. Inside the Swift compiler, it’s somewhat similar. Each section takes an input and produces an output for the next part.

For clarity, you can divide this architecture into three parts: a Frontend that compiles Swift code, a Middle-end that optimizes the output, and a Backend that generates the final machine code.

The Frontend: Understanding Your Code

The frontend is responsible for converting human-readable code (.swift) into a structured representation that the compiler can analyze and optimize. This process involves three steps: Parsing, Semantic Analysis, and Clang Importing.

Parsing

The parser is responsible for creating an Abstract Syntax Tree (AST). It contains no semantic or type information. It also checks for grammatical and syntactic issues, such as misspelled keywords, and emits warnings or errors based on the input.

Icllyedh Wkzkur Xhau (ADW): Ub’x u qfao nozo fjmekviwu lnev iqqotlgolab vpo uftlpulv mqvimniwu ed e jvoctuv. Uidp quwa tefyolihqz o lidy ut zqo hade, xulx ob ax abqdixbuik as xmapiyaph. An akily ajficopzeym weqoiwl, dubh ah kegemhmerep ehl niqdinqecs, upy bohuecd etgw bgu umnowtuim amwanketaud mfih sku bazkezot oc undet kaevt joiy so ishocnberq ndo hoqu.

Clang Importer

The Clang Importer reads Clang modules (such as <UIKit/UIKit.h>) and translates their C or Objective-C APIs into equivalent Swift APIs. This process produces an Abstract Syntax Tree (AST), which the Semantic Analyzer then uses as a reference to type-check your Swift code.

Semantic Analysis

The Semantic Analyzer takes in the AST, performs type checking and inference, emits warnings or errors for semantic issues, and finally transforms it into a fully type-checked AST.

The Middle-End: Optimization in SIL

The middle-end is where the magic happens. After the frontend generates a valid AST, it is lowered into a specialized, Swift-specific representation known as the Swift Intermediate Language (SIL). SIL has two main stages: Raw and Canonical. Raw SIL is the initial, unoptimized translation of your code, generated in OSSA (Ownership SSA) form. It’s a verbose version that makes every implicit action explicit, but hasn’t been verified for correctness yet. Canonical SIL is the output after the compiler performs necessary passes to simplify the code and verify its accuracy, such as ensuring all variables are initialized before use. This stable, verified SIL is then ready for the main optimization phases.

Irfozlmol Mjiluh Rollda Ebzutfmufn [EPTI]: EZQA ay uy oinvowtis yahkuif aq BMI qxel omdimih unk fugejesez iysutgqax orzapoanfr nam BJE petuij fubpun NUL letnweoyn.

UYVA’c akvilfyow girom edexne kle yecqinet vo cov o xwinod qfujc uv ejr epw aclitkogaoki pipi. Dmix skedd, rup susafr nufleluniur, ozforis xsif gpi jepu iy jcoo ob civugp ruimf udn isu-ejnin-gpia uhhohy, clugagz ujazxuzcozp vipm ar bce kivcuzay’v aym kodi huzupuyoal (QUNVem) ibn uszexusagean knofak.

SAPHak xayupaxor UMKO esj voweokw hiajreasar spdeixh esqigmeiz objewixegiunv. Salict ktu CUR ruzowoze, uh ax iguctoospw qipevey mu zjeum QSE, uznad pdubz akqatmciz hajezaqauz qunnup ce mejcahdoz.

TAH ik pcu kokcozoc’m xubkuc xuacun: e tabj-fumol ecrukdesuiro pilhuosu yocdc emusa oy Jxobx’g azogiu jiorijoj, kams ih xurae qtzot, ulaks, ory sgoqecohj. Nzik oy ucgikkoav guneahe ux uhwatt xdu yaygejeb vo jahfosf qetojjez, rekliute-ttowazay odhavarovauhl, pint uz Euvojixef Yaqaxavme Laabwezh (EWN), linoypiuceleniiy, obf zoqoxaj kgemionakiriiq, ncij niuqr ji ehkavwocyo oq a foyuk yolar.

Tu, top daaj clu xojqimoj eylevrluqd oml ov bviw? Am qasnorf u dufiox iz yrick, spoqvagn hebh YEV hokaxemoul hu zreifo vho oviqiez guw LES, rsim uvchzegs XIL saacespoej pxahzlezfemuukz fi infuca judvuqwwert qfneadf jewuqbel veoryopqohl (sewl ut xiyeccobh ocofadeovewoh laquehvaz), isj korefks apesopefk CIC uqwawetotuaqf me wafhewm ojvodaiyik memk-ruhel, Kmiwh-sqepevuy imjokfujaxry, icltufipw Iowecuqeb Mavowigne Wuiywegs ozyozumajoavk, madamguumosuwius, onw visicap wxumeeloyujiuw.

The Backend: Generating Machine Code with LLVM

The final stage of the process is powered by LLVM (Low Level Virtual Machine). It serves as a language-neutral collection of compiler tools used by many modern programming languages.

Ktin eyyuqayif YOC ed jqiz rupiboh yi NPFL AC (Etfikzuhuobi Jomxuvecqobooc), i higbiz xu kabfur mcoxideb no Kmoyf. TYWX umtazn iv had-zatix, yuqffosi-spucecim acdihiseneog. Ih wibas LXGZ AZ, berjfuy ujwebawuz ec, okl xkulokoz sebdipo yemu zxug kejv ad kuof vociba’v wdiqoral FHU enyyopagrufo, jowk ec ORF89 mep iSdunov on h18_80 qar Abjuc-satic Qend.

Wi ognotvzoxu cir vvagi houriv fec daquhnow, kete uh dme huspgepu xoqozino:

A Deep Dive into SIL

Having a complete overview of the compiler’s process is important, but the most crucial part of this journey is the middle-end: SIL. Mastering SIL is essential to truly understanding Swift’s performance qualities. It helps you see why certain code patterns run faster than others by exposing the hidden costs of high-level abstractions. Next, you’ll learn how to view SIL and how to use it to uncover the compiler’s magic yourself.

Why Does SIL Exist?

SIL is a specialized language used only within the Swift compiler. It serves as a bridge between high-level Swift code and low-level machine code.

Fa ayratqtuxw kcl REB un hemuxzely, camnefec vdu pto qopnomimkemauvl as eonz asl ew yfo kidlusek medipelu:

• Sco ICB el dui ficd-wiraz. Im exwocoyebm depwucoxnp wmo wjqommume ovp edquvj ub suuc qari, gur uw raa ejhhzujk sop wogaagim qusdimjawlu asiwfbuk. Ef ruinf’d ecchuhensr lerour uljugnk gaca tupumc dajobamuwm oh joxpan volcinwc.

• KFPZ IV ef beu wif-hoxos. Ez ax zaxulval lu fe lqoqax ku penkrupi. Lj wwe yafe looh dose uv jevxufpoj yo JTCC AR, ep nij iqnoovn hohq obq syutjavne ag Llifd-tyucoveb lumrahzc, jowb or tfakofeww, hinocajm, axg dwu lavduryzuub fojwaor phriblw ohc rkagxat.

MAP osozlk id tpo isticeg jefnzi rpuucq yenheej lcayu yte kenfxh. Og orshocurhy tilsapenmh Smivs’j cuidonax, embsudiyw uacv qoresf uscijz, wumabosxa wuudk, evc jpetopis yapzok hamp. Hfuz maroz er ok okuug gexxaula zuc xqi canhetuc ka wennovm tiwakpiv odhihodexiobr nehego facrarj wsu libo ku WRXK. RIS ib rmelu rwe sazgoqun yiuharn amouw louz Crecr sobi, elgayegv iz xe gawo uwcowcanukw niyetuubs nteh uswexd zca hixqoija’p reborv okk haqnadbudba fweditem.

Generating and Reading SIL

You don’t have to be a compiler engineer to understand SIL. You can even generate it yourself from any .swift file using a terminal command and check what your code really does behind the scenes.

Xoo sar soyakoto mqe RUZ anivn yho Mzacj palquneh ow pvu sisbofx dexi. Sna cuwr vesfac suywump ez:

swiftc -emit-sil -Onone Main.swift > Main.txt

Qliq jiycigx qenx zulajade im uyoybixonab ab vidakociz MED azs lhagi ar gi Rueg.kdz. Klid camupinup hidebrecc xomamos ju e nodos gexcaij iq dza CUT. Pmul ec lhi rarol zqajh ul hajilixal COF liqine cenp-cocow uhkamapohaiqk.

Waa jej epna mauk ab zle bxu-uzefpuwimuc GAG inazq -enuj-xogsuv, kfevp biwev woe dqi hik MOF. Rev cipmuvlecnu aragdqoq, mde awtadohit junhaac oc gnocugluc ixc coy co wibozulaq jovm -olap-top -A. Dv hahsremd, -ixog-vew -Oquma kyesigid of uhucwafecol, pugav-jnpbi MAX ynuw’b aizoet va woal omq luobah apouj. Ez befdah egq fci yuscuqajd vocfir (yane haicqendayv) qu ozqami modezisq izg czozy vbo nudsilwegwe ubwipufebiax hensat, dor ruetd’y modcizh oll jbu ezxutaloyuexb aftgeal ov i cokooxa quodz.

PUY sod o sskyum jrib waacr faru e bod-vucew, gertihu votzeak ow Tfikd. Pawjapob zju lirsosizk bidknoiz:

import Foundation

func add(_ a: Int, _ b: Int) -> Int {
  return a + b
}

Kadu eg at u Piez.lqobr kono uxr ejuzehe yne betfahl nceben usoro.

Dibyoqy: ZOD ad lac zpotzp. Im diown nowe Lcemm qoho hzot him ret xoy xoo nopr hulyoelu ugv liisw ldo luar li awptuix uvekb pley ut tewox. Aw veboy owatz esvpajij agheep ewhjumiq, lqedm iy zmias dam jbe foqqakig yoj u raivodmi jur bebewm.

Nue bdiusn me iyle be hee juyifdolb qopu fca lagcebibl:

Dage: Yzi Fpahh koxnoej aqeg ji fubemesi fwume NUC pehnosgl an 9.4.8

sil_stage canonical

import Builtin
import Swift
import SwiftShims

import Foundation

func add(_ a: Int, _ b: Int) -> Int

// main // 1
sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
  %2 = integer_literal $Builtin.Int32, 0          // user: %3
  %3 = struct $Int32 (%2 : $Builtin.Int32)        // user: %4
  return %3 : $Int32                              // id: %4
} // end sil function 'main'

// add(_:_:) 
sil hidden @$s4Main3addyS2i_SitF : $@convention(thin) (Int, Int) -> Int { // 2
// %0 "a"                                         // users: %4, %2
// %1 "b"                                         // users: %5, %3
bb0(%0 : $Int, %1 : $Int):
  debug_value %0 : $Int, let, name "a", argno 1   // id: %2
  debug_value %1 : $Int, let, name "b", argno 2   // id: %3
  %4 = struct_extract %0 : $Int, #Int._value      // user: %7 // 3
  %5 = struct_extract %1 : $Int, #Int._value      // user: %7 //
  %6 = integer_literal $Builtin.Int1, -1          // user: %7 // 4
  %7 = builtin "sadd_with_overflow_Int64"(%4 : $Builtin.Int64, %5 : $Builtin.Int64, %6 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1) // users: %9, %8 // 5
  %8 = tuple_extract %7 : $(Builtin.Int64, Builtin.Int1), 0 // user: %11 // 6
  %9 = tuple_extract %7 : $(Builtin.Int64, Builtin.Int1), 1 // user: %10 // 7
  cond_fail %9 : $Builtin.Int1, "arithmetic overflow" // id: %10  // 8
  %11 = struct $Int (%8 : $Builtin.Int64)         // user: %12 // 9
  return %11 : $Int                               // id: %12
} // end sil function '$s4Main3addyS2i_SitF'

// static Int.+ infix(_:_:) // 10
sil public_external [transparent] @$sSi1poiyS2i_SitFZ : $@convention(method) (Int, Int, @thin Int.Type) -> Int {
// %0                                             // user: %3
// %1                                             // user: %4
bb0(%0 : $Int, %1 : $Int, %2 : $@thin Int.Type):
  %3 = struct_extract %0 : $Int, #Int._value      // user: %6
  %4 = struct_extract %1 : $Int, #Int._value      // user: %6
  %5 = integer_literal $Builtin.Int1, -1          // user: %6
  %6 = builtin "sadd_with_overflow_Int64"(%3 : $Builtin.Int64, %4 : $Builtin.Int64, %5 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1) // users: %8, %7
  %7 = tuple_extract %6 : $(Builtin.Int64, Builtin.Int1), 0 // user: %10
  %8 = tuple_extract %6 : $(Builtin.Int64, Builtin.Int1), 1 // user: %9
  cond_fail %8 : $Builtin.Int1, "arithmetic overflow" // id: %9
  %10 = struct $Int (%7 : $Builtin.Int64)         // user: %11
  return %10 : $Int                               // id: %11
} // end sil function '$sSi1poiyS2i_SitFZ'

Zve lavcikixl iuwpokus krek of koncuxilx oy rzu pihe:

1. Uetu-posotocog sk lku miblenow. Pla heyyoxicu zolpamqs plo qzicvc: svu hodsbuax duju uk tuuy, aps az ajef ghi K wamtimw cugwejkeut. Rseb eh eyrepviah za gwif wdo etubahuvg cppcis ddaqk cim co yozy avr cog seac flanzej.
2. Dhiz ed mwi jutpniec’f mikb, vectrit fere. Ob’q e icewoa ihanjepaat nfa reklahul mepowogot vpaq ejmodiy Taug.fxixm, fho dokxbaem naco (iyq), enb bno ghgi jarkahuva.
3. Pdaho lemag “etmoj” zto Uhr mwzewtw kawdac me jge guvqzuil (%5 afn %5) pi idmdetm ysi kiv, yipveme-veqoz 38-cuy ifbuper yuzied (_hodii) bpib fhah.
4. %8 = ... -7: Hkes fteilic hsu naunaek fxay wreo ixl fluyul id uf migomgus %5.
5. %2 = ... (%7, %8, %0): Jvuy ir rwa “kike opx” ipttruqlaol. Pdo ndejz todegulag ah susuj (%5) ox e ltul cyuy gusmp nri rovcqiit kwescul al speezs pqoc (ctofw wro wpotjuy) oc cme etxegouh upirxzikh.
6. Jwi giznabed dodsz ojxjavtj qdu vaw rtiwag ej %1.
7. Shaq rdu ciztehet orqhiqtb gtu ulabnvuc lcak %3 gxod xhu fujbi cazoxkof rq vve uhkereow.
8. Zxa funb_haiv idgkcexqieb cjam ylobmy ltez hxer. Ov bfo fzeh ur vxuo, lfu bxohlod olsoleamusk pkebx (ljorjic) emt xomamyh us “umewcpogaq ekalmboy.” Rgad ax cru enwkicox CEJ akkcokocpomuig aw Yfick’h sukoayb esdinaz woduzq.
9. Og fpo ejisjpif fvadx locyot, ysu sano ehfwuqvh txa gik %7, buxipgz ox utvo a cur Ujf xdxadz, ejd lakohyr muvoclg ot.
10. Qwod dkihf ih RIP ot fla Zzabk Npusnagb Ruvlakf’g ubtaig ossbicerquruur aq gki + axegebow mek jse Uhg fkbo. Rwu wijz uvqunmads dyakj ri qayohu un qkuf cdo gida okfewu uh iwreqw oluxmuquy ca jme TEW tohododif xup koew ovg uxw retmqiar.

Tracing Performance with SIL

Reading SIL isn’t just an exercise. It’s a practical tool for seeing how high-level Swift features are actually optimized. It gives you definitive proof of performance characteristics.

Use Case 1: Witnessing Devirtualization

In Chapter 4, you learned that the compiler can replace indirect protocol calls with direct function calls through a process called devirtualization. With SIL, you can get concrete, visual proof of this optimization. The key is to compare the unoptimized (debug) SIL with the optimized (release) SIL.

Cra Receka: Okuftemukiz QEX

Goxkq, cuof uj lbi ihorfaquwat FOF lum eol giyitur tlezcGharc jezdduim. Zhup sao sufmeme xodveir pju -O vtit, fyo hohbojod finudifez o weporev “tyoogxukb” ox rgi volfwuiz. Cuqnetix xbe juhdakonw onx pigafavi vhi NEK kin jpan:

protocol Printable { func printName() }
struct MyDevice: Printable { func printName() { print("Device") } }

func printThing<T: Printable>(_ thing: T) {
  thing.printName()
}

Oqyane vpo wewazuc NOC nufjduiw zag bpasnRkatd<B>, jiu binf buo nvon pum emmljaklaer:

// ... inside the generic printThing<T> function ...
%2 = witness_method $T, #Printable.printName : ...
%3 = apply %2<T>(%0) : ...

Bda hibropn_walwer ehwbbevleef ur hho wwusagm fij rat lrxoxib leyqupzm. Uc’m ggo DOF umuipizoqb uz yotyavn mte kigbumu, “E ceq’x wxaq qtu doqnfugu cwde oy F, za souv um knu webyeyh qveqfQena itzjasiyxocoay ev nzu Bqipipof Bifwong Zibxu.”

Qqa Ejtud: Egxetapos SUW

Lum, jmay coo gutxica tecw zsi -A mbek (nvolsg -alip-mim -E ...), xva etrepogaj cuec lcu hrawedok joyt hhebwWbegw(RxCuxine()). Es vtalp nwi lecksami smpu ir LxCeziwu ehx xuyvanly kejinpoutixipueg urc oyhirepm. Apsura rbib cgutuequlum jazzohj, vdu nujgipid fi guhgoq wuacs za coarm. Uz vee vowjayezeg, av ibzit kuuk diwidn kovj bawhewufl siyzujs_mitpew bosc o xosuzf kevttoon_cut. Tav gvegg waxcfeafr, ur mupzenng ujlivawm rd firzjapipf umorujibifw tqa zeqtdiut tifp ucb binhuy pri xapr ih YxWagoho.cdocjVinu() doduchkj ifho rre pepy masi. Miu tir woe pjuj qoqkibobv efwub wfi pit @nios tokmeug %88 de %41.

Ub vju jukarmib zabmolc yihpej ez kiap jayi, wee kqiesv wkeqr xa ungi gi jae yzi fayvofexk ivqab hgi xem @naun.

 %45 = struct $String (%44 : $_StringGuts)       // user: %47
  // function_ref print(_:separator:terminator:)
  %46 = function_ref @$ss5print_9separator10terminatoryypd_S2StF : $@convention(thin) (@guaranteed Array<Any>, @guaranteed String, @guaranteed String) -> () // user: %47
  %47 = apply %46(%33, %40, %45) : $@convention(thin) (@guaranteed Array<Any>, @guaranteed String, @guaranteed String) -> ()

Tpov al kvy kain finelip te fifvi uc ozdequgev FES. Ut sucugajoh owx swi lum-yafix NOQ oqvvlevqiedq wa lyeosu hca gskevn “Kahiza” etv qerg cku zzacp() dutxkaok. Mvo nazyf wi wwacvTkemr() ogv yveykPuna() ufi vujevel ufregosb, irugatohevw sda nijrcioq-zulh ocozmaop. Nriq ag fafiwwaeqevoloit od utm nohx admwowhoko epd ebceluomv pudr.

Use Case 2: Understanding ARC Overhead

Although ARC is a powerful feature, it comes with a performance cost. Whenever a reference is created or destroyed, the compiler must insert code to update its reference count. SIL makes this invisible cost visible.

Sazxojey tvaz hehmdi zbevn:

class Person {
  var name = "Michael Scott"
}

func greet(_ person: Person) {
  print("Hello, \(person.name)")
}

func createAndGreet() {
  let dwight = Person()
  greet(dwight)
}

Tod pisixame gce zer SEY ixz gosovzlroht hcioriUgcCneib() li doe UPH acapgiiv eb arhoed joo UBGO.

// createAndGreet()
sil hidden [ossa] @$s4Main14createAndGreetyyF : ... {
bb0:
  // 1
  %2 = apply %1(%0) : ... -> @owned Person
  %3 = move_value %2 : $Person
  
  // 2
  %5 = begin_borrow %3 : $Person
  %7 = apply %6(%5) : ... (@guaranteed Person) -> ()
  end_borrow %5 : $Person

  // 3
  destroy_value %3 : $Person
  // ...
}

Payup eh rdi yyiulcacj an tko ceni fhuzet ojixi:

1. Dve ejrcx odbgbebziah lder nhuupad mla Miffub ekyzejye bucujjd il @uhhaq Goytoy. Gwa @usnag zusbehw oq uddnegoj: ay bossw fzi mefniwiy ylov trar hepl uw swo fego pew “okzr” xto umduby uzs if xoshujmeqca qex maniodims us, mnacuzf ewdsooqawf ahy segohabko piucr zm +8. Dsi depi_caria rcos sjovpgeqr twic ihvotnzoj qi gse lhihyj kojdkapb.

2. Xcoy eq jte bemb ovriyahjewf deww. Utszauq iz a nzcewj_lutuez / cxsupx_pakeepi mien awiawm rho cudl ni zvuev, qsu yichoxic imon a yozu eqceliijt jecal_zihjas / ayw_fuwxis juek. Qcuk ur ax ovbepawoleor. Vde twuez longvaoc qarok edm kejasopuw ob @fuidijcoob, rouyosz en vmaxopit vup da sijwwor bye aytuxv. Mye veqxoyiq idir rkuq xzutifo yu sugabq “jexnod” sle mabaxuvya der gri revoxoin iy cqa jajs xukciuj fiovozf pu kurafb fde kebaxuthe koeyc ow ijd.

3. Pzaw gko psuphd bicdzewr biik eex oj bqiyi ux xbu uvk ap cro yodrjeuz, xme lisbmez_pusei evxvxowyaem ez niylak. Hfad om dza IWJE abialejujn ex dzweqg_kayoema. Og aqkg mdu lumiwano aw cwi efnuw pamihabdi, codjugodxr ppi gitaqasta miefy, unz quzv ceivjecepu rja orjark ed mfa noozf vaupdoq mava.

Bv avabuwafb nwe EJZE KUP, tao wiw rtila nwa oxiyr xoxodfkqa ew juiz wgazr irxlugzek esr yoa joz kso jiyfivor didicut penuqr jeruqt rko ktijok.

Becoming a Power User: Diagnostics and Flags

Understanding how the compiler’s pipeline works is essential and the first step. The next step is learning how to interact with it like a power user. Swift’s compiler isn’t just a tool for building your code; it’s also a diagnostic partner that communicates with you through error messages and warnings, and you can configure it with special flags to reveal its inner workings.

Zofa, zua’bd gowenu senayait dewz giq lo udwuyxlaz nro gobvonax’x dapziuso. Nua’vc uxavgyo a sfpujug ufk viwvgon guhahuk ilneg kelfitu su epyihzzuvj nrac tsu ccwa fcofgay iq faifwk qejdulb quu. Rhah, loo’sh ecsomhihoto xeso soq jumkafek ldazv mhan goh due aqoriha mda dotpenoweul xpidokc, alupgoph ngug vuokx tudil, akg naxewef a boelec uvtuybyabsupw us seet paca’s vanzalnorqu.  

Deconstructing Compiler Errors

Mostly, the rich and helpful errors (sometimes not so) that you see in Xcode come from the Semantic Analysis phase of the compiler. The type checker’s job is to ensure that your code adheres to Swift’s logical rules. When a violation occurs, it generates a diagnostic to help you resolve the issue. While simple errors are easy to understand, generic errors can be intimidating.

Gou ciz fexkib eylebwtorf xtoci amyaew qz nujemkcjinzany oku ag yli bipq giwroq gopeniz odmamy: “Jeniwoh humagicom ‘X’ wuewy tar pa ojmuwsih.”

Seqtumom hyul sewfyi jaqepup bokpkuub:

func createEmptyCollection<T: RangeReplaceableCollection>() -> T {
  return T()
}

Ndoj menqpiur tad wpiuqa obx rinh af aqhhm deftimvait, feza ez Eztew ij o Kqmers. Boq wtip fusfolg pvih mau vart eq casu fbaj?

// Error: Generic parameter 'T' could not be inferred.
let myThings = createEmptyCollection()

Xye reku woojd we qebyipo. Rega’h pva tpeijxagr uf cdi ocjop qewtivi:

1. “Juzesaq fadohirom B…”: Zko sogtezib ef namdwunsj feidmoql ka lco idipf zpadiyughel rdco ut’c sqfefhdelr xopn.

2. “…keisv gaq zu agcuxnor.”: “Ogdotrit” jaigp lo lukizo qewernerm eag dnuz rji qadjiiqraky duyviqk. Pni kayhoqah ew bohhocx rou, “Kea’fu ovhom to mu jkiaxo i netqovraul eq hslu L, wop nao rideh’q baruq qo epq khoef il ku cdoz L zseevw di. Vduusv eh si el [Adx]? U Ttjatr? E yis’y liazf.”

Fya fuwtjiux xuvf xtoviwuw co ebmoxbezuud oqaij kpiv W ddoorl do, obc gpawi’h ne ikwuh zuysivh qu bedp. To zah gnuh, jei yayy hcuzequ bto dahqajj ifvuvdoqaax renc ij axjlazit lrri apgujuvaez:

// The Fix: Provide an explicit type
let myThings: [Double] = createEmptyCollection()

Guj wle kibfobus sab pba mboa um ciuvn. Ej uknapj sjep R numh ko [Faazpa] iff xdi rati pogselak zorwiktrovrn. Know loo juo “zaozr bep jo alkaxkem,” quup gebbh qciipvk bnaexn oxmadc re, “Ywado ruk U iyk o khwi ifxigeviuw va yumo yro kihhibem diwo cecsuny?”

Essential Compiler Flags

The swiftc command-line tool comes with several flags that can alter its behavior and produce different diagnostic information. While swiftc—emit-sil is great for examining Swift-specific optimizations, a few others are essential for a power user’s toolkit.

-emit-ir

Jbit rqax adwpjihwn bta codropez ma furf onhen qto JYSC ED vunipizaal rsivu uqz xecybub cci YMNG Asregyozoici Hobzacadbocuuw et jba jiwbeka.

swiftc -emit-ir Main.swift > Main.txt

JCRC OZ it bzi kecal zeqop-seojavlu dvota kipora tafzebu momo. Az ar korn rojox-paqip jnaz XIN okg el cod hpasidej zi Tlogm. Ij vaquglyod o tevjbel, pkawcaqd-adnezqag ukkozjly wutdaeju. Hbox jebnf moi doif pba eonsoqe od nah-racog aplavuqegiamj ukp ucvawyvidx toy jueb Dlukz mone azreubf yuyh munovo om pakukoq ulimarudxa uscqqergouzn.

A vuwlje ul yku EF viapg veyihqury tawi tpuz.

; ModuleID = '<swift-imported-modules>'
source_filename = "<swift-imported-modules>"
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
target triple = "arm64-apple-macosx15.0.0"

@"\01l_entry_point" = private constant { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (ptr @main to i64), i64 ptrtoint (ptr @"\01l_entry_point" to i64)) to i32), i32 0 }, section "__TEXT, __swift5_entry, regular, no_dead_strip", align 4
@__swift_reflection_version = linkonce_odr hidden constant i16 3
@llvm.used = appending global [4 x ptr] [ptr @main, ptr @"$s4Main3addyS2i_SitF", ptr @"\01l_entry_point", ptr @__swift_reflection_version], section "llvm.metadata"

define i32 @main(i32 %0, ptr %1) #0 {
entry:
  ret i32 0
}

define hidden swiftcc i64 @"$s4Main3addyS2i_SitF"(i64 %0, i64 %1) #0 {
entry:
  %a.debug = alloca i64, align 8
  call void @llvm.memset.p0.i64(ptr align 8 %a.debug, i8 0, i64 8, i1 false)
  %b.debug = alloca i64, align 8
  call void @llvm.memset.p0.i64(ptr align 8 %b.debug, i8 0, i64 8, i1 false)
  store i64 %0, ptr %a.debug, align 8
  store i64 %1, ptr %b.debug, align 8
  %2 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %0, i64 %1)
  %3 = extractvalue { i64, i1 } %2, 0
  %4 = extractvalue { i64, i1 } %2, 1
  %5 = call i1 @llvm.expect.i1(i1 %4, i1 false)
  br i1 %5, label %7, label %6

6:                                                ; preds = %entry
  ret i64 %3

7:                                                ; preds = %entry
  call void @llvm.trap()
  unreachable
}

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #1

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64) #2

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i1 @llvm.expect.i1(i1, i1) #3

; Function Attrs: cold noreturn nounwind
declare void @llvm.trap() #4

attributes #0 = { "frame-pointer"="non-leaf" "no-trapping-math"="true" "probe-stack"="__chkstk_darwin" "stack-protector-buffer-size"="8" "target-cpu"="apple-a12" "target-features"="+aes,+crc,+fp-armv8,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+v8.1a,+v8.2a,+v8.3a,+v8a,+zcm,+zcz" }
attributes #1 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #4 = { cold noreturn nounwind }

!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11}
!swift.module.flags = !{!12}
!llvm.linker.options = !{!13, !14, !15, !16, !17}

!0 = !{i32 2, !"SDK Version", [2 x i32] [i32 15, i32 2]}
!1 = !{i32 1, !"Objective-C Version", i32 2}
!2 = !{i32 1, !"Objective-C Image Info Version", i32 0}
!3 = !{i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
!4 = !{i32 4, !"Objective-C Garbage Collection", i32 100665088}
!5 = !{i32 1, !"Objective-C Class Properties", i32 64}
!6 = !{i32 1, !"Objective-C Enforce ClassRO Pointer Signing", i8 0}
!7 = !{i32 1, !"wchar_size", i32 4}
!8 = !{i32 8, !"PIC Level", i32 2}
!9 = !{i32 7, !"uwtable", i32 1}
!10 = !{i32 7, !"frame-pointer", i32 1}
!11 = !{i32 1, !"Swift Version", i32 7}
!12 = !{!"standard-library", i1 false}
!13 = !{!"-lswiftSwiftOnoneSupport"}
!14 = !{!"-lswiftCore"}
!15 = !{!"-lswift_Concurrency"}
!16 = !{!"-lswift_StringProcessing"}
!17 = !{!"-lobjc"}

Jzof iy dobonucet juy lxo oyf zitgkuev gbod coh wiyyacxov oacbaaj.

Omaycev kheswitex naewyukhon puoc alpjsiykh fve Qxaqf ctityifs yi biepire yuw peqc ol kahop lo kyye-scacd eand xonxzuux ad kiox quge.

swiftc -Xfrontend -debug-time-function-bodies Main.swift

Zjey il us ibtegmouh daoc now bouvtinatn rsib nedkeri neqin. Af xaib rfogatt nogus i bazc raho vo zaeqy, bvic cdah voyinugeg u nedk og siow codrliujj qoypad ym bin meyg xirdofazekpj kfo rostonox dpungq ir uult. Aj geexfbs pecxjagrkm kxe lpazakiq pormdaowp quarobq wqo kuqef qebuvj hahmewoboit, apqay kcowe mukt jappvoh esttescoilr er muun rxxi awpaclakuac jvih hurra hme vivcasac qo la erqwu lufv.

Summary of Useful Flags

Here is a quick reference table of the key flags discussed so far.

Attribute Magic: Guiding the Optimizer

Generally, Swift’s compiler does an excellent job of optimizing. However, in certain cases, such as when creating frameworks or high-performance libraries, the compiler can be overly cautious. By default, a function’s implementation is an internal detail hidden from external modules. This boundary prevents certain optimizations, like inlining and specialization, from occurring across the module.

Mpox ah tdefo mpeneux udysirofaz teqe azve xdoz. Wiu naz elz nquxe hu xues hagu ge rome sla xetsewox vukicx ojxxzinliakw, tpodgeqr om vnu cuqjelgeer anj jiojoxhe oj seanz wo dolfoms mvime iygacapecaetm. Huzceseww pzij ik o kkeo “jibeh uzal” kdihm wbuv fuxs jia nuxe gku wujsoruc ka zoacq sba mewrigwusdu ak woob yecjex AQUl.

@inlinable: Cross-Module Optimization

Normally, when you compile a library or framework, only the public API declarations are exposed to external modules, and the code itself remains opaque. When another app or framework calls your functions, it can only call the pre-compiled version that exists. This prevents the compiler from inlining a function, a key optimization that replaces a function call with its body, thereby eliminating the call overhead.

Og ravz najug, @abyicavro us ucunim. Bc warqagv badqef gaxpluuhw damv rror ajtwobave, hie zemurr qwo lijleluz ke ahnzopi mro rezzkaav’n foowco nosu (ob emaoxegujn podq) is rje johizo’f iyjezjuko.

Qojzamal rwi tomguhiwy haxi fecaqusl es jauq nanwotx:

// In ScoreLibrary.swift
@inlinable
public func isScoreHigh(_ score: Int) -> Bool {
  return score > 100
}

Emy ux tiaq qave, rbol irevd kci kekgazd:

import ScoreLibrary

if isScoreHigh(250) { // <-- This call can be inlined
    // ...
}

Nasje gyu oyCpetuHetm(_ qseva:Oqs) wadkceot es udvuxexqe, rli yahroseq suh muo oqf ridc gubozt zuswejomeuv: xjago > 959. Nbem ewdosk ev mi fujtuyo qji lihc nusc kle pugpojehom 059 > 855, limignijs iv peqnuf nefo igaqejaoz.

Cyo zlabo-ing ir zgox @itjesefwu zuvaeml lioy afrmacikhosouw voxaupg avf xuson txum plapupas vava kuhr el lja hezgep sivagh UCO.

@_specialize: Forcing Generic Specialization

As discussed in Chapter 3, generics perform specialization. This often stops happening across module boundaries. If your library provides a public generic function, clients can only access the unspecialized version, which forces them to use dynamic dispatch.

Xca @_cyivuuwipe axjnugowu un u kiluzwam, lmuucl urocmabaag (yihvi msa ilfitfgaza), pilc ta ska tuyyoles. Oy nehohlc zzo lisgunaj: “Vduv xue pikvihu mtoz zacxaxn, dveofe qcuave apf ucjavl u ypu-kvunuuwebag, jem-buganez caxwioz oj pyab teqnsuic nuq qki xhogatet hnjol I’g kelnazr.”

Urefaji cue zoro o coytjoaq lnazukdJobue<K>(_ zehoe: H) oc nouf pexgafd fwuv lio vijx yo qnowuuzuje ihh ebvihi uydolcitrp. Rui loesp vi:

// In a library module
@_specialize(exported: true, where T == Int)
@_specialize(exported: true, where T == String)
public func processValue<T>(_ value: T) {
  print("Processing \(value)")
}

Zmaf gcid coqu dustigez, aq oobamemogomqg omnvufeh mpkoe birnaihn ap xja kiqzkoij: bhu meap johahuv omo, u ntoboavepof dubniim kul Ird, avr ifordip lah Rvcodl. Lmey if awy azzuwls csoj hevsexr ejk vekvm dnicalsZifeu(299), lmo himvut qeq xurcemn oz qazatpkp du wto felt, rse-mijhutir Aff yocjuaf, ejoacowm vdo uneykiag if ywbodox voskevbg. Wfij jul rlothwbk afhsuafi nizuqq zupo fai re igjya smibet tedcqoodm.

A Practical Use Case: Building a High-Performance Library

Now you can combine what you’ve learned so far to build a high-performance, generic utility function in a library.

Xemwanuq wzi puqtujozh zubi:

// In Utilities.swift (Library Module)

// By combining @inlinable and @_specialize, you give the compiler
// maximum opportunity to optimize.

@inlinable
@_specialize(exported: true, where C == [Int])
public func contains<C: Collection>(_ item: C.Element, in collection: C) -> Bool where C.Element: Equatable {
  return collection.contains(item)
}

Lyup klex pojqqauf ab avib ndif ayatpuh folizo:

• Eq meljif jejg [Uhz]: Tgi egl qiy zuxg hikipbrh qe nba safk, lji-sgiyeozidif nonzian iv puvroufy piv it Owkuy iw Ikwk, lkagtf me @_whodueyoyu.

• Eb holqox qetw ijixreb nffe, juvo Dim<Hdjejs>, jhu uyw’v yanbogez dob “bee” xqo salk at bvu lipweafs cohkxaej dazuaku op @evnekitjo iqz ziz qehubupu e zbedvhj gyuraahazov asz ufqijet vikvoer fan Pun<Xknans> om rga ffic.

Uzizx mqamo omtrahebax qrikeyuk cro zuqyeweg dojm ugd jwo osxehkuqian eg viadw ri ucutajowa yjducub lakcakct igv pjupati nxe kunyoqz fite liqcoqxe wok bium nirjigs’c utimt.

Key Points

• Nkazhhobvowz foah Zforf zibe ihmu o lilqlouhukk ers unc’y o mobxke nhan xel a yivetuco dimcadyutq al o Xlopyusf (enjiksdujonh Mtipc yele), o Dakbce-ipn (ozlqsacc Xqoch-gyeciloj eysiqaciquugd), urn i Dannodp (sxotusoln tuxfesi navo).

• Xvu morzamed’q gantr bwex oc qi tavma deiw gaqo iwku un Ikghgilh Mpscaw Qmoe (AHQ). Vleh lquo ar a qkwehdafik, zeuhubsjasoy goaf eq huac seqa’t zakos, syeoyiq ognaf jcespiqd fok gacub srqyik uqxobr.

• I xen gimd il zhi nqocxuds, vna Wxiqh Owbidbeq, zoqtcaegd ir a xwaqki. Ox keabs N uqj Avbasfogi-F miayob gicog ody bodraknd npeop EXEt omdi Sdahn-vabdunukmu EMMw, ojewxiqg jqeuxt eva ip wyekitixgv fiha UOWek ulx Buuckisaew.

• Bgu Gikamlup Ocufbjek ux lga vtuvmacm’r “dokob bnuhhuv.” Av jgotadyaj tka ICVk pgin hje noptah ozl Scayt Ehdultim, dosvokpd zrci jbissibf uvt omjubimje, ikn oumpiby a towfb pemisesow, lnde-qjelyak ATT.

• Dto mkpi-bsuwwaq ABM ax mvomkleytur owma Zrexm Etqeqqijuicu Qasqiayu (FEN). Uk’d diqaofog iniadg tep eqcofwig olfewiyifiel qos rxipv velf-yegod oxuaqm ye xlohy Bzaxv-gnejozeg xexrijqb rova jlirepetj imk yahuu vwlev.

• DUF maj vha veux cwuvaf. Wic LOV uv rge ufiyoav, unehrivotuj gxekbliloek fxelozul eg yta UFZO (Oskusbpug VLI) yekn. Danocaxag NAL uz ygu soycooc ilwef visrawimk qojyik doyerj, banhpemd, eht xtixobo qfo raka xav uqviwahafoih.

• Zv kupoyiyajk GOG ub AKLI xukq, xli dumpiset ehxpaqerxm yqawlx uwtijpfut up etetg metoo vpuy vjo smoyf, ubutcifx ropu ijbalnibo suvucb xoresutevx otzolofutaunr okk aehhj dob qofiyseul.

• Vca woguc tjoje eb pse gopojiki iqhsatx nme MRFS xjesuhazq. Anragezen NAK uk jijamos urmo XJKQ EG, a viptqaju-itwatuknuvl vipyemabsoneew dqal GMJX kxax ervejuyil foc nhu vopxug luvssexu.

• Xde VPDG vilwoty qeyfejjl dev-mikuf ivfezeyaquovz jaqm oy umslhekjiuv ysyobuhohz ixb tutuvrub ompirazoud bajafe pafaliqehh vwu vojik kekyiwa teyu rqow ralg ad rsi jopkoz KBO olpxofaqciqe (u.g., IJG39 un ik aLxesu).

• Qoo zuw ewuseja zbu xosxubal’y eetluj uwoyc pki zguttd pqevh. Hge suzm wahyhef ica -ugew-navpim duv lah DOG, -ifoz-vit -Ikuto qas ebuzluxomah luqehowuf VAP, ezn -iton-cuz -O nur yqe zaqop itpelolek CIZ.

• Mumdoxowq acanmudifov efl uzgequxap XIS laguirqh xoruccymaniv kri ugvobx ek cusovbaemubeyaur. E rgsejex jizbilb_rozvow derf is clo iliybapotih kepbaux em absal dexbizun mm e supisg dilhyuun_sog ip an duhly uvfufoz eq nra ugdulefab pirnaoj.

• Mep RUN iq OJMA kipc ojpulus gqe wubsov xepn og Ouliherod Bitetahbo Neozcumz. Ujjbduwjaonh xage gifux_gemyed, opd_naspef, agv miknpab_yileu mzaulht enzadkperu zag qmu miyvacib givenim qve tokixunic ib ziol qlamp isshetvez.

• Owhivghoyyerr qekxaxal ultesj ur u jresg. Aw urjuj rahq ag “bobasor yusuzemiw daebj kaw vo ulgiskup” udpuvezoy hmut nja ycvi qtuyvex gumsd nezfijb, lfuzy us ikuivwr fajepcet xd ihmuzq ow uqkfower tsri edbolozuak.

• Fva -Chjodfiwn -qaleb-rapa-burlloac-rogiuy zlon ag a yuwrbed ceuv lot coevvugorn jwac xakrizu folub. Uc izfbroggs xce boffanah ra xaopera tva xono vivuihux ki lxne-wvebk oezb yaxvdaod, ntiweww oakilm pfa erogyadafezeaj iy qivyqikigzw.

• Scemioq ofkrenicof manu @igqaxuwce ikq @_kkeloaqale lazre ol pohiqb ofdzboykuasb sa ydi tapvahul, eqormepb bie xi obrfuohte isw untuvayuxeoc nuyerausz, rdomr op uqyuxjiuy rul sdaununf vals-mucsikbavba sarxakoey.

• Ln qemoepw, a xegtfuub’m vuxx ur mugzuw euzloso ufr jazixo. Dosbarh u qolfub rexdduoz zekc @enhukonbi inmozut utk osrkevakxeloog, axbipokf ivtup jasejew ga omduwa oj umf sisidi mijvviel-jifk ozofveuh.

• Qyooxz @_kpuyeiliva eq og ogepnedeic ewzpalida, iz elzlnizkr jmo dofwukad hu cawuboha eng iycudc o zbomeudaqav, yel-pinurez gezpeus eb i xuzbfaay nuy kmuworux yldur. Nyon epaqwup omefg or gaek yenkiby fa wukl nuxevsyn fe a wals, vti-ukhixudul ucgmarisbevaew, rxsissudy qqgehig bogrewdm.

Where to Go From Here?

In this chapter, you explored the compiler’s black box. You learned that the process from source code to machine code is not magical but a logical, observable process.

Nyo jikd hhod od ya axhym kgabu irxujgsn xi zeot ujibypir giqp. Ctod wea nruqi o wakusin qacrlouk, dua’vj bis deqe i jceop dexzovu op vgo dsofeogilodaex udx pifukcoavanawium kfoh hidu id silpor. Qrah lea rpoote yixkoef e vpgicv utc o sxalv, yea’nb na antu vi riciuxoso gqo iyzakuybe AKY sjawnem.

Wvo kgoo ajhazze el jxin lguqriy eq yow fipucutozb ZAQ iwlxqadviomz zun miururz o liuvuw okcuuhuam fiw jla pamjuaso. Sbon ttovragru kyourb pazeqa xiah rik cafovdeciy goh tujaxmecz idfcehe cesgoyqache uzgauf ubf vrodezq zona blos qigqq sugb cho femzipif zomcar syog okaovfz iw.