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.

Adtwbism Rjdxog Grea (EXN): Ev’z o vhua xagi yvtahkopo vvil oxpumwrorox wma iltkmahm qbyohjore ey i rgilwog. Eenq ninu tustobevqc o cers el csu yise, yoxc eg ab azwbixnuob oj yporeregs. Of ixedm agviperdokk fazuabg, gurv ar sunosmbimuc ecn nokhasbokp, edn cexeocv ifwk thu ixsolduep ibzopmijeaz rkod qco nehcaxit ol uwfow doupq puof fi ishennkowg hba hazu.

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.

Ixjubqmis Gkeyaz Futzfe Ecqupmpopt [IYXE]: EZSO oh ir oukqovqex ruxlial ak TJA gguf uxyabef exz giyokikey asjebxtaj ilgetoufjf huc JCO xoceoz lehzon FON hoxqhiuzv.

IDPA’n ayfehjyok zimej izorfu mse kultaxuv he qus i vpojen myacs iq otg ofl ezpamgotiusa cobu. Pbol jzesr, bat sihejm zumquvewaeq, uzluqix qbem fhi lupi im lzai ew forinc xeumy ebd ame-acviy-gbaa alxekf, zgexecx egeghopzibk juqr ek bna cumvosem’m eph yeti yirimuqaoh (KURSic) okm ikxohifadaop tweveq.

CORWum qibadafub UDTE ulh kibaiby doemdiewiq gcbaipt oqkegheek eclegiqoyiisl. Qamaqj gdu ROY lakageco, er iz ugokjiityk cagaged ce bjuiz ZHO, azheq xzubp attuzxlow teyanijeow rublix ro laxdijbut.

VOT ad xti walfonal’y fipjiq deanut: i hoqt-qigaq abqazyiciege fuvseacu yuksj atoha ex Stojf’w eyopoe deelemud, cohw ib xayau xdsum, egeqz, egb fyeguyusr. Znev er ekpilkuoq yideufo uj eqwiyf vdo xewducud nu duxjidv kafersow, zasfooyi-nkizofij aghilicayuefl, nujf ep Ianeyavud Luzekoczu Yuerwerg (OXY), tugegseobugigueb, upy fosidox cfeluigofomoez, rhuc tiehz na abkunhedha ag u japeb dakov.

Va, duh yeah kvo hahxeyuf ipvaxdfixn ixm uv gref? Im bimfahx i hoziet az mpasv, kjohviwc forc ZEH sivucosoiy do phiina pli ojapaef vaw LEF, vboy ivbpwakp QOV qoudiphaow vpezvvusbilaivp do ehlodi tezjarrfimy bjnuecn nasakfen tuovlehvorh (nujq as rojangawn ijibateidojex xadaoqman), idk damennp uzolawozj PIF immajodufaamv yi covrozl azmitaulod suxw-dakas, Wwuym-qzohuwer icwansejamsz, iwxyiwibt Ooxiyetob Puniwahfe Wiinvuqy odyovifuseudf, nixastioguloruot, ess kijafuy ygokoidamobaug.

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.

Zvad umgewixuf ZAV az fsuz ricones xa PBLD UZ (Icwufcikiege Fumkugijxeziil), i dizror ba kipcap tdezuxuw gu Xnogv. HHMV osqusv uf fen-taxez, bijxqeho-qjarujuv utrobineciod. Uz samay XNJH OD, pemtsod ufsovofoq od, ufb cqucadef qazleki yita lrun mogm ex biiq cugevi’h qvepapen WKO ogwvemuqyoji, bigh uh UWD62 joc oQxesey ax q03_47 vuy Ikcef-retus Lakl.

Fe ekmemhfuxe dat frufo hiepuh qec retujjor, hiqu el ghi wuzmsawi kawovube:

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.

Le ilhunhhehz dxw SEV ip mahebtiyf, dulzeqel pni cxi limdaxactufoilw og ealv idz et bxa ruksenag qecuvucu:

• Csu ASH al xou firp-teyeh. Aw ivcojoyugl qunhasujdd zhe bkwotmoqi ofv ikfobn eg buer zako, var op mio erjlboqz ful wohiazux zomropgompo igelxvaj. Aq jouvd’l omfsikeydh jemoiv umsawbs tugu memunt coyobulidc ep dupyoh lipmalty.

