pmodules.pas 60 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719
  1. {
  2. $Id$
  3. Copyright (c) 1998-2002 by Florian Klaempfl
  4. Handles the parsing and loading of the modules (ppufiles)
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2 of the License, or
  8. (at your option) any later version.
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU General Public License for more details.
  13. You should have received a copy of the GNU General Public License
  14. along with this program; if not, write to the Free Software
  15. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16. ****************************************************************************
  17. }
  18. unit pmodules;
  19. {$i fpcdefs.inc}
  20. {$define New_GDB}
  21. interface
  22. procedure proc_unit;
  23. procedure proc_program(islibrary : boolean);
  24. implementation
  25. uses
  26. globtype,version,systems,tokens,
  27. cutils,cclasses,comphook,
  28. globals,verbose,fmodule,finput,fppu,
  29. symconst,symbase,symtype,symdef,symsym,symtable,
  30. aasmbase,aasmtai,aasmcpu,
  31. cgbase,cpuinfo,
  32. ncgutil,
  33. link,assemble,import,export,gendef,ppu,comprsrc,
  34. cresstr,cpubase,
  35. {$ifdef GDB}
  36. gdb,
  37. {$endif GDB}
  38. scanner,pbase,pexpr,psystem,psub;
  39. procedure fixseg(p:TAAsmoutput;sec:TSection);
  40. begin
  41. p.insert(Tai_section.Create(sec));
  42. if (cs_create_smart in aktmoduleswitches) then
  43. p.insert(Tai_cut.Create);
  44. p.concat(Tai_section.Create(sec_none));
  45. end;
  46. procedure create_objectfile;
  47. var
  48. DLLScanner : TDLLScanner;
  49. s : string;
  50. KeepShared : TStringList;
  51. begin
  52. { try to create import entries from system dlls }
  53. if target_info.DllScanSupported and
  54. (not current_module.linkOtherSharedLibs.Empty) then
  55. begin
  56. { Init DLLScanner }
  57. if assigned(CDLLScanner[target_info.system]) then
  58. DLLScanner:=CDLLScanner[target_info.system].Create
  59. else
  60. internalerror(200104121);
  61. KeepShared:=TStringList.Create;
  62. { Walk all shared libs }
  63. While not current_module.linkOtherSharedLibs.Empty do
  64. begin
  65. S:=current_module.linkOtherSharedLibs.Getusemask(link_allways);
  66. if not DLLScanner.scan(s) then
  67. KeepShared.Concat(s);
  68. end;
  69. DLLscanner.Free;
  70. { Recreate import section }
  71. if (target_info.system in [system_i386_win32,system_i386_wdosx]) then
  72. begin
  73. if assigned(importssection)then
  74. importssection.clear
  75. else
  76. importssection:=taasmoutput.Create;
  77. importlib.generatelib;
  78. end;
  79. { Readd the not processed files }
  80. while not KeepShared.Empty do
  81. begin
  82. s:=KeepShared.GetFirst;
  83. current_module.linkOtherSharedLibs.add(s,link_allways);
  84. end;
  85. KeepShared.Free;
  86. end;
  87. { create the .s file and assemble it }
  88. GenerateAsm(false);
  89. { Also create a smartlinked version ? }
  90. if (cs_create_smart in aktmoduleswitches) then
  91. begin
  92. { regenerate the importssection for win32 }
  93. if assigned(importssection) and
  94. (target_info.system in [system_i386_win32,system_i386_wdosx]) then
  95. begin
  96. importsSection.clear;
  97. importlib.generatesmartlib;
  98. end;
  99. GenerateAsm(true);
  100. if target_asm.needar then
  101. Linker.MakeStaticLibrary;
  102. end;
  103. { resource files }
  104. CompileResourceFiles;
  105. end;
  106. procedure insertobjectfile;
  107. { Insert the used object file for this unit in the used list for this unit }
  108. begin
  109. current_module.linkunitofiles.add(current_module.objfilename^,link_static);
  110. current_module.flags:=current_module.flags or uf_static_linked;
  111. if (cs_create_smart in aktmoduleswitches) then
  112. begin
  113. current_module.linkunitstaticlibs.add(current_module.staticlibfilename^,link_smart);
  114. current_module.flags:=current_module.flags or uf_smart_linked;
  115. end;
  116. end;
  117. procedure insertsegment;
  118. begin
  119. { Insert Ident of the compiler }
  120. if (not (cs_create_smart in aktmoduleswitches))
  121. {$ifndef EXTDEBUG}
  122. and (not current_module.is_unit)
  123. {$endif}
  124. then
  125. begin
  126. { align the first data }
  127. dataSegment.insert(Tai_align.Create(const_align(32)));
  128. dataSegment.insert(Tai_string.Create('FPC '+full_version_string+
  129. ' ['+date_string+'] for '+target_cpu_string+' - '+target_info.shortname));
  130. end;
  131. { align code segment }
  132. codeSegment.concat(Tai_align.Create(aktalignment.procalign));
  133. { Insert start and end of sections }
  134. fixseg(codesegment,sec_code);
  135. fixseg(datasegment,sec_data);
  136. fixseg(bsssegment,sec_bss);
  137. { we should use .rdata section for these two no ? }
  138. { .rdata is a read only data section (PM) }
  139. fixseg(rttilist,sec_data);
  140. fixseg(consts,sec_data);
  141. if assigned(resourcestringlist) then
  142. fixseg(resourcestringlist,sec_data);
  143. {$ifdef GDB}
  144. if assigned(debuglist) then
  145. begin
  146. debugList.insert(Tai_symbol.Createname('gcc2_compiled',0));
  147. debugList.insert(Tai_symbol.Createname('fpc_compiled',0));
  148. fixseg(debuglist,sec_code);
  149. end;
  150. {$endif GDB}
  151. end;
  152. procedure InsertThreadvarTablesTable;
  153. var
  154. hp : tused_unit;
  155. ltvTables : taasmoutput;
  156. count : longint;
  157. begin
  158. ltvTables:=TAAsmOutput.Create;
  159. count:=0;
  160. hp:=tused_unit(usedunits.first);
  161. while assigned(hp) do
  162. begin
  163. If (hp.u.flags and uf_threadvars)=uf_threadvars then
  164. begin
  165. ltvTables.concat(Tai_const_symbol.Createdataname(hp.u.modulename^+'_$THREADVARLIST'));
  166. inc(count);
  167. end;
  168. hp:=tused_unit(hp.next);
  169. end;
  170. { Add program threadvars, if any }
  171. If (current_module.flags and uf_threadvars)=uf_threadvars then
  172. begin
  173. ltvTables.concat(Tai_const_symbol.Createdataname(current_module.modulename^+'_$THREADVARLIST'));
  174. inc(count);
  175. end;
  176. { TableCount }
  177. ltvTables.insert(Tai_const.Create_32bit(count));
  178. ltvTables.insert(Tai_symbol.Createdataname_global('FPC_THREADVARTABLES',0));
  179. ltvTables.insert(Tai_align.Create(const_align(pointer_size)));
  180. ltvTables.concat(Tai_symbol_end.Createname('FPC_THREADVARTABLES'));
  181. { insert in data segment }
  182. if (cs_create_smart in aktmoduleswitches) then
  183. dataSegment.concat(Tai_cut.Create);
  184. dataSegment.concatlist(ltvTables);
  185. ltvTables.free;
  186. end;
  187. procedure AddToThreadvarList(p:tnamedindexitem;arg:pointer);
  188. var
  189. ltvTable : taasmoutput;
  190. begin
  191. ltvTable:=taasmoutput(arg);
  192. if (tsym(p).typ=varsym) and
  193. (vo_is_thread_var in tvarsym(p).varoptions) then
  194. begin
  195. { address of threadvar }
  196. ltvTable.concat(tai_const_symbol.createdataname(tvarsym(p).mangledname));
  197. { size of threadvar }
  198. ltvTable.concat(tai_const.create_32bit(tvarsym(p).getsize));
  199. end;
  200. end;
  201. procedure InsertThreadvars;
  202. var
  203. ltvTable : TAAsmoutput;
  204. begin
  205. ltvTable:=TAAsmoutput.create;
  206. if assigned(current_module.globalsymtable) then
  207. current_module.globalsymtable.foreach_static({$ifdef FPCPROCVAR}@{$endif}AddToThreadvarList,ltvTable);
  208. current_module.localsymtable.foreach_static({$ifdef FPCPROCVAR}@{$endif}AddToThreadvarList,ltvTable);
  209. if ltvTable.first<>nil then
  210. begin
  211. { add begin and end of the list }
  212. ltvTable.insert(tai_symbol.createdataname_global(current_module.modulename^+'_$THREADVARLIST',0));
  213. ltvTable.concat(tai_const.create_32bit(0)); { end of list marker }
  214. ltvTable.concat(tai_symbol_end.createname(current_module.modulename^+'_$THREADVARLIST'));
  215. if (cs_create_smart in aktmoduleswitches) then
  216. dataSegment.concat(Tai_cut.Create);
  217. dataSegment.concatlist(ltvTable);
  218. current_module.flags:=current_module.flags or uf_threadvars;
  219. end;
  220. ltvTable.Free;
  221. end;
  222. Procedure InsertResourceTablesTable;
  223. var
  224. hp : tused_unit;
  225. ResourceStringTables : taasmoutput;
  226. count : longint;
  227. begin
  228. ResourceStringTables:=TAAsmOutput.Create;
  229. count:=0;
  230. hp:=tused_unit(usedunits.first);
  231. while assigned(hp) do
  232. begin
  233. If (hp.u.flags and uf_has_resources)=uf_has_resources then
  234. begin
  235. ResourceStringTables.concat(Tai_const_symbol.Createdataname(hp.u.modulename^+'_RESOURCESTRINGLIST'));
  236. inc(count);
  237. end;
  238. hp:=tused_unit(hp.next);
  239. end;
  240. { Add program resources, if any }
  241. If ResourceStringList<>Nil then
  242. begin
  243. ResourceStringTables.concat(Tai_const_symbol.Createdataname(current_module.modulename^+'_RESOURCESTRINGLIST'));
  244. Inc(Count);
  245. end;
  246. { TableCount }
  247. ResourceStringTables.insert(Tai_const.Create_32bit(count));
  248. ResourceStringTables.insert(Tai_symbol.Createdataname_global('FPC_RESOURCESTRINGTABLES',0));
  249. ResourceStringTables.insert(Tai_align.Create(const_align(4)));
  250. ResourceStringTables.concat(Tai_symbol_end.Createname('FPC_RESOURCESTRINGTABLES'));
  251. { insert in data segment }
  252. if (cs_create_smart in aktmoduleswitches) then
  253. dataSegment.concat(Tai_cut.Create);
  254. dataSegment.concatlist(ResourceStringTables);
  255. ResourceStringTables.free;
  256. end;
  257. procedure InsertInitFinalTable;
  258. var
  259. hp : tused_unit;
  260. unitinits : taasmoutput;
  261. count : longint;
  262. begin
  263. unitinits:=TAAsmOutput.Create;
  264. count:=0;
  265. hp:=tused_unit(usedunits.first);
  266. while assigned(hp) do
  267. begin
  268. { call the unit init code and make it external }
  269. if (hp.u.flags and (uf_init or uf_finalize))<>0 then
  270. begin
  271. if (hp.u.flags and uf_init)<>0 then
  272. unitinits.concat(Tai_const_symbol.Createname('INIT$$'+hp.u.modulename^))
  273. else
  274. unitinits.concat(Tai_const.Create_32bit(0));
  275. if (hp.u.flags and uf_finalize)<>0 then
  276. unitinits.concat(Tai_const_symbol.Createname('FINALIZE$$'+hp.u.modulename^))
  277. else
  278. unitinits.concat(Tai_const.Create_32bit(0));
  279. inc(count);
  280. end;
  281. hp:=tused_unit(hp.next);
  282. end;
  283. { Insert initialization/finalization of the program }
  284. if (current_module.flags and (uf_init or uf_finalize))<>0 then
  285. begin
  286. if (current_module.flags and uf_init)<>0 then
  287. unitinits.concat(Tai_const_symbol.Createname('INIT$$'+current_module.modulename^))
  288. else
  289. unitinits.concat(Tai_const.Create_32bit(0));
  290. if (current_module.flags and uf_finalize)<>0 then
  291. unitinits.concat(Tai_const_symbol.Createname('FINALIZE$$'+current_module.modulename^))
  292. else
  293. unitinits.concat(Tai_const.Create_32bit(0));
  294. inc(count);
  295. end;
  296. { TableCount,InitCount }
  297. unitinits.insert(Tai_const.Create_32bit(0));
  298. unitinits.insert(Tai_const.Create_32bit(count));
  299. unitinits.insert(Tai_symbol.Createdataname_global('INITFINAL',0));
  300. unitinits.insert(Tai_align.Create(const_align(4)));
  301. unitinits.concat(Tai_symbol_end.Createname('INITFINAL'));
  302. { insert in data segment }
  303. if (cs_create_smart in aktmoduleswitches) then
  304. dataSegment.concat(Tai_cut.Create);
  305. dataSegment.concatlist(unitinits);
  306. unitinits.free;
  307. end;
  308. procedure insertheap;
  309. begin
  310. if (cs_create_smart in aktmoduleswitches) then
  311. begin
  312. bssSegment.concat(Tai_cut.Create);
  313. dataSegment.concat(Tai_cut.Create);
  314. end;
  315. { On the Macintosh Classic M68k Architecture
  316. The Heap variable is simply a POINTER to the
  317. real HEAP. The HEAP must be set up by the RTL
  318. and must store the pointer in this value.
  319. On OS/2 the heap is also intialized by the RTL. We do
  320. not output a pointer }
  321. case target_info.system of
  322. system_i386_OS2,system_i386_EMX:
  323. ;
  324. system_powerpc_macos:
  325. ;
  326. system_alpha_linux:
  327. ;
  328. system_m68k_Mac:
  329. bssSegment.concat(Tai_datablock.Create_global('HEAP',4));
  330. system_m68k_PalmOS:
  331. ;
  332. else
  333. begin
  334. bssSegment.concat(Tai_align.Create(var_align(heapsize)));
  335. bssSegment.concat(Tai_datablock.Create_global('HEAP',heapsize));
  336. end;
  337. end;
  338. {$ifdef m68k}
  339. if target_info.system<>system_m68k_PalmOS then
  340. begin
  341. dataSegment.concat(Tai_align.Create(const_align(4)));
  342. dataSegment.concat(Tai_symbol.Createdataname_global('HEAPSIZE',4));
  343. dataSegment.concat(Tai_const.Create_32bit(heapsize));
  344. end;
  345. {$else m68k}
  346. dataSegment.concat(Tai_align.Create(const_align(4)));
  347. dataSegment.concat(Tai_symbol.Createdataname_global('HEAPSIZE',4));
  348. dataSegment.concat(Tai_const.Create_32bit(heapsize));
  349. {$endif m68k}
  350. end;
  351. procedure insertstacklength;
  352. begin
  353. { stacksize can be specified and is now simulated }
  354. dataSegment.concat(Tai_align.Create(const_align(4)));
  355. dataSegment.concat(Tai_symbol.Createdataname_global('__stklen',4));
  356. dataSegment.concat(Tai_const.Create_32bit(stacksize));
  357. end;
  358. procedure loaddefaultunits;
  359. procedure AddUnit(const s:string);
  360. var
  361. hp : tppumodule;
  362. unitsym : tunitsym;
  363. begin
  364. { load unit }
  365. hp:=registerunit(current_module,s,'');
  366. hp.loadppu;
  367. hp.adddependency(current_module);
  368. current_module.addusedunit(hp,false);
  369. { add to symtable stack }
  370. tsymtable(hp.globalsymtable).next:=symtablestack;
  371. symtablestack:=hp.globalsymtable;
  372. { insert unitsym }
  373. unitsym:=tunitsym.create(s,hp.globalsymtable);
  374. inc(unitsym.refs);
  375. refsymtable.insert(unitsym);
  376. end;
  377. begin
  378. { are we compiling the system unit? }
  379. if (cs_compilesystem in aktmoduleswitches) then
  380. begin
  381. { create system defines }
  382. createconstdefs;
  383. { we don't need to reset anything, it's already done in parser.pas }
  384. exit;
  385. end;
  386. { insert the system unit, it is allways the first }
  387. Symtablestack:=nil;
  388. AddUnit('System');
  389. SystemUnit:=TGlobalSymtable(Symtablestack);
  390. { read default constant definitions }
  391. make_ref:=false;
  392. readconstdefs;
  393. make_ref:=true;
  394. {$ifdef cpufpemu}
  395. { Floating point emulation unit? }
  396. if (cs_fp_emulation in aktmoduleswitches) then
  397. AddUnit('SoftFpu');
  398. {$endif cpufpemu}
  399. { Thread support unit? }
  400. if (cs_threading in aktmoduleswitches) then
  401. AddUnit('SysThrds');
  402. { Objpas unit? }
  403. if m_objpas in aktmodeswitches then
  404. AddUnit('ObjPas');
  405. { Profile unit? Needed for go32v2 only }
  406. if (cs_profile in aktmoduleswitches) and
  407. (target_info.system=system_i386_go32v2) then
  408. AddUnit('Profile');
  409. { Units only required for main module }
  410. if not(current_module.is_unit) then
  411. begin
  412. { Heaptrc unit }
  413. if (cs_gdb_heaptrc in aktglobalswitches) then
  414. AddUnit('HeapTrc');
  415. { Lineinfo unit }
  416. if (cs_gdb_lineinfo in aktglobalswitches) then
  417. AddUnit('LineInfo');
  418. end;
  419. { save default symtablestack }
  420. defaultsymtablestack:=symtablestack;
  421. end;
  422. procedure loadunits;
  423. var
  424. s,sorg : stringid;
  425. fn : string;
  426. pu : tused_unit;
  427. hp2 : tmodule;
  428. hp3 : tsymtable;
  429. oldprocdef : tprocdef;
  430. unitsym : tunitsym;
  431. begin
  432. oldprocdef:=current_procdef;
  433. consume(_USES);
  434. {$ifdef DEBUG}
  435. test_symtablestack;
  436. {$endif DEBUG}
  437. repeat
  438. s:=pattern;
  439. sorg:=orgpattern;
  440. consume(_ID);
  441. { support "<unit> in '<file>'" construct, but not for tp7 }
  442. if not(m_tp7 in aktmodeswitches) then
  443. begin
  444. if try_to_consume(_OP_IN) then
  445. fn:=FixFileName(get_stringconst)
  446. else
  447. fn:='';
  448. end;
  449. { Give a warning if objpas is loaded }
  450. if s='OBJPAS' then
  451. Message(parser_w_no_objpas_use_mode);
  452. { Using the unit itself is not possible }
  453. if (s<>current_module.modulename^) then
  454. begin
  455. { check if the unit is already used }
  456. hp2:=nil;
  457. pu:=tused_unit(current_module.used_units.first);
  458. while assigned(pu) do
  459. begin
  460. if (pu.u.modulename^=s) then
  461. begin
  462. hp2:=pu.u;
  463. break;
  464. end;
  465. pu:=tused_unit(pu.next);
  466. end;
  467. { Need to register the unit? }
  468. if not assigned(hp2) then
  469. hp2:=registerunit(current_module,sorg,fn);
  470. { the current module uses the unit hp2 }
  471. current_module.addusedunit(hp2,true);
  472. end
  473. else
  474. Message1(sym_e_duplicate_id,s);
  475. if token=_COMMA then
  476. begin
  477. pattern:='';
  478. consume(_COMMA);
  479. end
  480. else
  481. break;
  482. until false;
  483. consume(_SEMICOLON);
  484. { Load the units }
  485. pu:=tused_unit(current_module.used_units.first);
  486. while assigned(pu) do
  487. begin
  488. if pu.in_uses then
  489. begin
  490. { store the original name to create the unitsym }
  491. sorg:=pu.u.realmodulename^;
  492. tppumodule(pu.u).loadppu;
  493. { is our module compiled? then we can stop }
  494. if current_module.state=ms_compiled then
  495. exit;
  496. { add this unit to the dependencies }
  497. pu.u.adddependency(current_module);
  498. pu.checksum:=pu.u.crc;
  499. pu.interface_checksum:=pu.u.interface_crc;
  500. { Create unitsym, we need to use the name as specified, we
  501. can not use the modulename because that can be different
  502. when -Un is used. But when the names are the same then
  503. force the name of the module so there will be no difference
  504. in the case of the name }
  505. if upper(sorg)=pu.u.modulename^ then
  506. sorg:=pu.u.realmodulename^;
  507. unitsym:=tunitsym.create(sorg,pu.u.globalsymtable);
  508. if (pu.u.flags and (uf_init or uf_finalize))<>0 then
  509. inc(unitsym.refs);
  510. refsymtable.insert(unitsym);
  511. end;
  512. pu:=tused_unit(pu.next);
  513. end;
  514. { set the symtable to systemunit so it gets reorderd correctly,
  515. then insert the units in the symtablestack }
  516. pu:=tused_unit(current_module.used_units.first);
  517. symtablestack:=defaultsymtablestack;
  518. while assigned(pu) do
  519. begin
  520. {$IfDef GDB}
  521. if (cs_debuginfo in aktmoduleswitches) and
  522. (cs_gdb_dbx in aktglobalswitches) and
  523. not pu.is_stab_written then
  524. begin
  525. tglobalsymtable(pu.u.globalsymtable).concattypestabto(debuglist);
  526. pu.is_stab_written:=true;
  527. pu.unitid:=tsymtable(pu.u.globalsymtable).unitid;
  528. end;
  529. {$EndIf GDB}
  530. if pu.in_uses then
  531. begin
  532. { Reinsert in symtablestack }
  533. hp3:=symtablestack;
  534. while assigned(hp3) do
  535. begin
  536. { insert units only once ! }
  537. if pu.u.globalsymtable=hp3 then
  538. break;
  539. hp3:=hp3.next;
  540. { unit isn't inserted }
  541. if hp3=nil then
  542. begin
  543. tsymtable(pu.u.globalsymtable).next:=symtablestack;
  544. symtablestack:=tsymtable(pu.u.globalsymtable);
  545. {$ifdef DEBUG}
  546. test_symtablestack;
  547. {$endif DEBUG}
  548. end;
  549. end;
  550. end;
  551. pu:=tused_unit(pu.next);
  552. end;
  553. current_procdef:=oldprocdef;
  554. end;
  555. procedure write_gdb_info;
  556. {$IfDef GDB}
  557. var
  558. hp : tused_unit;
  559. begin
  560. if not (cs_debuginfo in aktmoduleswitches) then
  561. exit;
  562. { now insert the units in the symtablestack }
  563. hp:=tused_unit(current_module.used_units.first);
  564. while assigned(hp) do
  565. begin
  566. if (cs_debuginfo in aktmoduleswitches) and
  567. not hp.is_stab_written then
  568. begin
  569. tglobalsymtable(hp.u.globalsymtable).concattypestabto(debuglist);
  570. hp.is_stab_written:=true;
  571. hp.unitid:=tsymtable(hp.u.globalsymtable).unitid;
  572. end;
  573. hp:=tused_unit(hp.next);
  574. end;
  575. if (not current_module.in_interface) and
  576. assigned(current_module.localsymtable) then
  577. begin
  578. { all types }
  579. tstaticsymtable(current_module.localsymtable).concattypestabto(debuglist);
  580. { and all local symbols}
  581. tstaticsymtable(current_module.localsymtable).concatstabto(debuglist);
  582. end
  583. else if assigned(current_module.globalsymtable) then
  584. begin
  585. { all types }
  586. tglobalsymtable(current_module.globalsymtable).concattypestabto(debuglist);
  587. { and all local symbols}
  588. tglobalsymtable(current_module.globalsymtable).concatstabto(debuglist);
  589. end;
  590. if (cs_gdb_dbx in aktglobalswitches) then
  591. begin
  592. debugList.concat(tai_comment.Create(strpnew('EINCL of global '+
  593. tglobalsymtable(current_module.globalsymtable).name^+' has index '+
  594. tostr(tglobalsymtable(current_module.globalsymtable).unitid))));
  595. debugList.concat(Tai_stabs.Create(strpnew('"'+
  596. tglobalsymtable(current_module.globalsymtable).name^+'",'+
  597. tostr(N_EINCL)+',0,0,0')));
  598. tglobalsymtable(current_module.globalsymtable).dbx_count_ok:={true}false;
  599. dbx_counter:=tglobalsymtable(current_module.globalsymtable).prev_dbx_counter;
  600. do_count_dbx:=false;
  601. end;
  602. end;
  603. {$Else GDB}
  604. begin
  605. end;
  606. {$EndIf GDB}
  607. procedure parse_implementation_uses(symt:tsymtable);
  608. begin
  609. if token=_USES then
  610. begin
  611. loadunits;
  612. {$ifdef DEBUG}
  613. test_symtablestack;
  614. {$endif DEBUG}
  615. end;
  616. end;
  617. procedure setupglobalswitches;
  618. begin
  619. { can't have local browser when no global browser }
  620. if (cs_local_browser in aktmoduleswitches) and
  621. not(cs_browser in aktmoduleswitches) then
  622. exclude(aktmoduleswitches,cs_local_browser);
  623. { define a symbol in delphi,objfpc,tp,gpc mode }
  624. if (m_delphi in aktmodeswitches) then
  625. current_scanner.def_macro('FPC_DELPHI')
  626. else
  627. if (m_tp7 in aktmodeswitches) then
  628. current_scanner.def_macro('FPC_TP')
  629. else
  630. if (m_objfpc in aktmodeswitches) then
  631. current_scanner.def_macro('FPC_OBJFPC')
  632. else
  633. if (m_gpc in aktmodeswitches) then
  634. current_scanner.def_macro('FPC_GPC');
  635. end;
  636. function create_main_proc(const name:string;potype:tproctypeoption;st:tsymtable):tprocdef;
  637. var
  638. stt : tsymtable;
  639. ps : tprocsym;
  640. pd : tprocdef;
  641. begin
  642. { there should be no current_procinfo available }
  643. if assigned(current_procinfo) then
  644. internalerror(200304275);
  645. {Generate a procsym for main}
  646. make_ref:=false;
  647. { try to insert in in static symtable ! }
  648. stt:=symtablestack;
  649. symtablestack:=st;
  650. { generate procsym }
  651. ps:=tprocsym.create('$'+name);
  652. { main are allways used }
  653. inc(ps.refs);
  654. symtablestack.insert(ps);
  655. pd:=tprocdef.create(main_program_level);
  656. include(pd.procoptions,po_public);
  657. pd.procsym:=ps;
  658. ps.addprocdef(pd);
  659. { restore symtable }
  660. make_ref:=true;
  661. symtablestack:=stt;
  662. { set procdef options }
  663. pd.proctypeoption:=potype;
  664. pd.forwarddef:=false;
  665. pd.setmangledname(target_info.cprefix+name);
  666. pd.aliasnames.insert(pd.mangledname);
  667. { We don't need is a local symtable. Change it into the static
  668. symtable }
  669. pd.localst.free;
  670. pd.localst:=st;
  671. { set procinfo and current_procdef }
  672. current_procinfo:=cprocinfo.create(nil);
  673. current_module.procinfo:=current_procinfo;
  674. current_procinfo.procdef:=pd;
  675. current_procdef:=pd;
  676. { return procdef }
  677. create_main_proc:=pd;
  678. end;
  679. procedure release_main_proc(pd:tprocdef);
  680. begin
  681. { this is a main proc, so there should be no parent }
  682. if not(assigned(current_procinfo)) or
  683. assigned(current_procinfo.parent) or
  684. not(current_procinfo.procdef=pd) then
  685. internalerror(200304276);
  686. { remove procinfo }
  687. current_module.procinfo:=nil;
  688. current_procinfo.free;
  689. current_procinfo:=nil;
  690. { remove localst as it was replaced by staticsymtable }
  691. pd.localst:=nil;
  692. end;
  693. procedure gen_implicit_initfinal(list:taasmoutput;flag:word;st:tsymtable);
  694. var
  695. pd : tprocdef;
  696. oldexitlabel : tasmlabel;
  697. begin
  698. { update module flags }
  699. current_module.flags:=current_module.flags or flag;
  700. { create procdef }
  701. case flag of
  702. uf_init :
  703. begin
  704. pd:=create_main_proc(current_module.modulename^+'_init_implicit',potype_unitinit,st);
  705. pd.aliasnames.insert('INIT$$'+current_module.modulename^);
  706. end;
  707. uf_finalize :
  708. begin
  709. pd:=create_main_proc(current_module.modulename^+'_finalize_implicit',potype_unitfinalize,st);
  710. pd.aliasnames.insert('FINALIZE$$'+current_module.modulename^);
  711. end;
  712. else
  713. internalerror(200304253);
  714. end;
  715. { save labels }
  716. oldexitlabel:=aktexitlabel;
  717. { generate a dummy function }
  718. objectlibrary.getlabel(aktexitlabel);
  719. include(current_procinfo.flags,pi_do_call);
  720. gen_stackalloc_code(list,0);
  721. genentrycode(list,false);
  722. genexitcode(list,false);
  723. list.convert_registers;
  724. release_main_proc(pd);
  725. { restore }
  726. aktexitlabel:=oldexitlabel;
  727. end;
  728. procedure proc_unit;
  729. function is_assembler_generated:boolean;
  730. begin
  731. is_assembler_generated:=(Errorcount=0) and
  732. not(
  733. codeSegment.empty and
  734. dataSegment.empty and
  735. bssSegment.empty and
  736. ((importssection=nil) or importsSection.empty) and
  737. ((resourcesection=nil) or resourceSection.empty) and
  738. ((resourcestringlist=nil) or resourcestringList.empty)
  739. );
  740. end;
  741. var
  742. main_file: tinputfile;
  743. st : tsymtable;
  744. unitst : tglobalsymtable;
  745. {$ifdef GDB}
  746. pu : tused_unit;
  747. {$endif GDB}
  748. store_crc,store_interface_crc : cardinal;
  749. s2 : ^string; {Saves stack space}
  750. force_init_final : boolean;
  751. initfinalcode : taasmoutput;
  752. pd : tprocdef;
  753. begin
  754. initfinalcode:=taasmoutput.create;
  755. consume(_UNIT);
  756. if compile_level=1 then
  757. Status.IsExe:=false;
  758. if token=_ID then
  759. begin
  760. { create filenames and unit name }
  761. main_file := current_scanner.inputfile;
  762. while assigned(main_file.next) do
  763. main_file := main_file.next;
  764. current_module.SetFileName(main_file.path^+main_file.name^,true);
  765. current_module.SetModuleName(orgpattern);
  766. { check for system unit }
  767. new(s2);
  768. s2^:=upper(SplitName(main_file.name^));
  769. if (cs_check_unit_name in aktglobalswitches) and
  770. not((current_module.modulename^=s2^) or
  771. ((length(current_module.modulename^)>8) and
  772. (copy(current_module.modulename^,1,8)=s2^))) then
  773. Message1(unit_e_illegal_unit_name,current_module.realmodulename^);
  774. if (current_module.modulename^='SYSTEM') then
  775. include(aktmoduleswitches,cs_compilesystem);
  776. dispose(s2);
  777. end;
  778. consume(_ID);
  779. consume(_SEMICOLON);
  780. consume(_INTERFACE);
  781. { global switches are read, so further changes aren't allowed }
  782. current_module.in_global:=false;
  783. { handle the global switches }
  784. setupglobalswitches;
  785. message1(unit_u_loading_interface_units,current_module.modulename^);
  786. { update status }
  787. status.currentmodule:=current_module.realmodulename^;
  788. { maybe turn off m_objpas if we are compiling objpas }
  789. if (current_module.modulename^='OBJPAS') then
  790. exclude(aktmodeswitches,m_objpas);
  791. parse_only:=true;
  792. { generate now the global symboltable }
  793. st:=tglobalsymtable.create(current_module.modulename^);
  794. refsymtable:=st;
  795. unitst:=tglobalsymtable(st);
  796. { define first as local to overcome dependency conflicts }
  797. current_module.localsymtable:=st;
  798. { the unit name must be usable as a unit specifier }
  799. { inside the unit itself (PM) }
  800. { this also forbids to have another symbol }
  801. { with the same name as the unit }
  802. refsymtable.insert(tunitsym.create(current_module.realmodulename^,unitst));
  803. { load default units, like the system unit }
  804. loaddefaultunits;
  805. { reset }
  806. make_ref:=true;
  807. { insert qualifier for the system unit (allows system.writeln) }
  808. if not(cs_compilesystem in aktmoduleswitches) then
  809. begin
  810. if token=_USES then
  811. begin
  812. loadunits;
  813. { has it been compiled at a higher level ?}
  814. if current_module.state=ms_compiled then
  815. begin
  816. { this unit symtable is obsolete }
  817. { dispose(unitst,done);
  818. disposed as localsymtable !! }
  819. RestoreUnitSyms;
  820. exit;
  821. end;
  822. end;
  823. { ... but insert the symbol table later }
  824. st.next:=symtablestack;
  825. symtablestack:=st;
  826. end
  827. else
  828. { while compiling a system unit, some types are directly inserted }
  829. begin
  830. st.next:=symtablestack;
  831. symtablestack:=st;
  832. insert_intern_types(st);
  833. end;
  834. { now we know the place to insert the constants }
  835. constsymtable:=symtablestack;
  836. { move the global symtab from the temporary local to global }
  837. current_module.globalsymtable:=current_module.localsymtable;
  838. current_module.localsymtable:=nil;
  839. reset_global_defs;
  840. { number all units, so we know if a unit is used by this unit or
  841. needs to be added implicitly }
  842. current_module.numberunits;
  843. { ... parse the declarations }
  844. Message1(parser_u_parsing_interface,current_module.realmodulename^);
  845. read_interface_declarations;
  846. { leave when we got an error }
  847. if (Errorcount>0) and not status.skip_error then
  848. begin
  849. Message1(unit_f_errors_in_unit,tostr(Errorcount));
  850. status.skip_error:=true;
  851. exit;
  852. end;
  853. {else in inteface its somatimes necessary even if unused
  854. st^.allunitsused; }
  855. {$ifdef New_GDB}
  856. write_gdb_info;
  857. {$endIf Def New_GDB}
  858. if not(cs_compilesystem in aktmoduleswitches) then
  859. if (Errorcount=0) then
  860. tppumodule(current_module).getppucrc;
  861. { Parse the implementation section }
  862. consume(_IMPLEMENTATION);
  863. current_module.in_interface:=false;
  864. current_module.interface_compiled:=true;
  865. Message1(unit_u_loading_implementation_units,current_module.modulename^);
  866. parse_only:=false;
  867. { generates static symbol table }
  868. st:=tstaticsymtable.create(current_module.modulename^);
  869. current_module.localsymtable:=st;
  870. { remove the globalsymtable from the symtable stack }
  871. { to reinsert it after loading the implementation units }
  872. symtablestack:=unitst.next;
  873. { we don't want implementation units symbols in unitsymtable !! PM }
  874. refsymtable:=st;
  875. { Read the implementation units }
  876. parse_implementation_uses(unitst);
  877. if current_module.state=ms_compiled then
  878. begin
  879. RestoreUnitSyms;
  880. exit;
  881. end;
  882. { reset ranges/stabs in exported definitions }
  883. reset_global_defs;
  884. { All units are read, now give them a number }
  885. current_module.numberunits;
  886. { now we can change refsymtable }
  887. refsymtable:=st;
  888. { but reinsert the global symtable as lasts }
  889. unitst.next:=symtablestack;
  890. symtablestack:=unitst;
  891. tstoredsymtable(symtablestack).chainoperators;
  892. {$ifdef DEBUG}
  893. test_symtablestack;
  894. {$endif DEBUG}
  895. constsymtable:=symtablestack;
  896. {$ifdef Splitheap}
  897. if testsplit then
  898. begin
  899. Split_Heap;
  900. allow_special:=true;
  901. Switch_to_temp_heap;
  902. end;
  903. { it will report all crossings }
  904. allow_special:=false;
  905. {$endif Splitheap}
  906. Message1(parser_u_parsing_implementation,current_module.modulename^);
  907. if current_module.in_interface then
  908. internalerror(200212285);
  909. { Compile the unit }
  910. pd:=create_main_proc(current_module.modulename^+'_init',potype_unitinit,st);
  911. pd.aliasnames.insert('INIT$$'+current_module.modulename^);
  912. tcgprocinfo(current_procinfo).parse_body;
  913. tcgprocinfo(current_procinfo).generate_code;
  914. tcgprocinfo(current_procinfo).resetprocdef;
  915. release_main_proc(pd);
  916. { if the unit contains ansi/widestrings, initialization and
  917. finalization code must be forced }
  918. force_init_final:=tglobalsymtable(current_module.globalsymtable).needs_init_final or
  919. tstaticsymtable(current_module.localsymtable).needs_init_final;
  920. { should we force unit initialization? }
  921. { this is a hack, but how can it be done better ? }
  922. if force_init_final and ((current_module.flags and uf_init)=0) then
  923. begin
  924. gen_implicit_initfinal(initfinalcode,uf_init,st);
  925. codesegment.concatlist(initfinalcode);
  926. end;
  927. { finalize? }
  928. if token=_FINALIZATION then
  929. begin
  930. { set module options }
  931. current_module.flags:=current_module.flags or uf_finalize;
  932. { Compile the finalize }
  933. pd:=create_main_proc(current_module.modulename^+'_finalize',potype_unitfinalize,st);
  934. pd.aliasnames.insert('FINALIZE$$'+current_module.modulename^);
  935. tcgprocinfo(current_procinfo).parse_body;
  936. tcgprocinfo(current_procinfo).generate_code;
  937. tcgprocinfo(current_procinfo).resetprocdef;
  938. release_main_proc(pd);
  939. end
  940. else if force_init_final then
  941. begin
  942. gen_implicit_initfinal(initfinalcode,uf_finalize,st);
  943. codesegment.concatlist(initfinalcode);
  944. end;
  945. { the last char should always be a point }
  946. consume(_POINT);
  947. { generate a list of threadvars }
  948. InsertThreadvars;
  949. { Generate resoucestrings }
  950. If ResourceStrings.ResStrCount>0 then
  951. begin
  952. ResourceStrings.CreateResourceStringList;
  953. current_module.flags:=current_module.flags or uf_has_resources;
  954. { only write if no errors found }
  955. if (Errorcount=0) then
  956. ResourceStrings.WriteResourceFile(ForceExtension(current_module.ppufilename^,'.rst'));
  957. end;
  958. { test static symtable }
  959. if (Errorcount=0) then
  960. begin
  961. tstoredsymtable(st).allsymbolsused;
  962. tstoredsymtable(st).allunitsused;
  963. tstoredsymtable(st).allprivatesused;
  964. end;
  965. { size of the static data }
  966. datasize:=st.datasize;
  967. {$ifdef GDB}
  968. { add all used definitions even for implementation}
  969. if (cs_debuginfo in aktmoduleswitches) then
  970. begin
  971. {$IfnDef New_GDB}
  972. if assigned(current_module.globalsymtable) then
  973. begin
  974. { all types }
  975. tglobalsymtable(current_module.globalsymtable).concattypestabto(debuglist);
  976. { and all local symbols}
  977. tglobalsymtable(current_module.globalsymtable).concatstabto(debuglist);
  978. end;
  979. { all local types }
  980. tglobalsymtable(st)^.concattypestabto(debuglist);
  981. { and all local symbols}
  982. st^.concatstabto(debuglist);
  983. {$else New_GDB}
  984. write_gdb_info;
  985. {$endIf Def New_GDB}
  986. end;
  987. {$endif GDB}
  988. reset_global_defs;
  989. if (Errorcount=0) then
  990. begin
  991. { tests, if all (interface) forwards are resolved }
  992. tstoredsymtable(symtablestack).check_forwards;
  993. { check if all private fields are used }
  994. tstoredsymtable(symtablestack).allprivatesused;
  995. { remove cross unit overloads }
  996. tstoredsymtable(symtablestack).unchain_overloaded;
  997. end;
  998. {$ifdef GDB}
  999. tglobalsymtable(symtablestack).is_stab_written:=false;
  1000. {$endif GDB}
  1001. { leave when we got an error }
  1002. if (Errorcount>0) and not status.skip_error then
  1003. begin
  1004. Message1(unit_f_errors_in_unit,tostr(Errorcount));
  1005. status.skip_error:=true;
  1006. exit;
  1007. end;
  1008. { generate imports }
  1009. if current_module.uses_imports then
  1010. importlib.generatelib;
  1011. { insert own objectfile, or say that it's in a library
  1012. (no check for an .o when loading) }
  1013. if is_assembler_generated then
  1014. insertobjectfile
  1015. else
  1016. current_module.flags:=current_module.flags or uf_no_link;
  1017. if cs_local_browser in aktmoduleswitches then
  1018. current_module.localsymtable:=refsymtable;
  1019. {$ifdef GDB}
  1020. pu:=tused_unit(usedunits.first);
  1021. while assigned(pu) do
  1022. begin
  1023. if assigned(pu.u.globalsymtable) then
  1024. tglobalsymtable(pu.u.globalsymtable).is_stab_written:=false;
  1025. pu:=tused_unit(pu.next);
  1026. end;
  1027. {$endif GDB}
  1028. if is_assembler_generated then
  1029. begin
  1030. { finish asmlist by adding segment starts }
  1031. insertsegment;
  1032. { assemble }
  1033. create_objectfile;
  1034. end;
  1035. { Write out the ppufile after the object file has been created }
  1036. store_interface_crc:=current_module.interface_crc;
  1037. store_crc:=current_module.crc;
  1038. if (Errorcount=0) then
  1039. tppumodule(current_module).writeppu;
  1040. if not(cs_compilesystem in aktmoduleswitches) then
  1041. if store_interface_crc<>current_module.interface_crc then
  1042. Message1(unit_u_interface_crc_changed,current_module.ppufilename^);
  1043. {$ifdef EXTDEBUG}
  1044. if not(cs_compilesystem in aktmoduleswitches) then
  1045. if (store_crc<>current_module.crc) and simplify_ppu then
  1046. Message1(unit_u_implementation_crc_changed,current_module.ppufilename^);
  1047. {$endif EXTDEBUG}
  1048. { remove static symtable (=refsymtable) here to save some mem }
  1049. if not (cs_local_browser in aktmoduleswitches) then
  1050. begin
  1051. st.free;
  1052. current_module.localsymtable:=nil;
  1053. end;
  1054. RestoreUnitSyms;
  1055. { leave when we got an error }
  1056. if (Errorcount>0) and not status.skip_error then
  1057. begin
  1058. Message1(unit_f_errors_in_unit,tostr(Errorcount));
  1059. status.skip_error:=true;
  1060. exit;
  1061. end;
  1062. initfinalcode.free;
  1063. Message1(unit_u_finished_compiling,current_module.modulename^);
  1064. end;
  1065. procedure proc_program(islibrary : boolean);
  1066. var
  1067. main_file: tinputfile;
  1068. st : tsymtable;
  1069. hp : tmodule;
  1070. initfinalcode : taasmoutput;
  1071. pd : tprocdef;
  1072. begin
  1073. initfinalcode:=taasmoutput.create;
  1074. DLLsource:=islibrary;
  1075. Status.IsLibrary:=IsLibrary;
  1076. Status.IsExe:=true;
  1077. parse_only:=false;
  1078. { relocation works only without stabs under win32 !! PM }
  1079. { internal assembler uses rva for stabs info
  1080. so it should work with relocated DLLs }
  1081. if RelocSection and
  1082. (target_info.system in [system_i386_win32,system_i386_wdosx]) and
  1083. (target_info.assem<>as_i386_pecoff) then
  1084. begin
  1085. include(aktglobalswitches,cs_link_strip);
  1086. { Warning stabs info does not work with reloc section !! }
  1087. if cs_debuginfo in aktmoduleswitches then
  1088. begin
  1089. Message1(parser_w_parser_reloc_no_debug,current_module.mainsource^);
  1090. Message(parser_w_parser_win32_debug_needs_WN);
  1091. exclude(aktmoduleswitches,cs_debuginfo);
  1092. end;
  1093. end;
  1094. { get correct output names }
  1095. main_file := current_scanner.inputfile;
  1096. while assigned(main_file.next) do
  1097. main_file := main_file.next;
  1098. current_module.SetFileName(main_file.path^+main_file.name^,true);
  1099. if islibrary then
  1100. begin
  1101. consume(_LIBRARY);
  1102. stringdispose(current_module.modulename);
  1103. current_module.modulename:=stringdup(pattern);
  1104. current_module.islibrary:=true;
  1105. exportlib.preparelib(pattern);
  1106. consume(_ID);
  1107. consume(_SEMICOLON);
  1108. end
  1109. else
  1110. { is there an program head ? }
  1111. if token=_PROGRAM then
  1112. begin
  1113. consume(_PROGRAM);
  1114. stringdispose(current_module.modulename);
  1115. stringdispose(current_module.realmodulename);
  1116. current_module.modulename:=stringdup(pattern);
  1117. current_module.realmodulename:=stringdup(orgpattern);
  1118. if (target_info.system in [system_i386_WIN32,system_i386_wdosx]) then
  1119. exportlib.preparelib(pattern);
  1120. consume(_ID);
  1121. if token=_LKLAMMER then
  1122. begin
  1123. consume(_LKLAMMER);
  1124. repeat
  1125. consume(_ID);
  1126. until not try_to_consume(_COMMA);
  1127. consume(_RKLAMMER);
  1128. end;
  1129. consume(_SEMICOLON);
  1130. end
  1131. else if (target_info.system in [system_i386_WIN32,system_i386_wdosx]) then
  1132. exportlib.preparelib(current_module.modulename^);
  1133. { global switches are read, so further changes aren't allowed }
  1134. current_module.in_global:=false;
  1135. { setup things using the global switches }
  1136. setupglobalswitches;
  1137. { set implementation flag }
  1138. current_module.in_interface:=false;
  1139. current_module.interface_compiled:=true;
  1140. { insert after the unit symbol tables the static symbol table }
  1141. { of the program }
  1142. st:=tstaticsymtable.create(current_module.modulename^);;
  1143. current_module.localsymtable:=st;
  1144. refsymtable:=st;
  1145. { load standard units (system,objpas,profile unit) }
  1146. loaddefaultunits;
  1147. {Load the units used by the program we compile.}
  1148. if token=_USES then
  1149. loadunits;
  1150. tstoredsymtable(symtablestack).chainoperators;
  1151. { reset ranges/stabs in exported definitions }
  1152. reset_global_defs;
  1153. { All units are read, now give them a number }
  1154. current_module.numberunits;
  1155. {Insert the name of the main program into the symbol table.}
  1156. if current_module.realmodulename^<>'' then
  1157. st.insert(tunitsym.create(current_module.realmodulename^,st));
  1158. { ...is also constsymtable, this is the symtable where }
  1159. { the elements of enumeration types are inserted }
  1160. constsymtable:=st;
  1161. Message1(parser_u_parsing_implementation,current_module.mainsource^);
  1162. { The program intialization needs an alias, so it can be called
  1163. from the bootstrap code.}
  1164. if islibrary then
  1165. begin
  1166. pd:=create_main_proc(current_module.modulename^+'_main',potype_proginit,st);
  1167. { Win32 startup code needs a single name }
  1168. // if (target_info.system in [system_i386_win32,system_i386_wdosx]) then
  1169. pd.aliasnames.insert('PASCALMAIN');
  1170. { this code is called from C so we need to save some
  1171. registers }
  1172. include(pd.procoptions,po_savestdregs);
  1173. end
  1174. else
  1175. begin
  1176. pd:=create_main_proc('main',potype_proginit,st);
  1177. pd.aliasnames.insert('PASCALMAIN');
  1178. end;
  1179. {$IFDEF SPARC}
  1180. current_procinfo.After_Header;
  1181. {main function is declared as
  1182. PROCEDURE main(ArgC:Integer;ArgV,EnvP:ARRAY OF PChar):Integer;CDECL;
  1183. So, all parameters are passerd into registers in sparc architecture.}
  1184. {$ENDIF SPARC}
  1185. tcgprocinfo(current_procinfo).parse_body;
  1186. tcgprocinfo(current_procinfo).generate_code;
  1187. tcgprocinfo(current_procinfo).resetprocdef;
  1188. release_main_proc(pd);
  1189. { should we force unit initialization? }
  1190. if tstaticsymtable(current_module.localsymtable).needs_init_final then
  1191. begin
  1192. { initialize section }
  1193. gen_implicit_initfinal(initfinalcode,uf_init,st);
  1194. codesegment.concatlist(initfinalcode);
  1195. { finalize section }
  1196. gen_implicit_initfinal(initfinalcode,uf_finalize,st);
  1197. codesegment.concatlist(initfinalcode);
  1198. end;
  1199. { Add symbol to the exports section for win32 so smartlinking a
  1200. DLL will include the edata section }
  1201. if assigned(exportlib) and
  1202. (target_info.system in [system_i386_win32,system_i386_wdosx]) and
  1203. assigned(current_module._exports.first) then
  1204. codesegment.concat(tai_const_symbol.create(exportlib.edatalabel));
  1205. If ResourceStrings.ResStrCount>0 then
  1206. begin
  1207. ResourceStrings.CreateResourceStringList;
  1208. { only write if no errors found }
  1209. if (Errorcount=0) then
  1210. ResourceStrings.WriteResourceFile(ForceExtension(current_module.ppufilename^,'.rst'));
  1211. end;
  1212. { finalize? }
  1213. if token=_FINALIZATION then
  1214. begin
  1215. { set module options }
  1216. current_module.flags:=current_module.flags or uf_finalize;
  1217. { Compile the finalize }
  1218. pd:=create_main_proc(current_module.modulename^+'_finalize',potype_unitfinalize,st);
  1219. pd.aliasnames.insert('FINALIZE$$'+current_module.modulename^);
  1220. tcgprocinfo(current_procinfo).parse_body;
  1221. tcgprocinfo(current_procinfo).generate_code;
  1222. tcgprocinfo(current_procinfo).resetprocdef;
  1223. release_main_proc(pd);
  1224. end;
  1225. { consume the last point }
  1226. consume(_POINT);
  1227. {$ifdef New_GDB}
  1228. write_gdb_info;
  1229. {$endIf Def New_GDB}
  1230. { leave when we got an error }
  1231. if (Errorcount>0) and not status.skip_error then
  1232. begin
  1233. Message1(unit_f_errors_in_unit,tostr(Errorcount));
  1234. status.skip_error:=true;
  1235. exit;
  1236. end;
  1237. { test static symtable }
  1238. if (Errorcount=0) then
  1239. begin
  1240. tstoredsymtable(st).allsymbolsused;
  1241. tstoredsymtable(st).allunitsused;
  1242. tstoredsymtable(st).allprivatesused;
  1243. end;
  1244. { generate a list of threadvars }
  1245. InsertThreadvars;
  1246. { generate imports }
  1247. if current_module.uses_imports then
  1248. importlib.generatelib;
  1249. if islibrary or
  1250. (target_info.system in [system_i386_WIN32,system_i386_wdosx]) or
  1251. (target_info.system=system_i386_NETWARE) then
  1252. exportlib.generatelib;
  1253. { insert Tables and Heap }
  1254. insertThreadVarTablesTable;
  1255. insertResourceTablesTable;
  1256. insertinitfinaltable;
  1257. insertheap;
  1258. insertstacklength;
  1259. datasize:=symtablestack.datasize;
  1260. { finish asmlist by adding segment starts }
  1261. insertsegment;
  1262. { insert own objectfile }
  1263. insertobjectfile;
  1264. { assemble and link }
  1265. create_objectfile;
  1266. { leave when we got an error }
  1267. if (Errorcount>0) and not status.skip_error then
  1268. begin
  1269. Message1(unit_f_errors_in_unit,tostr(Errorcount));
  1270. status.skip_error:=true;
  1271. exit;
  1272. end;
  1273. { create the executable when we are at level 1 }
  1274. if (compile_level=1) then
  1275. begin
  1276. { insert all .o files from all loaded units }
  1277. hp:=tmodule(loaded_units.first);
  1278. while assigned(hp) do
  1279. begin
  1280. linker.AddModuleFiles(hp);
  1281. hp:=tmodule(hp.next);
  1282. end;
  1283. { write .def file }
  1284. if (cs_link_deffile in aktglobalswitches) then
  1285. deffile.writefile;
  1286. { finally we can create a executable }
  1287. if (not current_module.is_unit) then
  1288. begin
  1289. if DLLSource then
  1290. linker.MakeSharedLibrary
  1291. else
  1292. linker.MakeExecutable;
  1293. end;
  1294. end;
  1295. initfinalcode.free;
  1296. end;
  1297. end.
  1298. {
  1299. $Log$
  1300. Revision 1.112 2003-06-07 20:26:32 peter
  1301. * re-resolving added instead of reloading from ppu
  1302. * tderef object added to store deref info for resolving
  1303. Revision 1.111 2003/06/03 20:21:45 mazen
  1304. - removed unneeded ifdefs
  1305. - removed unneeded cases for sparc and x86_64
  1306. Revision 1.110 2003/06/03 13:01:59 daniel
  1307. * Register allocator finished
  1308. Revision 1.109 2003/05/26 21:17:17 peter
  1309. * procinlinenode removed
  1310. * aktexit2label removed, fast exit removed
  1311. + tcallnode.inlined_pass_2 added
  1312. Revision 1.108 2003/05/25 10:27:12 peter
  1313. * moved Comment calls to messge file
  1314. Revision 1.107 2003/05/22 21:31:35 peter
  1315. * defer codegeneration for nested procedures
  1316. Revision 1.106 2003/05/15 18:58:53 peter
  1317. * removed selfpointer_offset, vmtpointer_offset
  1318. * tvarsym.adjusted_address
  1319. * address in localsymtable is now in the real direction
  1320. * removed some obsolete globals
  1321. Revision 1.105 2003/05/11 19:31:28 florian
  1322. * fixed implicit init/final code for units, stack frame was wrong for ppc
  1323. Revision 1.104 2003/04/28 21:19:02 peter
  1324. * fix stabs generation for implicit initfinal
  1325. Revision 1.103 2003/04/27 11:21:34 peter
  1326. * aktprocdef renamed to current_procdef
  1327. * procinfo renamed to current_procinfo
  1328. * procinfo will now be stored in current_module so it can be
  1329. cleaned up properly
  1330. * gen_main_procsym changed to create_main_proc and release_main_proc
  1331. to also generate a tprocinfo structure
  1332. * fixed unit implicit initfinal
  1333. Revision 1.102 2003/04/27 07:29:50 peter
  1334. * current_procdef cleanup, current_procdef is now always nil when parsing
  1335. a new procdef declaration
  1336. * aktprocsym removed
  1337. * lexlevel removed, use symtable.symtablelevel instead
  1338. * implicit init/final code uses the normal genentry/genexit
  1339. * funcret state checking updated for new funcret handling
  1340. Revision 1.101 2003/04/23 12:35:34 florian
  1341. * fixed several issues with powerpc
  1342. + applied a patch from Jonas for nested function calls (PowerPC only)
  1343. * ...
  1344. Revision 1.100 2003/04/12 15:13:03 peter
  1345. * Use the original unitname when defining a unitsym
  1346. Revision 1.99 2003/03/23 23:21:42 hajny
  1347. + emx target added
  1348. Revision 1.98 2003/03/17 22:20:08 peter
  1349. *** empty log message ***
  1350. Revision 1.97 2003/03/17 13:36:39 peter
  1351. * fix import linking under linux
  1352. Revision 1.96 2003/02/19 22:00:14 daniel
  1353. * Code generator converted to new register notation
  1354. - Horribily outdated todo.txt removed
  1355. Revision 1.95 2003/02/06 22:36:55 mazen
  1356. * fixing bug related to errornous program main entry stack frame
  1357. Revision 1.94 2003/01/30 21:46:20 peter
  1358. * tai_const_symbol.createdataname added
  1359. Revision 1.93 2003/01/11 11:19:54 hajny
  1360. * correction from rev. 1.88 put back
  1361. Revision 1.92 2003/01/08 18:43:56 daniel
  1362. * Tregister changed into a record
  1363. Revision 1.91 2003/01/05 13:36:53 florian
  1364. * x86-64 compiles
  1365. + very basic support for float128 type (x86-64 only)
  1366. Revision 1.90 2002/12/29 18:17:23 peter
  1367. * insert unitsym with the name as specified in the uses list
  1368. Revision 1.89 2002/12/29 14:57:50 peter
  1369. * unit loading changed to first register units and load them
  1370. afterwards. This is needed to support uses xxx in yyy correctly
  1371. * unit dependency check fixed
  1372. Revision 1.88 2002/12/27 19:09:33 hajny
  1373. * another (hopefully final ;-) ) fix for not linked import libraries for units with no code
  1374. Revision 1.87 2002/12/24 23:32:56 peter
  1375. * Use FixFilename for specified unit sourcefile in uses
  1376. Revision 1.86 2002/12/06 16:56:58 peter
  1377. * only compile cs_fp_emulation support when cpufpuemu is defined
  1378. * define cpufpuemu for m68k only
  1379. Revision 1.85 2002/11/30 21:32:24 carl
  1380. + Add loading of softfpu in emulation mode
  1381. + Correct routine call for softfpu
  1382. * Extended type must also be defined even with softfpu
  1383. Revision 1.84 2002/11/15 01:58:53 peter
  1384. * merged changes from 1.0.7 up to 04-11
  1385. - -V option for generating bug report tracing
  1386. - more tracing for option parsing
  1387. - errors for cdecl and high()
  1388. - win32 import stabs
  1389. - win32 records<=8 are returned in eax:edx (turned off by default)
  1390. - heaptrc update
  1391. - more info for temp management in .s file with EXTDEBUG
  1392. Revision 1.83 2002/11/09 15:33:26 carl
  1393. * major alignment updates
  1394. Revision 1.82 2002/10/16 06:32:52 michael
  1395. + Renamed thread unit to systhrds
  1396. Revision 1.81 2002/10/14 19:42:34 peter
  1397. * only use init tables for threadvars
  1398. Revision 1.80 2002/10/06 19:41:30 peter
  1399. * Add finalization of typed consts
  1400. * Finalization of globals in the main program
  1401. Revision 1.79 2002/09/09 17:34:15 peter
  1402. * tdicationary.replace added to replace and item in a dictionary. This
  1403. is only allowed for the same name
  1404. * varsyms are inserted in symtable before the types are parsed. This
  1405. fixes the long standing "var longint : longint" bug
  1406. - consume_idlist and idstringlist removed. The loops are inserted
  1407. at the callers place and uses the symtable for duplicate id checking
  1408. Revision 1.78 2002/09/07 15:25:07 peter
  1409. * old logs removed and tabs fixed
  1410. Revision 1.77 2002/09/03 16:26:27 daniel
  1411. * Make Tprocdef.defs protected
  1412. Revision 1.76 2002/09/02 18:46:26 peter
  1413. * insert PASCALMAIN in library for Win32 only
  1414. Revision 1.75 2002/08/31 15:59:30 florian
  1415. + HEAP* stuff must be generated for Linux/PPC as well
  1416. + direct assembler reader searches now global and static symtables as well
  1417. Revision 1.74 2002/08/25 19:25:20 peter
  1418. * sym.insert_in_data removed
  1419. * symtable.insertvardata/insertconstdata added
  1420. * removed insert_in_data call from symtable.insert, it needs to be
  1421. called separatly. This allows to deref the address calculation
  1422. * procedures now calculate the parast addresses after the procedure
  1423. directives are parsed. This fixes the cdecl parast problem
  1424. * push_addr_param has an extra argument that specifies if cdecl is used
  1425. or not
  1426. Revision 1.73 2002/08/18 20:06:25 peter
  1427. * inlining is now also allowed in interface
  1428. * renamed write/load to ppuwrite/ppuload
  1429. * tnode storing in ppu
  1430. * nld,ncon,nbas are already updated for storing in ppu
  1431. Revision 1.72 2002/08/17 09:23:39 florian
  1432. * first part of procinfo rewrite
  1433. Revision 1.71 2002/08/11 13:24:12 peter
  1434. * saving of asmsymbols in ppu supported
  1435. * asmsymbollist global is removed and moved into a new class
  1436. tasmlibrarydata that will hold the info of a .a file which
  1437. corresponds with a single module. Added librarydata to tmodule
  1438. to keep the library info stored for the module. In the future the
  1439. objectfiles will also be stored to the tasmlibrarydata class
  1440. * all getlabel/newasmsymbol and friends are moved to the new class
  1441. Revision 1.70 2002/08/10 14:46:29 carl
  1442. + moved target_cpu_string to cpuinfo
  1443. * renamed asmmode enum.
  1444. * assembler reader has now less ifdef's
  1445. * move from nppcmem.pas -> ncgmem.pas vec. node.
  1446. Revision 1.69 2002/07/26 21:15:41 florian
  1447. * rewrote the system handling
  1448. Revision 1.68 2002/07/04 20:43:01 florian
  1449. * first x86-64 patches
  1450. Revision 1.67 2002/07/01 18:46:25 peter
  1451. * internal linker
  1452. * reorganized aasm layer
  1453. Revision 1.66 2002/05/16 19:46:43 carl
  1454. + defines.inc -> fpcdefs.inc to avoid conflicts if compiling by hand
  1455. + try to fix temp allocation (still in ifdef)
  1456. + generic constructor calls
  1457. + start of tassembler / tmodulebase class cleanup
  1458. Revision 1.65 2002/05/14 19:34:49 peter
  1459. * removed old logs and updated copyright year
  1460. Revision 1.64 2002/05/12 16:53:09 peter
  1461. * moved entry and exitcode to ncgutil and cgobj
  1462. * foreach gets extra argument for passing local data to the
  1463. iterator function
  1464. * -CR checks also class typecasts at runtime by changing them
  1465. into as
  1466. * fixed compiler to cycle with the -CR option
  1467. * fixed stabs with elf writer, finally the global variables can
  1468. be watched
  1469. * removed a lot of routines from cga unit and replaced them by
  1470. calls to cgobj
  1471. * u32bit-s32bit updates for and,or,xor nodes. When one element is
  1472. u32bit then the other is typecasted also to u32bit without giving
  1473. a rangecheck warning/error.
  1474. * fixed pascal calling method with reversing also the high tree in
  1475. the parast, detected by tcalcst3 test
  1476. Revision 1.63 2002/05/06 19:54:50 carl
  1477. + added more patches from Mazen for SPARC port
  1478. Revision 1.62 2002/04/20 21:32:24 carl
  1479. + generic FPC_CHECKPOINTER
  1480. + first parameter offset in stack now portable
  1481. * rename some constants
  1482. + move some cpu stuff to other units
  1483. - remove unused constents
  1484. * fix stacksize for some targets
  1485. * fix generic size problems which depend now on EXTEND_SIZE constant
  1486. Revision 1.61 2002/04/19 15:46:02 peter
  1487. * mangledname rewrite, tprocdef.mangledname is now created dynamicly
  1488. in most cases and not written to the ppu
  1489. * add mangeledname_prefix() routine to generate the prefix of
  1490. manglednames depending on the current procedure, object and module
  1491. * removed static procprefix since the mangledname is now build only
  1492. on demand from tprocdef.mangledname
  1493. Revision 1.60 2002/04/14 16:53:10 carl
  1494. + align code section and data section according to alignment rules
  1495. Revision 1.59 2002/04/07 17:58:38 carl
  1496. + generic stack checking
  1497. Revision 1.58 2002/04/04 19:06:03 peter
  1498. * removed unused units
  1499. * use tlocation.size in cg.a_*loc*() routines
  1500. }