BeIRCodeGen.cpp 95 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826
  1. #include "BeIRCodeGen.h"
  2. #include "../Compiler/BfIRCodeGen.h"
  3. #include "BeDbgModule.h"
  4. #include "BeefySysLib/util/BeefPerf.h"
  5. #include "llvm/IR/DIBuilder.h"
  6. #include "BeefySysLib/util/AllocDebug.h"
  7. #include "BeefySysLib/util/Hash.h"
  8. #include "BeModule.h"
  9. #include "BeContext.h"
  10. #include "../Compiler/CeMachine.h"
  11. #ifdef _DEBUG
  12. #define BE_EXTRA_CHECKS
  13. #endif
  14. USING_NS_BF;
  15. //#define CODEGEN_TRACK
  16. #ifdef CODEGEN_TRACK
  17. #include "../Compiler/MemReporter.h"
  18. MemReporter gBEMemReporter;
  19. CritSect gBEMemReporterCritSect;
  20. int gBEMemReporterSize = 0;
  21. #define BE_MEM_START \
  22. int startPos = mStream->GetReadPos();
  23. #define BE_MEM_END(name) \
  24. gBEMemReporter.Add(name, mStream->GetReadPos() - startPos);
  25. static const char* gIRCmdNames[] =
  26. {
  27. "Module_Start",
  28. "Module_SetTargetTriple",
  29. "Module_AddModuleFlag",
  30. "WriteIR",
  31. "SetType",
  32. "SetInstType",
  33. "PrimitiveType",
  34. "CreateStruct",
  35. "StructSetBody",
  36. "Type",
  37. "TypeInst",
  38. "TypeInstPtr",
  39. "GetType",
  40. "GetPointerToFuncType",
  41. "GetPointerToType",
  42. "GetSizedArrayType",
  43. "CreateConstStruct",
  44. "CreateConstStructZero",
  45. "CreateConstArray",
  46. "CreateConstString",
  47. "SetName",
  48. "CreateUndefValue",
  49. "NumericCast",
  50. "CmpEQ",
  51. "CmpNE",
  52. "CmpSLT",
  53. "CmpULT",
  54. "CmpSLE",
  55. "CmpULE",
  56. "CmpSGT",
  57. "CmpUGT",
  58. "CmpSGE",
  59. "CmpUGE",
  60. "Add",
  61. "Sub",
  62. "Mul",
  63. "SDiv",
  64. "UDiv",
  65. "SRem",
  66. "URem",
  67. "And",
  68. "Or",
  69. "Xor",
  70. "Shl",
  71. "AShr",
  72. "LShr",
  73. "Neg",
  74. "Not",
  75. "BitCast",
  76. "PtrToInt",
  77. "IntToPtr",
  78. "InboundsGEP1_32",
  79. "InboundsGEP2_32",
  80. "InBoundsGEP1",
  81. "InBoundsGEP2",
  82. "IsNull",
  83. "IsNotNull",
  84. "ExtractValue",
  85. "InsertValue",
  86. "Alloca",
  87. "AllocaArray",
  88. "SetAllocaAlignment",
  89. "SetAllocaNoChkStkHint",
  90. "SetAllocaForceMem",
  91. "LifetimeStart",
  92. "LifetimeEnd",
  93. "LifetimeExtend",
  94. "ValueScopeStart",
  95. "ValueScopeRetain",
  96. "ValueScopeSoftEnd",
  97. "ValueScopeHardEnd",
  98. "Load",
  99. "AlignedLoad",
  100. "Store",
  101. "AlignedStore",
  102. "MemSet",
  103. "Fence",
  104. "StackSave",
  105. "StackRestore",
  106. "GlobalVariable",
  107. "GlobalVar_SetUnnamedAddr",
  108. "GlobalVar_SetInitializer",
  109. "GlobalVar_SetAlignment",
  110. "GlobalStringPtr",
  111. "CreateBlock",
  112. "MaybeChainNewBlock",
  113. "AddBlock",
  114. "DropBlocks",
  115. "MergeBlockDown",
  116. "SetInsertPoint",
  117. "SetInsertPointAtStart",
  118. "EraseFromParent",
  119. "DeleteBlock",
  120. "EraseInstFromParent",
  121. "CreateBr",
  122. "CreateBr_NoCollapse",
  123. "CreateCondBr",
  124. "MoveBlockToEnd",
  125. "CreateSwitch",
  126. "AddSwitchCase",
  127. "SetSwitchDefaultDest",
  128. "CreatePhi",
  129. "AddPhiIncoming",
  130. "GetIntrinsic",
  131. "CreateFunctionType",
  132. "CreateFunction",
  133. "EnsureFunctionPatchable",
  134. "RemapBindFunction",
  135. "SetActiveFunction",
  136. "CreateCall",
  137. "SetCallCallingConv",
  138. "SetFuncCallingConv",
  139. "SetTailCall",
  140. "SetCallAttribute",
  141. "CreateRet",
  142. "CreateRetVoid",
  143. "CreateUnreachable",
  144. "Call_AddAttribute",
  145. "Call_AddAttribute1",
  146. "Func_AddAttribute",
  147. "Func_AddAttribute1",
  148. "Func_SetParamName",
  149. "Func_DeleteBody",
  150. "Func_EraseFromParent",
  151. "Func_SetLinkage",
  152. "SaveDebugLocation",
  153. "RestoreDebugLocation",
  154. "ClearDebugLocation",
  155. "ClearDebugLocationInst",
  156. "UpdateDebugLocation",
  157. "SetCurrentDebugLocation",
  158. "Nop",
  159. "EnsureInstructionAt",
  160. "StatementStart",
  161. "ObjectAccessCheck",
  162. "DbgInit",
  163. "DbgFinalize",
  164. "DbgCreateCompileUnit",
  165. "DbgCreateFile",
  166. "ConstValueI64",
  167. "DbgGetCurrentLocation",
  168. "DbgSetType",
  169. "DbgSetInstType",
  170. "DbgGetType",
  171. "DbgGetTypeInst",
  172. "DbgTrackDITypes",
  173. "DbgCreateNamespace",
  174. "DbgCreateImportedModule",
  175. "DbgCreateBasicType",
  176. "DbgCreateStructType",
  177. "DbgCreateEnumerationType",
  178. "DbgCreatePointerType",
  179. "DbgCreateReferenceType",
  180. "DbgCreateConstType",
  181. "DbgCreateArtificialType",
  182. "DbgCreateArrayType",
  183. "DbgCreateReplaceableCompositeType",
  184. "DbgCreateForwardDecl",
  185. "DbgCreateSizedForwardDecl",
  186. "BeIRCmd_DbgSetTypeSize",
  187. "DbgReplaceAllUses",
  188. "DbgDeleteTemporary",
  189. "DbgMakePermanent",
  190. "CreateEnumerator",
  191. "DbgCreateMemberType",
  192. "DbgStaticCreateMemberType",
  193. "DbgCreateInheritance",
  194. "DbgCreateMethod",
  195. "DbgCreateFunction",
  196. "DbgCreateParameterVariable",
  197. "DbgCreateSubroutineType",
  198. "DbgCreateAutoVariable",
  199. "DbgInsertValueIntrinsic",
  200. "DbgInsertDeclare",
  201. "DbgLifetimeEnd",
  202. "DbgCreateGlobalVariable",
  203. "DbgCreateLexicalBlock",
  204. "DbgCreateLexicalBlockFile",
  205. "DbgCreateAnnotation"
  206. };
  207. BF_STATIC_ASSERT(BF_ARRAY_COUNT(gIRCmdNames) == BfIRCmd_COUNT);
  208. #else
  209. #define BE_MEM_START
  210. #define BE_MEM_END(name)
  211. #endif
  212. #pragma warning(disable:4146)
  213. #define CMD_PARAM(ty, name) ty name; Read(name);
  214. BeIRCodeGen::BeIRCodeGen()
  215. {
  216. mBfIRBuilder = NULL;
  217. mStream = NULL;
  218. mActiveFunction = NULL;
  219. mBeContext = NULL;
  220. mBeModule = NULL;
  221. mHasDebugLoc = false;
  222. mDebugging = false;
  223. mCmdCount = 0;
  224. }
  225. BeIRCodeGen::~BeIRCodeGen()
  226. {
  227. BF_ASSERT(mSavedDebugLocs.size() == 0);
  228. delete mBeModule;
  229. delete mBeContext;
  230. delete mStream;
  231. }
  232. void BeIRCodeGen::Hash(BeHashContext& hashCtx)
  233. {
  234. // if (mBeModule->mModuleName == "IDE_IDEApp")
  235. // {
  236. // hashCtx.mDbgViz = true;
  237. // NOP;
  238. // }
  239. hashCtx.Mixin(mPtrSize);
  240. hashCtx.Mixin(mIsOptimized);
  241. if (mBeModule != NULL)
  242. mBeModule->Hash(hashCtx);
  243. Array<BeStructType*> structHashList;
  244. for (auto beType : mBeContext->mTypes)
  245. {
  246. if (!beType->IsStruct())
  247. continue;
  248. auto beStructType = (BeStructType*)beType;
  249. if (beStructType->mHashId != -1)
  250. continue;
  251. structHashList.Add(beStructType);
  252. }
  253. structHashList.Sort([](BeStructType* lhs, BeStructType* rhs)
  254. {
  255. return lhs->mName < rhs->mName;
  256. });
  257. for (auto beStructType : structHashList)
  258. {
  259. beStructType->HashReference(hashCtx);
  260. }
  261. }
  262. bool BeIRCodeGen::IsModuleEmpty()
  263. {
  264. if (!mBeModule->mFunctions.IsEmpty())
  265. return false;
  266. if (!mBeModule->mGlobalVariables.IsEmpty())
  267. return false;
  268. return true;
  269. }
  270. void BeIRCodeGen::FatalError(const StringImpl& err)
  271. {
  272. String failStr = "Fatal Error in Module: ";
  273. if (mBeModule != NULL)
  274. failStr += mBeModule->mModuleName;
  275. failStr += "\n";
  276. if (mBeModule != NULL)
  277. {
  278. BeDumpContext dumpCtx;
  279. if (mActiveFunction != NULL)
  280. {
  281. failStr += "Function: ";
  282. failStr += mActiveFunction->mName;
  283. failStr += "\n";
  284. }
  285. if (mBeModule->mCurDbgLoc != NULL)
  286. {
  287. failStr += "DbgLoc: ";
  288. dumpCtx.ToString(failStr, mBeModule->mCurDbgLoc);
  289. failStr += "\n";
  290. }
  291. }
  292. failStr += err;
  293. BF_FATAL(failStr);
  294. }
  295. void BeIRCodeGen::NotImpl()
  296. {
  297. BF_FATAL("Not implemented");
  298. }
  299. BeType* BeIRCodeGen::GetBeType(BfTypeCode typeCode, bool& isSigned)
  300. {
  301. isSigned = false;
  302. BeTypeCode beTypeCode = BeTypeCode_None;
  303. switch (typeCode)
  304. {
  305. case BfTypeCode_None:
  306. beTypeCode = BeTypeCode_None;
  307. break;
  308. case BfTypeCode_NullPtr:
  309. beTypeCode = BeTypeCode_NullPtr;
  310. break;
  311. case BfTypeCode_Boolean:
  312. beTypeCode = BeTypeCode_Boolean;
  313. break;
  314. case BfTypeCode_Int8:
  315. isSigned = true;
  316. beTypeCode = BeTypeCode_Int8;
  317. break;
  318. case BfTypeCode_UInt8:
  319. case BfTypeCode_Char8:
  320. beTypeCode = BeTypeCode_Int8;
  321. break;
  322. case BfTypeCode_Int16:
  323. isSigned = true;
  324. beTypeCode = BeTypeCode_Int16;
  325. break;
  326. case BfTypeCode_Char16:
  327. case BfTypeCode_UInt16:
  328. beTypeCode = BeTypeCode_Int16;
  329. break;
  330. case BfTypeCode_Int32:
  331. isSigned = true;
  332. beTypeCode = BeTypeCode_Int32;
  333. break;
  334. case BfTypeCode_UInt32:
  335. case BfTypeCode_Char32:
  336. beTypeCode = BeTypeCode_Int32;
  337. break;
  338. case BfTypeCode_Int64:
  339. isSigned = true;
  340. beTypeCode = BeTypeCode_Int64;
  341. break;
  342. case BfTypeCode_UInt64:
  343. beTypeCode = BeTypeCode_Int64;
  344. break;
  345. case BfTypeCode_IntPtr:
  346. BF_FATAL("Illegal");
  347. /*isSigned = true;
  348. if (mModule->mSystem->mPtrSize == 4)
  349. return llvm::Type::getInt32Ty(*mLLVMContext);
  350. else
  351. return llvm::Type::getInt64Ty(*mLLVMContext);*/
  352. case BfTypeCode_UIntPtr:
  353. BF_FATAL("Illegal");
  354. /*if (mModule->mSystem->mPtrSize == 4)
  355. return llvm::Type::getInt32Ty(*mLLVMContext);
  356. else
  357. return llvm::Type::getInt64Ty(*mLLVMContext);*/
  358. case BfTypeCode_Float:
  359. isSigned = true;
  360. beTypeCode = BeTypeCode_Float;
  361. break;
  362. case BfTypeCode_Double:
  363. isSigned = true;
  364. beTypeCode = BeTypeCode_Double;
  365. break;
  366. }
  367. return mBeContext->GetPrimitiveType(beTypeCode);
  368. }
  369. BeIRTypeEntry& BeIRCodeGen::GetTypeEntry(int typeId)
  370. {
  371. BeIRTypeEntry& typeEntry = mTypes[typeId];
  372. if (typeEntry.mTypeId == -1)
  373. typeEntry.mTypeId = typeId;
  374. return typeEntry;
  375. }
  376. void BeIRCodeGen::FixValues(BeStructType* structType, CmdParamVec<BeValue*>& values)
  377. {
  378. if (values.size() >= structType->mMembers.size())
  379. return;
  380. int readIdx = values.size() - 1;
  381. values.resize(structType->mMembers.size());
  382. for (int i = (int)values.size() - 1; i >= 0; i--)
  383. {
  384. if (mBeContext->AreTypesEqual(values[readIdx]->GetType(), structType->mMembers[i].mType))
  385. {
  386. values[i] = values[readIdx];
  387. readIdx--;
  388. }
  389. else if (structType->mMembers[i].mType->IsSizedArray())
  390. {
  391. auto beConst = mBeModule->mAlloc.Alloc<BeConstant>();
  392. beConst->mType = structType->mMembers[i].mType;
  393. values[i] = beConst;
  394. }
  395. else
  396. {
  397. FatalError("Malformed structure values");
  398. }
  399. }
  400. }
  401. void BeIRCodeGen::FixValues(BeStructType* structType, SizedArrayImpl<BeConstant*>& values)
  402. {
  403. if (values.size() >= structType->mMembers.size())
  404. return;
  405. int readIdx = values.size() - 1;
  406. values.resize(structType->mMembers.size());
  407. for (int i = (int)values.size() - 1; i >= 0; i--)
  408. {
  409. if (mBeContext->AreTypesEqual(values[readIdx]->GetType(), structType->mMembers[i].mType))
  410. {
  411. values[i] = values[readIdx];
  412. readIdx--;
  413. }
  414. else if (structType->mMembers[i].mType->IsSizedArray())
  415. {
  416. auto beConst = mBeModule->mAlloc.Alloc<BeConstant>();
  417. beConst->mType = structType->mMembers[i].mType;
  418. values[i] = beConst;
  419. }
  420. else
  421. {
  422. FatalError("Malformed structure values");
  423. }
  424. }
  425. }
  426. void BeIRCodeGen::Init(const BfSizedArray<uint8>& buffer)
  427. {
  428. BP_ZONE("BeIRCodeGen::Init");
  429. BF_ASSERT(mStream == NULL);
  430. mStream = new ChunkedDataBuffer();
  431. mStream->InitFlatRef(buffer.mVals, buffer.mSize);
  432. #ifdef CODEGEN_TRACK
  433. AutoCrit autoCrit(gBEMemReporterCritSect);
  434. AutoMemReporter autoMemReporter(&gBEMemReporter, "BeIRCodeGen");
  435. #endif
  436. //
  437. {
  438. BP_ZONE("BeIRCodeGen::ProcessBfIRData.HandleNextCmds");
  439. while (mStream->GetReadPos() < buffer.mSize)
  440. {
  441. if (mFailed)
  442. break;
  443. HandleNextCmd();
  444. }
  445. }
  446. BF_ASSERT((mFailed) || (mStream->GetReadPos() == buffer.mSize));
  447. }
  448. void BeIRCodeGen::Process()
  449. {
  450. BP_ZONE("BeIRCodeGen::process");
  451. //mDebugging |= ((mBeModule->mDbgModule != NULL) && (mBeModule->mDbgModule->mFileName == "ClassQ"));
  452. if (mDebugging)
  453. {
  454. String dbgStr;
  455. dbgStr = mBeModule->ToString();
  456. OutputDebugStr(dbgStr);
  457. }
  458. mBeModule->DoInlining();
  459. if (mDebugging)
  460. {
  461. String dbgStr = "-------------- AFTER INLINING --------------\n";
  462. dbgStr += mBeModule->ToString();
  463. OutputDebugStr(dbgStr);
  464. }
  465. }
  466. void BeIRCodeGen::ProcessBfIRData(const BfSizedArray<uint8>& buffer)
  467. {
  468. BP_ZONE("BeIRCodeGen::ProcessBfIRData");
  469. Init(buffer);
  470. Process();
  471. }
  472. BfTypeCode BeIRCodeGen::GetTypeCode(BeType * type, bool isSigned)
  473. {
  474. switch (type->mTypeCode)
  475. {
  476. case BeTypeCode_Int8:
  477. return (isSigned) ? BfTypeCode_Int8 : BfTypeCode_UInt8;
  478. case BeTypeCode_Int16:
  479. return (isSigned) ? BfTypeCode_Int16 : BfTypeCode_UInt16;
  480. case BeTypeCode_Int32:
  481. return (isSigned) ? BfTypeCode_Int32 : BfTypeCode_UInt32;
  482. case BeTypeCode_Int64:
  483. return (isSigned) ? BfTypeCode_Int64 : BfTypeCode_UInt64;
  484. case BeTypeCode_Float:
  485. return BfTypeCode_Float;
  486. case BeTypeCode_Double:
  487. return BfTypeCode_Double;
  488. default:
  489. return BfTypeCode_None;
  490. }
  491. }
  492. void BeIRCodeGen::SetResult(int id, BeValue* value)
  493. {
  494. BeIRCodeGenEntry entry;
  495. entry.mKind = BeIRCodeGenEntryKind_Value;
  496. entry.mBeValue = value;
  497. mResults.TryAdd(id, entry);
  498. }
  499. void BeIRCodeGen::SetResult(int id, BeType* type)
  500. {
  501. BeIRCodeGenEntry entry;
  502. entry.mKind = BeIRCodeGenEntryKind_Type;
  503. entry.mBeType = type;
  504. mResults.TryAdd(id, entry);
  505. }
  506. void BeIRCodeGen::SetResult(int id, BeBlock* value)
  507. {
  508. BeIRCodeGenEntry entry;
  509. entry.mKind = BeIRCodeGenEntryKind_Block;
  510. entry.mBeBlock = value;
  511. mResults.TryAdd(id, entry);
  512. }
  513. void BeIRCodeGen::SetResult(int id, BeMDNode* md)
  514. {
  515. BeIRCodeGenEntry entry;
  516. entry.mKind = BeIRCodeGenEntryKind_Metadata;
  517. entry.mBeMetadata = md;
  518. mResults.TryAdd(id, entry);
  519. }
  520. int64 BeIRCodeGen::ReadSLEB128()
  521. {
  522. int64 val = 0;
  523. int64 shift = 0;
  524. uint8 byteVal;
  525. do
  526. {
  527. byteVal = mStream->Read();
  528. val |= ((int64)(byteVal & 0x7f)) << shift;
  529. shift += 7;
  530. } while (byteVal >= 128);
  531. // Sign extend negative numbers.
  532. if ((byteVal & 0x40) && (shift < 64))
  533. val |= (-1ULL) << shift;
  534. return val;
  535. }
  536. void BeIRCodeGen::Read(StringImpl& str)
  537. {
  538. BE_MEM_START;
  539. int len = (int)ReadSLEB128();
  540. str.Append('?', len);
  541. mStream->Read((void*)str.c_str(), len);
  542. BE_MEM_END("String");
  543. }
  544. void BeIRCodeGen::Read(int& i)
  545. {
  546. BE_MEM_START;
  547. i = (int)ReadSLEB128();
  548. BE_MEM_END("int");
  549. }
  550. void BeIRCodeGen::Read(int64& i)
  551. {
  552. BE_MEM_START;
  553. i = ReadSLEB128();
  554. BE_MEM_END("int64");
  555. }
  556. void BeIRCodeGen::Read(Val128& i)
  557. {
  558. i.mLow = (uint64)ReadSLEB128();
  559. i.mHigh = (uint64)ReadSLEB128();
  560. }
  561. void BeIRCodeGen::Read(bool& val)
  562. {
  563. BE_MEM_START;
  564. val = mStream->Read() != 0;
  565. BE_MEM_END("bool");
  566. }
  567. void BeIRCodeGen::Read(int8& val)
  568. {
  569. val = mStream->Read();
  570. }
  571. void BeIRCodeGen::Read(BeIRTypeEntry*& type)
  572. {
  573. BE_MEM_START;
  574. int typeId = (int)ReadSLEB128();
  575. type = &GetTypeEntry(typeId);
  576. BE_MEM_END("BeIRTypeEntry");
  577. }
  578. void BeIRCodeGen::Read(BeType*& beType)
  579. {
  580. BE_MEM_START;
  581. BfIRType::TypeKind typeKind = (BfIRType::TypeKind)mStream->Read();
  582. if (typeKind == BfIRType::TypeKind::TypeKind_None)
  583. {
  584. beType = NULL;
  585. BE_MEM_END("BeType");
  586. return;
  587. }
  588. if (typeKind == BfIRType::TypeKind::TypeKind_Stream)
  589. {
  590. int streamId = (int)ReadSLEB128();
  591. if (streamId == -1)
  592. {
  593. beType = NULL;
  594. BE_MEM_END("BeType");
  595. return;
  596. }
  597. auto& result = mResults[streamId];
  598. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Type);
  599. beType = result.mBeType;
  600. BE_MEM_END("BeType");
  601. return;
  602. }
  603. if (typeKind == BfIRType::TypeKind::TypeKind_SizedArray)
  604. {
  605. CMD_PARAM(BeType*, elementType);
  606. CMD_PARAM(int, length);
  607. beType = mBeContext->CreateSizedArrayType(elementType, length);
  608. return;
  609. }
  610. int typeId = (int)ReadSLEB128();
  611. if (typeKind == BfIRType::TypeKind::TypeKind_TypeCode)
  612. {
  613. bool isSigned = false;
  614. beType = GetBeType((BfTypeCode)typeId, isSigned);
  615. return;
  616. }
  617. auto& typeEntry = GetTypeEntry(typeId);
  618. if (typeKind == BfIRType::TypeKind::TypeKind_TypeId)
  619. beType = typeEntry.mBeType;
  620. else if (typeKind == BfIRType::TypeKind::TypeKind_TypeInstId)
  621. beType = typeEntry.mInstBeType;
  622. else if (typeKind == BfIRType::TypeKind::TypeKind_TypeInstPtrId)
  623. beType = mBeContext->GetPointerTo(typeEntry.mInstBeType);
  624. BE_MEM_END("BeType");
  625. }
  626. void BeIRCodeGen::Read(BeFunctionType*& beType)
  627. {
  628. BE_MEM_START;
  629. int streamId = (int)ReadSLEB128();
  630. auto& result = mResults[streamId];
  631. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Type);
  632. beType = (BeFunctionType*)result.mBeType;
  633. BE_MEM_END("BeFunctionType");
  634. }
  635. void BeIRCodeGen::Read(BeValue*& beValue)
  636. {
  637. BE_MEM_START;
  638. BfIRParamType paramType = (BfIRParamType)mStream->Read();
  639. if (paramType == BfIRParamType_None)
  640. {
  641. beValue = NULL;
  642. BE_MEM_END("ParamType_None");
  643. }
  644. else if (paramType == BfIRParamType_Const)
  645. {
  646. BfTypeCode typeCode = (BfTypeCode)mStream->Read();
  647. BfConstType constType = (BfConstType)typeCode;
  648. if (constType == BfConstType_GlobalVar)
  649. {
  650. CMD_PARAM(int, streamId);
  651. if (streamId == -1)
  652. {
  653. int streamId = mCmdCount++;
  654. CMD_PARAM(BeType*, varType);
  655. CMD_PARAM(bool, isConstant);
  656. BfIRLinkageType linkageType = (BfIRLinkageType)mStream->Read();
  657. CMD_PARAM(BeConstant*, initializer);
  658. CMD_PARAM(String, name);
  659. CMD_PARAM(bool, isTLS);
  660. BF_ASSERT(varType != NULL);
  661. auto globalVariable = mBeModule->mGlobalVariables.Alloc();
  662. globalVariable->mModule = mBeModule;
  663. globalVariable->mType = varType;
  664. globalVariable->mIsConstant = isConstant;
  665. globalVariable->mLinkageType = linkageType;
  666. globalVariable->mInitializer = initializer;
  667. globalVariable->mName = name;
  668. globalVariable->mIsTLS = isTLS;
  669. globalVariable->mAlign = varType->mAlign;
  670. globalVariable->mUnnamedAddr = false;
  671. globalVariable->mStorageKind = BfIRStorageKind_Normal;
  672. if (initializer != NULL)
  673. BF_ASSERT(varType->mAlign > 0);
  674. SetResult(streamId, globalVariable);
  675. beValue = globalVariable;
  676. }
  677. else
  678. beValue = GetBeValue(streamId);
  679. beValue->mRefCount++;
  680. BE_MEM_END("ParamType_Const_GlobalVar");
  681. return;
  682. }
  683. else if ((constType == BfConstType_BitCast) || (constType == BfConstType_BitCastNull))
  684. {
  685. CMD_PARAM(BeConstant*, target);
  686. CMD_PARAM(BeType*, toType);
  687. auto castedVal = mBeModule->mAlloc.Alloc<BeCastConstant>();
  688. castedVal->mInt64 = target->mInt64;
  689. castedVal->mType = toType;
  690. castedVal->mTarget = target;
  691. BF_ASSERT(target->GetType() != NULL);
  692. BF_ASSERT(!target->GetType()->IsComposite());
  693. beValue = castedVal;
  694. BE_MEM_END("ParamType_Const_BitCast");
  695. return;
  696. }
  697. else if (constType == BfConstType_GEP32_1)
  698. {
  699. CMD_PARAM(BeConstant*, target);
  700. CMD_PARAM(int, idx0);
  701. BF_ASSERT(target->GetType()->IsPointer());
  702. auto gepConstant = mBeModule->mAlloc.Alloc<BeGEP1Constant>();
  703. gepConstant->mTarget = target;
  704. gepConstant->mIdx0 = idx0;
  705. beValue = gepConstant;
  706. BE_MEM_END("ParamType_Const_GEP32_1");
  707. return;
  708. }
  709. else if (constType == BfConstType_GEP32_2)
  710. {
  711. CMD_PARAM(BeConstant*, target);
  712. CMD_PARAM(int, idx0);
  713. CMD_PARAM(int, idx1);
  714. BF_ASSERT(target->GetType()->IsPointer());
  715. auto gepConstant = mBeModule->mAlloc.Alloc<BeGEP2Constant>();
  716. gepConstant->mTarget = target;
  717. gepConstant->mIdx0 = idx0;
  718. gepConstant->mIdx1 = idx1;
  719. beValue = gepConstant;
  720. BE_MEM_END("ParamType_Const_GEP32_2");
  721. return;
  722. }
  723. else if (constType == BfConstType_ExtractValue)
  724. {
  725. CMD_PARAM(BeConstant*, target);
  726. CMD_PARAM(int, idx0);
  727. auto gepConstant = mBeModule->mAlloc.Alloc<BeExtractValueConstant>();
  728. gepConstant->mTarget = target;
  729. gepConstant->mIdx0 = idx0;
  730. beValue = gepConstant;
  731. BE_MEM_END("ParamType_Const_ExtractValue");
  732. return;
  733. }
  734. else if (constType == BfConstType_PtrToInt)
  735. {
  736. CMD_PARAM(BeConstant*, target);
  737. BfTypeCode toTypeCode = (BfTypeCode)mStream->Read();
  738. BF_ASSERT(target->GetType()->IsPointer());
  739. bool isSigned = false;
  740. BeType* toType = GetBeType(toTypeCode, isSigned);
  741. auto castedVal = mBeModule->mAlloc.Alloc<BeCastConstant>();
  742. castedVal->mInt64 = target->mInt64;
  743. castedVal->mType = toType;
  744. castedVal->mTarget = target;
  745. BF_ASSERT(target->GetType() != NULL);
  746. beValue = castedVal;
  747. BE_MEM_END("ParamType_Const_PtrToInt");
  748. return;
  749. }
  750. else if (constType == BfConstType_IntToPtr)
  751. {
  752. CMD_PARAM(BeConstant*, target);
  753. CMD_PARAM(BeType*, toType);
  754. auto castedVal = mBeModule->mAlloc.Alloc<BeCastConstant>();
  755. castedVal->mInt64 = target->mInt64;
  756. castedVal->mType = toType;
  757. castedVal->mTarget = target;
  758. BF_ASSERT(target->GetType() != NULL);
  759. BF_ASSERT(!target->GetType()->IsComposite());
  760. BF_ASSERT(toType->IsPointer());
  761. beValue = castedVal;
  762. BE_MEM_END("ParamType_Const_IntToPtr");
  763. return;
  764. }
  765. else if (constType == BfConstType_AggZero)
  766. {
  767. CMD_PARAM(BeType*, type);
  768. auto beConst = mBeModule->mAlloc.Alloc<BeConstant>();
  769. beConst->mType = type;
  770. beValue = beConst;
  771. BE_MEM_END("ParamType_Const_AggZero");
  772. return;
  773. }
  774. else if (constType == BfConstType_Agg)
  775. {
  776. CMD_PARAM(BeType*, type);
  777. CMD_PARAM(CmdParamVec<BeConstant*>, values);
  778. if (type->IsSizedArray())
  779. {
  780. auto arrayType = (BeSizedArrayType*)type;
  781. int fillCount = (int)(arrayType->mLength - values.size());
  782. if (fillCount > 0)
  783. {
  784. auto lastValue = values.back();
  785. for (int i = 0; i < fillCount; i++)
  786. values.push_back(lastValue);
  787. }
  788. }
  789. else if (type->IsVector())
  790. {
  791. auto vecType = (BeVectorType*)type;
  792. int fillCount = (int)(vecType->mLength - values.size());
  793. if (fillCount > 0)
  794. {
  795. auto lastValue = values.back();
  796. for (int i = 0; i < fillCount; i++)
  797. values.push_back(lastValue);
  798. }
  799. }
  800. else
  801. {
  802. BF_ASSERT(type->IsStruct());
  803. }
  804. auto constStruct = mBeModule->mOwnedValues.Alloc<BeStructConstant>();
  805. constStruct->mType = type;
  806. if (type->IsStruct())
  807. FixValues((BeStructType*)type, values);
  808. for (int i = 0; i < (int)values.size(); i++)
  809. {
  810. auto val = values[i];
  811. BeConstant* constant = BeValueDynCast<BeConstant>(val);
  812. if (type->IsSizedArray())
  813. {
  814. auto arrayType = (BeSizedArrayType*)type;
  815. auto memberType = constant->GetType();
  816. if (memberType != arrayType->mElementType)
  817. Fail("ConstAgg array member type mismatch");
  818. }
  819. else if (type->IsVector())
  820. {
  821. auto vecType = (BeVectorType*)type;
  822. auto memberType = constant->GetType();
  823. if (memberType != vecType->mElementType)
  824. Fail("ConstAgg vector member type mismatch");
  825. }
  826. else
  827. {
  828. BF_ASSERT(type->IsStruct());
  829. auto structType = (BeStructType*)type;
  830. auto valType = constant->GetType();
  831. if (structType->mIsOpaque)
  832. {
  833. Fail("ConstAgg with opaque struct");
  834. }
  835. else if (valType != structType->mMembers[i].mType)
  836. {
  837. if (valType->IsSizedArray())
  838. {
  839. auto valSizedType = (BeSizedArrayType*)valType;
  840. if (valSizedType->mSize == 0)
  841. {
  842. constant->mType = structType->mMembers[i].mType;
  843. constStruct->mMemberValues.Add(constant);
  844. continue;
  845. }
  846. }
  847. Fail("ConstAgg struct member type mismatch");
  848. }
  849. }
  850. constStruct->mMemberValues.Add(constant);
  851. }
  852. beValue = constStruct;
  853. BE_MEM_END("ParamType_Const_Array");
  854. return;
  855. }
  856. else if (constType == BfConstType_ArrayZero8)
  857. {
  858. CMD_PARAM(int, count);
  859. auto beType = mBeContext->CreateSizedArrayType(mBeContext->GetPrimitiveType(BeTypeCode_Int8), count);
  860. auto beConst = mBeModule->mAlloc.Alloc<BeConstant>();
  861. beConst->mType = beType;
  862. beValue = beConst;
  863. return;
  864. }
  865. else if (constType == BfConstType_Undef)
  866. {
  867. CMD_PARAM(BeType*, type);
  868. auto constUndef = mBeModule->mOwnedValues.Alloc<BeUndefConstant>();
  869. constUndef->mType = type;
  870. beValue = constUndef;
  871. return;
  872. }
  873. else if (constType == BfConstType_TypeOf)
  874. {
  875. CMD_PARAM(BeType*, type);
  876. beValue = mReflectDataMap[type];
  877. BF_ASSERT(beValue != NULL);
  878. return;
  879. }
  880. else if (constType == BfConstType_TypeOf_Comptime)
  881. {
  882. CMD_PARAM(BeType*, typeType);
  883. CMD_PARAM(int, bfTypeId);
  884. auto beConst = mBeModule->mAlloc.Alloc<BeTypeOfConstant>();
  885. beConst->mType = typeType;
  886. beConst->mBfTypeId = bfTypeId;
  887. beValue = beConst;
  888. return;
  889. }
  890. else if (constType == BfConstType_TypeOf_WithData)
  891. {
  892. CMD_PARAM(BeType*, type);
  893. CMD_PARAM(BeValue*, value);
  894. mReflectDataMap[type] = value;
  895. beValue = value;
  896. return;
  897. }
  898. bool isSigned = false;
  899. BeType* llvmConstType = GetBeType(typeCode, isSigned);
  900. if (typeCode == BfTypeCode_Float)
  901. {
  902. float f;
  903. mStream->Read(&f, sizeof(float));
  904. beValue = mBeModule->GetConstant(llvmConstType, f);
  905. BE_MEM_END("ParamType_Single");
  906. }
  907. else if (typeCode == BfTypeCode_Double)
  908. {
  909. double d;
  910. mStream->Read(&d, sizeof(double));
  911. beValue = mBeModule->GetConstant(llvmConstType, d);
  912. BE_MEM_END("ParamType_Const_Double");
  913. }
  914. else if (typeCode == BfTypeCode_Boolean)
  915. {
  916. CMD_PARAM(bool, boolVal);
  917. beValue = mBeModule->GetConstant(llvmConstType, boolVal);
  918. BE_MEM_END("ParamType_Const_Boolean");
  919. }
  920. else if (typeCode == BfTypeCode_None)
  921. {
  922. beValue = NULL;
  923. BE_MEM_END("ParamType_Const_None");
  924. }
  925. else if (typeCode == BfTypeCode_NullPtr)
  926. {
  927. CMD_PARAM(BeType*, nullType);
  928. beValue = mBeModule->GetConstantNull((BePointerType*)nullType);
  929. BE_MEM_END("ParamType_Const_NullPtr");
  930. }
  931. else if (BfIRBuilder::IsInt(typeCode))
  932. {
  933. int64 intVal = ReadSLEB128();
  934. auto constVal = mBeModule->GetConstant(llvmConstType, intVal);
  935. beValue = constVal;
  936. BE_MEM_END("ParamType_Const_Int");
  937. }
  938. else
  939. {
  940. BF_FATAL("Unhandled");
  941. }
  942. }
  943. else if (paramType == BfIRParamType_Arg)
  944. {
  945. int argIdx = mStream->Read();
  946. beValue = mBeModule->GetArgument(argIdx);
  947. BE_MEM_END("ParamType_Arg");
  948. }
  949. else if (paramType == BfIRParamType_StreamId_Abs8)
  950. {
  951. int cmdId = mStream->Read();
  952. auto& result = mResults[cmdId];
  953. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Value);
  954. beValue = result.mBeValue;
  955. BE_MEM_END("ParamType_StreamId");
  956. }
  957. else if (paramType == BfIRParamType_StreamId_Rel)
  958. {
  959. int cmdId = mCmdCount - (int)ReadSLEB128();
  960. auto& result = mResults[cmdId];
  961. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Value);
  962. beValue = result.mBeValue;
  963. BE_MEM_END("ParamType_StreamId");
  964. }
  965. else
  966. {
  967. int cmdId = mCmdCount - (paramType - BfIRParamType_StreamId_Back1) - 1;
  968. auto& result = mResults[cmdId];
  969. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Value);
  970. beValue = result.mBeValue;
  971. BE_MEM_END("ParamType_StreamId");
  972. }
  973. if (beValue != NULL)
  974. beValue->mRefCount++;
  975. }
  976. void BeIRCodeGen::Read(BeConstant*& llvmConstant)
  977. {
  978. BE_MEM_START;
  979. BeValue* value;
  980. Read(value);
  981. if (value == NULL)
  982. {
  983. llvmConstant = NULL;
  984. }
  985. else
  986. {
  987. BF_ASSERT(BeValueDynCast<BeConstant>(value));
  988. llvmConstant = (BeConstant*)value;
  989. }
  990. BE_MEM_END("BeConstant");
  991. }
  992. void BeIRCodeGen::Read(BeFunction*& beFunc)
  993. {
  994. BE_MEM_START;
  995. int streamId = (int)ReadSLEB128();
  996. if (streamId == -1)
  997. {
  998. beFunc = NULL;
  999. return;
  1000. }
  1001. auto& result = mResults[streamId];
  1002. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Value);
  1003. BF_ASSERT(BeValueDynCast<BeFunction>(result.mBeValue));
  1004. beFunc = (BeFunction*)result.mBeValue;
  1005. BE_MEM_END("BeFunction");
  1006. beFunc->mRefCount++;
  1007. }
  1008. void BeIRCodeGen::Read(BeBlock*& beBlock)
  1009. {
  1010. BE_MEM_START;
  1011. int streamId = (int)ReadSLEB128();
  1012. auto& result = mResults[streamId];
  1013. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Block);
  1014. beBlock = (BeBlock*)result.mBeType;
  1015. BE_MEM_END("BeBlock");
  1016. beBlock->mRefCount++;
  1017. }
  1018. void BeIRCodeGen::Read(BeMDNode*& llvmMD)
  1019. {
  1020. BE_MEM_START;
  1021. int streamId = (int)ReadSLEB128();
  1022. if (streamId == -1)
  1023. {
  1024. llvmMD = NULL;
  1025. return;
  1026. }
  1027. auto& result = mResults[streamId];
  1028. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Metadata);
  1029. llvmMD = result.mBeMetadata;
  1030. BE_MEM_END("BeMDNode");
  1031. if (llvmMD != NULL)
  1032. llvmMD->mRefCount++;
  1033. }
  1034. void BeIRCodeGen::HandleNextCmd()
  1035. {
  1036. if (mFailed)
  1037. {
  1038. mStream->SetReadPos(mStream->GetSize());
  1039. return;
  1040. }
  1041. int curId = mCmdCount;
  1042. BfIRCmd cmd = (BfIRCmd)mStream->Read();
  1043. mCmdCount++;
  1044. #ifdef CODEGEN_TRACK
  1045. gBEMemReporter.BeginSection(gIRCmdNames[cmd]);
  1046. gBEMemReporter.Add(1);
  1047. #endif
  1048. switch (cmd)
  1049. {
  1050. case BfIRCmd_Module_Start:
  1051. {
  1052. CMD_PARAM(String, moduleName);
  1053. CMD_PARAM(int, ptrSize);
  1054. CMD_PARAM(bool, isOptimized);
  1055. BF_ASSERT(mBeModule == NULL);
  1056. mPtrSize = ptrSize;
  1057. mIsOptimized = isOptimized;
  1058. mBeContext = new BeContext();
  1059. mBeModule = new BeModule(moduleName, mBeContext);
  1060. mBeModule->mBeIRCodeGen = this;
  1061. mBeContext->mPointerSize = ptrSize;
  1062. for (auto constInt : mConfigConsts)
  1063. {
  1064. auto constVal = mBeModule->mAlloc.Alloc<BeConstant>();
  1065. constVal->mType = mBeContext->GetPrimitiveType(BeTypeCode_Int32);
  1066. constVal->mInt64 = constInt;
  1067. mBeModule->mConfigConsts32.Add(constVal);
  1068. constVal = mBeModule->mAlloc.Alloc<BeConstant>();
  1069. constVal->mType = mBeContext->GetPrimitiveType(BeTypeCode_Int64);
  1070. constVal->mInt64 = constInt;
  1071. mBeModule->mConfigConsts64.Add(constVal);
  1072. }
  1073. }
  1074. break;
  1075. case BfIRCmd_Module_SetTargetTriple:
  1076. {
  1077. CMD_PARAM(String, targetTriple);
  1078. CMD_PARAM(String, targetCPU);
  1079. mBeModule->mTargetTriple = targetTriple;
  1080. mBeModule->mTargetCPU = targetCPU;
  1081. }
  1082. break;
  1083. case BfIRCmd_Module_AddModuleFlag:
  1084. {
  1085. CMD_PARAM(String, flag);
  1086. CMD_PARAM(int, val);
  1087. //mBeModule->addModuleFlag(BeModule::Warning, flag, val);
  1088. }
  1089. break;
  1090. case BfIRCmd_WriteIR:
  1091. {
  1092. /*CMD_PARAM(String, fileName);
  1093. std::error_code ec;
  1094. Beraw_fd_ostream outStream(fileName.c_str(), ec, Besys::fs::OpenFlags::F_Text);
  1095. if (ec)
  1096. {
  1097. Fail("Failed writing IR '" + fileName + "': " + ec.message());
  1098. }
  1099. else
  1100. mBeModule->print(outStream, NULL);*/
  1101. }
  1102. break;
  1103. case BfIRCmd_Abort:
  1104. {
  1105. Fail("Stream aborted");
  1106. }
  1107. break;
  1108. case BfIRCmd_SetType:
  1109. {
  1110. CMD_PARAM(int, typeId);
  1111. CMD_PARAM(BeType*, type);
  1112. auto& typeEntry = GetTypeEntry(typeId);
  1113. typeEntry.mBeType = type;
  1114. if (typeEntry.mInstBeType == NULL)
  1115. typeEntry.mInstBeType = type;
  1116. }
  1117. break;
  1118. case BfIRCmd_SetInstType:
  1119. {
  1120. CMD_PARAM(int, typeId);
  1121. CMD_PARAM(BeType*, type);
  1122. GetTypeEntry(typeId).mInstBeType = type;
  1123. }
  1124. break;
  1125. case BfIRCmd_PrimitiveType:
  1126. {
  1127. BfTypeCode typeCode = (BfTypeCode)mStream->Read();
  1128. bool isSigned = false;
  1129. SetResult(curId, GetBeType(typeCode, isSigned));
  1130. }
  1131. break;
  1132. case BfIRCmd_CreateStruct:
  1133. {
  1134. CMD_PARAM(String, typeName);
  1135. SetResult(curId, mBeContext->CreateStruct(typeName));
  1136. }
  1137. break;
  1138. case BfIRCmd_CreateAnonymousStruct:
  1139. {
  1140. CMD_PARAM(CmdParamVec<BeType*>, members);
  1141. BeStructType* structType = mBeContext->CreateStruct(members);
  1142. SetResult(curId, structType);
  1143. }
  1144. break;
  1145. case BfIRCmd_StructSetBody:
  1146. {
  1147. CMD_PARAM(BeType*, type);
  1148. CMD_PARAM(CmdParamVec<BeType*>, members);
  1149. CMD_PARAM(int, instSize);
  1150. CMD_PARAM(int, instAlign);
  1151. CMD_PARAM(bool, isPacked);
  1152. if ((type == NULL) || (type->mTypeCode != BeTypeCode_Struct))
  1153. {
  1154. Fail("StructSetBody invalid type");
  1155. break;
  1156. }
  1157. bool failed = false;
  1158. for (auto member : members)
  1159. {
  1160. if (member->mSize < 0)
  1161. {
  1162. Fail("StructSetBody invalid member type");
  1163. failed = true;
  1164. }
  1165. }
  1166. if (!failed)
  1167. {
  1168. BF_ASSERT(type->mTypeCode == BeTypeCode_Struct);
  1169. auto structType = (BeStructType*)type;
  1170. mBeContext->SetStructBody(structType, members, isPacked);
  1171. structType->mSize = instSize;
  1172. structType->mAlign = instAlign;
  1173. }
  1174. }
  1175. break;
  1176. case BfIRCmd_Type:
  1177. {
  1178. CMD_PARAM(BeIRTypeEntry*, typeEntry);
  1179. auto type = typeEntry->mBeType;
  1180. SetResult(curId, type);
  1181. }
  1182. break;
  1183. case BfIRCmd_TypeInst:
  1184. {
  1185. CMD_PARAM(BeIRTypeEntry*, typeEntry);
  1186. SetResult(curId, typeEntry->mInstBeType);
  1187. }
  1188. break;
  1189. case BfIRCmd_TypeInstPtr:
  1190. {
  1191. CMD_PARAM(BeIRTypeEntry*, typeEntry);
  1192. SetResult(curId, mBeContext->GetPointerTo(typeEntry->mInstBeType));
  1193. }
  1194. break;
  1195. case BfIRCmd_GetType:
  1196. {
  1197. CMD_PARAM(BeValue*, value);
  1198. auto type = value->GetType();
  1199. SetResult(curId, type);
  1200. }
  1201. break;
  1202. case BfIRCmd_GetPointerToFuncType:
  1203. {
  1204. CMD_PARAM(BeFunctionType*, funcType);
  1205. SetResult(curId, mBeContext->GetPointerTo(funcType));
  1206. }
  1207. break;
  1208. case BfIRCmd_GetPointerToType:
  1209. {
  1210. CMD_PARAM(BeType*, type);
  1211. SetResult(curId, mBeContext->GetPointerTo(type));
  1212. }
  1213. break;
  1214. case BfIRCmd_GetSizedArrayType:
  1215. {
  1216. CMD_PARAM(BeType*, elementType);
  1217. CMD_PARAM(int, length);
  1218. SetResult(curId, mBeContext->CreateSizedArrayType(elementType, length));
  1219. }
  1220. break;
  1221. case BfIRCmd_GetVectorType:
  1222. {
  1223. CMD_PARAM(BeType*, elementType);
  1224. CMD_PARAM(int, length);
  1225. SetResult(curId, mBeContext->CreateVectorType(elementType, length));
  1226. }
  1227. break;
  1228. case BfIRCmd_CreateConstAgg:
  1229. {
  1230. CMD_PARAM(BeType*, type);
  1231. CMD_PARAM(CmdParamVec<BeValue*>, values);
  1232. auto constStruct = mBeModule->mOwnedValues.Alloc<BeStructConstant>();
  1233. constStruct->mType = type;
  1234. if (type->IsStruct())
  1235. {
  1236. FixValues((BeStructType*)type, values);
  1237. BF_ASSERT(((BeStructType*)type)->mMembers.size() == values.size());
  1238. for (int i = 0; i < (int)values.size(); i++)
  1239. {
  1240. auto val = values[i];
  1241. BF_ASSERT(mBeContext->AreTypesEqual(((BeStructType*)type)->mMembers[i].mType, val->GetType()));
  1242. constStruct->mMemberValues.push_back(BeValueDynCast<BeConstant>(val));
  1243. }
  1244. }
  1245. else
  1246. {
  1247. BF_ASSERT(type->IsSizedArray());
  1248. auto arrayType = (BeSizedArrayType*)type;
  1249. int fillCount = (int)(arrayType->mLength - values.size());
  1250. if (fillCount > 0)
  1251. {
  1252. auto lastValue = values.back();
  1253. for (int i = 0; i < fillCount; i++)
  1254. values.push_back(lastValue);
  1255. }
  1256. BF_ASSERT(arrayType->mLength == values.size());
  1257. for (int i = 0; i < (int)values.size(); i++)
  1258. {
  1259. auto val = values[i];
  1260. BF_ASSERT(mBeContext->AreTypesEqual(((BeSizedArrayType*)type)->mElementType, val->GetType()));
  1261. constStruct->mMemberValues.push_back(BeValueDynCast<BeConstant>(val));
  1262. }
  1263. }
  1264. SetResult(curId, constStruct);
  1265. }
  1266. break;
  1267. case BfIRCmd_CreateConstStructZero:
  1268. {
  1269. CMD_PARAM(BeType*, type);
  1270. auto beConst = mBeModule->mAlloc.Alloc<BeConstant>();
  1271. beConst->mType = type;
  1272. SetResult(curId, beConst);
  1273. }
  1274. break;
  1275. case BfIRCmd_CreateConstString:
  1276. {
  1277. CMD_PARAM(String, str);
  1278. auto constStruct = mBeModule->mOwnedValues.Alloc<BeStringConstant>();
  1279. constStruct->mString = str;
  1280. auto charType = mBeContext->GetPrimitiveType(BeTypeCode_Int8);
  1281. constStruct->mType = mBeContext->CreateSizedArrayType(charType, str.length() + 1);
  1282. SetResult(curId, constStruct);
  1283. }
  1284. break;
  1285. case BfIRCmd_ConfigConst:
  1286. {
  1287. CMD_PARAM(int, constIdx);
  1288. BfTypeCode typeCode = (BfTypeCode)mStream->Read();
  1289. if (typeCode == BfTypeCode_IntPtr)
  1290. typeCode = (mPtrSize == 4) ? BfTypeCode_Int32 : BfTypeCode_Int64;
  1291. BeConstant* constVal = (typeCode == BfTypeCode_Int32) ?
  1292. mBeModule->mConfigConsts32[constIdx] :
  1293. mBeModule->mConfigConsts64[constIdx];
  1294. SetResult(curId, constVal);
  1295. }
  1296. break;
  1297. case BfIRCmd_SetName:
  1298. {
  1299. CMD_PARAM(BeValue*, val);
  1300. CMD_PARAM(String, name);
  1301. val->SetName(name);
  1302. }
  1303. break;
  1304. case BfIRCmd_CreateUndefValue:
  1305. {
  1306. CMD_PARAM(BeType*, type);
  1307. SetResult(curId, mBeModule->CreateUndefValue(type));
  1308. }
  1309. break;
  1310. case BfIRCmd_NumericCast:
  1311. {
  1312. CMD_PARAM(BeValue*, val);
  1313. CMD_PARAM(bool, valIsSigned);
  1314. BfTypeCode typeCode = (BfTypeCode)mStream->Read();
  1315. auto valType = val->GetType();
  1316. if ((!valType->IsIntable()) && (!valType->IsFloat()))
  1317. {
  1318. Fail("Invalid NumericCast target");
  1319. }
  1320. BfTypeCode valTypeCode = GetTypeCode(valType, valIsSigned);
  1321. if (auto srcCastConstant = BeValueDynCast<BeCastConstant>(val))
  1322. {
  1323. BeType* toType = GetBeType(typeCode, valIsSigned);
  1324. auto castedVal = mBeModule->mAlloc.Alloc<BeCastConstant>();
  1325. castedVal->mInt64 = srcCastConstant->mInt64;
  1326. castedVal->mType = toType;
  1327. castedVal->mTarget = srcCastConstant->mTarget;
  1328. SetResult(curId, castedVal);
  1329. break;
  1330. }
  1331. bool toSigned = false;
  1332. auto toBeType = GetBeType(typeCode, toSigned);
  1333. BeValue* retVal = mBeModule->CreateNumericCast(val, toBeType, valIsSigned, toSigned);
  1334. SetResult(curId, retVal);
  1335. }
  1336. break;
  1337. case BfIRCmd_CmpEQ:
  1338. {
  1339. CMD_PARAM(BeValue*, lhs);
  1340. CMD_PARAM(BeValue*, rhs);
  1341. if (lhs->GetType() != rhs->GetType())
  1342. Fail("Type mismatch for CmpEQ");
  1343. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_EQ, lhs, rhs));
  1344. }
  1345. break;
  1346. case BfIRCmd_CmpNE:
  1347. {
  1348. CMD_PARAM(BeValue*, lhs);
  1349. CMD_PARAM(BeValue*, rhs);
  1350. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_NE, lhs, rhs));
  1351. }
  1352. break;
  1353. case BfIRCmd_CmpSLT:
  1354. {
  1355. CMD_PARAM(BeValue*, lhs);
  1356. CMD_PARAM(BeValue*, rhs);
  1357. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_SLT, lhs, rhs));
  1358. }
  1359. break;
  1360. case BfIRCmd_CmpULT:
  1361. {
  1362. CMD_PARAM(BeValue*, lhs);
  1363. CMD_PARAM(BeValue*, rhs);
  1364. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_ULT, lhs, rhs));
  1365. }
  1366. break;
  1367. case BfIRCmd_CmpSLE:
  1368. {
  1369. CMD_PARAM(BeValue*, lhs);
  1370. CMD_PARAM(BeValue*, rhs);
  1371. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_SLE, lhs, rhs));
  1372. }
  1373. break;
  1374. case BfIRCmd_CmpULE:
  1375. {
  1376. CMD_PARAM(BeValue*, lhs);
  1377. CMD_PARAM(BeValue*, rhs);
  1378. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_ULE, lhs, rhs));
  1379. }
  1380. break;
  1381. case BfIRCmd_CmpSGT:
  1382. {
  1383. CMD_PARAM(BeValue*, lhs);
  1384. CMD_PARAM(BeValue*, rhs);
  1385. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_SGT, lhs, rhs));
  1386. }
  1387. break;
  1388. case BfIRCmd_CmpUGT:
  1389. {
  1390. CMD_PARAM(BeValue*, lhs);
  1391. CMD_PARAM(BeValue*, rhs);
  1392. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_UGT, lhs, rhs));
  1393. }
  1394. break;
  1395. case BfIRCmd_CmpSGE:
  1396. {
  1397. CMD_PARAM(BeValue*, lhs);
  1398. CMD_PARAM(BeValue*, rhs);
  1399. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_SGE, lhs, rhs));
  1400. }
  1401. break;
  1402. case BfIRCmd_CmpUGE:
  1403. {
  1404. CMD_PARAM(BeValue*, lhs);
  1405. CMD_PARAM(BeValue*, rhs);
  1406. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_UGE, lhs, rhs));
  1407. }
  1408. break;
  1409. case BfIRCmd_Add:
  1410. {
  1411. CMD_PARAM(BeValue*, lhs);
  1412. CMD_PARAM(BeValue*, rhs);
  1413. CMD_PARAM(int8, overflowCheckKind);
  1414. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_Add, lhs, rhs, (BfOverflowCheckKind)overflowCheckKind));
  1415. }
  1416. break;
  1417. case BfIRCmd_Sub:
  1418. {
  1419. CMD_PARAM(BeValue*, lhs);
  1420. CMD_PARAM(BeValue*, rhs);
  1421. CMD_PARAM(int8, overflowCheckKind);
  1422. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_Subtract, lhs, rhs, (BfOverflowCheckKind)overflowCheckKind));
  1423. }
  1424. break;
  1425. case BfIRCmd_Mul:
  1426. {
  1427. CMD_PARAM(BeValue*, lhs);
  1428. CMD_PARAM(BeValue*, rhs);
  1429. CMD_PARAM(int8, overflowCheckKind);
  1430. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_Multiply, lhs, rhs, (BfOverflowCheckKind)overflowCheckKind));
  1431. }
  1432. break;
  1433. case BfIRCmd_SDiv:
  1434. {
  1435. CMD_PARAM(BeValue*, lhs);
  1436. CMD_PARAM(BeValue*, rhs);
  1437. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_SDivide, lhs, rhs));
  1438. }
  1439. break;
  1440. case BfIRCmd_UDiv:
  1441. {
  1442. CMD_PARAM(BeValue*, lhs);
  1443. CMD_PARAM(BeValue*, rhs);
  1444. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_UDivide, lhs, rhs));
  1445. }
  1446. break;
  1447. case BfIRCmd_SRem:
  1448. {
  1449. CMD_PARAM(BeValue*, lhs);
  1450. CMD_PARAM(BeValue*, rhs);
  1451. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_SModulus, lhs, rhs));
  1452. }
  1453. break;
  1454. case BfIRCmd_URem:
  1455. {
  1456. CMD_PARAM(BeValue*, lhs);
  1457. CMD_PARAM(BeValue*, rhs);
  1458. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_UModulus, lhs, rhs));
  1459. }
  1460. break;
  1461. case BfIRCmd_And:
  1462. {
  1463. CMD_PARAM(BeValue*, lhs);
  1464. CMD_PARAM(BeValue*, rhs);
  1465. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_BitwiseAnd, lhs, rhs));
  1466. }
  1467. break;
  1468. case BfIRCmd_Or:
  1469. {
  1470. CMD_PARAM(BeValue*, lhs);
  1471. CMD_PARAM(BeValue*, rhs);
  1472. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_BitwiseOr, lhs, rhs));
  1473. }
  1474. break;
  1475. case BfIRCmd_Xor:
  1476. {
  1477. CMD_PARAM(BeValue*, lhs);
  1478. CMD_PARAM(BeValue*, rhs);
  1479. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_ExclusiveOr, lhs, rhs));
  1480. }
  1481. break;
  1482. case BfIRCmd_Shl:
  1483. {
  1484. CMD_PARAM(BeValue*, lhs);
  1485. CMD_PARAM(BeValue*, rhs);
  1486. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_LeftShift, lhs, rhs));
  1487. }
  1488. break;
  1489. case BfIRCmd_AShr:
  1490. {
  1491. CMD_PARAM(BeValue*, lhs);
  1492. CMD_PARAM(BeValue*, rhs);
  1493. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_ARightShift, lhs, rhs));
  1494. }
  1495. break;
  1496. case BfIRCmd_LShr:
  1497. {
  1498. CMD_PARAM(BeValue*, lhs);
  1499. CMD_PARAM(BeValue*, rhs);
  1500. SetResult(curId, mBeModule->CreateBinaryOp(BeBinaryOpKind_RightShift, lhs, rhs));
  1501. }
  1502. break;
  1503. case BfIRCmd_Neg:
  1504. {
  1505. CMD_PARAM(BeValue*, val);
  1506. auto negInst = mBeModule->AllocInst<BeNegInst>();
  1507. negInst->mValue = val;
  1508. SetResult(curId, negInst);
  1509. }
  1510. break;
  1511. case BfIRCmd_Not:
  1512. {
  1513. CMD_PARAM(BeValue*, val);
  1514. auto negInst = mBeModule->AllocInst<BeNotInst>();
  1515. negInst->mValue = val;
  1516. SetResult(curId, negInst);
  1517. }
  1518. break;
  1519. case BfIRCmd_BitCast:
  1520. {
  1521. CMD_PARAM(BeValue*, val);
  1522. CMD_PARAM(BeType*, toType);
  1523. if (auto funcVal = BeValueDynCast<BeFunction>(val))
  1524. {
  1525. auto beConst = mBeModule->mAlloc.Alloc<BeConstant>();
  1526. beConst->mTarget = funcVal;
  1527. BF_ASSERT(funcVal->mType != NULL);
  1528. beConst->mType = toType;
  1529. SetResult(curId, beConst);
  1530. break;
  1531. }
  1532. SetResult(curId, mBeModule->CreateBitCast(val, toType));
  1533. }
  1534. break;
  1535. case BfIRCmd_PtrToInt:
  1536. {
  1537. CMD_PARAM(BeValue*, val);
  1538. auto typeCode = (BfTypeCode)mStream->Read();
  1539. bool isSigned = false;
  1540. auto beType = GetBeType(typeCode, isSigned);
  1541. BF_ASSERT(beType != NULL);
  1542. auto numericCastInst = mBeModule->AllocInst<BeNumericCastInst>();
  1543. numericCastInst->mValue = val;
  1544. numericCastInst->mValSigned = false;
  1545. numericCastInst->mToType = beType;
  1546. numericCastInst->mToSigned = isSigned;
  1547. SetResult(curId, numericCastInst);
  1548. }
  1549. break;
  1550. case BfIRCmd_IntToPtr:
  1551. {
  1552. CMD_PARAM(BeValue*, val);
  1553. CMD_PARAM(BeType*, toType);
  1554. auto bitcastInst = mBeModule->AllocInst<BeBitCastInst>();
  1555. bitcastInst->mValue = val;
  1556. bitcastInst->mToType = toType;
  1557. SetResult(curId, bitcastInst);
  1558. }
  1559. break;
  1560. case BfIRCmd_InboundsGEP1_32:
  1561. {
  1562. CMD_PARAM(BeValue*, val);
  1563. CMD_PARAM(int, idx0);
  1564. BF_ASSERT(val->GetType()->IsPointer());
  1565. BeType* int32Type = mBeContext->GetPrimitiveType(BeTypeCode_Int32);
  1566. SetResult(curId, mBeModule->CreateGEP(val, mBeModule->GetConstant(int32Type, (int64)idx0), NULL));
  1567. }
  1568. break;
  1569. case BfIRCmd_InboundsGEP2_32:
  1570. {
  1571. CMD_PARAM(BeValue*, val);
  1572. CMD_PARAM(int, idx0);
  1573. CMD_PARAM(int, idx1);
  1574. BF_ASSERT(val->GetType()->IsPointer());
  1575. BeType* int32Type = mBeContext->GetPrimitiveType(BeTypeCode_Int32);
  1576. SetResult(curId, mBeModule->CreateGEP(val, mBeModule->GetConstant(int32Type, (int64)idx0), mBeModule->GetConstant(int32Type, (int64)idx1)));
  1577. }
  1578. break;
  1579. case BfIRCmd_InBoundsGEP1:
  1580. {
  1581. CMD_PARAM(BeValue*, val);
  1582. CMD_PARAM(BeValue*, idx0);
  1583. BF_ASSERT(val->GetType()->IsPointer());
  1584. SetResult(curId, mBeModule->CreateGEP(val, idx0, NULL));
  1585. }
  1586. break;
  1587. case BfIRCmd_InBoundsGEP2:
  1588. {
  1589. CMD_PARAM(BeValue*, val);
  1590. CMD_PARAM(BeValue*, idx0);
  1591. CMD_PARAM(BeValue*, idx1);
  1592. BF_ASSERT(val->GetType()->IsPointer());
  1593. SetResult(curId, mBeModule->CreateGEP(val, idx0, idx1));
  1594. }
  1595. break;
  1596. case BfIRCmd_IsNull:
  1597. {
  1598. CMD_PARAM(BeValue*, val);
  1599. BF_ASSERT(val->GetType()->IsPointer());
  1600. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_EQ, val, mBeModule->GetConstantNull((BePointerType*)val->GetType())));
  1601. }
  1602. break;
  1603. case BfIRCmd_IsNotNull:
  1604. {
  1605. CMD_PARAM(BeValue*, val);
  1606. BF_ASSERT(val->GetType()->IsPointer());
  1607. SetResult(curId, mBeModule->CreateCmp(BeCmpKind_NE, val, mBeModule->GetConstantNull((BePointerType*)val->GetType())));
  1608. }
  1609. break;
  1610. case BfIRCmd_ExtractValue:
  1611. {
  1612. CMD_PARAM(BeValue*, val);
  1613. CMD_PARAM(int, idx);
  1614. BF_ASSERT(val->GetType()->IsComposite());
  1615. if (val->GetType()->mTypeCode == BeTypeCode_Struct)
  1616. {
  1617. auto structType = (BeStructType*)val->GetType();
  1618. if (idx >= structType->mMembers.mSize)
  1619. {
  1620. FatalError("ExtractValue OOB");
  1621. }
  1622. }
  1623. auto extractValueInst = mBeModule->AllocInst<BeExtractValueInst>();
  1624. extractValueInst->mAggVal = val;
  1625. extractValueInst->mIdx = idx;
  1626. SetResult(curId, extractValueInst);
  1627. }
  1628. break;
  1629. case BfIRCmd_InsertValue:
  1630. {
  1631. CMD_PARAM(BeValue*, agg);
  1632. CMD_PARAM(BeValue*, val);
  1633. CMD_PARAM(int, idx);
  1634. auto insertValueInst = mBeModule->AllocInst<BeInsertValueInst>();
  1635. insertValueInst->mAggVal = agg;
  1636. insertValueInst->mMemberVal = val;
  1637. insertValueInst->mIdx = idx;
  1638. SetResult(curId, insertValueInst);
  1639. }
  1640. break;
  1641. case BfIRCmd_Alloca:
  1642. {
  1643. CMD_PARAM(BeType*, type);
  1644. if (type->IsStruct())
  1645. {
  1646. BF_ASSERT(!((BeStructType*)type)->mIsOpaque);
  1647. }
  1648. auto allocaInst = mBeModule->CreateAlloca(type);
  1649. allocaInst->mAlign = type->mAlign;
  1650. SetResult(curId, allocaInst);
  1651. }
  1652. break;
  1653. case BfIRCmd_AllocaArray:
  1654. {
  1655. CMD_PARAM(BeType*, type);
  1656. CMD_PARAM(BeValue*, arraySize);
  1657. if (auto constant = BeValueDynCast<BeConstant>(arraySize))
  1658. {
  1659. //BF_ASSERT(constant->mInt64 >= 0);
  1660. }
  1661. auto allocaInst = mBeModule->AllocInst<BeAllocaInst>();
  1662. allocaInst->mType = type;
  1663. allocaInst->mAlign = type->mAlign;
  1664. allocaInst->mArraySize = arraySize;
  1665. SetResult(curId, allocaInst);
  1666. }
  1667. break;
  1668. case BfIRCmd_SetAllocaAlignment:
  1669. {
  1670. CMD_PARAM(BeValue*, val);
  1671. CMD_PARAM(int, alignment);
  1672. auto inst = BeValueDynCast<BeAllocaInst>(val);
  1673. inst->mAlign = alignment;
  1674. //TODO: Implement
  1675. /*inst->setAlignment(alignment);*/
  1676. }
  1677. break;
  1678. case BfIRCmd_AliasValue:
  1679. {
  1680. CMD_PARAM(BeValue*, val);
  1681. auto inst = mBeModule->AllocInst<BeAliasValueInst>();
  1682. inst->mPtr = val;
  1683. SetResult(curId, inst);
  1684. }
  1685. break;
  1686. case BfIRCmd_LifetimeStart:
  1687. {
  1688. CMD_PARAM(BeValue*, val);
  1689. auto inst = mBeModule->AllocInst<BeLifetimeStartInst>();
  1690. inst->mPtr = val;
  1691. SetResult(curId, inst);
  1692. }
  1693. break;
  1694. case BfIRCmd_LifetimeEnd:
  1695. {
  1696. CMD_PARAM(BeValue*, val);
  1697. #ifdef _DEBUG
  1698. val->mLifetimeEnded = true;
  1699. #endif
  1700. auto inst = mBeModule->AllocInst<BeLifetimeEndInst>();
  1701. inst->mPtr = val;
  1702. SetResult(curId, inst);
  1703. }
  1704. break;
  1705. case BfIRCmd_LifetimeSoftEnd:
  1706. {
  1707. CMD_PARAM(BeValue*, val);
  1708. auto inst = mBeModule->AllocInst<BeLifetimeSoftEndInst>();
  1709. inst->mPtr = val;
  1710. SetResult(curId, inst);
  1711. }
  1712. break;
  1713. case BfIRCmd_LifetimeExtend:
  1714. {
  1715. CMD_PARAM(BeValue*, val);
  1716. auto inst = mBeModule->AllocInst<BeLifetimeExtendInst>();
  1717. inst->mPtr = val;
  1718. SetResult(curId, inst);
  1719. }
  1720. break;
  1721. case BfIRCmd_ValueScopeStart:
  1722. {
  1723. auto inst = mBeModule->AllocInst<BeValueScopeStartInst>();
  1724. SetResult(curId, inst);
  1725. }
  1726. break;
  1727. case BfIRCmd_ValueScopeRetain:
  1728. {
  1729. CMD_PARAM(BeValue*, val);
  1730. auto inst = mBeModule->AllocInst<BeValueScopeRetainInst>();
  1731. inst->mValue = val;
  1732. }
  1733. break;
  1734. case BfIRCmd_ValueScopeSoftEnd:
  1735. {
  1736. CMD_PARAM(BeValue*, val);
  1737. auto inst = mBeModule->AllocInst<BeValueScopeEndInst>();
  1738. inst->mScopeStart = (BeValueScopeStartInst*)val;
  1739. inst->mIsSoft = true;
  1740. //TODO: Is this always correct? This keeps there from being nops inserted on block opens ( { )
  1741. inst->mDbgLoc = NULL;
  1742. }
  1743. break;
  1744. case BfIRCmd_ValueScopeHardEnd:
  1745. {
  1746. CMD_PARAM(BeValue*, val);
  1747. auto inst = mBeModule->AllocInst<BeValueScopeEndInst>();
  1748. inst->mScopeStart = (BeValueScopeStartInst*)val;
  1749. inst->mIsSoft = false;
  1750. //TODO: Is this always correct? This keeps there from being nops inserted on block opens ( { )
  1751. inst->mDbgLoc = NULL;
  1752. }
  1753. break;
  1754. case BfIRCmd_SetAllocaNoChkStkHint:
  1755. {
  1756. CMD_PARAM(BeValue*, val);
  1757. auto inst = BeValueDynCast<BeAllocaInst>(val);
  1758. inst->mNoChkStk = true;
  1759. }
  1760. break;
  1761. case BfIRCmd_SetAllocaForceMem:
  1762. {
  1763. CMD_PARAM(BeValue*, val);
  1764. auto inst = BeValueDynCast<BeAllocaInst>(val);
  1765. inst->mForceMem = true;
  1766. }
  1767. break;
  1768. case BfIRCmd_Load:
  1769. {
  1770. CMD_PARAM(BeValue*, val);
  1771. #ifdef _DEBUG
  1772. auto ptrType = val->GetType();
  1773. BF_ASSERT(ptrType->IsPointer());
  1774. // We call via a function pointer so there's never a reason to allow loading of a funcPtr
  1775. BF_ASSERT(((BePointerType*)ptrType)->mElementType->mTypeCode != BeTypeCode_Function);
  1776. // Disallow loading from a NULL constant
  1777. if (val->GetTypeId() == BeConstant::TypeId)
  1778. {
  1779. if (auto constant = BeValueDynCast<BeConstant>(val))
  1780. {
  1781. BF_ASSERT(constant->mTarget != NULL);
  1782. }
  1783. }
  1784. #endif
  1785. CMD_PARAM(bool, isVolatile);
  1786. SetResult(curId, mBeModule->CreateLoad(val, isVolatile));
  1787. }
  1788. break;
  1789. case BfIRCmd_AlignedLoad:
  1790. {
  1791. CMD_PARAM(BeValue*, val);
  1792. CMD_PARAM(int, alignment);
  1793. CMD_PARAM(bool, isVolatile);
  1794. #ifdef _DEBUG
  1795. // Disallow loading from a NULL constant
  1796. if (val->GetTypeId() == BeConstant::TypeId)
  1797. {
  1798. if (auto constant = BeValueDynCast<BeConstant>(val))
  1799. {
  1800. BF_ASSERT(constant->mTarget != NULL);
  1801. }
  1802. }
  1803. auto ptrType = val->GetType();
  1804. BF_ASSERT(ptrType->IsPointer());
  1805. #endif
  1806. SetResult(curId, mBeModule->CreateAlignedLoad(val, alignment, isVolatile));
  1807. }
  1808. break;
  1809. case BfIRCmd_Store:
  1810. {
  1811. CMD_PARAM(BeValue*, val);
  1812. CMD_PARAM(BeValue*, ptr);
  1813. #ifdef _DEBUG
  1814. auto ptrType = ptr->GetType();
  1815. auto valType = val->GetType();
  1816. if ((!ptrType->IsPointer()) || (!mBeContext->AreTypesEqual(((BePointerType*)ptrType)->mElementType, valType)))
  1817. {
  1818. String errStr;
  1819. errStr += "BfIRCmd_Store Match Failure:\n";
  1820. BeDumpContext dumpCtx;
  1821. errStr += "Val: ";
  1822. dumpCtx.ToString(errStr, val);
  1823. errStr += "\nPtr: ";
  1824. dumpCtx.ToString(errStr, ptr);
  1825. FatalError(errStr);
  1826. }
  1827. #endif
  1828. CMD_PARAM(bool, isVolatile);
  1829. SetResult(curId, mBeModule->CreateStore(val, ptr, isVolatile));
  1830. }
  1831. break;
  1832. case BfIRCmd_AlignedStore:
  1833. {
  1834. CMD_PARAM(BeValue*, val);
  1835. CMD_PARAM(BeValue*, ptr);
  1836. CMD_PARAM(int, alignment);
  1837. CMD_PARAM(bool, isVolatile);
  1838. #ifdef _DEBUG
  1839. auto ptrType = ptr->GetType();
  1840. auto valType = val->GetType();
  1841. if ((!ptrType->IsPointer()) || (!mBeContext->AreTypesEqual(((BePointerType*)ptrType)->mElementType, valType)))
  1842. {
  1843. String errStr;
  1844. errStr += "BfIRCmd_Store Match Failure:\n";
  1845. BeDumpContext dumpCtx;
  1846. errStr += "Val: ";
  1847. dumpCtx.ToString(errStr, val);
  1848. errStr += "\nPtr: ";
  1849. dumpCtx.ToString(errStr, ptr);
  1850. FatalError(errStr);
  1851. }
  1852. #endif
  1853. SetResult(curId, mBeModule->CreateAlignedStore(val, ptr, alignment, isVolatile));
  1854. }
  1855. break;
  1856. case BfIRCmd_MemSet:
  1857. {
  1858. auto inst = mBeModule->AllocInst<BeMemSetInst>();
  1859. Read(inst->mAddr);
  1860. Read(inst->mVal);
  1861. Read(inst->mSize);
  1862. Read(inst->mAlignment);
  1863. SetResult(curId, inst);
  1864. }
  1865. break;
  1866. case BfIRCmd_Fence:
  1867. {
  1868. BfIRFenceType fenceType = (BfIRFenceType)mStream->Read();
  1869. mBeModule->AllocInst<BeFenceInst>();
  1870. }
  1871. break;
  1872. case BfIRCmd_StackSave:
  1873. {
  1874. SetResult(curId, mBeModule->AllocInst<BeStackSaveInst>());
  1875. }
  1876. break;
  1877. case BfIRCmd_StackRestore:
  1878. {
  1879. CMD_PARAM(BeValue*, stackVal);
  1880. auto stackRestoreInst = mBeModule->AllocInst<BeStackRestoreInst>();
  1881. stackRestoreInst->mStackVal = stackVal;
  1882. SetResult(curId, stackRestoreInst);
  1883. }
  1884. break;
  1885. case BfIRCmd_GlobalVariable:
  1886. {
  1887. CMD_PARAM(BeType*, varType);
  1888. CMD_PARAM(bool, isConstant);
  1889. BfIRLinkageType linkageType = (BfIRLinkageType)mStream->Read();
  1890. CMD_PARAM(StringT<256>, name);
  1891. CMD_PARAM(bool, isTLS);
  1892. CMD_PARAM(BeConstant*, initializer);
  1893. BF_ASSERT(varType != NULL);
  1894. auto globalVariable = mBeModule->mGlobalVariables.Alloc();
  1895. globalVariable->mModule = mBeModule;
  1896. globalVariable->mType = varType;
  1897. globalVariable->mIsConstant = isConstant;
  1898. globalVariable->mLinkageType = linkageType;
  1899. globalVariable->mInitializer = initializer;
  1900. globalVariable->mName = name;
  1901. globalVariable->mIsTLS = isTLS;
  1902. globalVariable->mUnnamedAddr = false;
  1903. globalVariable->mStorageKind = BfIRStorageKind_Normal;
  1904. if (initializer != NULL)
  1905. {
  1906. globalVariable->mAlign = varType->mAlign;
  1907. BF_ASSERT(varType->mAlign > 0);
  1908. BF_ASSERT(mBeContext->AreTypesEqual(varType, initializer->GetType()));
  1909. }
  1910. else
  1911. globalVariable->mAlign = -1;
  1912. SetResult(curId, globalVariable);
  1913. }
  1914. break;
  1915. case BfIRCmd_GlobalVar_SetUnnamedAddr:
  1916. {
  1917. CMD_PARAM(BeValue*, val);
  1918. CMD_PARAM(bool, unnamedAddr);
  1919. BF_ASSERT(BeValueDynCast<BeGlobalVariable>(val) != NULL);
  1920. ((BeGlobalVariable*)val)->mUnnamedAddr = true;
  1921. }
  1922. break;
  1923. case BfIRCmd_GlobalVar_SetInitializer:
  1924. {
  1925. CMD_PARAM(BeValue*, val);
  1926. CMD_PARAM(BeConstant*, initializer);
  1927. BF_ASSERT(BeValueDynCast<BeGlobalVariable>(val) != NULL);
  1928. auto globalVariable = (BeGlobalVariable*)val;
  1929. globalVariable->mInitializer = initializer;
  1930. if (globalVariable->mInitializer != NULL)
  1931. {
  1932. globalVariable->mAlign = globalVariable->mType->mAlign;
  1933. BF_ASSERT(globalVariable->mAlign != -1);
  1934. }
  1935. }
  1936. break;
  1937. case BfIRCmd_GlobalVar_SetAlignment:
  1938. {
  1939. CMD_PARAM(BeValue*, val);
  1940. CMD_PARAM(int, alignment);
  1941. BF_ASSERT(BeValueDynCast<BeGlobalVariable>(val) != NULL);
  1942. auto globalVariable = (BeGlobalVariable*)val;
  1943. globalVariable->mAlign = alignment;
  1944. BF_ASSERT(alignment > 0);
  1945. if (globalVariable->mInitializer != NULL)
  1946. {
  1947. BF_ASSERT(globalVariable->mAlign != -1);
  1948. }
  1949. }
  1950. break;
  1951. case BfIRCmd_GlobalVar_SetStorageKind:
  1952. {
  1953. CMD_PARAM(BeValue*, val);
  1954. CMD_PARAM(int, storageKind);
  1955. BF_ASSERT(BeValueDynCast<BeGlobalVariable>(val) != NULL);
  1956. auto globalVariable = (BeGlobalVariable*)val;
  1957. globalVariable->mStorageKind = (BfIRStorageKind)storageKind;
  1958. }
  1959. break;
  1960. case BfIRCmd_GlobalStringPtr:
  1961. {
  1962. CMD_PARAM(String, str);
  1963. auto constStruct = mBeModule->mOwnedValues.Alloc<BeStringConstant>();
  1964. constStruct->mString = str;
  1965. auto charType = mBeContext->GetPrimitiveType(BeTypeCode_Int8);
  1966. constStruct->mType = mBeContext->CreateSizedArrayType(charType, str.length() + 1);
  1967. auto globalVariable = mBeModule->mGlobalVariables.Alloc();
  1968. globalVariable->mModule = mBeModule;
  1969. globalVariable->mType = constStruct->mType;
  1970. globalVariable->mIsConstant = true;
  1971. globalVariable->mLinkageType = BfIRLinkageType_Internal;
  1972. globalVariable->mInitializer = constStruct;
  1973. globalVariable->mName = StrFormat("__str%d", (int)mBeModule->mGlobalVariables.size() - 1);
  1974. globalVariable->mIsTLS = false;
  1975. globalVariable->mAlign = 1;
  1976. globalVariable->mUnnamedAddr = false;
  1977. auto castedVal = mBeModule->mAlloc.Alloc<BeCastConstant>();
  1978. castedVal->mType = mBeContext->GetPointerTo(charType);
  1979. castedVal->mTarget = globalVariable;
  1980. SetResult(curId, castedVal);
  1981. //SetResult(curId, globalVariable);
  1982. }
  1983. break;
  1984. case BfIRCmd_SetReflectTypeData:
  1985. {
  1986. CMD_PARAM(BeType*, type);
  1987. CMD_PARAM(BeValue*, value);
  1988. mReflectDataMap[type] = value;
  1989. }
  1990. break;
  1991. case BfIRCmd_CreateBlock:
  1992. {
  1993. CMD_PARAM(String, name);
  1994. CMD_PARAM(bool, addNow);
  1995. auto block = mBeModule->CreateBlock(name);
  1996. if (addNow)
  1997. mBeModule->AddBlock(mActiveFunction, block);
  1998. SetResult(curId, block);
  1999. }
  2000. break;
  2001. case BfIRCmd_MaybeChainNewBlock:
  2002. {
  2003. CMD_PARAM(String, name);
  2004. auto newBlock = mBeModule->GetInsertBlock();
  2005. if (!newBlock->IsEmpty())
  2006. {
  2007. auto bb = mBeModule->CreateBlock(name);
  2008. mBeModule->CreateBr(bb);
  2009. mBeModule->AddBlock(mActiveFunction, bb);
  2010. mBeModule->SetInsertPoint(bb);
  2011. newBlock = bb;
  2012. }
  2013. SetResult(curId, newBlock);
  2014. }
  2015. break;
  2016. case BfIRCmd_AddBlock:
  2017. {
  2018. CMD_PARAM(BeBlock*, block);
  2019. mBeModule->AddBlock(mActiveFunction, block);
  2020. }
  2021. break;
  2022. case BfIRCmd_DropBlocks:
  2023. {
  2024. CMD_PARAM(BeBlock*, startingBlock);
  2025. auto& basicBlockList = mActiveFunction->mBlocks;
  2026. int postExitBlockIdx = -1;
  2027. /*auto itr = basicBlockList.begin();
  2028. while (itr != basicBlockList.end())
  2029. {
  2030. auto block = *itr;
  2031. if (block == startingBlock)
  2032. {
  2033. basicBlockList.erase(itr, basicBlockList.end());
  2034. break;
  2035. }
  2036. ++itr;
  2037. }*/
  2038. for (int i = 0; i < (int)basicBlockList.size(); i++)
  2039. {
  2040. if (basicBlockList[i] == startingBlock)
  2041. {
  2042. basicBlockList.RemoveRange(i, basicBlockList.size() - i);
  2043. break;
  2044. }
  2045. }
  2046. }
  2047. break;
  2048. case BfIRCmd_MergeBlockDown:
  2049. {
  2050. CMD_PARAM(BeBlock*, fromBlock);
  2051. CMD_PARAM(BeBlock*, intoBlock);
  2052. for (auto inst : fromBlock->mInstructions)
  2053. inst->mParentBlock = intoBlock;
  2054. if (!fromBlock->mInstructions.IsEmpty())
  2055. intoBlock->mInstructions.Insert(0, &fromBlock->mInstructions[0], fromBlock->mInstructions.size());
  2056. mBeModule->RemoveBlock(mActiveFunction, fromBlock);
  2057. }
  2058. break;
  2059. case BfIRCmd_GetInsertBlock:
  2060. {
  2061. SetResult(curId, mBeModule->mActiveBlock);
  2062. }
  2063. break;
  2064. case BfIRCmd_SetInsertPoint:
  2065. {
  2066. CMD_PARAM(BeBlock*, block);
  2067. mBeModule->SetInsertPoint(block);
  2068. }
  2069. break;
  2070. case BfIRCmd_SetInsertPointAtStart:
  2071. {
  2072. CMD_PARAM(BeBlock*, block);
  2073. mBeModule->SetInsertPointAtStart(block);
  2074. }
  2075. break;
  2076. case BfIRCmd_EraseFromParent:
  2077. {
  2078. CMD_PARAM(BeBlock*, block);
  2079. mBeModule->RemoveBlock(mActiveFunction, block);
  2080. }
  2081. break;
  2082. case BfIRCmd_DeleteBlock:
  2083. {
  2084. CMD_PARAM(BeBlock*, block);
  2085. }
  2086. break;
  2087. case BfIRCmd_EraseInstFromParent:
  2088. {
  2089. CMD_PARAM(BeValue*, instVal);
  2090. BeInst* inst = (BeInst*)instVal;
  2091. bool wasRemoved = inst->mParentBlock->mInstructions.Remove(inst);
  2092. BF_ASSERT(wasRemoved);
  2093. #ifdef _DEBUG
  2094. inst->mWasRemoved = true;
  2095. #endif
  2096. }
  2097. break;
  2098. case BfIRCmd_CreateBr:
  2099. {
  2100. CMD_PARAM(BeBlock*, block);
  2101. mBeModule->CreateBr(block);
  2102. }
  2103. break;
  2104. case BfIRCmd_CreateBr_Fake:
  2105. {
  2106. CMD_PARAM(BeBlock*, block);
  2107. auto inst = mBeModule->CreateBr(block);
  2108. inst->mIsFake = true;
  2109. }
  2110. break;
  2111. case BfIRCmd_CreateBr_NoCollapse:
  2112. {
  2113. CMD_PARAM(BeBlock*, block);
  2114. auto inst = mBeModule->CreateBr(block);
  2115. inst->mNoCollapse = true;
  2116. }
  2117. break;
  2118. case BfIRCmd_CreateCondBr:
  2119. {
  2120. CMD_PARAM(BeValue*, condVal);
  2121. CMD_PARAM(BeBlock*, trueBlock);
  2122. CMD_PARAM(BeBlock*, falseBlock);
  2123. mBeModule->CreateCondBr(condVal, trueBlock, falseBlock);
  2124. }
  2125. break;
  2126. case BfIRCmd_MoveBlockToEnd:
  2127. {
  2128. CMD_PARAM(BeBlock*, block);
  2129. mBeModule->RemoveBlock(mActiveFunction, block);
  2130. mBeModule->AddBlock(mActiveFunction, block);
  2131. }
  2132. break;
  2133. case BfIRCmd_CreateSwitch:
  2134. {
  2135. CMD_PARAM(BeValue*, val);
  2136. CMD_PARAM(BeBlock*, dest);
  2137. CMD_PARAM(int, numCases);
  2138. auto switchInst = mBeModule->AllocInstOwned<BeSwitchInst>();
  2139. switchInst->mValue = val;
  2140. switchInst->mDefaultBlock = dest;
  2141. switchInst->mCases.Reserve(numCases);
  2142. SetResult(curId, switchInst);
  2143. }
  2144. break;
  2145. case BfIRCmd_AddSwitchCase:
  2146. {
  2147. CMD_PARAM(BeValue*, switchVal);
  2148. CMD_PARAM(BeValue*, caseVal);
  2149. CMD_PARAM(BeBlock*, caseBlock);
  2150. BeSwitchCase switchCase;
  2151. switchCase.mValue = (BeConstant*)caseVal;
  2152. switchCase.mBlock = caseBlock;
  2153. ((BeSwitchInst*)switchVal)->mCases.push_back(switchCase);
  2154. }
  2155. break;
  2156. case BfIRCmd_SetSwitchDefaultDest:
  2157. {
  2158. CMD_PARAM(BeValue*, switchVal);
  2159. CMD_PARAM(BeBlock*, caseBlock);
  2160. ((BeSwitchInst*)switchVal)->mDefaultBlock = caseBlock;
  2161. }
  2162. break;
  2163. case BfIRCmd_CreatePhi:
  2164. {
  2165. CMD_PARAM(BeType*, type);
  2166. CMD_PARAM(int, incomingCount);
  2167. auto phiInst = mBeModule->AllocInstOwned<BePhiInst>();
  2168. phiInst->mType = type;
  2169. SetResult(curId, phiInst);
  2170. }
  2171. break;
  2172. case BfIRCmd_AddPhiIncoming:
  2173. {
  2174. CMD_PARAM(BeValue*, phiValue);
  2175. CMD_PARAM(BeValue*, value);
  2176. CMD_PARAM(BeBlock*, comingFrom);
  2177. if (phiValue->GetType() != value->GetType())
  2178. {
  2179. Fail("AddPhiIncoming type mismatch");
  2180. break;
  2181. }
  2182. auto phiIncoming = mBeModule->mAlloc.Alloc<BePhiIncoming>();
  2183. phiIncoming->mBlock = comingFrom;
  2184. phiIncoming->mValue = value;
  2185. ((BePhiInst*)phiValue)->mIncoming.push_back(phiIncoming);
  2186. }
  2187. break;
  2188. case BfIRCmd_GetIntrinsic:
  2189. {
  2190. CMD_PARAM(String, intrinName);
  2191. CMD_PARAM(int, intrinId);
  2192. CMD_PARAM(BeType*, returnType);
  2193. CMD_PARAM(CmdParamVec<BeType*>, paramTypes);
  2194. auto intrin = mBeModule->mAlloc.Alloc<BeIntrinsic>();
  2195. intrin->mName = intrinName;
  2196. intrin->mKind = (BfIRIntrinsic)intrinId;
  2197. intrin->mReturnType = returnType;
  2198. SetResult(curId, intrin);
  2199. }
  2200. break;
  2201. case BfIRCmd_CreateFunctionType:
  2202. {
  2203. CMD_PARAM(BeType*, resultType);
  2204. CMD_PARAM(CmdParamVec<BeType*>, paramTypes);
  2205. CMD_PARAM(bool, isVarArg);
  2206. auto functionType = mBeContext->CreateFunctionType(resultType, paramTypes, isVarArg);
  2207. SetResult(curId, functionType);
  2208. }
  2209. break;
  2210. case BfIRCmd_CreateFunction:
  2211. {
  2212. CMD_PARAM(BeFunctionType*, type);
  2213. BfIRLinkageType linkageType = (BfIRLinkageType)mStream->Read();
  2214. CMD_PARAM(String, name);
  2215. SetResult(curId, mBeModule->CreateFunction(type, linkageType, name));
  2216. }
  2217. break;
  2218. case BfIRCmd_SetFunctionName:
  2219. {
  2220. CMD_PARAM(BeValue*, func);
  2221. CMD_PARAM(String, name);
  2222. BeFunction* beFunc = BeValueDynCast<BeFunction>(func);
  2223. beFunc->mName = name;
  2224. }
  2225. break;
  2226. case BfIRCmd_EnsureFunctionPatchable:
  2227. {
  2228. }
  2229. break;
  2230. case BfIRCmd_RemapBindFunction:
  2231. {
  2232. CMD_PARAM(BeValue*, func);
  2233. // We need to store this value to a data segment so we get a symbol we can remap during hot swap
  2234. // We actually do this to ensure that we don't bind to the NEW method but rather the old one- so
  2235. // delegate equality checks still work
  2236. BeFunction* beFunc = BeValueDynCast<BeFunction>(func);
  2237. if (beFunc != NULL)
  2238. {
  2239. if (beFunc->mRemapBindVar == NULL)
  2240. {
  2241. auto globalVariable = mBeModule->mGlobalVariables.Alloc();
  2242. globalVariable->mModule = mBeModule;
  2243. globalVariable->mType = beFunc->mType;
  2244. globalVariable->mIsConstant = true;
  2245. globalVariable->mLinkageType = BfIRLinkageType_External;
  2246. globalVariable->mInitializer = beFunc;
  2247. globalVariable->mName = StrFormat("bf_hs_preserve@%s_%s", beFunc->mName.c_str(), mBeModule->mModuleName.c_str());
  2248. globalVariable->mIsTLS = false;
  2249. globalVariable->mAlign = 8;
  2250. globalVariable->mUnnamedAddr = false;
  2251. beFunc->mRemapBindVar = globalVariable;
  2252. /*if (mBeModule->mDbgModule != NULL)
  2253. {
  2254. auto dbgGlobalVariable = mBeModule->mDbgModule->mGlobalVariables.Alloc();
  2255. dbgGlobalVariable->mContext = mBeContext;
  2256. dbgGlobalVariable->mName = name;
  2257. dbgGlobalVariable->mLinkageName = globalVariable->mName;
  2258. dbgGlobalVariable->mFile = (BeDbgFile*)file;
  2259. dbgGlobalVariable->mLineNum = lineNum;
  2260. dbgGlobalVariable->mType = (BeDbgType*)type;
  2261. dbgGlobalVariable->mIsLocalToUnit = isLocalToUnit;
  2262. dbgGlobalVariable->mValue = val;
  2263. dbgGlobalVariable->mDecl = decl;
  2264. }*/
  2265. }
  2266. SetResult(curId, mBeModule->CreateLoad(beFunc->mRemapBindVar, false));
  2267. }
  2268. else
  2269. SetResult(curId, func);
  2270. }
  2271. break;
  2272. case BfIRCmd_SetActiveFunction:
  2273. {
  2274. CMD_PARAM(BeFunction*, func);
  2275. mActiveFunction = func;
  2276. mBeModule->mActiveFunction = func;
  2277. }
  2278. break;
  2279. case BfIRCmd_CreateCall:
  2280. {
  2281. CMD_PARAM(BeValue*, func);
  2282. CMD_PARAM(CmdParamVec<BeValue*>, args);
  2283. #ifdef BE_EXTRA_CHECKS
  2284. auto funcPtrType = func->GetType();
  2285. if (funcPtrType != NULL)
  2286. {
  2287. BF_ASSERT(funcPtrType->IsPointer());
  2288. auto funcType = (BeFunctionType*)((BePointerType*)funcPtrType)->mElementType;
  2289. BF_ASSERT(funcType->mTypeCode == BeTypeCode_Function);
  2290. bool argsMatched = true;
  2291. if (!funcType->mIsVarArg)
  2292. {
  2293. if (funcType->mParams.size() != args.size())
  2294. {
  2295. argsMatched = false;
  2296. }
  2297. else
  2298. {
  2299. int argIdx = 0;
  2300. for (int argIdx = 0; argIdx < (int)args.size(); argIdx++)
  2301. {
  2302. if (args[argIdx] == NULL)
  2303. argsMatched = false;
  2304. else if (funcType->mParams[argIdx].mType != args[argIdx]->GetType())
  2305. argsMatched = false;
  2306. }
  2307. }
  2308. }
  2309. if (!argsMatched)
  2310. {
  2311. String errStr;
  2312. errStr += "BfIRCmd_CreateCall Match Failure:\n";
  2313. BeDumpContext dumpCtx;
  2314. dumpCtx.ToString(errStr, func);
  2315. errStr += "\n";
  2316. dumpCtx.ToString(errStr, funcType);
  2317. errStr += "\n";
  2318. for (int argIdx = 0; argIdx < (int)args.size(); argIdx++)
  2319. {
  2320. errStr += StrFormat("ARG #%d: ", argIdx);
  2321. dumpCtx.ToString(errStr, args[argIdx]);
  2322. errStr += "\n";
  2323. }
  2324. FatalError(errStr);
  2325. }
  2326. }
  2327. else
  2328. {
  2329. BF_ASSERT(func->GetTypeId() == BeIntrinsic::TypeId);
  2330. }
  2331. #endif
  2332. SetResult(curId, mBeModule->CreateCall(func, args));
  2333. }
  2334. break;
  2335. case BfIRCmd_SetCallCallingConv:
  2336. {
  2337. CMD_PARAM(BeValue*, callInst);
  2338. BfIRCallingConv callingConv = (BfIRCallingConv)mStream->Read();
  2339. ((BeCallInst*)callInst)->mCallingConv = callingConv;
  2340. }
  2341. break;
  2342. case BfIRCmd_SetFuncCallingConv:
  2343. {
  2344. CMD_PARAM(BeFunction*, func);
  2345. BfIRCallingConv callingConv = (BfIRCallingConv)mStream->Read();
  2346. func->mCallingConv = callingConv;
  2347. }
  2348. break;
  2349. case BfIRCmd_SetTailCall:
  2350. {
  2351. CMD_PARAM(BeValue*, callInstVal);
  2352. BeCallInst* callInst = (BeCallInst*)callInstVal;
  2353. callInst->mTailCall = true;
  2354. }
  2355. break;
  2356. case BfIRCmd_SetCallAttribute:
  2357. {
  2358. CMD_PARAM(BeValue*, callInstVal);
  2359. CMD_PARAM(int, paramIdx);
  2360. BfIRAttribute attribute = (BfIRAttribute)mStream->Read();
  2361. BeCallInst* callInst = (BeCallInst*)callInstVal;
  2362. if (attribute == BfIRAttribute_NoReturn)
  2363. callInst->mNoReturn = true;
  2364. }
  2365. break;
  2366. case BfIRCmd_CreateRet:
  2367. {
  2368. CMD_PARAM(BeValue*, val);
  2369. #ifdef BE_EXTRA_CHECKS
  2370. auto retType = val->GetType();
  2371. auto funcType = mActiveFunction->GetFuncType();
  2372. BF_ASSERT(retType == funcType->mReturnType);
  2373. #endif
  2374. SetResult(curId, mBeModule->CreateRet(val));
  2375. }
  2376. break;
  2377. case BfIRCmd_CreateSetRet:
  2378. {
  2379. CMD_PARAM(BeValue*, val);
  2380. CMD_PARAM(int, returnTypeId);
  2381. SetResult(curId, mBeModule->CreateSetRet(val, returnTypeId));
  2382. }
  2383. break;
  2384. case BfIRCmd_CreateRetVoid:
  2385. {
  2386. mBeModule->CreateRetVoid();
  2387. }
  2388. break;
  2389. case BfIRCmd_CreateUnreachable:
  2390. {
  2391. mBeModule->AllocInst<BeUnreachableInst>();
  2392. }
  2393. break;
  2394. case BfIRCmd_Call_AddAttribute:
  2395. {
  2396. CMD_PARAM(BeValue*, callInstVal);
  2397. CMD_PARAM(int, argIdx);
  2398. BfIRAttribute attribute = (BfIRAttribute)mStream->Read();
  2399. BeCallInst* callInst = (BeCallInst*)callInstVal;
  2400. if (argIdx > 0)
  2401. {
  2402. if (attribute == BfIRAttribute_StructRet)
  2403. {
  2404. auto valType = callInst->mArgs[argIdx - 1].mValue->GetType();
  2405. BF_ASSERT(valType->IsPointer());
  2406. callInst->mArgs[argIdx - 1].mStructRet = true;
  2407. }
  2408. else if (attribute == BfIRAttribute_ZExt)
  2409. callInst->mArgs[argIdx - 1].mZExt = true;
  2410. else if (attribute == BfIRAttribute_NoAlias)
  2411. callInst->mArgs[argIdx - 1].mNoAlias = true;
  2412. else if (attribute == BfIRAttribute_NoCapture)
  2413. callInst->mArgs[argIdx - 1].mNoCapture = true;
  2414. else if (attribute == BfIRAttribute_ByVal)
  2415. {
  2416. }
  2417. else
  2418. BF_FATAL("Unhandled");
  2419. }
  2420. else
  2421. {
  2422. if (attribute == BfIRAttribute_NoReturn)
  2423. callInst->mNoReturn = true;
  2424. else
  2425. BF_FATAL("Unhandled");
  2426. }
  2427. }
  2428. break;
  2429. case BfIRCmd_Call_AddAttribute1:
  2430. {
  2431. CMD_PARAM(BeValue*, inst);
  2432. CMD_PARAM(int, argIdx);
  2433. BfIRAttribute attribute = (BfIRAttribute)mStream->Read();
  2434. CMD_PARAM(int, arg);
  2435. BeCallInst* callInst = BeValueDynCast<BeCallInst>(inst);
  2436. if (callInst != NULL)
  2437. {
  2438. if (argIdx > 0)
  2439. {
  2440. if (attribute == BfIRAttribute_Dereferencable)
  2441. {
  2442. callInst->mArgs[argIdx - 1].mDereferenceableSize = arg;
  2443. if (auto func = BeValueDynCast<BeFunction>(callInst->mFunc))
  2444. {
  2445. BF_ASSERT(func->mParams[argIdx - 1].mDereferenceableSize == arg);
  2446. }
  2447. }
  2448. else if (attribute == BfIRAttribute_ByVal)
  2449. {
  2450. callInst->mArgs[argIdx - 1].mByRefSize = arg;
  2451. if (auto func = BeValueDynCast<BeFunction>(callInst->mFunc))
  2452. {
  2453. BF_ASSERT((func->mParams[argIdx - 1].mByValSize == arg) || (func->mParams[argIdx - 1].mByValSize == -1));
  2454. }
  2455. }
  2456. else
  2457. BF_FATAL("Unhandled");
  2458. }
  2459. else
  2460. {
  2461. BF_FATAL("Unhandled");
  2462. }
  2463. }
  2464. }
  2465. break;
  2466. case BfIRCmd_Func_AddAttribute:
  2467. {
  2468. CMD_PARAM(BeFunction*, func);
  2469. CMD_PARAM(int, argIdx);
  2470. BfIRAttribute attribute = (BfIRAttribute)mStream->Read();
  2471. if (argIdx > 0)
  2472. {
  2473. if (attribute == BfIRAttribute_StructRet)
  2474. func->mParams[argIdx - 1].mStructRet = true;
  2475. else if (attribute == BfIRAttribute_NoAlias)
  2476. func->mParams[argIdx - 1].mNoAlias = true;
  2477. else if (attribute == BfIRAttribute_NoCapture)
  2478. func->mParams[argIdx - 1].mNoCapture = true;
  2479. else if (attribute == BfIRAttribute_ZExt)
  2480. func->mParams[argIdx - 1].mZExt = true;
  2481. else
  2482. BF_FATAL("Unhandled");
  2483. }
  2484. else
  2485. {
  2486. if (attribute == BfIRAttribute_VarRet)
  2487. func->mIsVarReturn = true;
  2488. else if (attribute == BFIRAttribute_AlwaysInline)
  2489. func->mAlwaysInline = true;
  2490. else if (attribute == BFIRAttribute_NoUnwind)
  2491. func->mNoUnwind = true;
  2492. else if (attribute == BFIRAttribute_UWTable)
  2493. func->mUWTable = true;
  2494. else if (attribute == BfIRAttribute_NoReturn)
  2495. func->mNoReturn = true;
  2496. else if (attribute == BFIRAttribute_NoFramePointerElim)
  2497. func->mNoFramePointerElim = true;
  2498. else if (attribute == BFIRAttribute_DllExport)
  2499. func->mIsDLLExport = true;
  2500. else if (attribute == BFIRAttribute_DllImport)
  2501. func->mIsDLLImport = true;
  2502. else if (attribute == BFIRAttribute_NoRecurse)
  2503. {
  2504. }
  2505. else if (attribute == BFIRAttribute_Constructor)
  2506. {
  2507. }
  2508. else if (attribute == BFIRAttribute_Destructor)
  2509. {
  2510. }
  2511. else
  2512. BF_FATAL("Unhandled");
  2513. }
  2514. }
  2515. break;
  2516. case BfIRCmd_Func_AddAttribute1:
  2517. {
  2518. CMD_PARAM(BeFunction*, func);
  2519. CMD_PARAM(int, argIdx);
  2520. BfIRAttribute attribute = (BfIRAttribute)mStream->Read();
  2521. CMD_PARAM(int, arg);
  2522. // This is for adding things like Dereferencable, which we don't use
  2523. if (argIdx > 0)
  2524. {
  2525. if (attribute == BfIRAttribute_Dereferencable)
  2526. func->mParams[argIdx - 1].mDereferenceableSize = arg;
  2527. else if (attribute == BfIRAttribute_ByVal)
  2528. func->mParams[argIdx - 1].mByValSize = arg;
  2529. else
  2530. BF_FATAL("Unhandled");
  2531. }
  2532. else
  2533. BF_FATAL("Unhandled");
  2534. }
  2535. break;
  2536. case BfIRCmd_Func_SetParamName:
  2537. {
  2538. CMD_PARAM(BeFunction*, func);
  2539. CMD_PARAM(int, argIdx);
  2540. CMD_PARAM(String, name);
  2541. if (argIdx > 0)
  2542. func->mParams[argIdx - 1].mName = name;
  2543. }
  2544. break;
  2545. case BfIRCmd_Func_DeleteBody:
  2546. {
  2547. CMD_PARAM(BeFunction*, func);
  2548. func->mBlocks.Clear();
  2549. }
  2550. break;
  2551. case BfIRCmd_Func_SafeRename:
  2552. {
  2553. CMD_PARAM(BeFunction*, func);
  2554. func->mName += StrFormat("__RENAME%d", curId);
  2555. }
  2556. break;
  2557. case BfIRCmd_Func_SafeRenameFrom:
  2558. {
  2559. CMD_PARAM(BeFunction*, func);
  2560. CMD_PARAM(String, prevName);
  2561. if (func->mName == prevName)
  2562. func->mName += StrFormat("__RENAME%d", curId);
  2563. }
  2564. break;
  2565. case BfIRCmd_Func_SetLinkage:
  2566. {
  2567. CMD_PARAM(BeFunction*, func);
  2568. BfIRLinkageType linkageType = (BfIRLinkageType)mStream->Read();
  2569. func->mLinkageType = linkageType;
  2570. }
  2571. break;
  2572. case BfIRCmd_SaveDebugLocation:
  2573. {
  2574. mSavedDebugLocs.push_back(mBeModule->GetCurrentDebugLocation());
  2575. }
  2576. break;
  2577. case BfIRCmd_RestoreDebugLocation:
  2578. {
  2579. mBeModule->SetCurrentDebugLocation(mSavedDebugLocs[mSavedDebugLocs.size() - 1]);
  2580. mSavedDebugLocs.pop_back();
  2581. }
  2582. break;
  2583. case BfIRCmd_DupDebugLocation:
  2584. {
  2585. mBeModule->DupCurrentDebugLocation();
  2586. }
  2587. break;
  2588. case BfIRCmd_ClearDebugLocation:
  2589. {
  2590. mBeModule->SetCurrentDebugLocation(NULL);
  2591. }
  2592. break;
  2593. case BfIRCmd_ClearDebugLocationInst:
  2594. {
  2595. CMD_PARAM(BeValue*, instValue);
  2596. auto inst = (BeInst*)instValue;
  2597. inst->mDbgLoc = NULL;
  2598. }
  2599. break;
  2600. case BfIRCmd_ClearDebugLocationInstLast:
  2601. {
  2602. if ((mBeModule->mActiveBlock != NULL) && (!mBeModule->mActiveBlock->mInstructions.IsEmpty()))
  2603. {
  2604. auto inst = mBeModule->mActiveBlock->mInstructions.back();
  2605. inst->mDbgLoc = NULL;
  2606. }
  2607. }
  2608. break;
  2609. case BfIRCmd_UpdateDebugLocation:
  2610. {
  2611. CMD_PARAM(BeValue*, instValue);
  2612. auto inst = (BeInst*)instValue;
  2613. inst->mDbgLoc = mBeModule->mCurDbgLoc;
  2614. }
  2615. break;
  2616. case BfIRCmd_SetCurrentDebugLocation:
  2617. {
  2618. CMD_PARAM(int, line);
  2619. CMD_PARAM(int, column);
  2620. CMD_PARAM(BeMDNode*, diScope);
  2621. CMD_PARAM(BeMDNode*, diInlinedAt);
  2622. BF_ASSERT(diScope != NULL);
  2623. mBeModule->SetCurrentDebugLocation(line - 1, column - 1, diScope, (BeDbgLoc*)diInlinedAt);
  2624. }
  2625. break;
  2626. case BfIRCmd_Nop:
  2627. {
  2628. mBeModule->CreateNop();
  2629. }
  2630. break;
  2631. case BfIRCmd_EnsureInstructionAt:
  2632. {
  2633. mBeModule->AllocInst<BeEnsureInstructionAtInst>();
  2634. }
  2635. break;
  2636. case BfIRCmd_StatementStart:
  2637. {
  2638. }
  2639. break;
  2640. case BfIRCmd_ObjectAccessCheck:
  2641. {
  2642. CMD_PARAM(BeValue*, val);
  2643. CMD_PARAM(bool, useAsm);
  2644. auto inst = mBeModule->AllocInst<BeObjectAccessCheckInst>();
  2645. inst->mValue = val;
  2646. SetResult(curId, mBeModule->GetInsertBlock());
  2647. }
  2648. break;
  2649. case BfIRCmd_Comptime_Error:
  2650. {
  2651. CMD_PARAM(int32, error);
  2652. auto inst = mBeModule->AllocInst<BeComptimeError>();
  2653. inst->mError = error;
  2654. SetResult(curId, inst);
  2655. }
  2656. break;
  2657. case BfIRCmd_Comptime_GetBfType:
  2658. {
  2659. CMD_PARAM(int32, typeId);
  2660. CMD_PARAM(BeType*, resultType);
  2661. auto inst = mBeModule->AllocInst<BeComptimeGetType>();
  2662. inst->mTypeId = typeId;
  2663. inst->mResultType = resultType;
  2664. SetResult(curId, inst);
  2665. }
  2666. break;
  2667. case BfIRCmd_Comptime_GetReflectType:
  2668. {
  2669. CMD_PARAM(int32, typeId);
  2670. CMD_PARAM(BeType*, resultType);
  2671. auto inst = mBeModule->AllocInst<BeComptimeGetReflectType>();
  2672. inst->mTypeId = typeId;
  2673. inst->mResultType = resultType;
  2674. SetResult(curId, inst);
  2675. }
  2676. break;
  2677. case BfIRCmd_Comptime_DynamicCastCheck:
  2678. {
  2679. CMD_PARAM(BeValue*, value);
  2680. CMD_PARAM(int32, typeId);
  2681. CMD_PARAM(BeType*, resultType);
  2682. auto inst = mBeModule->AllocInst<BeComptimeDynamicCastCheck>();
  2683. inst->mValue = value;
  2684. inst->mTypeId = typeId;
  2685. inst->mResultType = resultType;
  2686. SetResult(curId, inst);
  2687. }
  2688. break;
  2689. case BfIRCmd_Comptime_GetVirtualFunc:
  2690. {
  2691. CMD_PARAM(BeValue*, value);
  2692. CMD_PARAM(int32, virtualTableIdx);
  2693. CMD_PARAM(BeType*, resultType);
  2694. auto inst = mBeModule->AllocInst<BeComptimeGetVirtualFunc>();
  2695. inst->mValue = value;
  2696. inst->mVirtualTableIdx = virtualTableIdx;
  2697. inst->mResultType = resultType;
  2698. SetResult(curId, inst);
  2699. }
  2700. break;
  2701. case BfIRCmd_Comptime_GetInterfaceFunc:
  2702. {
  2703. CMD_PARAM(BeValue*, value);
  2704. CMD_PARAM(int32, ifaceTypeId);
  2705. CMD_PARAM(int32, methodIdx);
  2706. CMD_PARAM(BeType*, resultType);
  2707. auto inst = mBeModule->AllocInst<BeComptimeGetInterfaceFunc>();
  2708. inst->mValue = value;
  2709. inst->mIFaceTypeId = ifaceTypeId;
  2710. inst->mMethodIdx = methodIdx;
  2711. inst->mResultType = resultType;
  2712. SetResult(curId, inst);
  2713. }
  2714. break;
  2715. case BfIRCmd_DbgInit:
  2716. {
  2717. /*mDIBuilder = new BeDIBuilder(*mBeModule); */
  2718. mBeModule->mDbgModule = new BeDbgModule();
  2719. mBeModule->mDbgModule->mBeModule = mBeModule;
  2720. }
  2721. break;
  2722. case BfIRCmd_DbgFinalize:
  2723. {
  2724. /*for (auto typeEntryPair : mTypes)
  2725. {
  2726. auto& typeEntry = typeEntryPair.second;
  2727. if (typeEntry.mInstDIType != NULL)
  2728. typeEntry.mInstDIType->resolveCycles();
  2729. }
  2730. mDIBuilder->finalize();*/
  2731. }
  2732. break;
  2733. case BfIRCmd_DbgCreateCompileUnit:
  2734. {
  2735. CMD_PARAM(int, lang);
  2736. CMD_PARAM(String, fileName);
  2737. CMD_PARAM(String, directory);
  2738. CMD_PARAM(String, producer);
  2739. CMD_PARAM(bool, isOptimized);
  2740. CMD_PARAM(String, flags);
  2741. CMD_PARAM(int, runtimeVer);
  2742. CMD_PARAM(bool, linesOnly);
  2743. mBeModule->mDbgModule->mFileName = fileName;
  2744. mBeModule->mDbgModule->mDirectory = directory;
  2745. mBeModule->mDbgModule->mProducer = producer;
  2746. //mDebugging = fileName == "TestToots";
  2747. SetResult(curId, mBeModule->mDbgModule);
  2748. }
  2749. break;
  2750. case BfIRCmd_DbgCreateFile:
  2751. {
  2752. CMD_PARAM(String, fileName);
  2753. CMD_PARAM(String, directory);
  2754. CMD_PARAM(Val128, md5Hash);
  2755. auto dbgFile = mBeModule->mDbgModule->mFiles.Alloc();
  2756. dbgFile->mFileName = fileName;
  2757. dbgFile->mDirectory = directory;
  2758. dbgFile->mMD5Hash = md5Hash;
  2759. dbgFile->mIdx = (int)mBeModule->mDbgModule->mFiles.size() - 1;
  2760. SetResult(curId, dbgFile);
  2761. }
  2762. break;
  2763. case BfIRCmd_DbgGetCurrentLocation:
  2764. {
  2765. SetResult(curId, mBeModule->mCurDbgLoc);
  2766. }
  2767. break;
  2768. case BfIRCmd_DbgSetType:
  2769. {
  2770. CMD_PARAM(int, typeId);
  2771. CMD_PARAM(BeMDNode*, type);
  2772. auto& typeEntry = GetTypeEntry(typeId);
  2773. typeEntry.mDIType = BeValueDynCast<BeDbgType>(type);
  2774. if (typeEntry.mInstDIType == NULL)
  2775. typeEntry.mInstDIType = BeValueDynCast<BeDbgType>(type);
  2776. }
  2777. break;
  2778. case BfIRCmd_DbgSetInstType:
  2779. {
  2780. CMD_PARAM(int, typeId);
  2781. CMD_PARAM(BeMDNode*, type);
  2782. GetTypeEntry(typeId).mInstDIType = BeValueDynCast<BeDbgType>(type);
  2783. }
  2784. break;
  2785. case BfIRCmd_DbgGetType:
  2786. {
  2787. CMD_PARAM(int, typeId);
  2788. if (mBeModule->mCeMachine != NULL)
  2789. {
  2790. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgTypeId>();
  2791. dbgType->mTypeId = typeId;
  2792. SetResult(curId, dbgType);
  2793. }
  2794. else
  2795. SetResult(curId, GetTypeEntry(typeId).mDIType);
  2796. }
  2797. break;
  2798. case BfIRCmd_DbgGetTypeInst:
  2799. {
  2800. CMD_PARAM(int, typeId);
  2801. auto result = GetTypeEntry(typeId).mInstDIType;
  2802. //BF_ASSERT(result);
  2803. SetResult(curId, result);
  2804. }
  2805. break;
  2806. case BfIRCmd_DbgTrackDITypes:
  2807. {
  2808. CMD_PARAM(int, typeId);
  2809. auto& typeEntry = GetTypeEntry(typeId);
  2810. /*if (typeEntry.mDIType != NULL)
  2811. BeMetadataTracking::track(*(BeMetadata**)&typeEntry.mDIType);
  2812. if (typeEntry.mInstDIType != NULL)
  2813. BeMetadataTracking::track(*(BeMetadata**)&typeEntry.mInstDIType);*/
  2814. //NotImpl();
  2815. }
  2816. break;
  2817. case BfIRCmd_DbgCreateNamespace:
  2818. {
  2819. CMD_PARAM(BeMDNode*, scope);
  2820. CMD_PARAM(String, name);
  2821. CMD_PARAM(BeMDNode*, file);
  2822. CMD_PARAM(int, lineNum);
  2823. auto dbgNamespace = mBeModule->mOwnedValues.Alloc<BeDbgNamespace>();
  2824. dbgNamespace->mScope = scope;
  2825. dbgNamespace->mName = name;
  2826. SetResult(curId, dbgNamespace);
  2827. }
  2828. break;
  2829. case BfIRCmd_DbgCreateImportedModule:
  2830. {
  2831. CMD_PARAM(BeMDNode*, context);
  2832. CMD_PARAM(BeMDNode*, namespaceNode);
  2833. CMD_PARAM(int, lineNum);
  2834. /*SetResult(curId, mDIBuilder->createImportedModule((BeDIScope*)context, (BeDINamespace*)namespaceNode, lineNum));*/
  2835. //NotImpl();
  2836. }
  2837. break;
  2838. case BfIRCmd_DbgCreateBasicType:
  2839. {
  2840. CMD_PARAM(String, name);
  2841. CMD_PARAM(int64, sizeInBits);
  2842. CMD_PARAM(int64, alignInBits);
  2843. CMD_PARAM(int, encoding);
  2844. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgBasicType>();
  2845. dbgType->mName = name;
  2846. dbgType->mSize = (int)(sizeInBits / 8);
  2847. dbgType->mAlign = (int)(alignInBits / 8);
  2848. dbgType->mEncoding = encoding;
  2849. SetResult(curId, dbgType);
  2850. }
  2851. break;
  2852. case BfIRCmd_DbgCreateStructType:
  2853. {
  2854. CMD_PARAM(BeMDNode*, context);
  2855. CMD_PARAM(String, name);
  2856. CMD_PARAM(BeMDNode*, file);
  2857. CMD_PARAM(int, lineNum);
  2858. CMD_PARAM(int64, sizeInBits);
  2859. CMD_PARAM(int64, alignInBits);
  2860. CMD_PARAM(int, flags);
  2861. CMD_PARAM(BeMDNode*, derivedFrom);
  2862. CMD_PARAM(CmdParamVec<BeMDNode*>, members);
  2863. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgStructType>();
  2864. dbgType->mScope = context;
  2865. dbgType->mName = name;
  2866. dbgType->mSize = (int)(sizeInBits / 8);
  2867. dbgType->mAlign = (int)(alignInBits / 8);
  2868. dbgType->mDerivedFrom = BeValueDynCast<BeDbgType>(derivedFrom);
  2869. dbgType->mDefFile = (BeDbgFile*)file;
  2870. dbgType->mDefLine = lineNum - 1;
  2871. dbgType->mIsFullyDefined = true;
  2872. dbgType->SetMembers(members);
  2873. SetResult(curId, dbgType);
  2874. }
  2875. break;
  2876. case BfIRCmd_DbgCreateEnumerationType:
  2877. {
  2878. CMD_PARAM(BeMDNode*, context);
  2879. CMD_PARAM(String, name);
  2880. CMD_PARAM(BeMDNode*, file);
  2881. CMD_PARAM(int, lineNum);
  2882. CMD_PARAM(int64, sizeInBits);
  2883. CMD_PARAM(int64, alignInBits);
  2884. CMD_PARAM(CmdParamVec<BeMDNode*>, members);
  2885. CMD_PARAM(BeMDNode*, underlyingType);
  2886. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgEnumType>();
  2887. dbgType->mScope = context;
  2888. dbgType->mName = name;
  2889. dbgType->mSize = (int)(sizeInBits / 8);
  2890. dbgType->mAlign = (int)(alignInBits / 8);
  2891. dbgType->mIsFullyDefined = true;
  2892. dbgType->mElementType = BeValueDynCast<BeDbgType>(underlyingType);
  2893. for (auto member : members)
  2894. {
  2895. if (auto enumMember = BeValueDynCast<BeDbgEnumMember>(member))
  2896. {
  2897. dbgType->mMembers.push_back(enumMember);
  2898. }
  2899. else
  2900. NotImpl();
  2901. }
  2902. //dbgType->mDefFile = (BeDbgFile*)file;
  2903. //dbgType->mDefLine = line - 1;
  2904. SetResult(curId, dbgType);
  2905. }
  2906. break;
  2907. case BfIRCmd_DbgCreatePointerType:
  2908. {
  2909. CMD_PARAM(BeMDNode*, elementTypeNode);
  2910. BeDbgType* elementType = BeValueDynCast<BeDbgType>(elementTypeNode);
  2911. if (elementType == NULL)
  2912. {
  2913. if (auto dbgTypeId = BeValueDynCast<BeDbgTypeId>(elementTypeNode))
  2914. {
  2915. auto bfElementType = mBeModule->mCeMachine->mCeModule->mContext->mTypes[dbgTypeId->mTypeId];
  2916. auto bfPtrType = mBeModule->mCeMachine->mCeModule->CreatePointerType(bfElementType);
  2917. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgTypeId>();
  2918. dbgType->mTypeId = bfPtrType->mTypeId;
  2919. SetResult(curId, dbgType);
  2920. break;
  2921. }
  2922. }
  2923. BeDbgType* useType = elementType->FindDerivedType(BeDbgPointerType::TypeId);
  2924. if (useType == NULL)
  2925. {
  2926. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgPointerType>();
  2927. dbgType->mElement = elementType;
  2928. dbgType->mSize = mPtrSize;
  2929. dbgType->mAlign = mPtrSize;
  2930. elementType->mDerivedTypes.PushFront(dbgType, &mBeModule->mAlloc);
  2931. useType = dbgType;
  2932. }
  2933. SetResult(curId, useType);
  2934. }
  2935. break;
  2936. case BfIRCmd_DbgCreateReferenceType:
  2937. {
  2938. CMD_PARAM(BeMDNode*, elementTypeNode);
  2939. BeDbgType* elementType = BeValueDynCast<BeDbgType>(elementTypeNode);
  2940. if (elementType == NULL)
  2941. {
  2942. if (auto dbgTypeId = BeValueDynCast<BeDbgTypeId>(elementTypeNode))
  2943. {
  2944. auto bfElementType = mBeModule->mCeMachine->mCeModule->mContext->mTypes[dbgTypeId->mTypeId];
  2945. auto bfPtrType = mBeModule->mCeMachine->mCeModule->CreateRefType(bfElementType);
  2946. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgTypeId>();
  2947. dbgType->mTypeId = bfPtrType->mTypeId;
  2948. SetResult(curId, dbgType);
  2949. break;
  2950. }
  2951. }
  2952. auto useType = mBeModule->mDbgModule->CreateReferenceType(elementType);
  2953. SetResult(curId, useType);
  2954. }
  2955. break;
  2956. case BfIRCmd_DbgCreateConstType:
  2957. {
  2958. CMD_PARAM(BeMDNode*, elementTypeNode);
  2959. BeDbgType* elementType = BeValueDynCast<BeDbgType>(elementTypeNode);
  2960. if (elementType == NULL)
  2961. {
  2962. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgConstType>();
  2963. dbgType->mElement = elementTypeNode;
  2964. SetResult(curId, dbgType);
  2965. break;
  2966. }
  2967. BeDbgType* useType = elementType->FindDerivedType(BeDbgConstType::TypeId);
  2968. if (useType == NULL)
  2969. {
  2970. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgConstType>();
  2971. dbgType->mElement = elementType;
  2972. elementType->mDerivedTypes.PushFront(dbgType, &mBeModule->mAlloc);
  2973. useType = dbgType;
  2974. }
  2975. SetResult(curId, useType);
  2976. }
  2977. break;
  2978. case BfIRCmd_DbgCreateArtificialType:
  2979. {
  2980. CMD_PARAM(BeMDNode*, diType);
  2981. //auto dbgType = mBeModule->mOwnedValues.Alloc<BeDbgArtificialType>();
  2982. //dbgType->mElement = (BeDbgType*)diType;
  2983. // Does the artificial thing do anything for us actually?
  2984. auto dbgType = diType;
  2985. SetResult(curId, dbgType);
  2986. }
  2987. break;
  2988. case BfIRCmd_DbgCreateArrayType:
  2989. {
  2990. CMD_PARAM(int64, sizeInBits);
  2991. CMD_PARAM(int64, alignInBits);
  2992. CMD_PARAM(BeMDNode*, elementType);
  2993. CMD_PARAM(int64, numElements);
  2994. auto dbgArray = mBeModule->mDbgModule->mTypes.Alloc<BeDbgArrayType>();
  2995. dbgArray->mSize = (int)(sizeInBits / 8);
  2996. dbgArray->mAlign = (int)(alignInBits / 8);
  2997. dbgArray->mElement = BeValueDynCast<BeDbgType>(elementType);
  2998. dbgArray->mNumElements = numElements;
  2999. SetResult(curId, dbgArray);
  3000. }
  3001. break;
  3002. case BfIRCmd_DbgCreateReplaceableCompositeType:
  3003. {
  3004. CMD_PARAM(int, tag);
  3005. CMD_PARAM(String, name);
  3006. CMD_PARAM(BeMDNode*, scope);
  3007. CMD_PARAM(BeMDNode*, file);
  3008. CMD_PARAM(int, line);
  3009. CMD_PARAM(int64, sizeInBits);
  3010. CMD_PARAM(int64, alignInBits);
  3011. CMD_PARAM(int, flags);
  3012. if (tag == llvm::dwarf::DW_TAG_structure_type)
  3013. {
  3014. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgStructType>();
  3015. dbgType->mScope = scope;
  3016. dbgType->mName = name;
  3017. dbgType->mSize = (int)(sizeInBits / 8);
  3018. dbgType->mAlign = (int)(alignInBits / 8);
  3019. dbgType->mDefFile = (BeDbgFile*)file;
  3020. dbgType->mDefLine = line - 1;
  3021. SetResult(curId, dbgType);
  3022. }
  3023. else if (tag == llvm::dwarf::DW_TAG_enumeration_type)
  3024. {
  3025. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgEnumType>();
  3026. dbgType->mScope = scope;
  3027. dbgType->mName = name;
  3028. dbgType->mSize = (int)(sizeInBits / 8);
  3029. dbgType->mAlign = (int)(alignInBits / 8);
  3030. //dbgType->mDefFile = (BeDbgFile*)file;
  3031. //dbgType->mDefLine = line - 1;
  3032. SetResult(curId, dbgType);
  3033. }
  3034. else
  3035. NotImpl();
  3036. }
  3037. break;
  3038. case BfIRCmd_DbgCreateForwardDecl:
  3039. {
  3040. CMD_PARAM(int, tag);
  3041. CMD_PARAM(String, name);
  3042. CMD_PARAM(BeMDNode*, scope);
  3043. CMD_PARAM(BeMDNode*, file);
  3044. CMD_PARAM(int, line);
  3045. if (tag == llvm::dwarf::DW_TAG_structure_type)
  3046. {
  3047. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgStructType>();
  3048. dbgType->mScope = scope;
  3049. dbgType->mName = name;
  3050. dbgType->mDefFile = (BeDbgFile*)file;
  3051. dbgType->mDefLine = line;
  3052. SetResult(curId, dbgType);
  3053. }
  3054. else if (tag == llvm::dwarf::DW_TAG_enumeration_type)
  3055. {
  3056. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgEnumType>();
  3057. dbgType->mScope = scope;
  3058. dbgType->mName = name;
  3059. SetResult(curId, dbgType);
  3060. }
  3061. else
  3062. NotImpl();
  3063. }
  3064. break;
  3065. case BfIRCmd_DbgCreateSizedForwardDecl:
  3066. {
  3067. CMD_PARAM(int, tag);
  3068. CMD_PARAM(String, name);
  3069. CMD_PARAM(BeMDNode*, scope);
  3070. CMD_PARAM(BeMDNode*, file);
  3071. CMD_PARAM(int, line);
  3072. CMD_PARAM(int64, sizeInBits);
  3073. CMD_PARAM(int64, alignInBits);
  3074. if (tag == llvm::dwarf::DW_TAG_structure_type)
  3075. {
  3076. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgStructType>();
  3077. dbgType->mDefFile = (BeDbgFile*)file;
  3078. dbgType->mDefLine = line;
  3079. dbgType->mScope = scope;
  3080. dbgType->mName = name;
  3081. dbgType->mSize = (int)(sizeInBits / 8);
  3082. dbgType->mAlign = (int)(alignInBits / 8);
  3083. SetResult(curId, dbgType);
  3084. }
  3085. else if (tag == llvm::dwarf::DW_TAG_enumeration_type)
  3086. {
  3087. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgEnumType>();
  3088. dbgType->mScope = scope;
  3089. dbgType->mName = name;
  3090. dbgType->mSize = (int)(sizeInBits / 8);
  3091. dbgType->mAlign = (int)(alignInBits / 8);
  3092. SetResult(curId, dbgType);
  3093. }
  3094. else
  3095. NotImpl();
  3096. }
  3097. break;
  3098. case BeIRCmd_DbgSetTypeSize:
  3099. {
  3100. CMD_PARAM(BeMDNode*, mdType);
  3101. CMD_PARAM(int64, sizeInBits);
  3102. CMD_PARAM(int64, alignInBits);
  3103. if (auto dbgType = BeValueDynCast<BeDbgType>(mdType))
  3104. {
  3105. dbgType->mSize = (int)(sizeInBits / 8);
  3106. dbgType->mAlign = (int)(alignInBits / 8);
  3107. }
  3108. }
  3109. break;
  3110. case BfIRCmd_DbgReplaceAllUses:
  3111. {
  3112. CMD_PARAM(BeMDNode*, diPrevNode);
  3113. CMD_PARAM(BeMDNode*, diNewNode);
  3114. /*diPrevNode->replaceAllUsesWith(diNewNode); */
  3115. NotImpl();
  3116. }
  3117. break;
  3118. case BfIRCmd_DbgDeleteTemporary:
  3119. {
  3120. CMD_PARAM(BeMDNode*, diNode);
  3121. /*BeMDNode::deleteTemporary(diNode);*/
  3122. NotImpl();
  3123. }
  3124. break;
  3125. case BfIRCmd_DbgMakePermanent:
  3126. {
  3127. CMD_PARAM(BeMDNode*, diNode);
  3128. CMD_PARAM(BeMDNode*, diBaseType);
  3129. CMD_PARAM(CmdParamVec<BeMDNode*>, members);
  3130. if (auto dbgType = BeValueDynCast<BeDbgStructType>(diNode))
  3131. {
  3132. dbgType->SetMembers(members);
  3133. }
  3134. else if (auto dbgType = BeValueDynCast<BeDbgEnumType>(diNode))
  3135. {
  3136. dbgType->mElementType = BeValueDynCast<BeDbgType>(diBaseType);
  3137. dbgType->SetMembers(members);
  3138. }
  3139. else
  3140. NotImpl();
  3141. SetResult(curId, diNode);
  3142. break;
  3143. }
  3144. case BfIRCmd_CreateEnumerator:
  3145. {
  3146. CMD_PARAM(String, name);
  3147. CMD_PARAM(int64, val);
  3148. auto enumValue = mBeModule->mOwnedValues.Alloc<BeDbgEnumMember>();
  3149. enumValue->mName = name;
  3150. enumValue->mValue = val;
  3151. SetResult(curId, enumValue);
  3152. }
  3153. break;
  3154. case BfIRCmd_DbgCreateMemberType:
  3155. {
  3156. CMD_PARAM(BeMDNode*, scope);
  3157. CMD_PARAM(String, name);
  3158. CMD_PARAM(BeMDNode*, file);
  3159. CMD_PARAM(int, lineNumber);
  3160. CMD_PARAM(int64, sizeInBits);
  3161. CMD_PARAM(int64, alignInBits);
  3162. CMD_PARAM(int64, offsetInBits);
  3163. CMD_PARAM(int, flags);
  3164. CMD_PARAM(BeMDNode*, type);
  3165. BF_ASSERT(type != NULL);
  3166. auto dbgMember = mBeModule->mOwnedValues.Alloc<BeDbgStructMember>();
  3167. dbgMember->mName = name;
  3168. dbgMember->mType = BeValueDynCast<BeDbgType>(type);
  3169. dbgMember->mOffset = (int)(offsetInBits / 8);
  3170. dbgMember->mFlags = flags;
  3171. SetResult(curId, dbgMember);
  3172. }
  3173. break;
  3174. case BfIRCmd_DbgStaticCreateMemberType:
  3175. {
  3176. CMD_PARAM(BeMDNode*, scope);
  3177. CMD_PARAM(String, name);
  3178. CMD_PARAM(BeMDNode*, file);
  3179. CMD_PARAM(int, lineNumber);
  3180. CMD_PARAM(BeMDNode*, type);
  3181. CMD_PARAM(int, flags);
  3182. CMD_PARAM(BeConstant*, val);
  3183. BF_ASSERT(type != NULL);
  3184. auto dbgMember = mBeModule->mOwnedValues.Alloc<BeDbgStructMember>();
  3185. dbgMember->mName = name;
  3186. dbgMember->mType = BeValueDynCast<BeDbgType>(type);
  3187. dbgMember->mOffset = -1;
  3188. dbgMember->mStaticValue = val;
  3189. dbgMember->mFlags = flags;
  3190. dbgMember->mIsStatic = true;
  3191. SetResult(curId, dbgMember);
  3192. }
  3193. break;
  3194. case BfIRCmd_DbgCreateInheritance:
  3195. {
  3196. CMD_PARAM(BeMDNode*, type);
  3197. CMD_PARAM(BeMDNode*, baseType);
  3198. CMD_PARAM(int64, baseOffset);
  3199. CMD_PARAM(int, flags);
  3200. auto dbgInheritance = mBeModule->mAlloc.Alloc<BeDbgInheritance>();
  3201. dbgInheritance->mBaseType = BeValueDynCast<BeDbgType>(baseType);
  3202. SetResult(curId, dbgInheritance);
  3203. }
  3204. break;
  3205. case BfIRCmd_DbgCreateMethod:
  3206. {
  3207. CMD_PARAM(BeMDNode*, context);
  3208. CMD_PARAM(String, name);
  3209. CMD_PARAM(String, linkageName);
  3210. CMD_PARAM(BeMDNode*, file);
  3211. CMD_PARAM(int, lineNum);
  3212. CMD_PARAM(BeMDNode*, type);
  3213. CMD_PARAM(bool, isLocalToUnit);
  3214. CMD_PARAM(bool, isDefinition);
  3215. CMD_PARAM(int, vk);
  3216. CMD_PARAM(int, vIndex);
  3217. CMD_PARAM(BeMDNode*, vTableHolder);
  3218. CMD_PARAM(int, flags);
  3219. CMD_PARAM(bool, isOptimized);
  3220. CMD_PARAM(BeValue*, fn);
  3221. CMD_PARAM(CmdParamVec<BeMDNode*>, genericArgs);
  3222. CMD_PARAM(CmdParamVec<BeConstant*>, genericConstValueArgs);
  3223. auto dbgFunc = mBeModule->mOwnedValues.Alloc<BeDbgFunction>();
  3224. dbgFunc->mScope = context;
  3225. dbgFunc->mFile = (BeDbgFile*)file;
  3226. dbgFunc->mLine = lineNum - 1;
  3227. dbgFunc->mType = (BeDbgFunctionType*)type;
  3228. dbgFunc->mName = name;
  3229. dbgFunc->mLinkageName = linkageName;
  3230. dbgFunc->mValue = (BeFunction*)fn;
  3231. dbgFunc->mIsLocalToUnit = isLocalToUnit;
  3232. dbgFunc->mVK = vk;
  3233. dbgFunc->mVIndex = vIndex;
  3234. dbgFunc->mIsStaticMethod = (flags & llvm::DINode::FlagStaticMember) != 0;
  3235. dbgFunc->mFlags = flags;
  3236. for (auto arg : genericArgs)
  3237. {
  3238. BF_ASSERT(arg != NULL);
  3239. dbgFunc->mGenericArgs.Add(BeValueDynCast<BeDbgType>(arg));
  3240. }
  3241. for (auto genericConstValue : genericConstValueArgs)
  3242. dbgFunc->mGenericConstValueArgs.Add(genericConstValue);
  3243. if (dbgFunc->mValue != NULL)
  3244. dbgFunc->mValue->mDbgFunction = dbgFunc;
  3245. dbgFunc->mIdx = (int)mBeModule->mDbgModule->mFuncs.size();
  3246. mBeModule->mDbgModule->mFuncs.push_back(dbgFunc);
  3247. SetResult(curId, dbgFunc);
  3248. }
  3249. break;
  3250. case BfIRCmd_DbgCreateFunction:
  3251. {
  3252. CMD_PARAM(BeMDNode*, context);
  3253. CMD_PARAM(String, name);
  3254. CMD_PARAM(String, linkageName);
  3255. CMD_PARAM(BeMDNode*, file);
  3256. CMD_PARAM(int, lineNum);
  3257. CMD_PARAM(BeMDNode*, type);
  3258. CMD_PARAM(bool, isLocalToUnit);
  3259. CMD_PARAM(bool, isDefinition);
  3260. CMD_PARAM(int, scopeLine);
  3261. CMD_PARAM(int, flags);
  3262. CMD_PARAM(bool, isOptimized);
  3263. CMD_PARAM(BeValue*, fn);
  3264. auto dbgFunc = mBeModule->mOwnedValues.Alloc<BeDbgFunction>();
  3265. dbgFunc->mScope = context;
  3266. dbgFunc->mFile = (BeDbgFile*)file;
  3267. dbgFunc->mLine = lineNum - 1;
  3268. dbgFunc->mType = (BeDbgFunctionType*)type;
  3269. dbgFunc->mName = name;
  3270. dbgFunc->mLinkageName = linkageName;
  3271. dbgFunc->mValue = (BeFunction*)fn;
  3272. dbgFunc->mIsLocalToUnit = isLocalToUnit;
  3273. dbgFunc->mFlags = flags;
  3274. /*if (auto dbgStructType = BeValueDynCast<BeDbgStructType>(context))
  3275. {
  3276. // This will get added to the struct later
  3277. }
  3278. else
  3279. {
  3280. }*/
  3281. if (dbgFunc->mValue != NULL)
  3282. dbgFunc->mValue->mDbgFunction = dbgFunc;
  3283. dbgFunc->mIdx = (int)mBeModule->mDbgModule->mFuncs.size();
  3284. mBeModule->mDbgModule->mFuncs.push_back(dbgFunc);
  3285. SetResult(curId, dbgFunc);
  3286. }
  3287. break;
  3288. case BfIRCmd_DbgCreateParameterVariable:
  3289. {
  3290. CMD_PARAM(BeMDNode*, scope);
  3291. CMD_PARAM(String, name);
  3292. CMD_PARAM(int, argNo);
  3293. CMD_PARAM(BeMDNode*, file);
  3294. CMD_PARAM(int, lineNum);
  3295. CMD_PARAM(BeMDNode*, type);
  3296. CMD_PARAM(bool, alwaysPreserve);
  3297. CMD_PARAM(int, flags);
  3298. BF_ASSERT(type != NULL);
  3299. auto dbgFunc = (BeDbgFunction*)scope;
  3300. auto dbgVar = mBeModule->mOwnedValues.Alloc<BeDbgVariable>();
  3301. dbgVar->mName = name;
  3302. dbgVar->mType = type;
  3303. dbgVar->mParamNum = argNo - 1;
  3304. int argIdx = argNo - 1;
  3305. //for (int i = ; i <= argNo - 1; i++)
  3306. while (argIdx >= (int)dbgFunc->mVariables.size())
  3307. dbgFunc->mVariables.push_back(NULL);
  3308. if (dbgFunc->mVariables[argIdx] == NULL)
  3309. dbgFunc->mVariables[argIdx] = dbgVar;
  3310. else
  3311. {
  3312. BF_ASSERT(dbgFunc->mVariables[argIdx]->mParamNum == -1);
  3313. dbgFunc->mVariables.Insert(argIdx, dbgVar);
  3314. }
  3315. //mActiveFunction->mDbgFunction->mVariables.push_back(dbgVar);
  3316. //dbgVar->mValue = mBeModule->GetArgument(argNo - 1);
  3317. SetResult(curId, dbgVar);
  3318. }
  3319. break;
  3320. case BfIRCmd_DbgCreateSubroutineType:
  3321. {
  3322. CMD_PARAM(CmdParamVec<BeMDNode*>, elements);
  3323. auto dbgFuncType = mBeModule->mOwnedValues.Alloc<BeDbgFunctionType>();
  3324. if (!elements.empty())
  3325. {
  3326. dbgFuncType->mReturnType = BeValueDynCast<BeDbgType>(elements[0]);
  3327. for (int i = 1; i < (int)elements.size(); i++)
  3328. dbgFuncType->mParams.push_back(BeValueDynCast<BeDbgType>(elements[i]));
  3329. }
  3330. SetResult(curId, dbgFuncType);
  3331. }
  3332. break;
  3333. case BfIRCmd_DbgCreateAutoVariable:
  3334. {
  3335. CMD_PARAM(BeMDNode*, scope);
  3336. CMD_PARAM(String, name);
  3337. CMD_PARAM(BeMDNode*, file);
  3338. CMD_PARAM(int, lineNo);
  3339. CMD_PARAM(BeMDNode*, type);
  3340. CMD_PARAM(int, initType);
  3341. BF_ASSERT(type != NULL);
  3342. auto dbgVar = mBeModule->mOwnedValues.Alloc<BeDbgVariable>();
  3343. dbgVar->mName = name;
  3344. dbgVar->mType = type;
  3345. dbgVar->mScope = scope;
  3346. dbgVar->mInitType = (BfIRInitType)initType;
  3347. mActiveFunction->mDbgFunction->mVariables.push_back(dbgVar);
  3348. BF_ASSERT(name != "__CRASH_AUTOVARIABLE__");
  3349. SetResult(curId, dbgVar);
  3350. }
  3351. break;
  3352. case BfIRCmd_DbgInsertValueIntrinsic:
  3353. {
  3354. CMD_PARAM(BeValue*, val);
  3355. CMD_PARAM(BeMDNode*, varInfo);
  3356. auto dbgVar = BeValueDynCast<BeDbgVariable>(varInfo);
  3357. //dbgVar->mValue = val;
  3358. //dbgVar->mDeclDbgLoc = mBeModule->mCurDbgLoc;
  3359. if (val == NULL)
  3360. {
  3361. val = mBeModule->GetConstant(mBeContext->GetPrimitiveType(BeTypeCode_Int32), (int64)0);
  3362. }
  3363. auto inst = mBeModule->AllocInst<BeDbgDeclareInst>();
  3364. inst->mValue = val;
  3365. inst->mDbgVar = dbgVar;
  3366. inst->mIsValue = true;
  3367. SetResult(curId, inst);
  3368. }
  3369. break;
  3370. case BfIRCmd_DbgInsertDeclare:
  3371. {
  3372. CMD_PARAM(BeValue*, val);
  3373. CMD_PARAM(BeMDNode*, varInfo);
  3374. CMD_PARAM(BeValue*, insertBefore);
  3375. auto dbgVar = BeValueDynCast<BeDbgVariable>(varInfo);
  3376. //dbgVar->mValue = val;
  3377. //dbgVar->mDeclDbgLoc = mBeModule->mCurDbgLoc;
  3378. auto inst = mBeModule->mAlloc.Alloc<BeDbgDeclareInst>();
  3379. inst->mValue = val;
  3380. inst->mDbgVar = dbgVar;
  3381. inst->mIsValue = false;
  3382. if (insertBefore == NULL)
  3383. mBeModule->AddInst(inst);
  3384. else
  3385. NotImpl();
  3386. SetResult(curId, inst);
  3387. }
  3388. break;
  3389. case BfIRCmd_DbgLifetimeEnd:
  3390. {
  3391. CMD_PARAM(BeMDNode*, varInfo);
  3392. auto inst = mBeModule->AllocInst<BeLifetimeEndInst>();
  3393. inst->mPtr = varInfo;
  3394. }
  3395. break;
  3396. case BfIRCmd_DbgCreateGlobalVariable:
  3397. {
  3398. CMD_PARAM(BeMDNode*, context);
  3399. CMD_PARAM(String, name);
  3400. CMD_PARAM(String, linkageName);
  3401. CMD_PARAM(BeMDNode*, file);
  3402. CMD_PARAM(int, lineNum);
  3403. CMD_PARAM(BeMDNode*, type);
  3404. CMD_PARAM(bool, isLocalToUnit);
  3405. CMD_PARAM(BeConstant*, val);
  3406. CMD_PARAM(BeMDNode*, decl);
  3407. auto dbgGlobalVariable = mBeModule->mDbgModule->mGlobalVariables.Alloc();
  3408. dbgGlobalVariable->mContext = context;
  3409. dbgGlobalVariable->mName = name;
  3410. dbgGlobalVariable->mLinkageName = linkageName;
  3411. dbgGlobalVariable->mFile = (BeDbgFile*)file;
  3412. dbgGlobalVariable->mLineNum = lineNum;
  3413. dbgGlobalVariable->mType = type;
  3414. dbgGlobalVariable->mIsLocalToUnit = isLocalToUnit;
  3415. dbgGlobalVariable->mValue = val;
  3416. dbgGlobalVariable->mDecl = decl;
  3417. SetResult(curId, dbgGlobalVariable);
  3418. }
  3419. break;
  3420. case BfIRCmd_DbgCreateLexicalBlock:
  3421. {
  3422. CMD_PARAM(BeMDNode*, scope);
  3423. CMD_PARAM(BeMDNode*, file);
  3424. CMD_PARAM(int, lineNum);
  3425. CMD_PARAM(int, col);
  3426. auto dbgLexicalBlock = mBeModule->mOwnedValues.Alloc<BeDbgLexicalBlock>();
  3427. BF_ASSERT(BeValueDynCast<BeDbgFile>(file) != NULL);
  3428. dbgLexicalBlock->mFile = (BeDbgFile*)file;
  3429. dbgLexicalBlock->mScope = scope;
  3430. dbgLexicalBlock->mId = mBeModule->mCurLexBlockId++;
  3431. SetResult(curId, dbgLexicalBlock);
  3432. }
  3433. break;
  3434. case BfIRCmd_DbgCreateAnnotation:
  3435. {
  3436. CMD_PARAM(BeMDNode*, scope);
  3437. CMD_PARAM(String, name);
  3438. CMD_PARAM(BeValue*, value);
  3439. if (auto dbgFunc = BeValueDynCast<BeDbgFunction>(scope))
  3440. {
  3441. auto beType = value->GetType();
  3442. BeDbgType** dbgTypePtr;
  3443. if (mOnDemandTypeMap.TryAdd(beType, NULL, &dbgTypePtr))
  3444. {
  3445. auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgBasicType>();
  3446. dbgType->mSize = beType->mSize;
  3447. dbgType->mAlign = beType->mAlign;
  3448. dbgType->mEncoding = llvm::dwarf::DW_ATE_signed;
  3449. *dbgTypePtr = dbgType;
  3450. }
  3451. auto dbgVar = mBeModule->mOwnedValues.Alloc<BeDbgVariable>();
  3452. dbgVar->mName = "#" + name;
  3453. dbgVar->mType = *dbgTypePtr;
  3454. dbgVar->mValue = value;
  3455. dbgVar->mScope = scope;
  3456. dbgFunc->mVariables.Add(dbgVar);
  3457. auto inst = mBeModule->AllocInst<BeDbgDeclareInst>();
  3458. inst->mValue = value;
  3459. inst->mDbgVar = dbgVar;
  3460. inst->mIsValue = true;
  3461. }
  3462. else
  3463. NotImpl();
  3464. }
  3465. break;
  3466. default:
  3467. BF_FATAL("Unhandled");
  3468. break;
  3469. }
  3470. #ifdef CODEGEN_TRACK
  3471. gBEMemReporter.EndSection();
  3472. gBEMemReporterSize += mStream->GetReadPos() - curId;
  3473. #endif
  3474. }
  3475. void BeIRCodeGen::SetConfigConst(int idx, int value)
  3476. {
  3477. BF_ASSERT(idx == (int)mConfigConsts.size());
  3478. mConfigConsts.Add(value);
  3479. }
  3480. BeValue* BeIRCodeGen::TryGetBeValue(int id)
  3481. {
  3482. auto& result = mResults[id];
  3483. if (result.mKind != BeIRCodeGenEntryKind_Value)
  3484. return NULL;
  3485. #ifdef BE_EXTRA_CHECKS
  3486. BF_ASSERT(!result.mBeValue->mLifetimeEnded);
  3487. BF_ASSERT(!result.mBeValue->mWasRemoved);
  3488. #endif
  3489. return result.mBeValue;
  3490. }
  3491. BeValue* BeIRCodeGen::GetBeValue(int id)
  3492. {
  3493. auto& result = mResults[id];
  3494. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Value);
  3495. #ifdef BE_EXTRA_CHECKS
  3496. BF_ASSERT(!result.mBeValue->mLifetimeEnded);
  3497. BF_ASSERT(!result.mBeValue->mWasRemoved);
  3498. #endif
  3499. return result.mBeValue;
  3500. }
  3501. BeType* BeIRCodeGen::GetBeType(int id)
  3502. {
  3503. auto& result = mResults[id];
  3504. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Type);
  3505. return result.mBeType;
  3506. }
  3507. BeBlock* BeIRCodeGen::GetBeBlock(int id)
  3508. {
  3509. auto& result = mResults[id];
  3510. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Block);
  3511. return result.mBeBlock;
  3512. }
  3513. BeMDNode* BeIRCodeGen::GetBeMetadata(int id)
  3514. {
  3515. auto& result = mResults[id];
  3516. BF_ASSERT(result.mKind == BeIRCodeGenEntryKind_Metadata);
  3517. return result.mBeMetadata;
  3518. }
  3519. BeType* BeIRCodeGen::GetBeTypeById(int id)
  3520. {
  3521. return GetTypeEntry(id).mBeType;
  3522. }
  3523. BeState BeIRCodeGen::GetState()
  3524. {
  3525. BeState state;
  3526. state.mActiveFunction = mActiveFunction;
  3527. state.mSavedDebugLocs = mSavedDebugLocs;
  3528. state.mHasDebugLoc = mHasDebugLoc;
  3529. state.mActiveBlock = mBeModule->mActiveBlock;
  3530. state.mInsertPos = mBeModule->mInsertPos;
  3531. state.mCurDbgLoc = mBeModule->mCurDbgLoc;
  3532. state.mPrevDbgLocInline = mBeModule->mPrevDbgLocInline;
  3533. state.mLastDbgLoc = mBeModule->mLastDbgLoc;
  3534. return state;
  3535. }
  3536. void BeIRCodeGen::SetState(const BeState& state)
  3537. {
  3538. mActiveFunction = state.mActiveFunction;
  3539. mBeModule->mActiveFunction = mActiveFunction;
  3540. mSavedDebugLocs = state.mSavedDebugLocs;
  3541. mHasDebugLoc = state.mHasDebugLoc;
  3542. mBeModule->mActiveBlock = state.mActiveBlock;
  3543. mBeModule->mInsertPos = state.mInsertPos;
  3544. mBeModule->mCurDbgLoc = state.mCurDbgLoc;
  3545. mBeModule->mPrevDbgLocInline = state.mPrevDbgLocInline;
  3546. mBeModule->mLastDbgLoc = state.mLastDbgLoc;
  3547. }