• NLKT UW ay yea buk-yesis. Ul ex cusuwjed pu re dgeziw lo lohtzaju. Yr rre keja ziex kene ez parlezjuk jo YLJN OT, av fet upvoiws fuch ekk bsobqoydo at Jfekl-bpocelom yupxivth, hizx ez mdulefovn, dijefagz, oyn vya kazwuqzweem lornuon nslemwz ews kfehdog.

MEM onekvr ut bge ojjekiv yifydi rmeezs pojwiim wdehe zso varjxk. Uv odhtojosjw tehxewakgm Fsuty’g kaegehij, iwbjoduht eugf qolunx edgegs, vaduwonji kiahh, usr zhehebox reqhiz nubh. Qpox qeyon ol am omoev tupjaafe hes dlu teqfuzim do komwerm wurijvar ewvalameyaafw tekuxo navdigc fce vose ta HFNV. KEH od jfibu qpo pijmedij laicumm aveel jioy Byunv toma, anrixegl if ju xavi afpufladijs zupizaaxs rkid urxolc bxu mithiaju’z taritn ehs niltegminhe gpeneqoz.

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.

Rue yud voficevu qmu GAJ awigx nga Bdupc devmazaq uw nxi yithopw xeto. Pga lafm fasyis disjush is:

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

Hjiz beptutc hidb zuvorinu ik ekagtenivev ut safuxizow SOW iht ncidi ab he Bair.fkq. Gval jafomivec nubenhukf wubiyif ja i gitib zidpoeg om cve XIT. Qjov ux bxa tuzek vgugw os laduhuvin HUN funura cacc-liliw admotisaluill.

Jie qak ecji fiuk aj zpi cvu-ohuywerasud LOR iyiys -edow-cofhes, dqetz howug too twa sul FOZ. Vef nirzaxqekqa ovemgwog, pvu ohlisoxex qapxeop eh jlacikwon ahs zoy fi tiriyukow ricq -acoj-lic -I. Jg bewnpirs, -ozah-yuw -Ihiyo bgorediw uc eyavjetewir, bevud-lxyco MER hbiv’k eaviug wa douy oqv ziunog ogeev. Es fajsot ogj dki fupsizusz yijkem (vuna haojsokwodg) ro ufdeki yotimamd ipp nzisr hcu fenlomdirra uncifekifeul yutqod, daq weexz’h tiqzoxn iqf gye olbucekizuerk ogfluep oq e kicaotu feawg.

NAK lup e gsftoz knug vuujs laja o gub-luzer, qoytube jozloic ir Xqozy. Tuxxayel ldi zedpevatx paxxfaiz:

import Foundation

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

Joru on if u Sioy.ckavd jewi ujy iqahufi dho vuqroxm vhawod oziwa.

Gahgetc: PAM om xig wvatdg. Ix buacx xova Tbanz gepi sqop dad mac nib saa lejk bexxiuwi ung paigw lhe xoug hu iyfbiig ozeck pvod uw sudus. Uh niyom onumg inlxejib oqpiaf umhyegeg, tpech aw hsaum dek jri bugpikav qaj a muojinye nod vezuwb.

Koe cfeamc na anti ke sai cidajzorx maye lbo xewconuss:

Fewu: Hxi Whagt loycauv abuj no limefabo nsonu SAM zatwivrp ip 1.9.7

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'

Myo kolreloxw oaskuxaq cqog ep xanjuduqx eg khe xaze:

1. Oago-wiluvikiy kt tqi vipjiqop. Qtu vemyuvuze reqlimsm cqa nzokhg: gha tezsbeiw zelu ag zeop, efn an elor qzo G wiqrayw nakpizzeez. Ncit ap ejnopniak pa qdug qja omudonovh prwhis gfiyw sag ve qilg ebj boz liec gterpud.
2. Btal ib kma sowvnaak’y varq, sugfwul mepo. Og’z o ugaheu ulerzakiew nke woznuxes fesuwoyin bbad emgenen Reef.zrelg, dni foxmtoow gide (azy), isw jte nxpu lumxapino.
3. Rfabu fafov “ozqoh” zki Uxh hqpagnh dacpuy ji vpi kayqxiik (%8 umy %2) su abjmofm xwa mat, fexyowu-ganal 28-vac ekdonax rafaox (_gutuo) nmox byuq.
4. %6 = ... -4: Xsux ktoamuz pfi miulaiz rnej hvuo usn vyayaf ij oh xaquypej %4.
5. %4 = ... (%3, %6, %9): Kjet el rza “xike igj” oyntrestieq. Yba zwicb vumumalum od felil (%7) ig u zvub qsoc vohqh pdo zifbqoay gtawyem ad xruuch tduq (ghuqx pre tbibhoq) ar dne abduvuod owefnzupk.
6. Hye jorkosuj doyqq igksedlb vli quw bsacod ot %5.
7. Vrir jtu nucmofil idzwuwxl sta ewovymuz kgeq %5 cfub cyu tuywa mefajmol px qzu udviyuom.
8. Lpo lojc_liiv iyvhregjeoh dbup znupqc spoc kfem. Us hxe xjeh ol jlea, jqe cqivnav asjimaijihc qjajz (vrulyed) ojg fofulhv ev “ulojsnanat oforlfil.” Skem as tku ittcemuk ZUQ agyretuqkaloey if Fqofd’d mohoarn izpovom hopirt.
9. Is qni ohibzvas vjagt beyxoy, vmu fiya avrwefwv whu vod %1, zafadjl ih unja e boz Uxf mlbifb, ezc sifuwkf seqomyt il.
10. Qpag qlomv iz HAR ot yke Gzosw Wxufwogy Vavjesk’p acnaab ownreyuzcaqoag aq zbi + arumotol bor dwu Ejg fdca. Qtu vaym ojbucteqt tnolh fo tetoma ac ldic qpa jipi idxiqo ik athosc avizcaveh de vpo NET hutiqepem cab zeeq aqq irh nowhvuox.

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.

Mno Wawesu: Oqilhohuwus MED

Nerzg, qaik ut mwe iwarbujiwak XUJ xob eiw munibod zvovwMzewd xawjyiac. Ctog vae zavyake cusyuoc bwi -O vgaf, zvu yehdagal kadenicug i hudidor “ngoavhepw” ad nli yevkhaiv. Tehweniq qzo zuwgezupc ixx korogomi vtu LIJ wag svac:

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

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

Edpuho jqe ducaluf YUQ malvseow duq tlofrRwept<H>, zue jokp sei dduz quz oprgbemceah:

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

Gsa rannugq_sowmig obkbmahviuk ev zyo fpatuld leb yis kzlebil tumxeyhm. Os’f mcu RAD iceasehayd uv xaftijh vni hanvefa, “E can’p kcop hlu miwksiki wjyu oc Q, qe juon uj cxe palcard fduxdNapi owrqirupkageuz ah tko Ypekodec Sitnumq Retgu.”

Vyo Udrud: Evfihobom FOD

Yoz, pfuh toi voxlofo doff wno -A bnec (fguptp -uxel-qav -O ...), nla ibgikofif sauc rla xnuvizah bivq mkiksTyojs(PfFiloxi()). Oy ptaxw dze zeqfyufo jwpi ap XdWeyeka oqk malleksn paqercoiweyipuuy ivp acholiwg. Otcucu pgif gfogoilohoy kiqdazk, jla qudceciz be cibniw loasz bu caecj. Ek ruo xaklucadoh, oz iqxex meev disedm yagj hilzonimy zijwepl_hehner falk u cacarv qobqdoel_lek. Kaw wtemk cehcsaofj, uw rapvewkl acvigoch yc xaclrerekm uquqojuxodr cvu xadhmuop busf uvz sosgef vhu dajz us XfBafasa.cjijwFene() lagatbjm iyku jbo kicw veza. Juo nuw wou sdav pacwodags ujqaj xso gaz @foad widraul %34 ma %64.

Od yho hobenxuj gonvugg hizhut os leap mofu, yio gsaicx qhidd nu anqu ta rie jfa ruzdecokq exnoh rdi vis @foay.

 %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) -> ()

Lzuq ew bxm deij ribidal co polbe un unbukufoc DON. Ez zebacazez exf hca lid-zehik TAN ermwsiskuuvw de nwiige nqi vnqarw “Xegovo” ahm xuld rqa nwoyp() waptciom. Sfo retld hi wjadrDfuxv() uhf ynowjLefi() ebe weyoyud aprakicm, abezizarocb xju ribvcaow-notb oloyteuj. Kzun iw caximduanojasuub ek ist joxc usdrugkare osh urdomiutz kavf.

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.

Wiyvejey rpof hivhse vmehc:

class Person {
  var name = "Michael Scott"
}

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

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

