WebAssembly/Instructions: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		This page is created because it's annoying to constantly jump around the official WebAssembly documentation.
2	2
3	3		The page requires careful review as official specs are updated
4	4
5	5		## Instructions
6	6
7	7		Instruction
8	8
9	9		Byte Code
10	10
11	11		Execution
12	12
13	13		Notes
14	14
15	15		unreachable
16	16
17	17		\$00
18	18
19	19
20	20		1\. Trap
21	21
22	22		nop
23	23
24	24		\$01
25	25
26	26
27	27		1\. Do nothing
28	28
29	29		block
30	30
31	31		\$02 blocktype
32	32
33	33
34	34		1\. Let n be the arity \\|t?\\| of the result type t?.
35	35
36	36		2\. Let L be the label whose arity is n and whose continuation is the end of the block.
37	37
38	38		3\. Enter the block instr∗ with label L.
39	39
40	40		block must always be closed with end
41	41
42	42		loop
43	43
44	44		\$03
45	45
46	46		if
47	47
48	48		\$04
49	49
50	50		else
51	51
52	52		\$05
53	53
54	54		can only be used with if. Only single else is allowed per if
55	55
56	56		(reserved)
57	57
58	58		\$06..\$0A
59	59
60	60		end
61	61
62	62		\$0B
63	63
64	64		end can only close block or loop clocks
65	65
66	66		br labelidx
67	67
68	68		\$0C labelidx
69	69
70	70
71	71		1\. Assert: due to validation, the stack contains at least l+1 labels.
72	72
73	73		2\. Let L be the l-th label appearing on the stack, starting from the top and counting from zero.
74	74
75	75		3\. Let n be the arity of L.
76	76
77	77		4\. Assert: due to validation, there are at least n values on the top of the stack.
78	78
79	79		5\. Pop the values valn from the stack.
80	80
81	81		6\. Repeat l+1 times:
82	82
83	83
84	84		a\. While the top of the stack is a value, do:
85	85
86	86
87	87		i\. Pop the value from the stack.
88	88
89	89		b\. Assert: due to validation, the top of the stack now is a label.
90	90
91	91		c\. Pop the label from the stack.
92	92
93	93		7\. Push the values valn to the stack.
94	94
95	95		8\. Jump to the continuation of L.
96	96
97	97		Branching - Unconditional
98	98
99	99		Branching is possible only within a block. The block itself defines labels where the branching can go to.
100	100
101	101		br_if labelidx
102	102
103	103		\$0D labelidx
104	104
105	105
106	106		1\. Assert: due to validation, a value of value type i32 is on the top of the stack.
107	107
108	108		2\. Pop the value i32.const c from the stack.
109	109
110	110		3\. If c is non-zero, then:
111	111
112	112
113	113		a\. Execute the instruction (br l).
114	114
115	115		4\. Else:
116	116
117	117
118	118		b\. Do nothing.
119	119
120	120		Branching - Conditional
121	121
122	122		Branching is possible only within a block. The block itself defines labels where the branching can go to.
123	123
124	124		br_table vec(labelidxI) labelidx
125	125
126	126		\$0E
127	127
128	128		return
129	129
130	130		\$0F
131	131
132	132		call funcidx
133	133
134	134		\$10
135	135
136	136
137	137		1\. Let F be the current frame.
138	138
139	139		2\. Assert: due to validation, F.module.funcaddrs\[x\] exists.
140	140
141	141		3\. Let a be the function address F.module.funcaddrs\[x\].
142	142
143	143		4\. Invoke the function instance at address a.
144	144
145	145		call_indirect typeuse
146	146
147	147		\$11
148	148
149	149
150	150		1\. Let F be the current frame.
151	151
152	152		2\. Assert: due to validation, F.module.tableaddrs\[0\] exists.
153	153
154	154		3\. Let ta be the table address F.module.tableaddrs\[0\].
155	155
156	156		4\. Assert: due to validation, S.tables\[ta\] exists.
157	157
158	158		5\. Let tab be the table instance S.tables\[ta\].
159	159
160	160		6\. Assert: due to validation, F.module.types\[x\] exists.
161	161
162	162		7\. Let ftexpect be the function type F.module.types\[x\].
163	163
164	164		8\. Assert: due to validation, a value with value type i32 is on the top of the stack.
165	165
166	166		9\. Pop the value i32.const i from the stack.
167	167
168	168		10\. If i is not smaller than the length of tab.elem, then:
169	169
170	170
171	171		a\. Trap.
172	172
173	173		11\. If tab.elem\[i\] is uninitialized, then:
174	174
175	175
176	176		a\. Trap.
177	177
178	178		12\. Let a be the function address tab.elem\[i\].
179	179
180	180		13\. Assert: due to validation, S.funcs\[a\] exists.
181	181
182	182		14\. Let f be the function instance S.funcs\[a\].
183	183
184	184		15\. Let ft<sub>actual</sub> be the function type f.type.
185	185
186	186		16\. If ft<sub>actual</sub> and ft<sub>expect</sub> differ, then:
187	187
188	188
189	189		a\. Trap.
190	190
191	191		17\. Invoke the function instance at address a.
192	192
193	193		Note that call_indirect text syntax is different:
194	194
195		-	~~`call_indirect (type x)`~~
	195	+	``` pascal
	196	+	call_indirect (type x)
	197	+	```
