rax86int.pas 80 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341
  1. {
  2. Copyright (c) 1998-2002 by Carl Eric Codere and Peter Vreman
  3. Does the parsing process for the intel styled inline assembler.
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program; if not, write to the Free Software
  14. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15. ****************************************************************************
  16. }
  17. Unit Rax86int;
  18. {$i fpcdefs.inc}
  19. interface
  20. uses
  21. cclasses,
  22. cpubase,
  23. globtype,
  24. aasmbase,
  25. rasm,
  26. rax86;
  27. type
  28. tasmtoken = (
  29. AS_NONE,AS_LABEL,AS_LLABEL,AS_STRING,AS_INTNUM,
  30. AS_COMMA,AS_LBRACKET,AS_RBRACKET,AS_LPAREN,
  31. AS_RPAREN,AS_COLON,AS_DOT,AS_PLUS,AS_MINUS,AS_STAR,
  32. AS_SEPARATOR,AS_ID,AS_REGISTER,AS_OPCODE,AS_SLASH,
  33. {------------------ Assembler directives --------------------}
  34. AS_ALIGN,AS_DB,AS_DW,AS_DD,AS_DQ,AS_END,
  35. {------------------ Assembler Operators --------------------}
  36. AS_BYTE,AS_WORD,AS_DWORD,AS_QWORD,AS_TBYTE,AS_DQWORD,AS_OWORD,AS_XMMWORD,AS_YWORD,AS_YMMWORD,AS_NEAR,AS_FAR,
  37. AS_HIGH,AS_LOW,AS_OFFSET,AS_SIZEOF,AS_VMTOFFSET,AS_SEG,AS_TYPE,AS_PTR,AS_MOD,AS_SHL,AS_SHR,AS_NOT,
  38. AS_AND,AS_OR,AS_XOR,AS_WRT,AS___GOTPCREL);
  39. type
  40. tx86intreader = class(tasmreader)
  41. actasmtoken : tasmtoken;
  42. prevasmtoken : tasmtoken;
  43. ActOpsize : topsize;
  44. inexpression : boolean;
  45. constructor create;override;
  46. function is_asmopcode(const s: string):boolean;
  47. function is_asmoperator(const s: string):boolean;
  48. function is_asmdirective(const s: string):boolean;
  49. function is_register(const s:string):boolean;
  50. function is_locallabel(const s:string):boolean;
  51. function Assemble: tlinkedlist;override;
  52. procedure GetToken;
  53. function consume(t : tasmtoken):boolean;
  54. procedure RecoverConsume(allowcomma:boolean);
  55. procedure BuildRecordOffsetSize(const expr: string;var offset:aint;var size:aint; var mangledname: string; needvmtofs: boolean);
  56. procedure BuildConstSymbolExpression(needofs,isref,startingminus:boolean;var value:aint;var asmsym:string;var asmsymtyp:TAsmsymtype);
  57. function BuildConstExpression:aint;
  58. function BuildRefConstExpression:aint;
  59. procedure BuildReference(oper : tx86operand);
  60. procedure BuildOperand(oper: tx86operand;istypecast:boolean);
  61. procedure BuildConstantOperand(oper: tx86operand);
  62. procedure BuildOpCode(instr : tx86instruction);
  63. procedure BuildConstant(constsize: byte);
  64. end;
  65. implementation
  66. uses
  67. { common }
  68. cutils,
  69. { global }
  70. globals,verbose,
  71. systems,cpuinfo,
  72. { aasm }
  73. aasmtai,aasmdata,aasmcpu,
  74. { symtable }
  75. symconst,symbase,symtype,symsym,symdef,symtable,
  76. { parser }
  77. scanner,pbase,
  78. { register allocator }
  79. rabase,rautils,itx86int,
  80. { codegen }
  81. cgbase,cgobj,procinfo
  82. ;
  83. type
  84. tasmkeyword = string[9];
  85. const
  86. { These tokens should be modified accordingly to the modifications }
  87. { in the different enumerations. }
  88. firstdirective = AS_ALIGN;
  89. lastdirective = AS_END;
  90. firstoperator = AS_BYTE;
  91. lastoperator = AS___GOTPCREL;
  92. _count_asmdirectives = longint(lastdirective)-longint(firstdirective);
  93. _count_asmoperators = longint(lastoperator)-longint(firstoperator);
  94. _asmdirectives : array[0.._count_asmdirectives] of tasmkeyword =
  95. ('ALIGN','DB','DW','DD','DQ','END');
  96. { problems with shl,shr,not,and,or and xor, they are }
  97. { context sensitive. }
  98. _asmoperators : array[0.._count_asmoperators] of tasmkeyword = (
  99. 'BYTE','WORD','DWORD','QWORD','TBYTE','DQWORD','OWORD','XMMWORD','YWORD','YMMWORD','NEAR','FAR','HIGH',
  100. 'LOW','OFFSET','SIZEOF','VMTOFFSET','SEG','TYPE','PTR','MOD','SHL','SHR','NOT','AND',
  101. 'OR','XOR','WRT','GOTPCREL');
  102. token2str : array[tasmtoken] of string[10] = (
  103. '','Label','LLabel','String','Integer',
  104. ',',',',',',',',',','[',']','(',
  105. ')',':','.','+','-','*',
  106. ';','identifier','register','opcode','/',
  107. '','','','','','END',
  108. '','','','','','','','','',
  109. '','','sizeof','vmtoffset','','type','ptr','mod','shl','shr','not',
  110. 'and','or','xor','wrt','..gotpcrel'
  111. );
  112. constructor tx86intreader.create;
  113. var
  114. i : tasmop;
  115. Begin
  116. inherited create;
  117. iasmops:=TFPHashList.create;
  118. for i:=firstop to lastop do
  119. iasmops.Add(upper(std_op2str[i]),Pointer(PtrInt(i)));
  120. end;
  121. {---------------------------------------------------------------------}
  122. { Routines for the tokenizing }
  123. {---------------------------------------------------------------------}
  124. function tx86intreader.is_asmopcode(const s: string):boolean;
  125. var
  126. cond : string[4];
  127. cnd : tasmcond;
  128. j: longint;
  129. Begin
  130. is_asmopcode:=FALSE;
  131. actopcode:=A_None;
  132. actcondition:=C_None;
  133. actopsize:=S_NO;
  134. { Search opcodes }
  135. actopcode:=tasmop(PtrUInt(iasmops.Find(s)));
  136. if actopcode<>A_NONE then
  137. begin
  138. actasmtoken:=AS_OPCODE;
  139. result:=TRUE;
  140. exit;
  141. end;
  142. { not found yet, check condition opcodes }
  143. j:=0;
  144. while (j<CondAsmOps) do
  145. begin
  146. if Copy(s,1,Length(CondAsmOpStr[j]))=CondAsmOpStr[j] then
  147. begin
  148. cond:=Copy(s,Length(CondAsmOpStr[j])+1,255);
  149. if cond<>'' then
  150. begin
  151. for cnd:=low(TasmCond) to high(TasmCond) do
  152. if Cond=Upper(cond2str[cnd]) then
  153. begin
  154. actopcode:=CondASmOp[j];
  155. actcondition:=cnd;
  156. is_asmopcode:=TRUE;
  157. actasmtoken:=AS_OPCODE;
  158. exit
  159. end;
  160. end;
  161. end;
  162. inc(j);
  163. end;
  164. end;
  165. function tx86intreader.is_asmoperator(const s: string):boolean;
  166. var
  167. i : longint;
  168. Begin
  169. for i:=0 to _count_asmoperators do
  170. if s=_asmoperators[i] then
  171. begin
  172. actasmtoken:=tasmtoken(longint(firstoperator)+i);
  173. is_asmoperator:=true;
  174. exit;
  175. end;
  176. is_asmoperator:=false;
  177. end;
  178. Function tx86intreader.is_asmdirective(const s: string):boolean;
  179. var
  180. i : longint;
  181. Begin
  182. for i:=0 to _count_asmdirectives do
  183. if s=_asmdirectives[i] then
  184. begin
  185. actasmtoken:=tasmtoken(longint(firstdirective)+i);
  186. is_asmdirective:=true;
  187. exit;
  188. end;
  189. is_asmdirective:=false;
  190. end;
  191. function tx86intreader.is_register(const s:string):boolean;
  192. var
  193. entry: TSymEntry;
  194. begin
  195. is_register:=false;
  196. actasmregister:=masm_regnum_search(lower(s));
  197. if (actasmregister=NR_NO) and
  198. (current_procinfo.procdef.proccalloption=pocall_register) and
  199. (po_assembler in current_procinfo.procdef.procoptions) then
  200. begin
  201. entry:=current_procinfo.procdef.parast.Find(s);
  202. if assigned(entry) and
  203. (entry.typ=paravarsym) and
  204. assigned(tparavarsym(entry).paraloc[calleeside].Location) and
  205. (tparavarsym(entry).paraloc[calleeside].Location^.Loc=LOC_REGISTER) then
  206. actasmregister:=tparavarsym(entry).paraloc[calleeside].Location^.register;
  207. end;
  208. if actasmregister<>NR_NO then
  209. begin
  210. is_register:=true;
  211. actasmtoken:=AS_REGISTER;
  212. end;
  213. end;
  214. function tx86intreader.is_locallabel(const s:string):boolean;
  215. begin
  216. is_locallabel:=(length(s)>1) and (s[1]='@');
  217. end;
  218. Procedure tx86intreader.GetToken;
  219. var
  220. len : longint;
  221. forcelabel : boolean;
  222. srsym : tsym;
  223. srsymtable : TSymtable;
  224. begin
  225. { save old token and reset new token }
  226. prevasmtoken:=actasmtoken;
  227. actasmtoken:=AS_NONE;
  228. { reset }
  229. forcelabel:=FALSE;
  230. actasmpattern:='';
  231. { while space and tab , continue scan... }
  232. while (c in [' ',#9]) do
  233. c:=current_scanner.asmgetchar;
  234. { get token pos }
  235. if not (c in [#10,#13,'{',';']) then
  236. current_scanner.gettokenpos;
  237. { Local Label, Label, Directive, Prefix or Opcode }
  238. if firsttoken and not (c in [#10,#13,'{',';']) then
  239. begin
  240. firsttoken:=FALSE;
  241. len:=0;
  242. while c in ['A'..'Z','a'..'z','0'..'9','_','@'] do
  243. begin
  244. { if there is an at_sign, then this must absolutely be a label }
  245. if c = '@' then
  246. forcelabel:=TRUE;
  247. inc(len);
  248. actasmpattern[len]:=c;
  249. c:=current_scanner.asmgetchar;
  250. end;
  251. actasmpattern[0]:=chr(len);
  252. uppervar(actasmpattern);
  253. { allow spaces }
  254. while (c in [' ',#9]) do
  255. c:=current_scanner.asmgetchar;
  256. { label ? }
  257. if c = ':' then
  258. begin
  259. if actasmpattern[1]='@' then
  260. actasmtoken:=AS_LLABEL
  261. else
  262. actasmtoken:=AS_LABEL;
  263. { let us point to the next character }
  264. c:=current_scanner.asmgetchar;
  265. firsttoken:=true;
  266. exit;
  267. end;
  268. { Are we trying to create an identifier with }
  269. { an at-sign...? }
  270. if forcelabel then
  271. Message(asmr_e_none_label_contain_at);
  272. { opcode ? }
  273. If is_asmopcode(actasmpattern) then
  274. Begin
  275. { check if we are in an expression }
  276. { then continue with asm directives }
  277. if not inexpression then
  278. exit;
  279. end;
  280. if is_asmdirective(actasmpattern) then
  281. exit;
  282. message1(asmr_e_unknown_opcode,actasmpattern);
  283. actasmtoken:=AS_NONE;
  284. exit;
  285. end
  286. else { else firsttoken }
  287. begin
  288. case c of
  289. '@' : { possiblities : - local label reference , such as in jmp @local1 }
  290. { - @Result, @Code or @Data special variables. }
  291. begin
  292. actasmpattern:=c;
  293. c:=current_scanner.asmgetchar;
  294. while c in ['A'..'Z','a'..'z','0'..'9','_','@'] do
  295. begin
  296. actasmpattern:=actasmpattern + c;
  297. c:=current_scanner.asmgetchar;
  298. end;
  299. uppervar(actasmpattern);
  300. actasmtoken:=AS_ID;
  301. exit;
  302. end;
  303. 'A'..'Z','a'..'z','_': { identifier, register, opcode, prefix or directive }
  304. begin
  305. actasmpattern:=c;
  306. c:=current_scanner.asmgetchar;
  307. while c in ['A'..'Z','a'..'z','0'..'9','_'] do
  308. begin
  309. actasmpattern:=actasmpattern + c;
  310. c:=current_scanner.asmgetchar;
  311. end;
  312. uppervar(actasmpattern);
  313. { after prefix we allow also a new opcode }
  314. If is_prefix(actopcode) and is_asmopcode(actasmpattern) then
  315. Begin
  316. { if we are not in a constant }
  317. { expression than this is an }
  318. { opcode. }
  319. if not inexpression then
  320. exit;
  321. end;
  322. { support st(X) for fpu registers }
  323. if (actasmpattern = 'ST') and (c='(') then
  324. Begin
  325. actasmpattern:=actasmpattern+c;
  326. c:=current_scanner.asmgetchar;
  327. { allow spaces }
  328. while (c in [' ',#9]) do
  329. c:=current_scanner.asmgetchar;
  330. if c in ['0'..'7'] then
  331. actasmpattern:=actasmpattern + c
  332. else
  333. Message(asmr_e_invalid_fpu_register);
  334. c:=current_scanner.asmgetchar;
  335. { allow spaces }
  336. while (c in [' ',#9]) do
  337. c:=current_scanner.asmgetchar;
  338. if c <> ')' then
  339. Message(asmr_e_invalid_fpu_register)
  340. else
  341. Begin
  342. actasmpattern:=actasmpattern + c;
  343. c:=current_scanner.asmgetchar;
  344. end;
  345. end;
  346. if is_asmdirective(actasmpattern) then
  347. exit;
  348. if is_asmoperator(actasmpattern) then
  349. exit;
  350. if is_register(actasmpattern) then
  351. exit;
  352. { allow spaces }
  353. while (c in [' ',#9]) do
  354. c:=current_scanner.asmgetchar;
  355. { if next is a '.' and this is a unitsym then we also need to
  356. parse the identifier }
  357. if (c='.') then
  358. begin
  359. asmsearchsym(actasmpattern,srsym,srsymtable);
  360. if assigned(srsym) and
  361. (srsym.typ=unitsym) and
  362. (srsym.owner.symtabletype in [staticsymtable,globalsymtable]) and
  363. srsym.owner.iscurrentunit then
  364. begin
  365. { Add . to create System.Identifier }
  366. actasmpattern:=actasmpattern+c;
  367. c:=current_scanner.asmgetchar;
  368. { Delphi allows System.@Halt, just ignore the @ }
  369. if c='@' then
  370. c:=current_scanner.asmgetchar;
  371. while c in ['A'..'Z','a'..'z','0'..'9','_','$'] do
  372. begin
  373. actasmpattern:=actasmpattern + upcase(c);
  374. c:=current_scanner.asmgetchar;
  375. end;
  376. end;
  377. end;
  378. actasmtoken:=AS_ID;
  379. exit;
  380. end;
  381. '''' : { string or character }
  382. begin
  383. actasmpattern:='';
  384. current_scanner.in_asm_string:=true;
  385. repeat
  386. if c = '''' then
  387. begin
  388. c:=current_scanner.asmgetchar;
  389. if c in [#10,#13] then
  390. begin
  391. Message(scan_f_string_exceeds_line);
  392. break;
  393. end;
  394. repeat
  395. if c='''' then
  396. begin
  397. c:=current_scanner.asmgetchar;
  398. if c='''' then
  399. begin
  400. actasmpattern:=actasmpattern+'''';
  401. c:=current_scanner.asmgetchar;
  402. if c in [#10,#13] then
  403. begin
  404. Message(scan_f_string_exceeds_line);
  405. break;
  406. end;
  407. end
  408. else
  409. break;
  410. end
  411. else
  412. begin
  413. actasmpattern:=actasmpattern+c;
  414. c:=current_scanner.asmgetchar;
  415. if c in [#10,#13] then
  416. begin
  417. Message(scan_f_string_exceeds_line);
  418. break
  419. end;
  420. end;
  421. until false; { end repeat }
  422. end
  423. else
  424. break; { end if }
  425. until false;
  426. current_scanner.in_asm_string:=false;
  427. actasmtoken:=AS_STRING;
  428. exit;
  429. end;
  430. '"' : { string or character }
  431. begin
  432. current_scanner.in_asm_string:=true;
  433. actasmpattern:='';
  434. repeat
  435. if c = '"' then
  436. begin
  437. c:=current_scanner.asmgetchar;
  438. if c in [#10,#13] then
  439. begin
  440. Message(scan_f_string_exceeds_line);
  441. break;
  442. end;
  443. repeat
  444. if c='"' then
  445. begin
  446. c:=current_scanner.asmgetchar;
  447. if c='"' then
  448. begin
  449. actasmpattern:=actasmpattern+'"';
  450. c:=current_scanner.asmgetchar;
  451. if c in [#10,#13] then
  452. begin
  453. Message(scan_f_string_exceeds_line);
  454. break;
  455. end;
  456. end
  457. else
  458. break;
  459. end
  460. else
  461. begin
  462. actasmpattern:=actasmpattern+c;
  463. c:=current_scanner.asmgetchar;
  464. if c in [#10,#13] then
  465. begin
  466. Message(scan_f_string_exceeds_line);
  467. break
  468. end;
  469. end;
  470. until false; { end repeat }
  471. end
  472. else
  473. break; { end if }
  474. until false;
  475. current_scanner.in_asm_string:=false;
  476. actasmtoken:=AS_STRING;
  477. exit;
  478. end;
  479. '$' :
  480. begin
  481. c:=current_scanner.asmgetchar;
  482. while c in ['0'..'9','A'..'F','a'..'f'] do
  483. begin
  484. actasmpattern:=actasmpattern + c;
  485. c:=current_scanner.asmgetchar;
  486. end;
  487. actasmpattern:=tostr(ParseVal(actasmpattern,16));
  488. actasmtoken:=AS_INTNUM;
  489. exit;
  490. end;
  491. '&' : { identifier }
  492. begin
  493. actasmpattern:='';
  494. c:=current_scanner.asmgetchar;
  495. while c in ['A'..'Z','a'..'z','0'..'9','_'] do
  496. begin
  497. actasmpattern:=actasmpattern + c;
  498. c:=current_scanner.asmgetchar;
  499. end;
  500. uppervar(actasmpattern);
  501. actasmtoken:=AS_ID;
  502. exit;
  503. end;
  504. ',' :
  505. begin
  506. actasmtoken:=AS_COMMA;
  507. c:=current_scanner.asmgetchar;
  508. exit;
  509. end;
  510. '[' :
  511. begin
  512. actasmtoken:=AS_LBRACKET;
  513. c:=current_scanner.asmgetchar;
  514. exit;
  515. end;
  516. ']' :
  517. begin
  518. actasmtoken:=AS_RBRACKET;
  519. c:=current_scanner.asmgetchar;
  520. exit;
  521. end;
  522. '(' :
  523. begin
  524. actasmtoken:=AS_LPAREN;
  525. c:=current_scanner.asmgetchar;
  526. exit;
  527. end;
  528. ')' :
  529. begin
  530. actasmtoken:=AS_RPAREN;
  531. c:=current_scanner.asmgetchar;
  532. exit;
  533. end;
  534. ':' :
  535. begin
  536. actasmtoken:=AS_COLON;
  537. c:=current_scanner.asmgetchar;
  538. exit;
  539. end;
  540. '.' :
  541. begin
  542. c:=current_scanner.asmgetchar;
  543. {$ifdef x86_64}
  544. if c='.' then
  545. begin
  546. actasmpattern:='..';
  547. c:=current_scanner.asmgetchar;
  548. repeat
  549. actasmpattern:=actasmpattern+c;
  550. c:=current_scanner.asmgetchar;
  551. until not(c in ['A'..'Z','a'..'z','0'..'9','_']);
  552. if upper(actasmpattern)<>'..GOTPCREL' then
  553. begin
  554. actasmtoken:=AS_ID;
  555. consume(AS___GOTPCREL);
  556. end;
  557. actasmtoken:=AS___GOTPCREL
  558. end
  559. else
  560. {$endif x86_64}
  561. actasmtoken:=AS_DOT;
  562. exit;
  563. end;
  564. '+' :
  565. begin
  566. actasmtoken:=AS_PLUS;
  567. c:=current_scanner.asmgetchar;
  568. exit;
  569. end;
  570. '-' :
  571. begin
  572. actasmtoken:=AS_MINUS;
  573. c:=current_scanner.asmgetchar;
  574. exit;
  575. end;
  576. '*' :
  577. begin
  578. actasmtoken:=AS_STAR;
  579. c:=current_scanner.asmgetchar;
  580. exit;
  581. end;
  582. '/' :
  583. begin
  584. actasmtoken:=AS_SLASH;
  585. c:=current_scanner.asmgetchar;
  586. exit;
  587. end;
  588. '0'..'9':
  589. begin
  590. actasmpattern:=c;
  591. c:=current_scanner.asmgetchar;
  592. { Get the possible characters }
  593. while c in ['0'..'9','A'..'F','a'..'f'] do
  594. begin
  595. actasmpattern:=actasmpattern + c;
  596. c:=current_scanner.asmgetchar;
  597. end;
  598. { Get ending character }
  599. uppervar(actasmpattern);
  600. c:=upcase(c);
  601. { possibly a binary number. }
  602. if (actasmpattern[length(actasmpattern)] = 'B') and (c <> 'H') then
  603. Begin
  604. { Delete the last binary specifier }
  605. delete(actasmpattern,length(actasmpattern),1);
  606. actasmpattern:=tostr(ParseVal(actasmpattern,2));
  607. actasmtoken:=AS_INTNUM;
  608. exit;
  609. end
  610. else
  611. Begin
  612. case c of
  613. 'O' :
  614. Begin
  615. actasmpattern:=tostr(ParseVal(actasmpattern,8));
  616. actasmtoken:=AS_INTNUM;
  617. c:=current_scanner.asmgetchar;
  618. exit;
  619. end;
  620. 'H' :
  621. Begin
  622. actasmpattern:=tostr(ParseVal(actasmpattern,16));
  623. actasmtoken:=AS_INTNUM;
  624. c:=current_scanner.asmgetchar;
  625. exit;
  626. end;
  627. else { must be an integer number }
  628. begin
  629. actasmpattern:=tostr(ParseVal(actasmpattern,10));
  630. actasmtoken:=AS_INTNUM;
  631. exit;
  632. end;
  633. end;
  634. end;
  635. end;
  636. ';','{',#13,#10 :
  637. begin
  638. c:=current_scanner.asmgetchar;
  639. firsttoken:=TRUE;
  640. actasmtoken:=AS_SEPARATOR;
  641. exit;
  642. end;
  643. else
  644. current_scanner.illegal_char(c);
  645. end;
  646. end;
  647. end;
  648. function tx86intreader.consume(t : tasmtoken):boolean;
  649. begin
  650. Consume:=true;
  651. if t<>actasmtoken then
  652. begin
  653. Message2(scan_f_syn_expected,token2str[t],token2str[actasmtoken]);
  654. Consume:=false;
  655. end;
  656. repeat
  657. gettoken;
  658. until actasmtoken<>AS_NONE;
  659. end;
  660. procedure tx86intreader.RecoverConsume(allowcomma:boolean);
  661. begin
  662. While not (actasmtoken in [AS_SEPARATOR,AS_END]) do
  663. begin
  664. if allowcomma and (actasmtoken=AS_COMMA) then
  665. break;
  666. Consume(actasmtoken);
  667. end;
  668. end;
  669. {*****************************************************************************
  670. Parsing Helpers
  671. *****************************************************************************}
  672. { This routine builds up a record offset after a AS_DOT
  673. token is encountered.
  674. On entry actasmtoken should be equal to AS_DOT }
  675. Procedure tx86intreader.BuildRecordOffsetSize(const expr: string;var offset:aint;var size:aint; var mangledname: string; needvmtofs: boolean);
  676. var
  677. s: string;
  678. Begin
  679. offset:=0;
  680. size:=0;
  681. s:=expr;
  682. while (actasmtoken=AS_DOT) do
  683. begin
  684. Consume(AS_DOT);
  685. if actasmtoken in [AS_BYTE,AS_ID,AS_WORD,AS_DWORD,AS_QWORD,AS_OWORD,AS_XMMWORD,AS_YWORD,AS_YMMWORD,AS_REGISTER] then
  686. begin
  687. s:=s+'.'+actasmpattern;
  688. consume(actasmtoken);
  689. end
  690. else
  691. begin
  692. Consume(AS_ID);
  693. RecoverConsume(true);
  694. break;
  695. end;
  696. end;
  697. if not GetRecordOffsetSize(s,offset,size,mangledname,needvmtofs) then
  698. Message(asmr_e_building_record_offset);
  699. end;
  700. Procedure tx86intreader.BuildConstSymbolExpression(needofs,isref,startingminus:boolean;var value:aint;var asmsym:string;var asmsymtyp:TAsmsymtype);
  701. var
  702. tempstr,expr,hs,mangledname : string;
  703. parenlevel : longint;
  704. l,k : aint;
  705. hasparen,
  706. errorflag,
  707. needvmtofs : boolean;
  708. prevtok : tasmtoken;
  709. hl : tasmlabel;
  710. hssymtyp : Tasmsymtype;
  711. def : tdef;
  712. sym : tsym;
  713. srsymtable : TSymtable;
  714. Begin
  715. { reset }
  716. value:=0;
  717. asmsym:='';
  718. asmsymtyp:=AT_DATA;
  719. errorflag:=FALSE;
  720. tempstr:='';
  721. expr:='';
  722. if startingminus then
  723. expr:='-';
  724. inexpression:=TRUE;
  725. parenlevel:=0;
  726. sym:=nil;
  727. needvmtofs:=FALSE;
  728. Repeat
  729. { Support ugly delphi constructs like: [ECX].1+2[EDX] }
  730. if isref and (actasmtoken=AS_LBRACKET) then
  731. break;
  732. Case actasmtoken of
  733. AS_LPAREN:
  734. Begin
  735. Consume(AS_LPAREN);
  736. expr:=expr + '(';
  737. inc(parenlevel);
  738. end;
  739. AS_RPAREN:
  740. Begin
  741. { Keep the AS_PAREN in actasmtoken, it is maybe a typecast }
  742. if parenlevel=0 then
  743. break;
  744. Consume(AS_RPAREN);
  745. expr:=expr + ')';
  746. dec(parenlevel);
  747. end;
  748. AS_SHL:
  749. Begin
  750. Consume(AS_SHL);
  751. expr:=expr + '<';
  752. end;
  753. AS_SHR:
  754. Begin
  755. Consume(AS_SHR);
  756. expr:=expr + '>';
  757. end;
  758. AS_SLASH:
  759. Begin
  760. Consume(AS_SLASH);
  761. expr:=expr + '/';
  762. end;
  763. AS_MOD:
  764. Begin
  765. Consume(AS_MOD);
  766. expr:=expr + '%';
  767. end;
  768. AS_STAR:
  769. Begin
  770. Consume(AS_STAR);
  771. if isref and (actasmtoken=AS_REGISTER) then
  772. break;
  773. expr:=expr + '*';
  774. end;
  775. AS_PLUS:
  776. Begin
  777. Consume(AS_PLUS);
  778. if isref and (actasmtoken=AS_REGISTER) then
  779. break;
  780. expr:=expr + '+';
  781. end;
  782. AS_MINUS:
  783. Begin
  784. Consume(AS_MINUS);
  785. expr:=expr + '-';
  786. end;
  787. AS_AND:
  788. Begin
  789. Consume(AS_AND);
  790. expr:=expr + '&';
  791. end;
  792. AS_NOT:
  793. Begin
  794. Consume(AS_NOT);
  795. expr:=expr + '~';
  796. end;
  797. AS_XOR:
  798. Begin
  799. Consume(AS_XOR);
  800. expr:=expr + '^';
  801. end;
  802. AS_OR:
  803. Begin
  804. Consume(AS_OR);
  805. expr:=expr + '|';
  806. end;
  807. AS_INTNUM:
  808. Begin
  809. expr:=expr + actasmpattern;
  810. Consume(AS_INTNUM);
  811. end;
  812. AS_VMTOFFSET,
  813. AS_OFFSET:
  814. begin
  815. if (actasmtoken = AS_OFFSET) then
  816. needofs:=true
  817. else
  818. needvmtofs:=true;
  819. Consume(actasmtoken);
  820. if actasmtoken<>AS_ID then
  821. Message(asmr_e_offset_without_identifier);
  822. end;
  823. AS_SIZEOF,
  824. AS_TYPE:
  825. begin
  826. l:=0;
  827. hasparen:=false;
  828. Consume(actasmtoken);
  829. if actasmtoken=AS_LPAREN then
  830. begin
  831. hasparen:=true;
  832. Consume(AS_LPAREN);
  833. end;
  834. if actasmtoken<>AS_ID then
  835. Message(asmr_e_type_without_identifier)
  836. else
  837. begin
  838. tempstr:=actasmpattern;
  839. Consume(AS_ID);
  840. if actasmtoken=AS_DOT then
  841. begin
  842. BuildRecordOffsetSize(tempstr,k,l,mangledname,false);
  843. if mangledname<>'' then
  844. { procsym }
  845. Message(asmr_e_wrong_sym_type);
  846. end
  847. else
  848. begin
  849. asmsearchsym(tempstr,sym,srsymtable);
  850. if assigned(sym) then
  851. begin
  852. case sym.typ of
  853. staticvarsym,
  854. localvarsym,
  855. paravarsym :
  856. l:=tabstractvarsym(sym).getsize;
  857. typesym :
  858. l:=ttypesym(sym).typedef.size;
  859. else
  860. Message(asmr_e_wrong_sym_type);
  861. end;
  862. end
  863. else
  864. Message1(sym_e_unknown_id,tempstr);
  865. end;
  866. end;
  867. str(l, tempstr);
  868. expr:=expr + tempstr;
  869. if hasparen then
  870. Consume(AS_RPAREN);
  871. end;
  872. AS_PTR :
  873. begin
  874. { Support ugly delphi constructs like <constant> PTR [ref] }
  875. break;
  876. end;
  877. AS_STRING:
  878. begin
  879. l:=0;
  880. case Length(actasmpattern) of
  881. 1 :
  882. l:=ord(actasmpattern[1]);
  883. 2 :
  884. l:=ord(actasmpattern[2]) + ord(actasmpattern[1]) shl 8;
  885. 3 :
  886. l:=ord(actasmpattern[3]) +
  887. Ord(actasmpattern[2]) shl 8 + ord(actasmpattern[1]) shl 16;
  888. 4 :
  889. l:=ord(actasmpattern[4]) + ord(actasmpattern[3]) shl 8 +
  890. Ord(actasmpattern[2]) shl 16 + ord(actasmpattern[1]) shl 24;
  891. else
  892. Message1(asmr_e_invalid_string_as_opcode_operand,actasmpattern);
  893. end;
  894. str(l, tempstr);
  895. expr:=expr + tempstr;
  896. Consume(AS_STRING);
  897. end;
  898. AS_ID:
  899. begin
  900. hs:='';
  901. hssymtyp:=AT_DATA;
  902. def:=nil;
  903. tempstr:=actasmpattern;
  904. prevtok:=prevasmtoken;
  905. { stop parsing a constant expression if we find an opcode after a
  906. non-operator like "db $66 mov eax,ebx" }
  907. if (prevtok in [AS_ID,AS_INTNUM,AS_RPAREN]) and
  908. is_asmopcode(actasmpattern) then
  909. break;
  910. consume(AS_ID);
  911. if SearchIConstant(tempstr,l) then
  912. begin
  913. str(l, tempstr);
  914. expr:=expr + tempstr;
  915. end
  916. else
  917. begin
  918. if is_locallabel(tempstr) then
  919. begin
  920. CreateLocalLabel(tempstr,hl,false);
  921. hs:=hl.name;
  922. hssymtyp:=AT_FUNCTION;
  923. end
  924. else
  925. if SearchLabel(tempstr,hl,false) then
  926. begin
  927. hs:=hl.name;
  928. hssymtyp:=AT_FUNCTION;
  929. end
  930. else
  931. begin
  932. asmsearchsym(tempstr,sym,srsymtable);
  933. if assigned(sym) then
  934. begin
  935. case sym.typ of
  936. staticvarsym :
  937. begin
  938. hs:=tstaticvarsym(sym).mangledname;
  939. def:=tstaticvarsym(sym).vardef;
  940. end;
  941. localvarsym,
  942. paravarsym :
  943. begin
  944. Message(asmr_e_no_local_or_para_allowed);
  945. end;
  946. procsym :
  947. begin
  948. if Tprocsym(sym).ProcdefList.Count>1 then
  949. Message(asmr_w_calling_overload_func);
  950. hs:=tprocdef(tprocsym(sym).ProcdefList[0]).mangledname;
  951. hssymtyp:=AT_FUNCTION;
  952. end;
  953. typesym :
  954. begin
  955. if not(ttypesym(sym).typedef.typ in [recorddef,objectdef]) then
  956. Message(asmr_e_wrong_sym_type);
  957. end;
  958. fieldvarsym :
  959. begin
  960. tempstr:=upper(tdef(sym.owner.defowner).GetTypeName)+'.'+tempstr;
  961. end;
  962. else
  963. Message(asmr_e_wrong_sym_type);
  964. end;
  965. end
  966. else
  967. Message1(sym_e_unknown_id,tempstr);
  968. end;
  969. { symbol found? }
  970. if hs<>'' then
  971. begin
  972. if asmsym='' then
  973. begin
  974. asmsym:=hs;
  975. asmsymtyp:=hssymtyp;
  976. end
  977. else
  978. Message(asmr_e_cant_have_multiple_relocatable_symbols);
  979. if (expr='') or (expr[length(expr)]='+') then
  980. begin
  981. { don't remove the + if there could be a record field }
  982. if actasmtoken<>AS_DOT then
  983. delete(expr,length(expr),1);
  984. end
  985. else
  986. if needofs then
  987. begin
  988. if (prevtok<>AS_OFFSET) then
  989. Message(asmr_e_need_offset);
  990. end
  991. else
  992. Message(asmr_e_only_add_relocatable_symbol);
  993. end;
  994. if (actasmtoken=AS_DOT) or
  995. (assigned(sym) and
  996. (sym.typ = fieldvarsym)) then
  997. begin
  998. BuildRecordOffsetSize(tempstr,l,k,hs,needvmtofs);
  999. if hs <> '' then
  1000. hssymtyp:=AT_FUNCTION
  1001. else
  1002. begin
  1003. str(l, tempstr);
  1004. expr:=expr + tempstr;
  1005. end
  1006. end
  1007. else
  1008. begin
  1009. if (expr='') or (expr[length(expr)] in ['+','-','/','*']) then
  1010. delete(expr,length(expr),1);
  1011. end;
  1012. if (actasmtoken=AS_LBRACKET) and
  1013. assigned(def) and
  1014. (def.typ=arraydef) then
  1015. begin
  1016. consume(AS_LBRACKET);
  1017. l:=BuildConstExpression;
  1018. if l<tarraydef(def).lowrange then
  1019. begin
  1020. Message(asmr_e_constant_out_of_bounds);
  1021. l:=0;
  1022. end
  1023. else
  1024. l:=(l-tarraydef(def).lowrange)*tarraydef(def).elesize;
  1025. str(l, tempstr);
  1026. expr:=expr + '+' + tempstr;
  1027. consume(AS_RBRACKET);
  1028. end;
  1029. end;
  1030. { check if there are wrong operator used like / or mod etc. }
  1031. if (hs<>'') and not(actasmtoken in [AS_MINUS,AS_PLUS,AS_COMMA,AS_SEPARATOR,AS_END,AS_RBRACKET]) then
  1032. Message(asmr_e_only_add_relocatable_symbol);
  1033. end;
  1034. AS_ALIGN,
  1035. AS_DB,
  1036. AS_DW,
  1037. AS_DD,
  1038. AS_DQ,
  1039. AS_END,
  1040. AS_RBRACKET,
  1041. AS_SEPARATOR,
  1042. AS_COMMA,
  1043. AS_COLON:
  1044. break;
  1045. else
  1046. begin
  1047. { write error only once. }
  1048. if not errorflag then
  1049. Message(asmr_e_invalid_constant_expression);
  1050. { consume tokens until we find COMMA or SEPARATOR }
  1051. Consume(actasmtoken);
  1052. errorflag:=TRUE;
  1053. end;
  1054. end;
  1055. Until false;
  1056. { calculate expression }
  1057. if not ErrorFlag then
  1058. value:=CalculateExpression(expr)
  1059. else
  1060. value:=0;
  1061. { no longer in an expression }
  1062. inexpression:=FALSE;
  1063. end;
  1064. Function tx86intreader.BuildConstExpression:aint;
  1065. var
  1066. l : aint;
  1067. hs : string;
  1068. hssymtyp : TAsmsymtype;
  1069. begin
  1070. BuildConstSymbolExpression(false,false,false,l,hs,hssymtyp);
  1071. if hs<>'' then
  1072. Message(asmr_e_relocatable_symbol_not_allowed);
  1073. BuildConstExpression:=l;
  1074. end;
  1075. Function tx86intreader.BuildRefConstExpression:aint;
  1076. var
  1077. l : aint;
  1078. hs : string;
  1079. hssymtyp : TAsmsymtype;
  1080. begin
  1081. BuildConstSymbolExpression(false,true,false,l,hs,hssymtyp);
  1082. if hs<>'' then
  1083. Message(asmr_e_relocatable_symbol_not_allowed);
  1084. BuildRefConstExpression:=l;
  1085. end;
  1086. procedure tx86intreader.BuildReference(oper : tx86operand);
  1087. var
  1088. scale : byte;
  1089. k,l : aint;
  1090. tempstr,hs : string;
  1091. tempsymtyp : tasmsymtype;
  1092. code : integer;
  1093. hreg : tregister;
  1094. GotStar,GotOffset,HadVar,
  1095. GotPlus,Negative : boolean;
  1096. hl : tasmlabel;
  1097. Begin
  1098. Consume(AS_LBRACKET);
  1099. if not(oper.opr.typ in [OPR_LOCAL,OPR_REFERENCE]) then
  1100. oper.InitRef;
  1101. GotStar:=false;
  1102. GotPlus:=true;
  1103. GotOffset:=false;
  1104. Negative:=false;
  1105. Scale:=0;
  1106. repeat
  1107. if GotOffset and (actasmtoken<>AS_ID) then
  1108. Message(asmr_e_invalid_reference_syntax);
  1109. Case actasmtoken of
  1110. AS_ID, { Constant reference expression OR variable reference expression }
  1111. AS_VMTOFFSET:
  1112. Begin
  1113. if not GotPlus then
  1114. Message(asmr_e_invalid_reference_syntax);
  1115. GotStar:=false;
  1116. GotPlus:=false;
  1117. if (actasmtoken = AS_VMTOFFSET) or
  1118. (SearchIConstant(actasmpattern,l) or
  1119. SearchRecordType(actasmpattern)) then
  1120. begin
  1121. l:=BuildRefConstExpression;
  1122. GotPlus:=(prevasmtoken=AS_PLUS);
  1123. GotStar:=(prevasmtoken=AS_STAR);
  1124. case oper.opr.typ of
  1125. OPR_LOCAL :
  1126. begin
  1127. if GotStar then
  1128. Message(asmr_e_invalid_reference_syntax);
  1129. if negative then
  1130. Dec(oper.opr.localsymofs,l)
  1131. else
  1132. Inc(oper.opr.localsymofs,l);
  1133. end;
  1134. OPR_REFERENCE :
  1135. begin
  1136. if GotStar then
  1137. oper.opr.ref.scalefactor:=l
  1138. else
  1139. begin
  1140. if negative then
  1141. Dec(oper.opr.ref.offset,l)
  1142. else
  1143. Inc(oper.opr.ref.offset,l);
  1144. end;
  1145. end;
  1146. end;
  1147. end
  1148. else
  1149. Begin
  1150. if negative and not oper.hasvar then
  1151. Message(asmr_e_only_add_relocatable_symbol)
  1152. else if oper.hasvar and not GotOffset and
  1153. (not negative or assigned(oper.opr.ref.relsymbol)) then
  1154. Message(asmr_e_cant_have_multiple_relocatable_symbols);
  1155. HadVar:=oper.hasvar and GotOffset;
  1156. tempstr:=actasmpattern;
  1157. Consume(AS_ID);
  1158. { typecasting? }
  1159. if (actasmtoken=AS_LPAREN) and
  1160. SearchType(tempstr,l) then
  1161. begin
  1162. oper.hastype:=true;
  1163. oper.typesize:=l;
  1164. Consume(AS_LPAREN);
  1165. BuildOperand(oper,true);
  1166. Consume(AS_RPAREN);
  1167. end
  1168. else
  1169. if is_locallabel(tempstr) then
  1170. begin
  1171. CreateLocalLabel(tempstr,hl,false);
  1172. oper.InitRef;
  1173. if not negative then
  1174. begin
  1175. oper.opr.ref.symbol:=hl;
  1176. oper.hasvar:=true;
  1177. end
  1178. else
  1179. oper.opr.ref.relsymbol:=hl;
  1180. end
  1181. else
  1182. if oper.SetupVar(tempstr,GotOffset) then
  1183. begin
  1184. { force OPR_LOCAL to be a reference }
  1185. if oper.opr.typ=OPR_LOCAL then
  1186. oper.opr.localforceref:=true
  1187. else
  1188. begin
  1189. {$ifdef x86_64}
  1190. if actasmtoken=AS_WRT then
  1191. begin
  1192. if (oper.opr.typ=OPR_REFERENCE) then
  1193. begin
  1194. Consume(AS_WRT);
  1195. Consume(AS___GOTPCREL);
  1196. if (oper.opr.ref.base<>NR_NO) or
  1197. (oper.opr.ref.index<>NR_NO) or
  1198. (oper.opr.ref.offset<>0) then
  1199. Message(asmr_e_wrong_gotpcrel_intel_syntax);
  1200. if tf_no_pic_supported in target_info.flags then
  1201. Message(asmr_e_no_gotpcrel_support);
  1202. oper.opr.ref.refaddr:=addr_pic;
  1203. oper.opr.ref.base:=NR_RIP;
  1204. end
  1205. else
  1206. message(asmr_e_invalid_reference_syntax);
  1207. end;
  1208. {$endif x86_64}
  1209. end;
  1210. end
  1211. else
  1212. Message1(sym_e_unknown_id,tempstr);
  1213. { record.field ? }
  1214. if actasmtoken=AS_DOT then
  1215. begin
  1216. BuildRecordOffsetSize(tempstr,l,k,hs,false);
  1217. if (hs<>'') then
  1218. Message(asmr_e_invalid_symbol_ref);
  1219. case oper.opr.typ of
  1220. OPR_LOCAL :
  1221. inc(oper.opr.localsymofs,l);
  1222. OPR_REFERENCE :
  1223. inc(oper.opr.ref.offset,l);
  1224. end;
  1225. oper.SetSize(k,false);
  1226. end;
  1227. if GotOffset then
  1228. begin
  1229. if oper.hasvar and (oper.opr.ref.base=current_procinfo.framepointer) then
  1230. begin
  1231. if (oper.opr.typ=OPR_REFERENCE) then
  1232. oper.opr.ref.base:=NR_NO;
  1233. oper.hasvar:=hadvar;
  1234. end
  1235. else
  1236. begin
  1237. if oper.hasvar and hadvar then
  1238. Message(asmr_e_cant_have_multiple_relocatable_symbols);
  1239. { should we allow ?? }
  1240. end;
  1241. end;
  1242. end;
  1243. GotOffset:=false;
  1244. end;
  1245. AS_PLUS :
  1246. Begin
  1247. Consume(AS_PLUS);
  1248. Negative:=false;
  1249. GotPlus:=true;
  1250. GotStar:=false;
  1251. Scale:=0;
  1252. end;
  1253. AS_DOT :
  1254. Begin
  1255. { Handle like a + }
  1256. Consume(AS_DOT);
  1257. Negative:=false;
  1258. GotPlus:=true;
  1259. GotStar:=false;
  1260. Scale:=0;
  1261. end;
  1262. AS_MINUS :
  1263. begin
  1264. Consume(AS_MINUS);
  1265. Negative:=true;
  1266. GotPlus:=true;
  1267. GotStar:=false;
  1268. Scale:=0;
  1269. end;
  1270. AS_STAR : { Scaling, with eax*4 order }
  1271. begin
  1272. Consume(AS_STAR);
  1273. hs:='';
  1274. l:=0;
  1275. case actasmtoken of
  1276. AS_LPAREN :
  1277. l:=BuildConstExpression;
  1278. AS_INTNUM:
  1279. Begin
  1280. hs:=actasmpattern;
  1281. Consume(AS_INTNUM);
  1282. end;
  1283. AS_REGISTER :
  1284. begin
  1285. case oper.opr.typ of
  1286. OPR_REFERENCE :
  1287. begin
  1288. if oper.opr.ref.scalefactor=0 then
  1289. begin
  1290. if scale<>0 then
  1291. begin
  1292. oper.opr.ref.scalefactor:=scale;
  1293. scale:=0;
  1294. end
  1295. else
  1296. Message(asmr_e_wrong_scale_factor);
  1297. end
  1298. else
  1299. Message(asmr_e_invalid_reference_syntax);
  1300. end;
  1301. OPR_LOCAL :
  1302. begin
  1303. if oper.opr.localscale=0 then
  1304. begin
  1305. if scale<>0 then
  1306. begin
  1307. oper.opr.localscale:=scale;
  1308. scale:=0;
  1309. end
  1310. else
  1311. Message(asmr_e_wrong_scale_factor);
  1312. end
  1313. else
  1314. Message(asmr_e_invalid_reference_syntax);
  1315. end;
  1316. end;
  1317. end;
  1318. else
  1319. Message(asmr_e_invalid_reference_syntax);
  1320. end;
  1321. if actasmtoken<>AS_REGISTER then
  1322. begin
  1323. if hs<>'' then
  1324. val(hs,l,code);
  1325. case oper.opr.typ of
  1326. OPR_REFERENCE :
  1327. oper.opr.ref.scalefactor:=l;
  1328. OPR_LOCAL :
  1329. oper.opr.localscale:=l;
  1330. end;
  1331. if l>9 then
  1332. Message(asmr_e_wrong_scale_factor);
  1333. end;
  1334. GotPlus:=false;
  1335. GotStar:=false;
  1336. end;
  1337. AS_REGISTER :
  1338. begin
  1339. if not((GotPlus and (not Negative)) or
  1340. GotStar) then
  1341. Message(asmr_e_invalid_reference_syntax);
  1342. hreg:=actasmregister;
  1343. Consume(AS_REGISTER);
  1344. { this register will be the index:
  1345. 1. just read a *
  1346. 2. next token is a *
  1347. 3. base register is already used }
  1348. case oper.opr.typ of
  1349. OPR_LOCAL :
  1350. begin
  1351. if (oper.opr.localindexreg<>NR_NO) then
  1352. Message(asmr_e_multiple_index);
  1353. oper.opr.localindexreg:=hreg;
  1354. if scale<>0 then
  1355. begin
  1356. oper.opr.localscale:=scale;
  1357. scale:=0;
  1358. end;
  1359. end;
  1360. OPR_REFERENCE :
  1361. begin
  1362. if (GotStar) or
  1363. (actasmtoken=AS_STAR) or
  1364. (oper.opr.ref.base<>NR_NO) then
  1365. begin
  1366. if (oper.opr.ref.index<>NR_NO) then
  1367. Message(asmr_e_multiple_index);
  1368. oper.opr.ref.index:=hreg;
  1369. if scale<>0 then
  1370. begin
  1371. oper.opr.ref.scalefactor:=scale;
  1372. scale:=0;
  1373. end;
  1374. end
  1375. else
  1376. begin
  1377. oper.opr.ref.base:=hreg;
  1378. {$ifdef x86_64}
  1379. { non-GOT based RIP-relative accesses are also position-independent }
  1380. if (oper.opr.ref.base=NR_RIP) and
  1381. (oper.opr.ref.refaddr<>addr_pic) then
  1382. oper.opr.ref.refaddr:=addr_pic_no_got;
  1383. {$endif x86_64}
  1384. end;
  1385. end;
  1386. end;
  1387. GotPlus:=false;
  1388. GotStar:=false;
  1389. end;
  1390. AS_OFFSET :
  1391. begin
  1392. Consume(AS_OFFSET);
  1393. GotOffset:=true;
  1394. end;
  1395. AS_TYPE,
  1396. AS_NOT,
  1397. AS_STRING,
  1398. AS_INTNUM,
  1399. AS_LPAREN : { Constant reference expression }
  1400. begin
  1401. if not GotPlus and not GotStar then
  1402. Message(asmr_e_invalid_reference_syntax);
  1403. BuildConstSymbolExpression(true,true,GotPlus and negative,l,tempstr,tempsymtyp);
  1404. { already handled by BuildConstSymbolExpression(); must be
  1405. handled there to avoid [reg-1+1] being interpreted as
  1406. [reg-(1+1)] }
  1407. negative:=false;
  1408. if tempstr<>'' then
  1409. begin
  1410. if GotStar then
  1411. Message(asmr_e_only_add_relocatable_symbol);
  1412. if not assigned(oper.opr.ref.symbol) then
  1413. oper.opr.ref.symbol:=current_asmdata.RefAsmSymbol(tempstr)
  1414. else
  1415. Message(asmr_e_cant_have_multiple_relocatable_symbols);
  1416. end;
  1417. case oper.opr.typ of
  1418. OPR_REFERENCE :
  1419. begin
  1420. if GotStar then
  1421. oper.opr.ref.scalefactor:=l
  1422. else if (prevasmtoken = AS_STAR) then
  1423. begin
  1424. if scale<>0 then
  1425. scale:=l*scale
  1426. else
  1427. scale:=l;
  1428. end
  1429. else
  1430. begin
  1431. Inc(oper.opr.ref.offset,l);
  1432. Inc(oper.opr.constoffset,l);
  1433. end;
  1434. end;
  1435. OPR_LOCAL :
  1436. begin
  1437. if GotStar then
  1438. oper.opr.localscale:=l
  1439. else if (prevasmtoken = AS_STAR) then
  1440. begin
  1441. if scale<>0 then
  1442. scale:=l*scale
  1443. else
  1444. scale:=l;
  1445. end
  1446. else
  1447. Inc(oper.opr.localsymofs,l);
  1448. end;
  1449. end;
  1450. GotPlus:=(prevasmtoken=AS_PLUS) or
  1451. (prevasmtoken=AS_MINUS);
  1452. if GotPlus then
  1453. negative := prevasmtoken = AS_MINUS;
  1454. GotStar:=(prevasmtoken=AS_STAR);
  1455. end;
  1456. AS_RBRACKET :
  1457. begin
  1458. if GotPlus or GotStar then
  1459. Message(asmr_e_invalid_reference_syntax);
  1460. Consume(AS_RBRACKET);
  1461. break;
  1462. end;
  1463. else
  1464. Begin
  1465. Message(asmr_e_invalid_reference_syntax);
  1466. RecoverConsume(true);
  1467. break;
  1468. end;
  1469. end;
  1470. until false;
  1471. end;
  1472. Procedure tx86intreader.BuildConstantOperand(oper: tx86operand);
  1473. var
  1474. l : aint;
  1475. tempstr : string;
  1476. tempsymtyp : tasmsymtype;
  1477. begin
  1478. if not (oper.opr.typ in [OPR_NONE,OPR_CONSTANT]) then
  1479. Message(asmr_e_invalid_operand_type);
  1480. BuildConstSymbolExpression(true,false,false,l,tempstr,tempsymtyp);
  1481. if tempstr<>'' then
  1482. begin
  1483. oper.opr.typ:=OPR_SYMBOL;
  1484. oper.opr.symofs:=l;
  1485. oper.opr.symbol:=current_asmdata.RefAsmSymbol(tempstr);
  1486. end
  1487. else
  1488. if oper.opr.typ=OPR_NONE then
  1489. begin
  1490. oper.opr.typ:=OPR_CONSTANT;
  1491. oper.opr.val:=l;
  1492. end
  1493. else
  1494. inc(oper.opr.val,l);
  1495. end;
  1496. Procedure tx86intreader.BuildOperand(oper: tx86operand;istypecast:boolean);
  1497. procedure AddLabelOperand(hl:tasmlabel);
  1498. begin
  1499. if (oper.opr.typ=OPR_NONE) and
  1500. is_calljmp(actopcode) then
  1501. begin
  1502. oper.opr.typ:=OPR_SYMBOL;
  1503. oper.opr.symbol:=hl;
  1504. end
  1505. else
  1506. begin
  1507. oper.InitRef;
  1508. oper.opr.ref.symbol:=hl;
  1509. end;
  1510. end;
  1511. var
  1512. expr,
  1513. hs : string;
  1514. tempreg : tregister;
  1515. l : aint;
  1516. hl : tasmlabel;
  1517. toffset,
  1518. tsize : aint;
  1519. begin
  1520. expr:='';
  1521. repeat
  1522. if actasmtoken=AS_DOT then
  1523. begin
  1524. if expr<>'' then
  1525. begin
  1526. BuildRecordOffsetSize(expr,toffset,tsize,hs,false);
  1527. if (oper.opr.typ<>OPR_NONE) and
  1528. (hs<>'') then
  1529. Message(asmr_e_wrong_sym_type);
  1530. oper.SetSize(tsize,true);
  1531. { we have used the size of a field. Reset the typesize of the record }
  1532. oper.typesize:=0;
  1533. case oper.opr.typ of
  1534. OPR_LOCAL :
  1535. begin
  1536. { don't allow direct access to fields of parameters, because that
  1537. will generate buggy code. Allow it only for explicit typecasting
  1538. and when the parameter is in a register (delphi compatible) }
  1539. if (not oper.hastype) and
  1540. (oper.opr.localsym.owner.symtabletype=parasymtable) and
  1541. (current_procinfo.procdef.proccalloption<>pocall_register) then
  1542. Message(asmr_e_cannot_access_field_directly_for_parameters);
  1543. inc(oper.opr.localsymofs,toffset);
  1544. oper.opr.localvarsize := tsize;
  1545. end;
  1546. OPR_CONSTANT :
  1547. inc(oper.opr.val,toffset);
  1548. OPR_REFERENCE :
  1549. begin
  1550. inc(oper.opr.ref.offset,toffset);
  1551. oper.opr.varsize := tsize;
  1552. end;
  1553. OPR_NONE :
  1554. begin
  1555. if (hs <> '') then
  1556. begin
  1557. oper.opr.typ:=OPR_SYMBOL;
  1558. oper.opr.symbol:=current_asmdata.RefAsmSymbol(hs);
  1559. end
  1560. else
  1561. begin
  1562. oper.opr.typ:=OPR_CONSTANT;
  1563. oper.opr.val:=toffset;
  1564. end;
  1565. end;
  1566. OPR_REGISTER :
  1567. Message(asmr_e_invalid_reference_syntax);
  1568. OPR_SYMBOL:
  1569. Message(asmr_e_invalid_symbol_ref);
  1570. else
  1571. internalerror(200309222);
  1572. end;
  1573. expr:='';
  1574. end
  1575. else
  1576. begin
  1577. { See it as a separator }
  1578. Consume(AS_DOT);
  1579. end;
  1580. end;
  1581. case actasmtoken of
  1582. AS_OFFSET,
  1583. AS_SIZEOF,
  1584. AS_VMTOFFSET,
  1585. AS_TYPE,
  1586. AS_NOT,
  1587. AS_STRING,
  1588. AS_PLUS,
  1589. AS_MINUS,
  1590. AS_LPAREN,
  1591. AS_INTNUM :
  1592. begin
  1593. case oper.opr.typ of
  1594. OPR_REFERENCE :
  1595. {$ifndef x86_64}
  1596. { this is for the i386 scenario where you have
  1597. <load got into ebx>
  1598. mov eax, [ebx].offset globalvar
  1599. x86-64 uses RIP-based addresses (both for GOT and non-GOT
  1600. relative accesses)
  1601. }
  1602. if (actasmtoken=AS_OFFSET) and
  1603. (cs_create_pic in current_settings.moduleswitches) then
  1604. begin
  1605. Consume(AS_OFFSET);
  1606. oper.opr.ref.refaddr:=addr_pic;
  1607. BuildOperand(oper,false);
  1608. end
  1609. else
  1610. {$endif x86_64}
  1611. begin
  1612. l := BuildRefConstExpression;
  1613. inc(oper.opr.ref.offset,l);
  1614. inc(oper.opr.constoffset,l);
  1615. end;
  1616. OPR_LOCAL :
  1617. begin
  1618. l := BuildConstExpression;
  1619. inc(oper.opr.localsymofs,l);
  1620. inc(oper.opr.localconstoffset,l);
  1621. end;
  1622. OPR_NONE,
  1623. OPR_CONSTANT :
  1624. BuildConstantOperand(oper);
  1625. else
  1626. Message(asmr_e_invalid_operand_type);
  1627. end;
  1628. end;
  1629. AS_PTR :
  1630. begin
  1631. if not oper.hastype then
  1632. begin
  1633. if (oper.opr.typ=OPR_CONSTANT) then
  1634. begin
  1635. oper.typesize:=oper.opr.val;
  1636. { reset constant value of operand }
  1637. oper.opr.typ:=OPR_NONE;
  1638. oper.opr.val:=0;
  1639. end
  1640. else
  1641. Message(asmr_e_syn_operand);
  1642. end;
  1643. Consume(AS_PTR);
  1644. oper.InitRef;
  1645. { if the operand subscripts a record, the typesize will be
  1646. rest -> save it here and restore it afterwards }
  1647. l:=oper.typesize;
  1648. BuildOperand(oper,false);
  1649. oper.setsize(l,true);
  1650. end;
  1651. AS_ID : { A constant expression, or a Variable ref. }
  1652. Begin
  1653. { Label or Special symbol reference? }
  1654. if actasmpattern[1] = '@' then
  1655. Begin
  1656. if actasmpattern = '@RESULT' then
  1657. Begin
  1658. oper.SetupResult;
  1659. Consume(AS_ID);
  1660. end
  1661. else
  1662. if (actasmpattern = '@CODE') or (actasmpattern = '@DATA') then
  1663. begin
  1664. Message(asmr_w_CODE_and_DATA_not_supported);
  1665. Consume(AS_ID);
  1666. end
  1667. else
  1668. { Local Label }
  1669. begin
  1670. CreateLocalLabel(actasmpattern,hl,false);
  1671. Consume(AS_ID);
  1672. AddLabelOperand(hl);
  1673. end;
  1674. end
  1675. else
  1676. { support result for delphi modes }
  1677. if (m_objpas in current_settings.modeswitches) and (actasmpattern='RESULT') then
  1678. begin
  1679. oper.SetUpResult;
  1680. Consume(AS_ID);
  1681. end
  1682. { probably a variable or normal expression }
  1683. { or a procedure (such as in CALL ID) }
  1684. else
  1685. Begin
  1686. { is it a constant ? }
  1687. if SearchIConstant(actasmpattern,l) then
  1688. Begin
  1689. case oper.opr.typ of
  1690. OPR_REFERENCE :
  1691. begin
  1692. l := BuildRefConstExpression;
  1693. inc(oper.opr.ref.offset,l);
  1694. inc(oper.opr.constoffset,l);
  1695. end;
  1696. OPR_LOCAL :
  1697. begin
  1698. l := BuildRefConstExpression;
  1699. inc(oper.opr.localsymofs,l);
  1700. inc(oper.opr.localconstoffset,l);
  1701. end;
  1702. OPR_NONE,
  1703. OPR_CONSTANT :
  1704. BuildConstantOperand(oper);
  1705. else
  1706. Message(asmr_e_invalid_operand_type);
  1707. end;
  1708. end
  1709. else
  1710. { Check for pascal label }
  1711. if SearchLabel(actasmpattern,hl,false) then
  1712. begin
  1713. Consume(AS_ID);
  1714. AddLabelOperand(hl);
  1715. end
  1716. else
  1717. { is it a normal variable ? }
  1718. Begin
  1719. expr:=actasmpattern;
  1720. Consume(AS_ID);
  1721. { typecasting? }
  1722. if SearchType(expr,l) then
  1723. begin
  1724. oper.hastype:=true;
  1725. oper.typesize:=l;
  1726. case actasmtoken of
  1727. AS_LPAREN :
  1728. begin
  1729. { Support Type([Reference]) }
  1730. Consume(AS_LPAREN);
  1731. BuildOperand(oper,true);
  1732. { Delphi also supports Type(Register) and
  1733. interprets it the same as Type([Register]). }
  1734. if (oper.opr.typ = OPR_REGISTER) then
  1735. { This also sets base to the register. }
  1736. oper.InitRef;
  1737. Consume(AS_RPAREN);
  1738. end;
  1739. AS_LBRACKET :
  1740. begin
  1741. { Support Var.Type[Index] }
  1742. { Convert @label.Byte[1] to reference }
  1743. if oper.opr.typ=OPR_SYMBOL then
  1744. oper.initref;
  1745. end;
  1746. end;
  1747. end
  1748. else
  1749. begin
  1750. if not oper.SetupVar(expr,false) then
  1751. Begin
  1752. { not a variable, check special variables.. }
  1753. if expr = 'SELF' then
  1754. oper.SetupSelf
  1755. else
  1756. Message1(sym_e_unknown_id,expr);
  1757. expr:='';
  1758. end;
  1759. { indexed access to variable? }
  1760. if actasmtoken=AS_LBRACKET then
  1761. begin
  1762. { ... then the operand size is not known anymore }
  1763. oper.size:=OS_NO;
  1764. BuildReference(oper);
  1765. end;
  1766. end;
  1767. end;
  1768. end;
  1769. end;
  1770. AS_REGISTER : { Register, a variable reference or a constant reference }
  1771. begin
  1772. { save the type of register used. }
  1773. tempreg:=actasmregister;
  1774. Consume(AS_REGISTER);
  1775. if actasmtoken = AS_COLON then
  1776. Begin
  1777. Consume(AS_COLON);
  1778. oper.InitRef;
  1779. oper.opr.ref.segment:=tempreg;
  1780. BuildReference(oper);
  1781. end
  1782. else
  1783. { Simple register }
  1784. begin
  1785. if (oper.opr.typ <> OPR_NONE) then
  1786. Message(asmr_e_syn_operand);
  1787. oper.opr.typ:=OPR_REGISTER;
  1788. oper.opr.reg:=tempreg;
  1789. oper.SetSize(tcgsize2size[reg_cgsize(oper.opr.reg)],true);
  1790. end;
  1791. end;
  1792. AS_LBRACKET: { a variable reference, register ref. or a constant reference }
  1793. Begin
  1794. BuildReference(oper);
  1795. end;
  1796. AS_SEG :
  1797. Begin
  1798. Message(asmr_e_seg_not_supported);
  1799. Consume(actasmtoken);
  1800. end;
  1801. AS_DWORD,
  1802. AS_BYTE,
  1803. AS_WORD,
  1804. AS_TBYTE,
  1805. AS_DQWORD,
  1806. AS_QWORD,
  1807. AS_OWORD,
  1808. AS_XMMWORD,
  1809. AS_YWORD,
  1810. AS_YMMWORD:
  1811. begin
  1812. { Type specifier }
  1813. oper.hastype:=true;
  1814. oper.typesize:=0;
  1815. case actasmtoken of
  1816. AS_DWORD : oper.typesize:=4;
  1817. AS_WORD : oper.typesize:=2;
  1818. AS_BYTE : oper.typesize:=1;
  1819. AS_QWORD : oper.typesize:=8;
  1820. AS_DQWORD : oper.typesize:=16;
  1821. AS_TBYTE : oper.typesize:=10;
  1822. AS_OWORD,
  1823. AS_XMMWORD: oper.typesize:=16;
  1824. AS_YWORD,
  1825. AS_YMMWORD: oper.typesize:=32;
  1826. else
  1827. internalerror(2010061101);
  1828. end;
  1829. Consume(actasmtoken);
  1830. if (actasmtoken=AS_LPAREN) then
  1831. begin
  1832. { Support "xxx ptr [Reference]" }
  1833. { in case the expression subscripts a record, the typesize
  1834. is reset, so save the explicit size we set above }
  1835. l:=oper.typesize;
  1836. Consume(AS_LPAREN);
  1837. BuildOperand(oper,true);
  1838. Consume(AS_RPAREN);
  1839. oper.setsize(l,true);
  1840. end;
  1841. end;
  1842. AS_SEPARATOR,
  1843. AS_END,
  1844. AS_COMMA,
  1845. AS_COLON:
  1846. begin
  1847. break;
  1848. end;
  1849. AS_RPAREN:
  1850. begin
  1851. if not istypecast then
  1852. begin
  1853. Message(asmr_e_syn_operand);
  1854. Consume(AS_RPAREN);
  1855. end
  1856. else
  1857. break;
  1858. end;
  1859. else
  1860. begin
  1861. Message(asmr_e_syn_operand);
  1862. RecoverConsume(true);
  1863. break;
  1864. end;
  1865. end;
  1866. until false;
  1867. { End of operand, update size if a typecast is forced }
  1868. if (oper.typesize<>0) and
  1869. (oper.opr.typ in [OPR_REFERENCE,OPR_LOCAL]) then
  1870. oper.SetSize(oper.typesize,true);
  1871. end;
  1872. Procedure tx86intreader.BuildOpCode(instr : tx86instruction);
  1873. var
  1874. PrefixOp,OverrideOp: tasmop;
  1875. operandnum : longint;
  1876. is_far_const:boolean;
  1877. i:byte;
  1878. begin
  1879. PrefixOp:=A_None;
  1880. OverrideOp:=A_None;
  1881. is_far_const:=false;
  1882. { prefix seg opcode / prefix opcode }
  1883. repeat
  1884. if is_prefix(actopcode) then
  1885. with instr do
  1886. begin
  1887. OpOrder:=op_intel;
  1888. PrefixOp:=ActOpcode;
  1889. opcode:=ActOpcode;
  1890. condition:=ActCondition;
  1891. opsize:=ActOpsize;
  1892. ConcatInstruction(curlist);
  1893. consume(AS_OPCODE);
  1894. end
  1895. else
  1896. if is_override(actopcode) then
  1897. with instr do
  1898. begin
  1899. OpOrder:=op_intel;
  1900. OverrideOp:=ActOpcode;
  1901. opcode:=ActOpcode;
  1902. condition:=ActCondition;
  1903. opsize:=ActOpsize;
  1904. ConcatInstruction(curlist);
  1905. consume(AS_OPCODE);
  1906. end
  1907. else
  1908. break;
  1909. { allow for newline after prefix or override }
  1910. while actasmtoken=AS_SEPARATOR do
  1911. consume(AS_SEPARATOR);
  1912. until (actasmtoken<>AS_OPCODE);
  1913. { opcode }
  1914. if (actasmtoken <> AS_OPCODE) then
  1915. begin
  1916. Message(asmr_e_invalid_or_missing_opcode);
  1917. RecoverConsume(false);
  1918. exit;
  1919. end;
  1920. { Fill the instr object with the current state }
  1921. with instr do
  1922. begin
  1923. OpOrder:=op_intel;
  1924. Opcode:=ActOpcode;
  1925. condition:=ActCondition;
  1926. opsize:=ActOpsize;
  1927. { Valid combination of prefix/override and instruction ? }
  1928. if (prefixop<>A_NONE) and (NOT CheckPrefix(PrefixOp,actopcode)) then
  1929. Message1(asmr_e_invalid_prefix_and_opcode,actasmpattern);
  1930. if (overrideop<>A_NONE) and (NOT CheckOverride(OverrideOp,ActOpcode)) then
  1931. Message1(asmr_e_invalid_override_and_opcode,actasmpattern);
  1932. end;
  1933. { pushf/popf/pusha/popa have to default to 16 bit in Intel mode
  1934. (Intel manual and Delphi-compatbile) -- setting the opsize for
  1935. these instructions doesn't change anything in the internal assember,
  1936. so change the opcode }
  1937. if (instr.opcode=A_POPF) then
  1938. instr.opcode:=A_POPFW
  1939. else if (instr.opcode=A_PUSHF) then
  1940. instr.opcode:=A_PUSHFW
  1941. {$ifndef x86_64}
  1942. else if (instr.opcode=A_PUSHA) then
  1943. instr.opcode:=A_PUSHAW
  1944. else if (instr.opcode=A_POPA) then
  1945. instr.opcode:=A_POPAW
  1946. {$endif x86_64}
  1947. ;
  1948. { We are reading operands, so opcode will be an AS_ID }
  1949. operandnum:=1;
  1950. is_far_const:=false;
  1951. Consume(AS_OPCODE);
  1952. { Zero operand opcode ? }
  1953. if actasmtoken in [AS_SEPARATOR,AS_END] then
  1954. begin
  1955. operandnum:=0;
  1956. exit;
  1957. end;
  1958. { Read Operands }
  1959. repeat
  1960. case actasmtoken of
  1961. { End of asm operands for this opcode }
  1962. AS_END,
  1963. AS_SEPARATOR :
  1964. break;
  1965. { Operand delimiter }
  1966. AS_COMMA :
  1967. begin
  1968. if operandnum > Max_Operands then
  1969. Message(asmr_e_too_many_operands)
  1970. else
  1971. Inc(operandnum);
  1972. Consume(AS_COMMA);
  1973. end;
  1974. {Far constant, i.e. jmp $0000:$11111111.}
  1975. AS_COLON:
  1976. begin
  1977. is_far_const:=true;
  1978. if operandnum>1 then
  1979. message(asmr_e_too_many_operands)
  1980. else
  1981. inc(operandnum);
  1982. consume(AS_COLON);
  1983. end;
  1984. { Type specifier }
  1985. AS_NEAR,
  1986. AS_FAR :
  1987. begin
  1988. if actasmtoken = AS_NEAR then
  1989. begin
  1990. Message(asmr_w_near_ignored);
  1991. instr.opsize:=S_NEAR;
  1992. end
  1993. else
  1994. begin
  1995. Message(asmr_w_far_ignored);
  1996. instr.opsize:=S_FAR;
  1997. end;
  1998. Consume(actasmtoken);
  1999. if actasmtoken=AS_PTR then
  2000. begin
  2001. Consume(AS_PTR);
  2002. instr.Operands[operandnum].InitRef;
  2003. end;
  2004. BuildOperand(instr.Operands[operandnum] as tx86operand,false);
  2005. end;
  2006. else
  2007. BuildOperand(instr.Operands[operandnum] as tx86operand,false);
  2008. end; { end case }
  2009. until false;
  2010. instr.ops:=operandnum;
  2011. { Check operands }
  2012. for i:=1 to operandnum do
  2013. begin
  2014. if is_far_const and
  2015. (instr.operands[i].opr.typ<>OPR_CONSTANT) then
  2016. message(asmr_e_expr_illegal)
  2017. else
  2018. if instr.operands[i].opr.typ=OPR_NONE then
  2019. Message(asmr_e_syntax_error);
  2020. end;
  2021. { e.g. for "push dword 1", "push word 6" }
  2022. if (instr.ops=1) and
  2023. (instr.operands[1].typesize<>0) then
  2024. instr.operands[1].setsize(instr.operands[1].typesize,false);
  2025. {$ifdef i8086}
  2026. { convert 'call symbol' to 'call far symbol' for memory models with far code }
  2027. for i:=1 to operandnum do
  2028. with instr.operands[i].opr do
  2029. if (instr.opcode=A_CALL) and (typ=OPR_SYMBOL) and (symbol<>nil) and (symbol.typ<>AT_DATA) then
  2030. if current_settings.x86memorymodel in x86_far_code_models then
  2031. begin
  2032. instr.opsize:=S_FAR;
  2033. end;
  2034. {$endif i8086}
  2035. end;
  2036. Procedure tx86intreader.BuildConstant(constsize: byte);
  2037. var
  2038. asmsymtyp : tasmsymtype;
  2039. asmsym,
  2040. expr: string;
  2041. value : aint;
  2042. Begin
  2043. Repeat
  2044. Case actasmtoken of
  2045. AS_STRING:
  2046. Begin
  2047. { DD and DW cases }
  2048. if constsize <> 1 then
  2049. Begin
  2050. if Not PadZero(actasmpattern,constsize) then
  2051. Message(scan_f_string_exceeds_line);
  2052. end;
  2053. expr:=actasmpattern;
  2054. Consume(AS_STRING);
  2055. Case actasmtoken of
  2056. AS_COMMA:
  2057. Consume(AS_COMMA);
  2058. AS_END,
  2059. AS_SEPARATOR: ;
  2060. else
  2061. Message(asmr_e_invalid_string_expression);
  2062. end;
  2063. ConcatString(curlist,expr);
  2064. end;
  2065. AS_PLUS,
  2066. AS_MINUS,
  2067. AS_LPAREN,
  2068. AS_NOT,
  2069. AS_INTNUM,
  2070. AS_ID :
  2071. Begin
  2072. BuildConstSymbolExpression(false,false,false,value,asmsym,asmsymtyp);
  2073. if asmsym<>'' then
  2074. begin
  2075. if constsize<>sizeof(pint) then
  2076. Message1(asmr_w_const32bit_for_address,asmsym);
  2077. ConcatConstSymbol(curlist,asmsym,asmsymtyp,value)
  2078. end
  2079. else
  2080. ConcatConstant(curlist,value,constsize);
  2081. end;
  2082. AS_COMMA:
  2083. begin
  2084. Consume(AS_COMMA);
  2085. end;
  2086. AS_ALIGN,
  2087. AS_DB,
  2088. AS_DW,
  2089. AS_DD,
  2090. AS_DQ,
  2091. AS_OPCODE,
  2092. AS_END,
  2093. AS_SEPARATOR:
  2094. break;
  2095. else
  2096. begin
  2097. Message(asmr_e_syn_constant);
  2098. RecoverConsume(false);
  2099. end
  2100. end;
  2101. Until false;
  2102. end;
  2103. function tx86intreader.Assemble: tlinkedlist;
  2104. Var
  2105. hl : tasmlabel;
  2106. instr : Tx86Instruction;
  2107. Begin
  2108. Message1(asmr_d_start_reading,'intel');
  2109. inexpression:=FALSE;
  2110. firsttoken:=TRUE;
  2111. { sets up all opcode and register tables in uppercase
  2112. done in the construtor now
  2113. if not _asmsorted then
  2114. Begin
  2115. SetupTables;
  2116. _asmsorted:=TRUE;
  2117. end;
  2118. }
  2119. curlist:=TAsmList.Create;
  2120. { we might need to know which parameters are passed in registers }
  2121. if not parse_generic then
  2122. current_procinfo.generate_parameter_info;
  2123. { start tokenizer }
  2124. c:=current_scanner.asmgetcharstart;
  2125. gettoken;
  2126. { main loop }
  2127. repeat
  2128. case actasmtoken of
  2129. AS_LLABEL:
  2130. Begin
  2131. if CreateLocalLabel(actasmpattern,hl,true) then
  2132. ConcatLabel(curlist,hl);
  2133. Consume(AS_LLABEL);
  2134. end;
  2135. AS_LABEL:
  2136. Begin
  2137. if SearchLabel(upper(actasmpattern),hl,true) then
  2138. ConcatLabel(curlist,hl)
  2139. else
  2140. Message1(asmr_e_unknown_label_identifier,actasmpattern);
  2141. Consume(AS_LABEL);
  2142. end;
  2143. AS_DW :
  2144. Begin
  2145. inexpression:=true;
  2146. Consume(AS_DW);
  2147. BuildConstant(2);
  2148. inexpression:=false;
  2149. end;
  2150. AS_DB :
  2151. Begin
  2152. inexpression:=true;
  2153. Consume(AS_DB);
  2154. BuildConstant(1);
  2155. inexpression:=false;
  2156. end;
  2157. AS_DD :
  2158. Begin
  2159. inexpression:=true;
  2160. Consume(AS_DD);
  2161. BuildConstant(4);
  2162. inexpression:=false;
  2163. end;
  2164. {$ifdef cpu64bitaddr}
  2165. AS_DQ:
  2166. Begin
  2167. inexpression:=true;
  2168. Consume(AS_DQ);
  2169. BuildConstant(8);
  2170. inexpression:=false;
  2171. end;
  2172. {$endif cpu64bitaddr}
  2173. AS_ALIGN:
  2174. Begin
  2175. Consume(AS_ALIGN);
  2176. ConcatAlign(curlist,BuildConstExpression);
  2177. if actasmtoken<>AS_SEPARATOR then
  2178. Consume(AS_SEPARATOR);
  2179. end;
  2180. AS_OPCODE :
  2181. Begin
  2182. instr:=Tx86Instruction.Create(Tx86Operand);
  2183. BuildOpcode(instr);
  2184. with instr do
  2185. begin
  2186. { We need AT&T style operands }
  2187. Swapoperands;
  2188. { Must be done with args in ATT order }
  2189. CheckNonCommutativeOpcodes;
  2190. AddReferenceSizes;
  2191. SetInstructionOpsize;
  2192. CheckOperandSizes;
  2193. ConcatInstruction(curlist);
  2194. end;
  2195. instr.Free;
  2196. end;
  2197. AS_SEPARATOR :
  2198. Begin
  2199. Consume(AS_SEPARATOR);
  2200. end;
  2201. AS_END :
  2202. break; { end assembly block }
  2203. else
  2204. Begin
  2205. Message(asmr_e_syntax_error);
  2206. RecoverConsume(false);
  2207. end;
  2208. end; { end case }
  2209. until false;
  2210. { check that all referenced local labels are defined }
  2211. checklocallabels;
  2212. { Return the list in an asmnode }
  2213. assemble:=curlist;
  2214. Message1(asmr_d_finish_reading,'intel');
  2215. end;
  2216. end.