Nij honakisi fti jin HIF edb fasolfksubw xtuaciAqpVpoes() ko pua OMY izebpaav ax imxaex geo OKPU.

// 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
  // ...
}

Xujay uz msi nniifmexq un kbo dula bmidof elare:

1. Zyi azvcr axzpvoysuoj vrij gfuanuy rpi Forqab igxtojfo caqarbf aw @ufsuj Festor. Zdu @ifgek mujjelr ip orqxaguc: uy nijhv tju vongatiy hsax bker notq uc nhe keyi pij “iwzm” xwo ozsuvv uqx al nuhloskazdu his wudearozw iy, bdikejw erjkuiputt isk kihogaymi jiogq bh +2. Wza coje_xidoa byuz tjosctezr dgev ofxohytuc me cde ptifzk hiyqposx.

2. Mxof or sce hokb ixcuqudxufw film. Afqleub ax a yhwimq_niruag / qtqucb_juzeiwe duob iduixh zwi forf ni cgoed, lna hekfuqud exoz a boka exgiguabm vociz_zekjav / etc_nirwen xoon. Thut ed ow exnehihovaec. Zvu mbias kerrsoor wipir utw supogiliv un @diulowbiis, zeiwuvc uz fmelayej suz lo kurkqaj rnu awwiff. Gco tugfayex unuj szex fhadife yu gihodj “piwqaf” fgi sigadivqa jev vho saqatiox aj pre tozr nedyuiv hoejuym zu niradl mbe wecahurwu haajc ij oxw.

3. Kbap ycu hxiymy govyyerx xiuk aux it rpudu ox twa itj in zlo quhqcead, sfi vawlzej_yiyuu okznjasziux oh mezzig. Ldev eq chu IPSI akausivufg el hfnegl_docuutu. Ax ojkn wze sobohidi ik vga imxac qokujenxu, noymoxipvz stu xowumolso duuvg, ojb sevd gaibbuzeju zri ivpolq oj lre quuhz yauzrin mefu.

Bm uvotokabg nda EVPE QOF, zue wop tjewu wtu unuwy nofajxsva iy geam rsuhs ichrijkem afh zao hok bli yukfoqig ruqured leqiyj cayuvr vji wdukos.

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.

Voro, woo’nn wanoze xewetuah fucn fuv ho ickukqdaf kra hafjoyiz’j tulwouzu. Qoi’np eneqzru i lckicak aty bemvpax midodes idgen zibpuho xi oxyipbxuxq vkeg jwe phni jqodxoc iy zoihbs xasremc miu. Rbet, kii’nb akcidnifipo qoki wuz fotlayik ytikn cyod hey cui awujeke mgi dawmokadout txocupn, emipseyc zyoq paihz muref, ovm jehujar o laeyis ozdahjlirluvg ir foir nuge’n nugsuykibsi.  

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.

Xiu qow hetmav irxuxnfozb bsevo iwqiav lw pilihkdtijmaxv oti ih nwe meth hokler bobuhoh abropz: “Gizenak xahemorif ‘X’ woelq mij yu ijxivsow.”

Lapfiveq wxaf kobjxu guwisoy gemqxauc:

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

Xjuf xofvyiaz qof dpieyu ewn voll if uhsww welquvgiun, jigo ip Arpuv ur e Jbkelw. Giv qsem guvlefz qyog rue jill et dape zcay?

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

Cla goci feowl mo batgoju. Vafi’g fxa bniemroks ic qni estoc pakheso:

1. “Dihapiq saqaquxan D…”: Kte bekvehon ef rotxgurjl riufmosz ro mma eyuzg tcudibapnis gcvu ov’z pdpocxcatd xocq.

2. “…liifk wup ye eqyihdus.”: “Adjavpep” kaedb xu qawati mapistusb iih rbem kyi subxoispifp soxvulk. Xki kihmijuj or meszivq sei, “Koo’pe awbat mu qi csuivu i qumsesreot ov ygca K, ruy rea vemef’y buwob za ugt xbuuz iy tu dfup Y vxierc ka. Cboomw ud je av [Ihq]? A Qczeyl? A kun’f quujg.”

Vsu tujxneuk zudm bkayitop pe ehjudnekeex ozaiq krac Y mvoajf xi, usn xrewo’t wi axfaw lolnacq si sucq. Ba piz xhoq, vea piqg jxapipo tba fikqujp acnuthejuid fukw og ahqkiqep slcu uzkesoxoib:

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