196	198
197	199		A plain numeric value is treated as table number, not function signature. The signature can also be explicitly specified
198	200
199		-	~~`call_indirect (param i32)(param f32)(result f64)`~~
	201	+	```text
	202	+	call_indirect (param i32)(param f32)(result f64)
	203	+	```
200	204
201	205		In this case the assembly would assign the proper type.
202	206
203	207		(reserved)
204	208
205	209		\$12..\$19
206	210
207	211		drop
208	212
209	213		\$1A
210	214
211	215		\[t\]→\[\]
212	216
213	217		select
214	218
215	219		\$1B
216	220
217	221		\[t t i32\]→\[t\]
218	222
219	223		(reserved)
220	224
221	225		\$1C..\$1F
222	226
223	227		local.get x
224	228
225	229		\$20
226	230
227	231		local.set x
228	232
229	233		\$21
230	234
231	235		local.tee x
232	236
233	237		\$22
234	238
235	239		global.get x
236	240
237	241		\$23
238	242
239	243		global.set x
240	244
241	245		\$24
242	246
243	247		(reserved)
244	248
245	249		\$25..\$27
246	250
247	251		i32.load memarg
248	252
249	253		\$28
250	254
251	255		t.load memarg and t.loadN_sx memarg
252	256
253	257
254	258		1\. Let F be the current frame.
255	259
256	260		2\. Assert: due to validation, F.module.memaddrs\[0\] exists.
257	261
258	262		3\. Let a be the memory address F.module.memaddrs\[0\].
259	263
260	264		4\. Assert: due to validation, S.mems\[a\] exists.
261	265
262	266		5\. Let mem be the memory instance S.mems\[a\].
263	267
264	268		6\. Assert: due to validation, a value of value type i32 is on the top of the stack.
265	269
266	270		7\. Pop the value i32.const i from the stack.
267	271
268	272		8\. Let ea be the integer i+memarg.offset.
269	273
270	274		9\. If N is not part of the instruction, then:
271	275
272	276
273	277		a\. Let N be the bit width \\|t\\| of value type t.
274	278
275	279		10\. If ea+N/8 is larger than the length of mem.data, then:
276	280
277	281
278	282		a\. Trap.
279	283
280	284		11\. Let b∗ be the byte sequence mem.data\[ea:N/8\].
281	285
282	286		12\. If N and sx are part of the instruction, then:
283	287
284	288
285	289		a\. Let n be the integer for which bytesiN(n)=b∗.
286	290
287	291		b\. Let c be the result of computing extend_sxN,\\|t\\|(n).
288	292
289	293		13\. Else:
290	294
291	295
292	296		a\. Let c be the constant for which bytest(c)=b∗.
293	297
294	298		14\. Push the value t.const c to the stack.
295	299
296	300		i64.load memarg
297	301
298	302		\$29
299	303
300	304		f32.load memarg
301	305
302	306		\$2A
303	307
304	308		f64.load memarg
305	309
306	310		\$2B
307	311
308	312		i32.load8_s memarg
309	313
310	314		\$2C
311	315
312	316		i32.load8_u memarg
313	317
314	318		\$2D
315	319
316	320		i32.load16_s memarg
317	321
318	322		\$2E
319	323
320	324		i32.load16_u memarg
321	325
322	326		\$2F
323	327
324	328		i64.load8_s memarg
325	329
326	330		\$30
327	331
328	332		i64.load8_u memarg
329	333
330	334		\$31
331	335
332	336		i64.load16_s memarg
333	337
334	338		\$32
335	339
336	340		i64.load16_u memarg
337	341
338	342		\$33
339	343
340	344		i64.load32_s memarg
341	345
342	346		\$34
343	347
344	348		i64.load32_u memarg
345	349
346	350		\$35
347	351
348	352		i32.store memarg
349	353
350	354		\$36
351	355
352	356		t.store memarg and t.storeN memarg
353	357
354	358
355	359		1\. Let F be the current frame.
356	360
357	361		2\. Assert: due to validation, F.module.memaddrs\[0\] exists.
358	362
359	363		3\. Let a be the memory address F.module.memaddrs\[0\].
360	364
361	365		4\. Assert: due to validation, S.mems\[a\] exists.
362	366
363	367		5\. Let mem be the memory instance S.mems\[a\].
364	368
365	369		5\. Assert: due to validation, a value of value type t is on the top of the stack.
366	370
367	371		7\. Pop the value t.const c from the stack.
368	372
369	373		8\. Assert: due to validation, a value of value type i32 is on the top of the stack.
370	374
371	375		9\. Pop the value i32.const i from the stack.
372	376
373	377		10\. Let ea be the integer i+memarg.offset.
374	378
375	379		11\. If N is not part of the instruction, then:
376	380
377	381
378	382		a\. Let N be the bit width \\|t\\| of value type t.
379	383
380	384		12\. If ea+N/8 is larger than the length of mem.data, then:
381	385
382	386
383	387		a\. Trap.
384	388
385	389		13\. If N is part of the instruction, then:
386	390
387	391
388	392		a\. Let n be the result of computing wrap\\|t\\|,N(c).
389	393
390	394		b\. Let b∗ be the byte sequence bytesiN(n).
391	395
392	396		14\. Else:
393	397
394	398
395	399		a\. Let b∗ be the byte sequence bytest(c).
396	400
397	401		15\. Replace the bytes mem.data\[ea:N/8\] with b∗.
398	402
399	403		i64.store memarg
400	404
401	405		\$37
402	406
403	407		f32.store memarg
404	408
405	409		\$38
406	410
407	411		f64.store memarg
408	412
409	413		\$39
410	414
411	415		i32.store8 memarg
412	416
413	417		\$3A
414	418
415	419		i32.store16 memarg
416	420
417	421		\$3B
418	422
419	423		i64.store8 memarg
420	424
421	425		\$3C
422	426
423	427		i64.store16 memarg
424	428
425	429		\$3D
426	430
427	431		i64.store32 memarg
428	432
429	433		\$3E
430	434
431	435		memory.size
432	436
433	437		\$3F
434	438
435	439		memory.grow
436	440
437	441		\$40
438	442
439	443		i32.const i32
440	444
441	445		\$41
442	446
443	447		i64.const i64
444	448
445	449		\$42
446	450
447	451		f32.const f32
448	452
449	453		\$43
450	454
451	455		f64.const f64
452	456
453	457		\$44
454	458
455	459		i32.eqz
456	460
457	461		\$45
458	462
459	463		Return 1 if i is zero, 0 otherwise.
460	464
461	465		i32.eq
462	466
463	467		\$46
464	468
465	469		Return 1 if i1 equals i2, 0 otherwise.
466	470
467	471		i32.ne
468	472
469	473		\$47
470	474
471	475		Return 1 if i1 does not equal i2, 0 otherwise.
472	476
473	477		i32.lt_s
474	478
475	479		\$48
476	480
477	481		Let j1 be the signed interpretation of i1.
478	482
479	483		Let j2 be the signed interpretation of i2.
480	484
481	485		Return 1 if j1 is less than j2, 0 otherwise.
482	486
483	487		i32.lt_u
484	488
485	489		\$49
486	490
487	491		Return 1 if i1 is less than i2, 0 otherwise.
488	492
489	493		i32.gt_s
490	494
491	495		\$4A
492	496
493	497		i32.gt_u
494	498
495	499		\$4B
496	500
497	501		i32.le_s
498	502
499	503		\$4C
500	504
501	505		i32.le_u
502	506
503	507		\$4D
504	508
505	509		i32.ge_s
506	510
507	511		\$4E
508	512
509	513		i32.ge_u
510	514
511	515		\$4F
512	516
513	517		i64.eqz
514	518
515	519		\$50
516	520
517	521		Return 1 if i is zero, 0 otherwise.
518	522
519	523		i64.eq
520	524
521	525		\$51
522	526
523	527		Return 1 if i1 equals i2, 0 otherwise.
524	528
525	529		i64.ne
526	530
527	531		\$52
528	532
529	533		Return 1 if i1 does not equal i2, 0 otherwise.
530	534
531	535		i64.lt_s
532	536
533	537		\$53
534	538
535	539		Let j1 be the signed interpretation of i1.
536	540
537	541		Let j2 be the signed interpretation of i2.
538	542
539	543		Return 1 if j1 is less than j2, 0 otherwise.
540	544
541	545		i64.lt_u
542	546
543	547		\$54
544	548
545	549		Return 1 if i1 is less than i2, 0 otherwise.
546	550
547	551		i64.gt_s
548	552
549	553		\$55
550	554
551	555		i64.gt_u
552	556
553	557		\$56
554	558
555	559		i64.le_s
556	560
557	561		\$57
558	562
559	563		i64.le_u
560	564
561	565		\$58
562	566
563	567		i64.ge_s
564	568
565	569		\$59
566	570
567	571		i64.ge_u
568	572
569	573		\$5A
570	574
571	575		f32.eq
572	576
573	577		\$5B
574	578
575	579		Return 1 if i1 equals i2, 0 otherwise.
576	580
577	581		f32.ne
578	582
579	583		\$5C
580	584
581	585		Return 1 if i1 does not equal i2, 0 otherwise.
582	586
583	587		f32.lt
584	588
585	589		\$5D
586	590
587	591		f32.gt
588	592
589	593		\$5E
590	594
591	595		f32.le
592	596
593	597		\$5F
594	598
595	599		f32.ge
596	600
597	601		\$60
598	602
599	603		f64.eq
600	604
601	605		\$61
602	606
603	607		Return 1 if i1 equals i2, 0 otherwise.
604	608
605	609		f64.ne
606	610
607	611		\$62
608	612
609	613		Return 1 if i1 does not equal i2, 0 otherwise.
610	614
611	615		f64.lt
612	616
613	617		\$63
614	618
615	619		f64.gt
616	620
617	621		\$64
618	622
619	623		f64.le
620	624
621	625		\$65
622	626
623	627		f64.ge
624	628
625	629		\$66
626	630
627	631		i32.clz
628	632
629	633		\$67
630	634
631	635		i32.ctz
632	636
633	637		\$68
634	638
635	639		i32.popcnt
636	640
637	641		\$69
638	642
639	643		i32.add
640	644
641	645		\$6A
642	646
643	647		i32.sub
644	648
645	649		\$6B
646	650
647	651		i32.mul
648	652
649	653		\$6C
650	654
651	655		i32.div_s
652	656
653	657		\$6D
654	658
655	659		i32.div_u
656	660
657	661		\$6E
658	662
659	663		i32.rem_s
660	664
661	665		\$6F
662	666
663	667		i32.rem_u
664	668
665	669		\$70
666	670
667	671		i32.and
668	672
669	673		\$71
670	674
671	675		i32.or
672	676
673	677		\$72
674	678
675	679		i32.xor
676	680
677	681		\$73
678	682
679	683		i32.shl
680	684
681	685		\$74
682	686
683	687		i32.shr_s
684	688
685	689		\$75
686	690
687	691		i32.shr_u
688	692
689	693		\$76
690	694
691	695		i32.rotl
692	696
693	697		\$77
694	698
695	699		i32.rotr
696	700
697	701		\$78
698	702
699	703		i64.clz
700	704
701	705		\$79
702	706
703	707		i64.ctz
704	708
705	709		\$7A
706	710
707	711		i64.popcnt
708	712
709	713		\$7B
710	714
711	715		i64.add
712	716
713	717		\$7C
714	718
715	719		i64.sub
716	720
717	721		\$7D
718	722
719	723		i64.mul
720	724
721	725		\$7E
722	726
723	727		i64.div_s
724	728
725	729		\$7F
726	730
727	731		i64.div_u
728	732
729	733		\$80
730	734
731	735		i64.rem_s
732	736
733	737		\$81
734	738
735	739		i64.rem_u
736	740
737	741		\$82
738	742
739	743		i64.and
740	744
741	745		\$83
742	746
743	747		i64.or
744	748
745	749		\$84
746	750
747	751		i64.xor
748	752
749	753		\$85
750	754
751	755		i64.shl
752	756
753	757		\$86
754	758
755	759		i64.shr_s
756	760
757	761		\$87
758	762
759	763		i64.shr_u
760	764
761	765		\$88
762	766
763	767		i64.rotl
764	768
765	769		\$89
766	770
767	771		i64.rotr
768	772
769	773		\$8A
770	774
771	775		f32.abs
772	776
773	777		\$8B
774	778
775	779		f32.neg
776	780
777	781		\$8C
778	782
779	783		f32.ceil
780	784
781	785		\$8D
782	786
783	787		f32.floor
784	788
785	789		\$8E
786	790
787	791		f32.trunc
788	792
789	793		\$8F
790	794
791	795		f32.nearest
792	796
793	797		\$90
794	798
795	799		f32.sqrt
796	800
797	801		\$91
798	802
799	803		f32.add
800	804
801	805		\$92
802	806
803	807		f32.sub
804	808
805	809		\$93
806	810
807	811		f32.mul
808	812
809	813		\$94
810	814
811	815		f32.div
812	816
813	817		\$95
814	818
815	819		f32.min
816	820
817	821		\$96
818	822
819	823		f32.max
820	824
821	825		\$97
822	826
823	827		f32.copysign
824	828
825	829		\$98
826	830
827	831		f64.abs
828	832
829	833		\$99
830	834
831	835		f64.neg
832	836
833	837		\$9A
834	838
835	839		f64.ceil
836	840
837	841		\$9B
838	842
839	843		f64.floor
840	844
841	845		\$9C
842	846
843	847		f64.trunc
844	848
845	849		\$9D
846	850
847	851		f64.nearest
848	852
849	853		\$9E
850	854
851	855		f64.sqrt
852	856
853	857		\$9F
854	858
855	859		f64.add
856	860
857	861		\$A0
858	862
859	863		f64.sub
860	864
861	865		\$A1
862	866
863	867		f64.mul
864	868
865	869		\$A2
866	870
867	871		f64.div
868	872
869	873		\$A3
870	874
871	875		f64.min
872	876
873	877		\$A4
874	878
875	879		f64.max
876	880
877	881		\$A5
878	882
879	883		f64.copysign
880	884
881	885		\$A6
882	886
883	887		i32.wrap_i64
884	888
885	889		\$A7
886	890
887	891		i32.trunc_f32_s
888	892
889	893		\$A8
890	894
891	895		i32.trunc_f32_u
892	896
893	897		\$A9
894	898
895	899		i32.trunc_f64_s
896	900
897	901		\$AA
898	902
899	903		i32.trunc_f64_u
900	904
901	905		\$AB
902	906
903	907		i64.extend_i32_s
904	908
905	909		\$AC
906	910
907	911		i64.extend_i32_u
908	912
909	913		\$AD
910	914
911	915		i64.trunc_f32_s
912	916
913	917		\$AE
914	918
915	919		i64.trunc_f32_u
916	920
917	921		\$AF
918	922
919	923		i64.trunc_f64_s
920	924
921	925		\$B0
922	926
923	927		i64.trunc_f64_u
924	928
925	929		\$B1
926	930
927	931		f32.convert_i32_s
928	932
929	933		\$B2
930	934
931	935		f32.convert_i32_u
932	936
933	937		\$B3
934	938
935	939		f32.convert_i64_s
936	940
937	941		\$B4
938	942
939	943		f32.convert_i64_u
940	944
941	945		\$B5
942	946
943	947		f32.demote_f64
944	948
945	949		\$B6
946	950
947	951		f64.convert_i32_s
948	952
949	953		\$B7
950	954
951	955		f64.convert_i32_u
952	956
953	957		\$B8
954	958
955	959		f64.convert_i64_s
956	960
957	961		\$B9
958	962
959	963		f64.convert_i64_u
960	964
961	965		\$BA
962	966
963	967		f64.promote_f32
964	968
965	969		\$BB
966	970
967	971		i32.reinterpret_f32
968	972
969	973		\$BC
970	974
971	975		i64.reinterpret_f64
972	976
973	977		\$BD
974	978
975	979		f32.reinterpret_i32
976	980
977	981		\$BE
978	982
979	983		f64.reinterpret_i64
980	984
981	985		\$BF
982	986
983	987		## See Also
984	988
985	989		- [[WebAssembly]]
986	990		- <http://webassembly.github.io/spec/core/intro/index.html> - official documentation
987	991
988	992		---
989	993		From the Free Pascal wiki, page "WebAssembly/Instructions", as it stood on 2019-10-24 after a change by Skalogryz, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
990	994		Category: WebAssembly

Back to history