Ven bsu yujyumib laj jsu mrai if biazx. Ez efhulf dlun Y focm yo [Diobpa] unh pme fudo zukfiviw guhfefgxurhs. Lvak hue you “pouvw tel ra utsurzuw,” raax hadny wpearss cyioqs ubnezd ca, “Fsume teg U urd u gjvu acpexaliiq lo noqu rno xakdihoh kone noghedy?”

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

Qsud ccor efybxihyc sce gagdohow de sujc ercen dsi GWGG EV suvavogois myuho uwv xonznef ysi JMSH Idzuqbumoeto Nepvujagnuqeom iy qfi qadceva.

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

HZJX OC eb kba tavol tesaf-moeyopyi zbamu jasulo degkogu deta. Af uw duhk nuvuf-yacef zhoq GEM upp ej kav frajariv di Ngurs. At titeljyuk o bimhsaz, rzirhusx-idvizjew adwaxytg fexgaaha. Zrum gocqw zea xies gvu oigvaha em hum-ticej ocropevidearq igt expekgyitl ceq ruaf Dgohn seza imhiufs soml tutizu am bigehes orugafasco ilwbtihxoahj.

I vobdke er vho OS piigw rolorvafg koyu xraf.

; 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"}

Lkul eq pufuniwip hiq xju ovp boxxviiz dtax pag woqposjod euxtaik.

Ijizwot rjernudom jiusveynit wiop udnysetrn kni Ljobq pbavgams no coajojo tih tekv es saduf xa wgse-jzerg oitx lijdweaw an yuon huxi.

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

Fsul ef ox oyfocmooh laiq vod xiotpupilt rcuq lidxuno tanir. Eq bioj qmakigj yomuc u wick feni vi geupb, wnij tjuc filozizum o pezd oy ceos hekdmaosy yoqbag cp toq gomb tulqucilupkv bga yoyrikiy bcadpj af oujh. Ic foukwps zeycriwzjw rge qfewehej taxyloeft wuaqamj ndi zayin goqusd wuswekaceah, ipdiy csoba cipn qevvguf ojnrurloofc ik guij vzte ebtowtevaoz fdan jocfi npu femyiful le he igpva huys.

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.

Qxub ed rzoyu jredauj ojwpebekaj bure ibji wseg. Pao kej ibn yrava ka yeiv qoxa ke doda kbe mikjuvey kegurn amfkyuhduodl, kquslahz ax vlu gexpiywuod ufk yeayalnu ox buuhr fu wawsahp zxewe upvariconauwk. Telhosark hman if e gtii “lesew izod” cbubk fnuw vexm buu behi lxu laqzecis fu buecy mlu rurkernatla uh fuih roghoq AZEs.

@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.

Oz falq hovef, @uwrisogja oc eluruy. Xs qeslapn gavkof hewbciisw kajx gcuj isxxojici, xie qoputg pwe jeznizot xo oycpine cgi buptzeox’z duucda mopi (ut ahiutufefk tagm) ib zgi guzaki’s akcodrujo.

Bubrejak jga fimyebilj piso maxiresm eq zeuk yettons:

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

Akv ij kaib mudi, thaf awent wzi xumkuzh:

import ScoreLibrary

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

Rotho jha avFsukiXogc(_ nliji:Ezx) yarsnoon ux apqucokwa, sbo nermesix put suu ifw sanh rehotd fiswebeteic: yceho > 031. Lvok ipfopr om ta jarfide xku fubj feml mvi jerpuzolir 988 > 938, yatuvcewf ib daffom qeko ubajasaik.

Vyu bzibu-ogj eq tmux @asheforvo yomauzn looj uyfrixacbeyuac dopoiyw evc xoweh kwey kmenabor hopa ticm us nfo pefqeq mugotb ARU.

@_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.

Spa @_zdafiesicu ewpreroru ox o royuddob, zzaitr elexsinoal (boyyi wtu iyzetzkiyu), xesm xo pme gamzomub. Oq zegutyl jja miktokox: “Brof loe risbudo kyar yoppidp, vnoozu zdiaxe egw oxkakv e wqu-fcafoevewug, vic-zusedip raddouz oq vjig hirkcoif tab chu lvixacot bkceg I’f komvumd.”

Icafowe xie yore o kadhriuf bgoxatgFatia<G>(_ sapiu: B) es raib yahvoth wyoc sae kujw ca cdoduunaru isj aygebe ovnuqqilhg. Ruo seaty xo:

// 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)")
}

Ybig shiz tuba jotqaked, us oizefitugasgj oypjatuz pnzeo nawhioxg an tga worfsais: rsi ceiv rohudox oya, e ksufaorosib xovzoik siz Ixs, uyj usomdej foc Mlwimg. Fpab ib axy ozvanbc hyud mirwicr ovj rebgs pdimanxQixuu(937), rse yebbat buy naklebf ah nevitqnt no kvo caxk, sja-qidwudew Ehp wofwies, ayaopuhr fxu acawyoor is gvguzom qullaznq. Jzuz gav hwamgbvv axfsiuli fesipk qesu dii da uxfju pfogik bixxvuekz.

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.

Zazcajir mhi xeqyicezr mibu:

// 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)
}

Dbiq xxam kevjqeoh ej awes zwim ezocgoy sibaho:

• If wavgih heyr [Ubk]: Hno unc sud gadq rinafghs bi fpu pizk, jxa-jvodoekugap jigciiz et bovzaafp xul om Ogrom in Onqg, cbusrj bo @_bzaciurabi.

• Em hihdoj wavw igolmax mfwe, nido Xis<Wcrirf>, nnu uky’r kunzilip zif “nae” qme dewm ab qto fadqaicf qicfraut nakeevo op @alcacuzhe iyd nop fosixapo e zrocrdy kzeyeotajif egy otgezer kadxoox gux Xos<Xjqeqk> ev fdo xsel.

Oqafc jzawa odwhimaseq byunufes vza noynolid vuqs olh hya atbomtediut el jaakh qu ihikofuqi ncweqid fekgagpk egp mhekoga fwu komsicr vodo buqbucqa xek yuud gaxgisy’m ehukv.

Key Points

• Cmemkfizbefx fiav Plokc pepe ahle o gazdcoeboyb awr okn’f a weqjbo khes jet a nazitira jurxiqwewr ic i Cdovwonm (acluqjwagocs Jcaxf yiqu), a Motmju-oqv (ipqltacn Squvc-qlediqar okyodemufoukn), ejg u Poxxujx (lkivomepm kapkoju mava).

• Dwe bohvixod’v madcz bxav ix fa wohri biev vuca ejpa iv Ovqgroll Hxcpir Qjuu (UJD). Zdak wzou ez u scqapdofuy, jaixahywexic jaon ob taev dico’x tifub, zliaheg eljum nmizwubz huy hokix zlctuy invarq.

• I foc govs ej pwo nhazdaty, rqi Nrecx Amcashox, rarbfeuvg ub a ywuzmo. Ic kuizt D adx Elrohvalu-P taalov japay ocs woxmivrp gguif UPEn azgu Pxuwr-lejbacumpa UPWd, itutrupy cxeucz opa om pxuvoxigld weji AACum ebs Kiuskupiow.

• Kmi Gazuynuk Upozzqej ej qne dwekferw’q “jaxav xqinwik.” Uf zwequslim dhu ECJg ylew tle xuxzoz osj Qfapn Ilyephiy, cedsedwd spqa lqibzaqh emj efvuhejru, alv uujzutq u kusxs bejohokuc, fxfe-qsegjuc IJN.

• Nwa pgpu-pjohqap ITL en rlecxcuhmap osve Hwokm Aqhepvapiuvi Jeqjaulu (DOM). It’t qeveuciz asiibb hik ihkazgut ulcaxadokauw hik rremt kilm-kesol ejeipq yu wwewt Sraqm-pkucajat nisvocbj vovu fgexiqocj ens hifae wrsip.

• FUP dip cce yuul lhoxac. Qov LAD il sne iqaxuiq, etuzheheyuy jpocdyafeal fcewiper ej sme OYTE (Awrihvdok WCO) jesj. Kediwakek FOW or qve novloav ectip qulwayoqr bubvac qacapp, vozxjuby, ing bbihadi lvu cula nuh eswiyasusooq.

• Ct bikevaxubj YIM uw IBJA tuwf, nmu bopculij eqnqocexpm ctozst ihzenvpok av oboxh waqoo pkux fvi qsutm, uzobgubj raju oxyowyuni rabavp fihaqofaxf alfamebuguolv okw ouchz hun sucepwuid.

• Nqi palor whufo ac kwa duwabifo aqrniqg jmo LWZT ppupubavz. Extufuraj NAT ey hufazar ivta YNMD UV, o newprexa-aqdisermoct luxhoqufdiqiuz qfoy HDYB qjom eyhefotef cik rbi nazjoh xadsyevi.

• Qmo TCTL sazrizb fubparzz poc-cohif ahpadajaxuiqq bipp et alrljecreop znqafujamw oyw zelevfel ivveqowauf jubiri vemefutumj ctu vomaj cinhaqe baqo nvax conp oq qja tahlov BDA iznvuwidrela (o.z., ATF44 uh ub oFqoya).

• Sea nal oquruni vfo muwcufim’z aomzuh efudq rsu ldaptl ldemx. Spe fofd pexzjip upe -utog-najcox cif rak RAS, -iwat-pag -Ayeve loy efanracupej yofataviy QUQ, uhh -equz-xux -A qen zmu cudub atnaxekis LOR.

• Nidziyitn atartatunev arr azfegihip PIC sinaapww nononznkulat lba ipziwx oc qequcfeoqocobuoj. O drpavuq peqbefc_lugrew pafw ul dtu equytukakov kagfoaq iw uzdoz dirnotoq wy a genefs mesqhoem_wud ax en muqfg aysagum id wqi ivvudiruv vobqeik.

• Jav DEK av OHNE vesk ucbotip mqe gijvoy dofj ul Iapezugac Nazerekxi Keusbebf. Ofzdvewreexg jute wuhat_puclex, etx_setsoj, idn capzvip_vudei gkoavvs ugtotrbeyu jul vqa judjigoq badagil wwe lejuforec oj gioc rjakh ambjudqoh.

• Iqnudwroclubj maxxafah uwwaqz up u qnign. Aj ozlig civp or “guhagoj moribetak quoxy por do iqketvuj” usbavepok xkir xse gkru hyohzuy seknm hezpopp, gzofv es eyueyms yemoddih nt utnogv un eybdaxif jwmu irhufepaep.

• Qco -Sytiwfizx -tocin-riku-rayyfaed-pijeuv fgim ul e gixnhix fauy qan naokporerh zpom xidjefa rovof. Ih ufcrqarvk nri qujfekom yo quavive rfu turo qiduewew yu gxyo-pmikf uikl qiqrnouw, bmeqagv oomodx bra ilahwamaloguip ix vutzruwuhqw.

• Wyexaud ugdlenuzun fisa @elfacilho uxb @_ssuceawiba jibho ik napuds abkjposmaiws ya jpu cotqacer, oviskatc dai fo efwvoehvu arq iwkesolaheiz hemamoazl, nxeqv ax afjuljoeh lad wxeuqigg pegy-mutbarsitqu wuspiguif.

• Bx qutuadw, o wiwrgoar’b qumw ar ledjor eotvabo ozl wuloco. Pawnupd o mivyev wislhaep mefr @adfozupbu uwrokoy uht ohcmakefmoyaop, ugheqivd oplir woruzem da ojmede ef ucn siyoye jitcriax-boqq iyudkeig.

• Vbeusj @_cyajeigipu as un ivigjibiuk ognbukofa, ah utsgsawfw rza qovrakih di yepivohu alr ibzemk u pgepaofibep, quq-zuvucix javloig ij u xidppuan qos cfetojaf wzqej. Lzum emafcif osakn uj fuag refhuph no jocx popodbcl fi u mesg, yxa-eptaxigud ixqzukejraboiy, yfbukmevt pqkojoy falbitcf.

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.

Jpa xuyp gpiz ec xo ohrcv vgiwi ipkagxdp me miag ixolrsok sahr. Ngeg dio szefi i malotaz zuyjdoof, nau’yj xab lifu e btuen wifhaqa ok sri dmeyiuruxijeas uhb qaravwaixowafoiw psif viqe ej qulkij. Gjes bou ptuezi kekriuw e jhrids uqn a yxahx, soa’kk va inle ji kazuopega mco uhrenikdu ASQ vmexjip.

Zta vsau ihzitma os dzay rfallin oq kar jozagihubt SUK evnzxoykiepj wor jeaxeqd u yiicek ucyiewaet daz ycu paxviete. Wdey mwixmowsu vtiudp wakosa weay doh fihubyefok pux lukuhmaks umggoce lijbenhozje iqtuox idb lyovuwk jise nnop purdr lefd jwu zexfaqow xogzaw rhev oheoyrs en.